Correctly collect overloads in class hierachy, fixes #863

Author: Frotty

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

@@ -18,6 +18,8 @@
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+import static de.peeeq.wurstscript.attributes.names.NameResolution.lookupMemberFuncs;
+
 
 /**
  * this attribute find the variable definition for every variable reference
@@ -64,19 +66,61 @@ public static FuncLink calculate(final ExprFuncRef node) {
         return getExtensionFunction(node.getLeft(), node.getRight(), node.getOp());
     }
 
-    public static @Nullable FuncLink calculate(final ExprMemberMethod node) {
-
-        Expr left = node.getLeft();
-        WurstType leftType = left.attrTyp();
-        String funcName = node.getFuncName();
+    public static de.peeeq.wurstscript.attributes.names.FuncLink calculate(final ExprMemberMethod node) {
+        // collect candidates
+        WurstType recvT = node.getLeft().attrTyp();
+        String name = node.getFuncName();
+        var cands = de.peeeq.wurstscript.attributes.names.NameResolution
+            .lookupMemberFuncs(node, recvT, name, /*showErrors=*/false);
+
+        if (cands.isEmpty()) return null;
+
+        // resolve with arguments using the same rules as signatures:
+        // build a (sig, link) pair for each candidate and pick the best match.
+        java.util.List<WurstType> argTypes = de.peeeq.wurstscript.attributes.AttrFuncDef.argumentTypesPre(node);
+        de.peeeq.wurstscript.attributes.names.FuncLink bestLink = null;
+        de.peeeq.wurstscript.types.FunctionSignature bestSig = null;
+
+        // Pass 1: exact matches only
+        for (var f : cands) {
+            var sig = de.peeeq.wurstscript.types.FunctionSignature.fromNameLink(f);
+            var matched = sig.matchAgainstArgs(argTypes, node);
+            if (matched != null) {
+                // choose the first exact match; if you want “most specific” tie-break, add it here
+                bestLink = f;
+                bestSig  = matched;
+                break;
+            }
+        }
 
-        @Nullable FuncLink result = searchMemberFunc(node, leftType, funcName, argumentTypes(node));
-        if (result == null) {
-            node.addError("The method " + funcName + " is undefined for receiver of type " + leftType);
+        if (bestLink == null) {
+            // Pass 2: best-effort (to align with diagnostics), pick the lowest badness
+            int bestBadness = Integer.MAX_VALUE;
+            for (var f : cands) {
+                var sig = de.peeeq.wurstscript.types.FunctionSignature.fromNameLink(f);
+                var res = sig.tryMatchAgainstArgs(argTypes, node.getArgs(), node);
+                if (res.getBadness() < bestBadness) {
+                    bestBadness = res.getBadness();
+                    bestLink = f;
+                    bestSig  = res.getSig();
+                }
+            }
         }
-        return result;
+
+        if (bestLink == null) return null;
+
+        // IMPORTANT: carry the mapping from the matched signature back into the link,
+        // so downstream types are fully bound at the call site.
+        var bound = bestLink.withTypeArgBinding(node, bestSig.getMapping());
+        return bound;
     }
 
+    public static @Nullable FunctionDefinition calculateDef(final ExprMemberMethod node) {
+        var fl = node.attrFuncLink();
+        return fl == null ? null : fl.getDef();
+    }
+
+
     public static @Nullable FuncLink calculate(final ExprFunctionCall node) {
         FuncLink result = searchFunction(node.getFuncName(), node, argumentTypes(node));
 

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

@@ -5,6 +5,7 @@
 import com.google.common.collect.Lists;
 import de.peeeq.wurstscript.ast.*;
 import de.peeeq.wurstscript.attributes.names.FuncLink;
+import de.peeeq.wurstscript.attributes.names.NameResolution;
 import de.peeeq.wurstscript.types.FunctionSignature;
 import de.peeeq.wurstscript.types.FunctionSignature.ArgsMatchResult;
 import de.peeeq.wurstscript.types.VariableBinding;
@@ -117,6 +118,28 @@ private static ImmutableCollection<FunctionSignature> findBestSignature(StmtCall
         return out.build();
     }
 
+    public static com.google.common.collect.ImmutableCollection<FunctionSignature> calculate(ExprMemberMethod mm) {
+        // 1) Collect all member candidates (includes inherited overloads)
+        WurstType recvT = mm.getLeft().attrTyp();
+        com.google.common.collect.ImmutableCollection<FuncLink> fs =
+            NameResolution.lookupMemberFuncs(mm, recvT, mm.getFuncName(), /*showErrors=*/false);
+
+        // 2) Convert to signatures using the bound link (receiver/params/return + type-arg binding)
+        com.google.common.collect.ImmutableList.Builder<FunctionSignature> out = com.google.common.collect.ImmutableList.builder();
+        for (FuncLink f : fs) {
+            FunctionSignature sig = FunctionSignature.fromNameLink(f);
+
+            // Apply any explicit/given type-args at the call-site to the signature mapping:
+            VariableBinding mapping = givenBinding(mm, sig.getDefinitionTypeVariables());
+            sig = sig.setTypeArgs(mm, mapping);
+
+            out.add(sig);
+        }
+
+        // 3) Reuse the common “pick best” logic (exact matches first, then best-errors)
+        return findBestSignature(mm, out.build());
+    }
+
 
     public static ImmutableCollection<FunctionSignature> calculate(ExprNewObject fc) {
         TypeDef typeDef = fc.attrTypeDef();

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

@@ -1473,4 +1473,35 @@ public void callingDestroyThisInConstructor() {
             "endpackage");
     }
 
+    @Test
+    public void overloadsHiddenBySubclassName_onlyZeroArgSeen_errorsOnArgs() {
+        testAssertOkLines(true,
+            "package Test",
+            "native testSuccess()",
+            "native println(string s)",
+            "class A",
+            "    function func(int i)",
+            "        println(\"func_int...\")",
+            "",
+            "    function func(string s)",
+            "        println(\"func_string...\")",
+            "",
+            "class B extends A",
+            "    function func()",
+            "        println(\"func_noarg\")",
+            "",
+            "    function func(bool b)",
+            "        println(\"func_boolean...\")",
+            "",
+            "init",
+            "    let b = new B()",
+            "    b.func()",
+            "    b.func(true)",
+            "    b.func(1)",
+            "    b.func(\"1\")",
+            "    testSuccess()"
+        );
+    }
+
+
 }