Let a module's type parameter carry a type class bound

Using a module copies its body into the class and replaces the module's type
parameters wherever they are used as types. A requirement of a bound is called on
the parameter itself, T.show(x), where T is a name and not a type, so the
replacement never reaches it. Renaming it to the using class's parameter is not
open either: a module body resolves names in the module's own scope by design, so
that name is one the scope deliberately cannot see. The bound was rejected outright
rather than mistranslated.

The instantiation now declares the module's parameters and records the arguments
chosen for them. The body keeps saying T, that name resolves to the instantiation's
own declaration, and the argument is right there to say what it stands for. The
arguments are recorded resolved rather than copied, because an argument names
something only the user's scope can see.

Declaring them is all it does. A module instantiation is not an
AstElementWithTypeParameters: these are names to look up, not variables for a call
to infer, and making them inferable made every method of a generic module's
instantiation ask a caller to infer a parameter its signature never mentions.
Generic modules keep resolving their parameters by matching the receiver type.

A receiver written on such a parameter denotes the argument bound to it. The
requirements it offers are the ones the parameter declared, so a module cannot
reach a bound it did not ask for, while their parameter and return types are the
argument's, which is what the copied body speaks in. Dispatch follows the argument:
on the using class's type variable when the argument is itself a parameter, and
straight to the instance otherwise, since a module used with a concrete argument
leaves no variable for generic elimination to substitute.

The bound is checked at the use, which is the only place that sees both the
parameter and the argument chosen for it.

Author: Frotty

de.peeeq.wurstscript/parserspec/wurstscript.parseq

@@ -82,7 +82,13 @@ ClassSlot =
 	  ConstructorDef(@ignoreForEquality de.peeeq.wurstscript.parser.WPos source, Modifiers modifiers, WParameters parameters, SuperConstructorCall superConstructorCall, WStatements body)
 	| OnDestroyDef(@ignoreForEquality de.peeeq.wurstscript.parser.WPos source, WStatements body)
 	| ModuleUse(@ignoreForEquality de.peeeq.wurstscript.parser.WPos source, Identifier moduleNameId, TypeExprList typeArgs)
+	// Carries the module's type parameters, and the arguments chosen for them, so a name inside the
+	// copied body still resolves: a requirement of a bound is called on the parameter itself, which
+	// is a name rather than a type, and a module body resolves names in the module's own scope
+	// rather than the user's. They are declarations, not parameters left to infer, which is why the
+	// instantiation is not an AstElementWithTypeParameters.
 	| ModuleInstanciation(@ignoreForEquality de.peeeq.wurstscript.parser.WPos source, Modifiers modifiers, Identifier nameId,
+			TypeParamDefs typeParameters, TypeExprList typeArgs,
 			ClassDefs innerClasses, FuncDefs methods, GlobalVarDefs vars, ConstructorDefs constructors,
 			ModuleInstanciations p_moduleInstanciations, ModuleUses moduleUses, OnDestroyDef onDestroy)
 	| ClassMember

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/ModuleExpander.java

@@ -75,8 +75,25 @@ private static ModuleInstanciations expandModules(ClassOrModule m, List<ClassOrM
 
             WPos source = moduleUse.getSource().artificial();
             WPos idSource = moduleUse.getModuleNameId().getSource().artificial();
+            // The instantiation declares the module's type parameters, so a name inside the copied
+            // body still resolves to something. Types have already been replaced by the arguments;
+            // what is left needing a name is a requirement called on the parameter itself.
+            TypeParamDefs instanciationTypeParams = Ast.TypeParamDefs();
+            for (TypeParamDef moduleParam : usedModule.getTypeParameters()) {
+                instanciationTypeParams.add(moduleParam.copy());
+            }
+            // Resolved rather than copied: an argument names something in the user's scope, and a
+            // module instantiation resolves names in the module's own. Resolving here keeps the type
+            // and needs no scope afterwards, which is what TypeExprResolved is for.
+            TypeExprList instanciationTypeArgs = Ast.TypeExprList();
+            for (int i = 0; i < numTypeArgs; i++) {
+                TypeExpr arg = moduleUse.getTypeArgs().get(i);
+                instanciationTypeArgs.add(Ast.TypeExprResolved(arg.getSource().artificial(), arg.attrTyp()));
+            }
             ModuleInstanciation mi = Ast.ModuleInstanciation(source, Ast.Modifiers(),
                     Ast.Identifier(idSource, usedModule.getName()),
+                    instanciationTypeParams,
+                    instanciationTypeArgs,
                     smartCopy(usedModule.getInnerClasses(), typeReplacements),
                     smartCopy(usedModule.getMethods(), typeReplacements),
                     smartCopy(usedModule.getVars(), typeReplacements),

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

@@ -7,6 +7,7 @@
 import de.peeeq.wurstscript.types.WurstType;
 import de.peeeq.wurstscript.types.WurstTypeTypeParam;
 import org.eclipse.jdt.annotation.Nullable;
+import de.peeeq.wurstscript.types.WurstTypeBoundTypeParam;
 
 public class AttrImplicitParameter {
 
@@ -97,9 +98,17 @@ public static boolean isTypeClassDispatch(Element e) {
             return false;
         }
         Expr left = hasReceiver.getLeft();
-        return left != null
-            && left.attrTyp() instanceof WurstTypeTypeParam tp
-            && tp.isStaticRef();
+        if (left == null) {
+            return false;
+        }
+        WurstType leftType = left.attrTyp();
+        if (leftType instanceof WurstTypeTypeParam tp) {
+            return tp.isStaticRef();
+        }
+        // A parameter of a module instantiation denotes the argument bound to it, so the receiver is
+        // a binding rather than the parameter itself. It still names a type parameter, which is what
+        // makes this a dispatch.
+        return leftType instanceof WurstTypeBoundTypeParam bound && bound.isStaticRef();
     }
 
     static OptExpr getFunctionCallImplicitParameter(FunctionCall e, FuncLink calledFunc, boolean showError) {

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

@@ -15,6 +15,7 @@
 import de.peeeq.wurstscript.types.WurstTypeEnum;
 import de.peeeq.wurstscript.types.WurstTypeModule;
 import org.eclipse.jdt.annotation.Nullable;
+import de.peeeq.wurstscript.types.WurstTypeBoundTypeParam;
 
 /**
  * this attribute find the variable definition for every variable reference
@@ -136,7 +137,7 @@ private static boolean isMethodCallReceiver(NameRef node) {
         if (!(typeDef instanceof TypeParamDef tp) || !TypeClassConstraints.hasBounds(tp)) {
             return null;
         }
-        WurstTypeTypeParam typ = new WurstTypeTypeParam(tp).asStaticRef();
+        WurstType typ = staticRefTypeFor(tp, node);
         return new OtherLink(Visibility.LOCAL, varName, typ) {
             @Override
             public de.peeeq.wurstscript.jassIm.ImExpr translate(NameRef e, ImTranslator t, ImFunction f) {
@@ -146,6 +147,34 @@ public de.peeeq.wurstscript.jassIm.ImExpr translate(NameRef e, ImTranslator t, I
         };
     }
 
+    /**
+     * The type a bounded parameter's name denotes in receiver position.
+     * <p>
+     * A parameter declared on a module instantiation stands for the argument the user supplied, so it
+     * denotes that type bound to this parameter: the requirement's own parameter types then substitute
+     * to the argument rather than to a name only the module can see. Everywhere else the parameter
+     * stands for itself.
+     */
+    private static WurstType staticRefTypeFor(TypeParamDef tp, NameRef node) {
+        WurstType argument = moduleInstanciationArgument(tp);
+        if (argument != null) {
+            return new WurstTypeBoundTypeParam(tp, argument, node).asStaticRef();
+        }
+        return new WurstTypeTypeParam(tp).asStaticRef();
+    }
+
+    /** The argument a module instantiation supplied for this parameter, or null if it is not one. */
+    private static @Nullable WurstType moduleInstanciationArgument(TypeParamDef tp) {
+        if (!(tp.getParent() != null && tp.getParent().getParent() instanceof ModuleInstanciation mi)) {
+            return null;
+        }
+        int index = mi.getTypeParameters().indexOf(tp);
+        if (index < 0 || index >= mi.getTypeArgs().size()) {
+            return null;
+        }
+        return mi.getTypeArgs().get(index).attrTyp();
+    }
+
     private static @Nullable NameLink lookupImplicitClosureSelf(NameRef node, boolean showErrors) {
         ExprClosure closure = node.attrNearestExprClosure();
         if (closure == null) {

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

@@ -4,6 +4,9 @@
 import com.google.common.collect.ImmutableSetMultimap;
 import de.peeeq.wurstscript.ast.*;
 
+import java.util.Collections;
+import java.util.List;
+
 public class TypeNameLinks {
 
     public static ImmutableMultimap<String, TypeLink> calculate(ClassOrModuleOrModuleInstanciation c) {
@@ -94,13 +97,27 @@ public static ImmutableMultimap<String, TypeLink> calculate(WStatements statemen
     }
 
     private static void addTypeParametersIfAny(ImmutableMultimap.Builder<String, TypeLink> result, WScope c) {
-        if (c instanceof AstElementWithTypeParameters) {
-            AstElementWithTypeParameters wtp = (AstElementWithTypeParameters) c;
-            for (TypeParamDef i : wtp.getTypeParameters()) {
-                result.put(i.getName(), TypeLink.create(i, c));
-            }
+        for (TypeParamDef i : declaredTypeParameters(c)) {
+            result.put(i.getName(), TypeLink.create(i, c));
         }
+    }
 
+    /**
+     * The type parameter names a scope introduces.
+     * <p>
+     * A module instantiation declares the module's parameters so that a receiver written on one
+     * still resolves once the body has been copied out of the module's scope. It is not an
+     * {@link AstElementWithTypeParameters}: the arguments are recorded on the instantiation, so
+     * these are names to look up rather than variables for a call to infer.
+     */
+    private static List<TypeParamDef> declaredTypeParameters(WScope c) {
+        if (c instanceof AstElementWithTypeParameters wtp) {
+            return wtp.getTypeParameters();
+        }
+        if (c instanceof ModuleInstanciation mi) {
+            return mi.getTypeParameters();
+        }
+        return Collections.emptyList();
     }
 
     private static void addJassTypes(ImmutableMultimap.Builder<String, TypeLink> result, CompilationUnit cu) {

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imtranslation/ExprTranslation.java

@@ -521,7 +521,7 @@ public static ImExpr translateIntern(FunctionCall e, ImTranslator t, ImFunction
      * function supplied by the instance chosen for the substituted type.
      */
     private static ImExpr translateTypeClassDispatch(FunctionCall e, ImTranslator t, ImFunction f) {
-        WurstTypeTypeParam receiver = (WurstTypeTypeParam) ((HasReceiver) e).getLeft().attrTyp();
+        WurstType receiver = ((HasReceiver) e).getLeft().attrTyp();
         FunctionDefinition called = e.attrFuncDef();
         if (!(called instanceof FuncDef method)) {
             throw new CompileError(e.attrSource(),
@@ -531,7 +531,36 @@ private static ImExpr translateTypeClassDispatch(FunctionCall e, ImTranslator t,
         for (Expr arg : e.getArgs()) {
             args.add(arg.imTranslateExpr(t, f));
         }
-        return JassIm.ImTypeVarDispatch(e, t.getTypeClassFunc(method), args, t.getTypeVar(receiver.getDef()));
+        ImTypeClassFunc requirement = t.getTypeClassFunc(method);
+        if (receiver instanceof WurstTypeBoundTypeParam bound) {
+            return translateModuleParamDispatch(e, bound, requirement, args, t);
+        }
+        return JassIm.ImTypeVarDispatch(e, requirement, args,
+            t.getTypeVar(((WurstTypeTypeParam) receiver).getDef()));
+    }
+
+    /**
+     * Dispatches a requirement called on a module instantiation's type parameter, which stands for
+     * the argument the using class supplied rather than for a variable of its own.
+     * <p>
+     * When that argument is itself a type parameter the dispatch is on the using class's variable,
+     * exactly as if the call had been written there. Otherwise the instance is already determined:
+     * a module used with a concrete argument leaves no variable for generic elimination to
+     * substitute, so the implementation is chosen here.
+     */
+    private static ImExpr translateModuleParamDispatch(FunctionCall e, WurstTypeBoundTypeParam bound,
+            ImTypeClassFunc requirement, ImExprs args, ImTranslator t) {
+        WurstType argument = bound.getBaseType().normalize();
+        if (argument instanceof WurstTypeTypeParam tp) {
+            return JassIm.ImTypeVarDispatch(e, requirement, args, t.getTypeVar(tp.getDef()));
+        }
+        Either<ImMethod, ImFunction> impl = bound.imTypeClassBinding(t).get(requirement);
+        if (impl == null) {
+            throw new CompileError(e.attrSource(),
+                "No type class instance supplies " + e.getFuncName() + " for " + argument + ".");
+        }
+        ImFunction target = impl.isRight() ? impl.get() : impl.getLeft().getImplementation();
+        return ImFunctionCall(e, target, ImTypeArguments(), args, false, CallType.NORMAL);
     }
 
     private static ImExpr translateFunctionCall(FunctionCall e, ImTranslator t, ImFunction f, boolean returnReveiver, boolean nullSafe) {

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

@@ -1,11 +1,14 @@
 package de.peeeq.wurstscript.types;
 
 import de.peeeq.wurstscript.ast.*;
+import de.peeeq.wurstscript.ast.Element;
+import de.peeeq.wurstscript.attributes.names.FuncLink;
 import org.eclipse.jdt.annotation.Nullable;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Stream;
 
 /**
  * Reads the type class bounds written on a new-style type parameter.
@@ -121,6 +124,81 @@ public static boolean hasBounds(TypeParamDef tp) {
         return boundExpr.lookupType(simple.getTypeName(), false) instanceof InterfaceDef i ? i : null;
     }
 
+    /**
+     * Surfaces the methods required by a type parameter's bounds as members of a receiver which
+     * stands for that parameter, so that {@code T.f(args)} resolves.
+     * <p>
+     * Bounds are ordered and an earlier one wins, but only over the same signature: two bounds may
+     * require the very same operation, and offering both would make every call ambiguous.
+     * Differently shaped overloads are not in competition, so later bounds still contribute them and
+     * overload resolution picks between them as usual.
+     *
+     * @param standsFor what the interface's own type parameter is bound to, which is what the
+     *                  requirement's parameter and return types substitute to.
+     * @param receiver  the type the call is written on.
+     */
+    public static void addRequirementMethods(TypeParamDef def, WurstType standsFor, WurstType receiver,
+                                             Element node, String name, List<FuncLink> result) {
+        List<FuncLink> supplied = new ArrayList<>();
+        for (InterfaceDef bound : boundInterfaces(def)) {
+            for (FuncDef method : bound.getMethods()) {
+                if (!method.getName().equals(name)) {
+                    continue;
+                }
+                FuncLink candidate = requirementLink(bound, method, standsFor, receiver, node);
+                if (!alreadySupplied(supplied, candidate, node)) {
+                    supplied.add(candidate);
+                }
+            }
+        }
+        result.addAll(supplied);
+    }
+
+    /** Every requirement of the bounds, for callers which want the whole set rather than one name. */
+    public static Stream<FuncLink> requirementMethods(TypeParamDef def, WurstType standsFor,
+                                                      WurstType receiver, Element node) {
+        return boundInterfaces(def).stream()
+                .flatMap(bound -> bound.getMethods().stream()
+                        .map(method -> requirementLink(bound, method, standsFor, receiver, node)));
+    }
+
+    /**
+     * Exposes one interface method as a requirement: the interface's own type parameter is
+     * substituted by what the receiver stands for, so the call reads {@code T.f(args)} with the
+     * arguments exactly as declared.
+     */
+    private static FuncLink requirementLink(InterfaceDef bound, FuncDef method, WurstType standsFor,
+                                            WurstType receiver, Element node) {
+        TypeParamDef ifaceParam = bound.getTypeParameters().get(0);
+        VariableBinding binding = VariableBinding.emptyMapping()
+                .set(ifaceParam, new WurstTypeBoundTypeParam(ifaceParam, standsFor, node));
+        return FuncLink.create(method, bound)
+                .withTypeArgBinding(node, binding)
+                .withReceiverType(receiver);
+    }
+
+    /** True when an earlier bound already supplied a requirement of the same shape. */
+    private static boolean alreadySupplied(List<FuncLink> supplied, FuncLink candidate, Element node) {
+        for (FuncLink existing : supplied) {
+            List<WurstType> a = existing.getParameterTypes();
+            List<WurstType> b = candidate.getParameterTypes();
+            if (a.size() != b.size()) {
+                continue;
+            }
+            boolean same = true;
+            for (int i = 0; i < a.size(); i++) {
+                if (!a.get(i).equalsType(b.get(i), node)) {
+                    same = false;
+                    break;
+                }
+            }
+            if (same) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * Looks up a method required by any bound of the given type parameter.
      * Earlier bounds win, matching the left-to-right order the bounds were written in.

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

@@ -27,21 +27,36 @@ public class WurstTypeBoundTypeParam extends WurstType {
     private final @Nullable Map<FuncDef, FuncLink> typeConstraintFunctions;
     private boolean indexInitialized = false;
     private final Element context;
+    /**
+     * True when this stands for the type parameter itself rather than a value of it, as in the
+     * receiver of {@code T.toIndex(x)}. Only this form exposes the methods required by the bounds.
+     */
+    private final boolean staticRef;
 
     public WurstTypeBoundTypeParam(TypeParamDef def, WurstType baseType, Element context) {
+        this(def, baseType, context, false);
+    }
+
+    private WurstTypeBoundTypeParam(TypeParamDef def, WurstType baseType, Element context, boolean staticRef) {
         if (baseType instanceof WurstTypeIntLiteral) {
             baseType = WurstTypeInt.instance();
         }
         this.typeParamDef = def;
         this.baseType = baseType;
         this.context = context;
+        this.staticRef = staticRef;
         if (def.getTypeParamConstraints() instanceof NoTypeParamConstraints) {
             this.typeConstraintFunctions = null;
         } else {
             this.typeConstraintFunctions = new HashMap<>();
         }
     }
 
+    /** The same binding, seen as the type parameter itself rather than as a value of it. */
+    public WurstTypeBoundTypeParam asStaticRef() {
+        return staticRef ? this : new WurstTypeBoundTypeParam(typeParamDef, baseType, context, true);
+    }
+
     @Override
     VariableBinding matchAgainstSupertypeIntern(WurstType other, @Nullable Element location, VariableBinding mapping, VariablePosition variablePosition) {
         return baseType.matchAgainstSupertypeIntern(other, location, mapping, NONE);
@@ -92,17 +107,27 @@ public boolean allowsDynamicDispatch() {
     @Override
     public void addMemberMethods(Element node, String name,
                                  List<FuncLink> result) {
+        if (staticRef) {
+            // The requirements are the parameter's own, so a module cannot reach a bound its
+            // parameter did not declare; their types come from the argument it is bound to, which
+            // is what the copied body was rewritten to speak in.
+            TypeClassConstraints.addRequirementMethods(typeParamDef, baseType, this, node, name, result);
+            return;
+        }
         baseType.addMemberMethods(node, name, result);
     }
 
     @Override
     public Stream<FuncLink> getMemberMethods(Element node) {
+        if (staticRef) {
+            return TypeClassConstraints.requirementMethods(typeParamDef, baseType, this, node);
+        }
         return baseType.getMemberMethods(node);
     }
 
     @Override
     public boolean isStaticRef() {
-        return baseType.isStaticRef();
+        return staticRef || baseType.isStaticRef();
     }
 
     @Override
@@ -113,7 +138,10 @@ public boolean isCastableToInt() {
 
     @Override
     public WurstType normalize() {
-        return baseType.normalize();
+        // A static reference denotes the parameter, not a value of what it is bound to. Normalising
+        // it away would leave the argument type, which knows nothing of the bounds the requirements
+        // are read from.
+        return staticRef ? this : baseType.normalize();
     }
 
     public FuncDef getFromIndex() {
@@ -178,7 +206,7 @@ private WurstTypeBoundTypeParam withBaseType(WurstType t) {
         if (t == baseType) {
             return this;
         }
-        return new WurstTypeBoundTypeParam(typeParamDef, t, context);
+        return new WurstTypeBoundTypeParam(typeParamDef, t, context, staticRef);
     }
 
     public TypeParamDef getTypeParamDef() {