added @ifNotDefined for #793

functions annotated with @ifNotDefined are only called, when no other
definition of the function is in scope

Author: peq

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/attributes/AttrFuncDef.java

@@ -15,6 +15,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 
 
 /**
@@ -178,6 +179,11 @@ private static FuncLink searchFunction(String funcName, @Nullable FuncRef node,
             return Utils.getFirst(funcs);
         }
 
+        funcs = ignoreWithIfNotDefinedAnnotation(node, funcs);
+        if (funcs.size() == 1) {
+            return Utils.getFirst(funcs);
+        }
+
         funcs = useLocalPackageIfPossible(node, funcs);
         if (funcs.size() == 1) {
             return Utils.getFirst(funcs);
@@ -188,6 +194,12 @@ private static FuncLink searchFunction(String funcName, @Nullable FuncRef node,
         return Utils.getFirst(funcs);
     }
 
+    private static List<FuncLink> ignoreWithIfNotDefinedAnnotation(FuncRef node, List<FuncLink> funcs) {
+        return funcs.stream()
+                .filter(fl -> !fl.hasIfNotDefinedAnnotation())
+                .collect(Collectors.toList());
+    }
+
 
     private static List<FuncLink> useLocalPackageIfPossible(FuncRef node,
                                                             List<FuncLink> funcs) {

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/attributes/AttrFunctionSignature.java

@@ -6,10 +6,13 @@
 import de.peeeq.wurstscript.types.WurstType;
 import de.peeeq.wurstscript.types.WurstTypeUnknown;
 import de.peeeq.wurstscript.utils.Utils;
+import fj.data.Either;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class AttrFunctionSignature {
 
@@ -37,20 +40,25 @@ private static FunctionSignature filterSigs(
             return FunctionSignature.empty;
         }
 
-        List<FunctionSignature> candidates = new ArrayList<>();
-        for (FunctionSignature sig : sigs) {
-            sig = sig.matchAgainstArgs(argTypes, location);
-            if (sig != null) {
-                candidates.add(sig);
-            }
+        List<FunctionSignature> candidates = filterByArgumentTypes(sigs, argTypes, location);
+        if (candidates.isEmpty()) {
+            // parameters match for no element, just return the first signature
+            return Utils.getFirst(sigs);
+        } else if (candidates.size() == 1) {
+            return candidates.get(0);
         }
+
+        candidates = filterByIfNotDefinedAnnotation(candidates);
         if (candidates.isEmpty()) {
             // parameters match for no element, just return the first signature
             return Utils.getFirst(sigs);
         } else if (candidates.size() == 1) {
             return candidates.get(0);
         }
 
+
+
+
         if (argTypes.stream().noneMatch(t -> t instanceof WurstTypeUnknown)) {
             // only show overloading error, if type for all arguments could be determined
             StringBuilder alternatives = new StringBuilder();
@@ -63,6 +71,24 @@ private static FunctionSignature filterSigs(
         return candidates.get(0);
     }
 
+    private static List<FunctionSignature> filterByIfNotDefinedAnnotation(List<FunctionSignature> candidates) {
+        return candidates.stream()
+                .filter(sig -> !sig.hasIfNotDefinedAnnotation())
+                .collect(Collectors.toList());
+    }
+
+    @NotNull
+    private static List<FunctionSignature> filterByArgumentTypes(Collection<FunctionSignature> sigs, List<WurstType> argTypes, StmtCall location) {
+        List<FunctionSignature> candidates = new ArrayList<>();
+        for (FunctionSignature sig : sigs) {
+            sig = sig.matchAgainstArgs(argTypes, location);
+            if (sig != null) {
+                candidates.add(sig);
+            }
+        }
+        return candidates;
+    }
+
     private static boolean isInitTrigFunc(StmtCall e) {
         if (e instanceof ExprFunctionCall) {
             ExprFunctionCall e2 = (ExprFunctionCall) e;

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/attributes/names/FuncLink.java

@@ -276,4 +276,8 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(def);
     }
+
+    public boolean hasIfNotDefinedAnnotation() {
+        return def.attrHasAnnotation("ifNotDefined");
+    }
 }

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/types/FunctionSignature.java

@@ -254,6 +254,14 @@ public List<TypeParamDef> case_ConstructorDef(ConstructorDef c) {
         });
     }
 
+    public boolean hasIfNotDefinedAnnotation() {
+        if (trace instanceof HasModifier) {
+            HasModifier m = (HasModifier) this.trace;
+            return m.attrHasAnnotation("ifNotDefined");
+        }
+        return false;
+    }
+
     public static class ArgsMatchResult {
         private final FunctionSignature sig;
         private final ImmutableList<CompileError> errors;

de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/NewFeatureTests.java

@@ -397,4 +397,44 @@ public void testForInCloseBeforeReturn() {
         );
     }
 
+    @Test
+    public void testIfNotDefinedAnnotation1() {
+        testAssertOkLines(true,
+                "function foo takes integer x returns integer",
+                "    return x + 1",
+                "endfunction",
+                "package Test",
+                "native testSuccess()",
+                "@ifNotDefined function foo(int x) returns int",
+                "    return x + 2",
+                "init",
+                "    if foo(3) == 4",
+                "        testSuccess()"
+        );
+    }
+
+    @Test
+    public void testIfNotDefinedAnnotation2() {
+        testAssertOkLines(true,
+                "package Test",
+                "native testSuccess()",
+                "@ifNotDefined function foo(int x) returns int",
+                "    return x + 2",
+                "init",
+                "    if foo(3) == 5",
+                "        testSuccess()"
+        );
+    }
+
+    @Test
+    public void testIfNotDefinedAnnotationNative() {
+        testAssertOkLines(true,
+                "native testSuccess takes nothing returns nothing",
+                "package Test",
+                "@ifNotDefined native testSuccess()",
+                "init",
+                "    testSuccess()"
+        );
+    }
+
 }