Fix generic call arguments being overridden by the generic mapper's selfmapping

CodeModel/src/main/java/org/openzen/zenscript/codemodel/GenericMapper.java

@@ -5,94 +5,100 @@
  */
 package org.openzen.zenscript.codemodel;
 
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.GenericTypeID;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.StoredType;
+import org.openzen.zencode.shared.*;
+import org.openzen.zenscript.codemodel.generic.*;
+import org.openzen.zenscript.codemodel.type.*;
+
+import java.util.*;
 
 /**
- *
  * @author Hoofdgebruiker
  */
 public class GenericMapper {
-	public static final GenericMapper EMPTY = new GenericMapper(CodePosition.BUILTIN, null, Collections.emptyMap());
-	
-	public final CodePosition position;
-	public final GlobalTypeRegistry registry;
-	private final Map<TypeParameter, StoredType> mapping;
-	
-	public GenericMapper(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
-		if (mapping == null)
-			throw new IllegalArgumentException();
-		
-		this.position = position;
-		this.registry = registry;
-		this.mapping = mapping;
-	}
-	
-	public Map<TypeParameter, StoredType> getMapping() {
-		return mapping;
-	}
-	
-	public StoredType map(StoredType original) {
-		return mapping.isEmpty() ? original : original.instance(this);
-	}
-	
-	public StoredType[] map(StoredType[] original) {
-		if (mapping.isEmpty() || original.length == 0)
-			return original;
-		
-		StoredType[] mapped = new StoredType[original.length];
-		for (int i = 0; i < original.length; i++)
-			mapped[i] = original[i].instance(this);
-		return mapped;
-	}
-	
-	public StoredType map(GenericTypeID type) {
-		//if (!mapping.containsKey(type.parameter))
-		//	throw new IllegalStateException("No mapping found for type " + type);
-		
-		return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type.stored();
-	}
-	
-	public FunctionHeader map(FunctionHeader original) {
-		return mapping.isEmpty() ? original : original.withGenericArguments(this);
-	}
-	
-	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
-		Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
-		resultMap.putAll(mapping);
-		return new GenericMapper(position, registry, resultMap);
-	}
-	
-	public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, TypeParameter[] parameters) {
-		Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
-		for (TypeParameter parameter : parameters)
-			resultMap.put(parameter, new StoredType(registry.getGeneric(parameter), null));
-		return new GenericMapper(position, registry, resultMap);
-	}
-	
-	@Override
-	public String toString() {
-		if (mapping.isEmpty())
-			return "{}";
-		
-		StringBuilder result = new StringBuilder();
-		result.append('{');
-		boolean first = true;
-		for (Map.Entry<TypeParameter, StoredType> entry : mapping.entrySet()) {
-			if (first) {
-				first = false;
-			} else {
-				result.append(", ");
-			}
-			result.append(entry.getKey().toString()).append(": ").append(entry.getValue());
-		}
-		result.append('}');
-		return result.toString();
-	}
+    
+    public static final GenericMapper EMPTY = new GenericMapper(CodePosition.BUILTIN, null, Collections
+            .emptyMap());
+    
+    public final CodePosition position;
+    public final GlobalTypeRegistry registry;
+    private final Map<TypeParameter, StoredType> mapping;
+    
+    public GenericMapper(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+        if(mapping == null)
+            throw new IllegalArgumentException();
+        
+        this.position = position;
+        this.registry = registry;
+        this.mapping = mapping;
+    }
+    
+    public Map<TypeParameter, StoredType> getMapping() {
+        return mapping;
+    }
+    
+    public StoredType map(StoredType original) {
+        return mapping.isEmpty() ? original : original.instance(this);
+    }
+    
+    public StoredType[] map(StoredType[] original) {
+        if(mapping.isEmpty() || original.length == 0)
+            return original;
+        
+        StoredType[] mapped = new StoredType[original.length];
+        for(int i = 0; i < original.length; i++)
+            mapped[i] = original[i].instance(this);
+        return mapped;
+    }
+    
+    public StoredType map(GenericTypeID type) {
+        //if (!mapping.containsKey(type.parameter))
+        //	throw new IllegalStateException("No mapping found for type " + type);
+        
+        return mapping.containsKey(type.parameter) ? mapping.get(type.parameter) : type.stored();
+    }
+    
+    public FunctionHeader map(FunctionHeader original) {
+        return mapping.isEmpty() ? original : original.withGenericArguments(this);
+    }
+    
+    public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+        Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
+        mapping.forEach((typeParameter, storedType) -> {
+            if(resultMap.containsKey(typeParameter)) {
+                if(storedType.type instanceof GenericTypeID && ((GenericTypeID) storedType.type).parameter == typeParameter) {
+                    return;
+                }
+            }
+            resultMap.put(typeParameter, storedType);
+        });
+        
+        return new GenericMapper(position, registry, resultMap);
+    }
+    
+    public GenericMapper getInner(CodePosition position, GlobalTypeRegistry registry, TypeParameter[] parameters) {
+        Map<TypeParameter, StoredType> resultMap = new HashMap<>(this.mapping);
+        for(TypeParameter parameter : parameters)
+            resultMap.put(parameter, new StoredType(registry.getGeneric(parameter), null));
+        return new GenericMapper(position, registry, resultMap);
+    }
+    
+    @Override
+    public String toString() {
+        if(mapping.isEmpty())
+            return "{}";
+        
+        StringBuilder result = new StringBuilder();
+        result.append('{');
+        boolean first = true;
+        for(Map.Entry<TypeParameter, StoredType> entry : mapping.entrySet()) {
+            if(first) {
+                first = false;
+            } else {
+                result.append(", ");
+            }
+            result.append(entry.getKey().toString()).append(": ").append(entry.getValue());
+        }
+        result.append('}');
+        return result.toString();
+    }
 }

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedCallArguments.java

@@ -5,16 +5,14 @@
  */
 package org.openzen.zenscript.parser.expression;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.*;
+import org.openzen.zenscript.codemodel.generic.*;
 import org.openzen.zenscript.lexer.ZSTokenType;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
@@ -144,7 +142,21 @@ public class ParsedCallArguments {
 		for (FunctionHeader header : candidates) {
 			//TODO: this is wrong!
 			boolean variadic = header.isVariadic();
+   
+			type_parameter_replacement:
+            if(typeArguments != null && typeArguments.length > 0 && header.typeParameters.length == typeArguments.length) {
+                final Map<TypeParameter, StoredType> types = new HashMap<>();
+                for(int i = 0; i < header.typeParameters.length; i++) {
+                    if(!header.typeParameters[i].matches(scope.getMemberCache(), typeArguments[i].type)) {
+                        break type_parameter_replacement;
+                    }
+                    types.put(header.typeParameters[i], typeArguments[i]);
+                }
+                header = header.withGenericArguments(new GenericMapper(position, scope.getTypeRegistry(), types));
+            }
+			
 			for (int i = 0; i < arguments.size(); i++) {
+			    
 				final StoredType parameterType = header.getParameterType(variadic, i);
 				if (!predictedTypes[i].contains(parameterType))
 					predictedTypes[i].add(parameterType);