Merge remote-tracking branch 'Stan/development' into development

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeContext.java

@@ -5,21 +5,16 @@
  */
 package org.openzen.zenscript.javabytecode;
 
-import java.util.HashMap;
-import java.util.Map;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
-import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.javashared.JavaSynthesizedClass;
-import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
+import org.openzen.zenscript.javashared.JavaSynthesizedFunction;
+import org.openzen.zenscript.javashared.JavaSynthesizedRange;
 import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
 import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
 import org.openzen.zenscript.javashared.JavaTypeInternalNameVisitor;
@@ -33,19 +28,20 @@ public class JavaBytecodeContext extends JavaContext {
 	private final TypeGenerator typeGenerator;
 	private final JavaTypeInternalNameVisitor internalNameVisitor;
 	private final JavaTypeDescriptorVisitor descriptorVisitor;
-	private final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
-	private final Map<String, JavaSynthesizedClass> ranges = new HashMap<>();
 	private int lambdaCounter = 0;
 	
-	public JavaBytecodeContext(JavaModule module) {
+	public JavaBytecodeContext(GlobalTypeRegistry registry, JavaModule module) {
+		super(registry);
+		
 		this.module = module;
 		
 		typeGenerator = new TypeGenerator();
-		internalNameVisitor = new JavaTypeInternalNameVisitor(typeGenerator);
-		descriptorVisitor = new JavaTypeDescriptorVisitor(typeGenerator);
+		internalNameVisitor = new JavaTypeInternalNameVisitor(this);
+		descriptorVisitor = new JavaTypeDescriptorVisitor(this);
 	}
 	
-	public JavaSyntheticClassGenerator getTypeGenerator() {
+	@Override
+	protected JavaSyntheticClassGenerator getTypeGenerator() {
 		return typeGenerator;
 	}
 	
@@ -66,69 +62,45 @@ public class JavaBytecodeContext extends JavaContext {
 		module.register(name, bytecode);
 	}
 
-    private JavaSynthesizedClass getLambdaInterface(FunctionTypeID function) {
-		String signature = JavaSynthesizedClassNamer.getFunctionSignature(function);
-		if (functions.containsKey(signature))
-			return functions.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(function));
-		
-		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createFunctionName(function);
-		functions.put(signature, result);
-		
-        createLambdaInterface(function.header, result.cls);
-        return result;
-    }
-	
-	private JavaSynthesizedClass getRangeType(RangeTypeID type) {
-		String signature = JavaSynthesizedClassNamer.getRangeSignature(type);
-		if (ranges.containsKey(signature))
-			return ranges.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(type));
-		
-		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createRangeName(type);
-		ranges.put(signature, result);
-		
-		createRangeClass(type.baseType, result.cls);
-		return result;
-	}
-
-    private void createLambdaInterface(FunctionHeader header, JavaClass cls) {
+    private void createLambdaInterface(JavaSynthesizedFunction function) {
         ClassWriter ifaceWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
         ifaceWriter.visitAnnotation("java/lang/FunctionalInterface", true).visitEnd();
-        ifaceWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, cls.internalName, null, "java/lang/Object", null);
+        ifaceWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, function.cls.internalName, null, "java/lang/Object", null);
 
         ifaceWriter
 				.visitMethod(
 					Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT,
 					"accept",
-					getMethodDescriptor(header),
-					getMethodSignature(header),
+					getMethodDescriptor(function.header),
+					getMethodSignature(function.header),
 					null)
 				.visitEnd();
 
-        register(cls.internalName, ifaceWriter.toByteArray());
+        register(function.cls.internalName, ifaceWriter.toByteArray());
     }
 	
-	private void createRangeClass(ITypeID baseType, JavaClass cls) {
+	private void createRangeClass(JavaSynthesizedRange range) {
 		ClassWriter rangeWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
-		rangeWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, cls.internalName, null, "java/lang/Object", null);
-		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "from", getDescriptor(baseType), null, null).visitEnd();
-		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(baseType), null, null).visitEnd();
+		rangeWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, range.cls.internalName, null, "java/lang/Object", null);
+		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "from", getDescriptor(range.baseType), null, null).visitEnd();
+		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(range.baseType), null, null).visitEnd();
 		
-		JavaMethod method = JavaMethod.getConstructor(cls, "(" + getDescriptor(baseType) + getDescriptor(baseType) + ")V", Opcodes.ACC_PUBLIC);
+		JavaMethod method = JavaMethod.getConstructor(range.cls, "(" + getDescriptor(range.baseType) + getDescriptor(range.baseType) + ")V", Opcodes.ACC_PUBLIC);
 		JavaWriter constructorWriter = new JavaWriter(rangeWriter, method, null, method.descriptor, null);
 		constructorWriter.loadObject(0);
 		constructorWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
 		constructorWriter.loadObject(0);
-		constructorWriter.load(getType(baseType), 1);
-		constructorWriter.putField(cls.internalName, "from", getDescriptor(baseType));
+		constructorWriter.load(getType(range.baseType), 1);
+		constructorWriter.putField(range.cls.internalName, "from", getDescriptor(range.baseType));
 		constructorWriter.loadObject(0);
-		constructorWriter.load(getType(baseType), 2);
-		constructorWriter.putField(cls.internalName, "to", getDescriptor(baseType));
+		constructorWriter.load(getType(range.baseType), 2);
+		constructorWriter.putField(range.cls.internalName, "to", getDescriptor(range.baseType));
 		constructorWriter.ret();
 		constructorWriter.end();
 		
 		rangeWriter.visitEnd();
 		
-		register(cls.internalName, rangeWriter.toByteArray());
+		register(range.cls.internalName, rangeWriter.toByteArray());
 	}
 
     public String getLambdaCounter() {
@@ -138,13 +110,13 @@ public class JavaBytecodeContext extends JavaContext {
 	private class TypeGenerator implements JavaSyntheticClassGenerator {
 
 		@Override
-		public JavaSynthesizedClass synthesizeFunction(FunctionTypeID type) {
-			return getLambdaInterface(type);
+		public void synthesizeFunction(JavaSynthesizedFunction function) {
+			createLambdaInterface(function);
 		}
 
 		@Override
-		public JavaSynthesizedClass synthesizeRange(RangeTypeID type) {
-			return getRangeType(type);
+		public void synthesizeRange(JavaSynthesizedRange range) {
+			createRangeClass(range);
 		}
 	}
 }

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeJarTarget.java

@@ -28,7 +28,7 @@ public class JavaBytecodeJarTarget implements Target {
 
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
-		return new JavaCompiler(debugCompiler, file);
+		return new JavaCompiler(module.compilationUnit.globalTypeRegistry, debugCompiler, file);
 	}
 
 	@Override

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaBytecodeRunTarget.java

@@ -25,7 +25,7 @@ public class JavaBytecodeRunTarget implements Target {
 
 	@Override
 	public JavaCompiler createCompiler(SemanticModule module) {
-		return new JavaCompiler(debugCompiler, null);
+		return new JavaCompiler(module.compilationUnit.globalTypeRegistry, debugCompiler, null);
 	}
 
 	@Override

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

@@ -25,6 +25,7 @@ import org.openzen.zenscript.javabytecode.compiler.definitions.JavaDefinitionVis
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
@@ -45,14 +46,14 @@ public class JavaCompiler implements ZenCodeCompiler {
 	private final List<HighLevelDefinition> definitions = new ArrayList<>();
 	private final List<ScriptBlock> scripts = new ArrayList<>();
 	
-	public JavaCompiler(File jarFile) {
-		this(false, jarFile);
+	public JavaCompiler(GlobalTypeRegistry registry, File jarFile) {
+		this(registry, false, jarFile);
 	}
 
-	public JavaCompiler(boolean debug, File jarFile) {
+	public JavaCompiler(GlobalTypeRegistry registry, boolean debug, File jarFile) {
 		target = new JavaModule(new File("classes"));
 		this.jarFile = jarFile;
-		this.context = new JavaBytecodeContext(target);
+		this.context = new JavaBytecodeContext(registry, target);
 		
 		scriptsClassWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 		scriptsClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Scripts", null, "java/lang/Object", null);

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java

@@ -27,7 +27,6 @@ import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaSynthesizedClass;
-import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
@@ -1648,6 +1647,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
             return null;
         }
         final String signature = context.getMethodSignature(expression.header);
+		final String signature2 = context.getMethodDescriptor(expression.header);
 		final String name = context.getLambdaCounter();
 
 		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", signature);
@@ -1990,13 +1990,13 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 				break;
 			case RANGE_FROM: {
 				RangeTypeID type = (RangeTypeID)expression.target.type;
-				JavaClass cls = context.getTypeGenerator().synthesizeRange(type).cls;
+				JavaClass cls = context.getRange(type).cls;
 				javaWriter.getField(cls.internalName, "from", context.getDescriptor(type.baseType));
 				break;
 			}
 			case RANGE_TO:
 				RangeTypeID type = (RangeTypeID)expression.target.type;
-				JavaClass cls = context.getTypeGenerator().synthesizeRange(type).cls;
+				JavaClass cls = context.getRange(type).cls;
 				javaWriter.getField(cls.internalName, "to", context.getDescriptor(type.baseType));
 				break;
 		}
@@ -2197,7 +2197,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
     @Override
     public Void visitRange(RangeExpression expression) {
 		RangeTypeID type = (RangeTypeID)expression.type;
-		JavaSynthesizedClass cls = context.getTypeGenerator().synthesizeRange(type);
+		JavaSynthesizedClass cls = context.getRange(type);
 		javaWriter.newObject(cls.cls.internalName);
 		javaWriter.dup();
 		expression.from.accept(this);

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaContext.java

@@ -5,15 +5,71 @@
  */
 package org.openzen.zenscript.javashared;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public abstract class JavaContext {
+	private final GlobalTypeRegistry registry;
+	private final Map<String, JavaSynthesizedFunction> functions = new HashMap<>();
+	private final Map<String, JavaSynthesizedRange> ranges = new HashMap<>();
+	
+	public JavaContext(GlobalTypeRegistry registry) {
+		this.registry = registry;
+		
+		{
+			TypeParameter t = new TypeParameter(CodePosition.BUILTIN, "T");
+			TypeParameter u = new TypeParameter(CodePosition.BUILTIN, "U");
+			TypeParameter v = new TypeParameter(CodePosition.BUILTIN, "V");
+			
+			functions.put("TToU", new JavaSynthesizedFunction(
+					new JavaClass("java.util.function", "Function", JavaClass.Kind.INTERFACE),
+					new TypeParameter[] { t, u },
+					new FunctionHeader(registry.getGeneric(u), registry.getGeneric(t)),
+					"apply"));
+			
+			functions.put("TUToV", new JavaSynthesizedFunction(
+					new JavaClass("java.util.function", "BiFunction", JavaClass.Kind.INTERFACE),
+					new TypeParameter[] { t, u, v },
+					new FunctionHeader(registry.getGeneric(v), registry.getGeneric(t), registry.getGeneric(u)),
+					"apply"));
+			
+			functions.put("TToVoid", new JavaSynthesizedFunction(
+					new JavaClass("java.util.function", "Consumer", JavaClass.Kind.INTERFACE),
+					new TypeParameter[] { t },
+					new FunctionHeader(BasicTypeID.VOID, registry.getGeneric(t)),
+					"accept"));
+			
+			functions.put("TUToVoid", new JavaSynthesizedFunction(
+					new JavaClass("java.util.function", "BiConsumer", JavaClass.Kind.INTERFACE),
+					new TypeParameter[] { t, u },
+					new FunctionHeader(BasicTypeID.VOID, registry.getGeneric(t), registry.getGeneric(u)),
+					"accept"));
+			
+			functions.put("TToBool", new JavaSynthesizedFunction(
+					new JavaClass("java.util.function", "Predicate", JavaClass.Kind.INTERFACE),
+					new TypeParameter[] { t },
+					new FunctionHeader(BasicTypeID.BOOL, registry.getGeneric(t)),
+					"test"));
+		}
+	}
+	
+	protected abstract JavaSyntheticClassGenerator getTypeGenerator();
+			
 	public abstract String getDescriptor(ITypeID type);
 	
 	public String getMethodDescriptor(FunctionHeader header) {
@@ -33,6 +89,114 @@ public abstract class JavaContext {
 		return getMethodDescriptor(header, true);
 	}
 	
+	public JavaSynthesizedFunctionInstance getFunction(FunctionTypeID type) {
+		String id = getFunctionId(type.header);
+		JavaSynthesizedFunction function;
+		if (!functions.containsKey(id)) {
+			JavaClass cls = new JavaClass("zsynthetic", "Function" + id, JavaClass.Kind.INTERFACE);
+			List<TypeParameter> typeParameters = new ArrayList<>();
+			List<FunctionParameter> parameters = new ArrayList<>();
+			for (FunctionParameter parameter : type.header.parameters) {
+				JavaTypeInfo typeInfo = JavaTypeInfo.get(parameter.type);
+				if (typeInfo.primitive) {
+					parameters.add(new FunctionParameter(parameter.type, Character.toString((char)('a' + parameters.size()))));
+				} else {
+					TypeParameter typeParameter = new TypeParameter(CodePosition.BUILTIN, getTypeParameter(typeParameters.size()));
+					typeParameters.add(typeParameter);
+					parameters.add(new FunctionParameter(registry.getGeneric(typeParameter), Character.toString((char)('a' + parameters.size()))));
+				}
+			}
+			ITypeID returnType;
+			{
+				JavaTypeInfo typeInfo = JavaTypeInfo.get(type.header.getReturnType());
+				if (typeInfo.primitive) {
+					returnType = type.header.getReturnType();
+				} else {
+					TypeParameter typeParameter = new TypeParameter(CodePosition.BUILTIN, getTypeParameter(typeParameters.size()));
+					typeParameters.add(typeParameter);
+					returnType = registry.getGeneric(typeParameter);
+				}
+			}
+			function = new JavaSynthesizedFunction(
+					cls,
+					typeParameters.toArray(new TypeParameter[typeParameters.size()]),
+					new FunctionHeader(returnType, parameters.toArray(new FunctionParameter[parameters.size()])),
+					"invoke");
+			
+			functions.put(id, function);
+			getTypeGenerator().synthesizeFunction(function);
+		} else {
+			function = functions.get(id);
+		}
+		
+		List<ITypeID> typeArguments = new ArrayList<>();
+		for (FunctionParameter parameter : type.header.parameters) {
+			JavaTypeInfo typeInfo = JavaTypeInfo.get(parameter.type);
+			if (!typeInfo.primitive) {
+				typeArguments.add(parameter.type);
+			}
+		}
+		if (!JavaTypeInfo.isPrimitive(type.header.getReturnType()))
+			typeArguments.add(type.header.getReturnType());
+		
+		return new JavaSynthesizedFunctionInstance(function, typeArguments.toArray(new ITypeID[typeArguments.size()]));
+	}
+	
+	private String getFunctionId(FunctionHeader header) {
+		StringBuilder signature = new StringBuilder();
+		int typeParameterIndex = 0;
+		for (FunctionParameter parameter : header.parameters) {
+			JavaTypeInfo typeInfo = JavaTypeInfo.get(parameter.type);
+			String id = typeInfo.primitive ? parameter.type.accept(new JavaSyntheticTypeSignatureConverter()) : getTypeParameter(typeParameterIndex++);
+			signature.append(id);
+		}
+		signature.append("To");
+		{
+			JavaTypeInfo typeInfo = JavaTypeInfo.get(header.getReturnType());
+			String id = typeInfo.primitive ? header.getReturnType().accept(new JavaSyntheticTypeSignatureConverter()) : getTypeParameter(typeParameterIndex++);
+			signature.append(id);
+		}
+		return signature.toString();
+	}
+	
+	private String getTypeParameter(int index) {
+	switch (index) {
+			case 0: return "T";
+			case 1: return "U";
+			case 2: return "V";
+			case 3: return "W";
+			case 4: return "X";
+			case 5: return "Y";
+			case 6: return "Z";
+			default: return "T" + index;
+		}
+	}
+	
+	public JavaSynthesizedClass getRange(RangeTypeID type) {
+		JavaTypeInfo typeInfo = JavaTypeInfo.get(type.baseType);
+		String id = typeInfo.primitive ? type.accept(new JavaSyntheticTypeSignatureConverter()) : "T";
+		JavaSynthesizedRange range;
+		if (!ranges.containsKey(id)) {
+			JavaClass cls = new JavaClass("zsynthetic", id + "Range", JavaClass.Kind.CLASS);
+			if (typeInfo.primitive) {
+				range = new JavaSynthesizedRange(cls, TypeParameter.NONE, type.baseType);
+			} else {
+				TypeParameter typeParameter = new TypeParameter(CodePosition.BUILTIN, "T");
+				range = new JavaSynthesizedRange(cls, new TypeParameter[] { typeParameter }, registry.getGeneric(typeParameter));
+			}
+			ranges.put(id, range);
+			getTypeGenerator().synthesizeRange(range);
+		} else {
+			range = ranges.get(id);
+		}
+		
+		if (typeInfo.primitive) {
+			return new JavaSynthesizedClass(range.cls, ITypeID.NONE);
+		} else {
+			return new JavaSynthesizedClass(range.cls, new ITypeID[] { type.baseType });
+		}
+	}
+	
 	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor) {
         StringBuilder descBuilder = new StringBuilder("(");
         if (isEnumConstructor)

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSynthesizedClass.java

@@ -5,7 +5,7 @@
  */
 package org.openzen.zenscript.javashared;
 
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
  *
@@ -13,14 +13,10 @@ import org.openzen.zenscript.codemodel.generic.TypeParameter;
  */
 public class JavaSynthesizedClass {
 	public final JavaClass cls;
-	public final TypeParameter[] typeParameters;
+	public final ITypeID[] typeArguments;
 	
-	public JavaSynthesizedClass(JavaClass cls, TypeParameter[] typeParameters) {
+	public JavaSynthesizedClass(JavaClass cls, ITypeID[] typeArguments) {
 		this.cls = cls;
-		this.typeParameters = typeParameters;
-	}
-
-	public JavaSynthesizedClass withTypeParameters(TypeParameter[] typeParameters) {
-		return new JavaSynthesizedClass(cls, typeParameters);
+		this.typeArguments = typeArguments;
 	}
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSynthesizedClassNamer.java

@@ -1,49 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.javashared;
-
-import java.util.ArrayList;
-import java.util.List;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.RangeTypeID;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaSynthesizedClassNamer {
-	private JavaSynthesizedClassNamer() {}
-	
-	public static JavaSynthesizedClass createFunctionName(FunctionTypeID function) {
-		String signature = getFunctionSignature(function);
-		
-		String className = "Function" + signature;
-		JavaClass cls = new JavaClass("zsynthetic", className, JavaClass.Kind.INTERFACE);
-		return new JavaSynthesizedClass(cls, extractTypeParameters(function));
-	}
-	
-	public static JavaSynthesizedClass createRangeName(RangeTypeID range) {
-		String signature = getRangeSignature(range);
-		JavaClass cls = new JavaClass("zsynthetic", signature, JavaClass.Kind.CLASS);
-		return new JavaSynthesizedClass(cls, extractTypeParameters(range));
-	}
-	
-	public static TypeParameter[] extractTypeParameters(ITypeID type) {
-		List<TypeParameter> result = new ArrayList<>();
-		type.extractTypeParameters(result);
-		return result.toArray(new TypeParameter[result.size()]);
-	}
-	
-	public static String getFunctionSignature(FunctionTypeID type) {
-		return new JavaSyntheticTypeSignatureConverter().visitFunction(type);
-	}
-	
-	public static String getRangeSignature(RangeTypeID type) {
-		return new JavaSyntheticTypeSignatureConverter().visitRange(type);
-	}
-}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSynthesizedFunction.java

@@ -0,0 +1,27 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSynthesizedFunction {
+	public final JavaClass cls;
+	public final TypeParameter[] typeParameters;
+	public final FunctionHeader header;
+	public final String method;
+	
+	public JavaSynthesizedFunction(JavaClass cls, TypeParameter[] parameters, FunctionHeader header, String method) {
+		this.cls = cls;
+		this.typeParameters = parameters;
+		this.header = header;
+		this.method = method;
+	}
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSynthesizedFunctionInstance.java

@@ -0,0 +1,30 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSynthesizedFunctionInstance {
+	private final JavaSynthesizedFunction function;
+	public final ITypeID[] typeArguments;
+	
+	public JavaSynthesizedFunctionInstance(JavaSynthesizedFunction function, ITypeID[] typeArguments) {
+		this.function = function;
+		this.typeArguments = typeArguments;
+	}
+	
+	public JavaClass getCls() {
+		return function.cls;
+	}
+	
+	public String getMethod() {
+		return function.method;
+	}
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSynthesizedRange.java

@@ -0,0 +1,25 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSynthesizedRange {
+	public final JavaClass cls;
+	public final TypeParameter[] typeParameters;
+	public final ITypeID baseType;
+	
+	public JavaSynthesizedRange(JavaClass cls, TypeParameter[] typeParameters, ITypeID baseType) {
+		this.cls = cls;
+		this.typeParameters = typeParameters;
+		this.baseType = baseType;
+	}
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSyntheticClassGenerator.java

@@ -5,15 +5,12 @@
  */
 package org.openzen.zenscript.javashared;
 
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
-import org.openzen.zenscript.codemodel.type.RangeTypeID;
-
 /**
  *
  * @author Hoofdgebruiker
  */
 public interface JavaSyntheticClassGenerator {
-	JavaSynthesizedClass synthesizeFunction(FunctionTypeID type);
+	void synthesizeFunction(JavaSynthesizedFunction function);
 	
-	JavaSynthesizedClass synthesizeRange(RangeTypeID type);
+	void synthesizeRange(JavaSynthesizedRange range);
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaTypeDescriptorVisitor.java

@@ -6,17 +6,17 @@ import org.openzen.zenscript.codemodel.type.*;
 
 public class JavaTypeDescriptorVisitor implements ITypeVisitor<String> {
 	private final JavaTypeDescriptorVisitor forOptional;
-	private final JavaSyntheticClassGenerator generator;
+	private final JavaContext context;
 	private final boolean optional;
 	
-	public JavaTypeDescriptorVisitor(JavaSyntheticClassGenerator generator) {
-		this(generator, false);
+	public JavaTypeDescriptorVisitor(JavaContext context) {
+		this(context, false);
 	}
 	
-	private JavaTypeDescriptorVisitor(JavaSyntheticClassGenerator generator, boolean optional) {
+	private JavaTypeDescriptorVisitor(JavaContext context, boolean optional) {
 		this.optional = optional;
-		this.generator = generator;
-		forOptional = optional ? this : new JavaTypeDescriptorVisitor(generator, true);
+		this.context = context;
+		forOptional = optional ? this : new JavaTypeDescriptorVisitor(context, true);
 	}
 	
     @Override
@@ -85,7 +85,7 @@ public class JavaTypeDescriptorVisitor implements ITypeVisitor<String> {
 
     @Override
     public String visitFunction(FunctionTypeID function) {
-        return "L" + generator.synthesizeFunction(function).cls.internalName + ";";
+        return "L" + context.getFunction(function).getCls().internalName + ";";
     }
 
     @Override
@@ -110,7 +110,7 @@ public class JavaTypeDescriptorVisitor implements ITypeVisitor<String> {
 
     @Override
     public String visitRange(RangeTypeID range) {
-		return "L" + generator.synthesizeRange(range).cls.internalName + ";";
+		return "L" + context.getRange(range).cls.internalName + ";";
     }
 
     @Override

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaTypeInfo.java

@@ -0,0 +1,102 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.type.ArrayTypeID;
+import org.openzen.zenscript.codemodel.type.AssocTypeID;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.ITypeVisitor;
+import org.openzen.zenscript.codemodel.type.IteratorTypeID;
+import org.openzen.zenscript.codemodel.type.ModifiedTypeID;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaTypeInfo {
+	private static final JavaTypeInfo PRIMITIVE = new JavaTypeInfo(true);
+	private static final JavaTypeInfo OBJECT = new JavaTypeInfo(false);
+	private static final JavaTypeInfoVisitor VISITOR = new JavaTypeInfoVisitor();
+	
+	public static JavaTypeInfo get(ITypeID type) {
+		return type.accept(VISITOR);
+	}
+	
+	public static boolean isPrimitive(ITypeID type) {
+		return type.accept(VISITOR).primitive;
+	}
+	
+	public final boolean primitive;
+	
+	private JavaTypeInfo(boolean primitive) {
+		this.primitive = primitive;
+	}
+	
+	private static class JavaTypeInfoVisitor implements ITypeVisitor<JavaTypeInfo> {
+
+		@Override
+		public JavaTypeInfo visitBasic(BasicTypeID basic) {
+			switch (basic) {
+				case STRING:
+				case NULL:
+					return OBJECT;
+				default:
+					return PRIMITIVE;
+			}
+		}
+
+		@Override
+		public JavaTypeInfo visitArray(ArrayTypeID array) {
+			return OBJECT;
+		}
+
+		@Override
+		public JavaTypeInfo visitAssoc(AssocTypeID assoc) {
+			return OBJECT;
+		}
+
+		@Override
+		public JavaTypeInfo visitGenericMap(GenericMapTypeID map) {
+			return OBJECT;
+		}
+
+		@Override
+		public JavaTypeInfo visitIterator(IteratorTypeID iterator) {
+			return OBJECT;
+		}
+
+		@Override
+		public JavaTypeInfo visitFunction(FunctionTypeID function) {
+			return OBJECT;
+		}
+
+		@Override
+		public JavaTypeInfo visitDefinition(DefinitionTypeID definition) {
+			return OBJECT;
+		}
+
+		@Override
+		public JavaTypeInfo visitGeneric(GenericTypeID generic) {
+			return OBJECT;
+		}
+
+		@Override
+		public JavaTypeInfo visitRange(RangeTypeID range) {
+			return OBJECT;
+		}
+
+		@Override
+		public JavaTypeInfo visitModified(ModifiedTypeID type) {
+			return type.baseType.accept(this);
+		}
+	}
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaTypeInternalNameVisitor.java

@@ -6,17 +6,17 @@ import org.openzen.zenscript.codemodel.type.*;
 
 public class JavaTypeInternalNameVisitor implements ITypeVisitor<String> {
 	private final JavaTypeInternalNameVisitor forOptional;
-	private final JavaSyntheticClassGenerator generator;
+	private final JavaContext context;
 	private final boolean optional;
 	
-	public JavaTypeInternalNameVisitor(JavaSyntheticClassGenerator generator) {
-		this(generator, false);
+	public JavaTypeInternalNameVisitor(JavaContext context) {
+		this(context, false);
 	}
 	
-	private JavaTypeInternalNameVisitor(JavaSyntheticClassGenerator generator, boolean optional) {
+	private JavaTypeInternalNameVisitor(JavaContext context, boolean optional) {
 		this.optional = optional;
-		this.generator = generator;
-		forOptional = optional ? this : new JavaTypeInternalNameVisitor(generator, true);
+		this.context = context;
+		forOptional = optional ? this : new JavaTypeInternalNameVisitor(context, true);
 	}
 	
     @Override
@@ -80,7 +80,7 @@ public class JavaTypeInternalNameVisitor implements ITypeVisitor<String> {
 
     @Override
     public String visitFunction(FunctionTypeID function) {
-        return generator.synthesizeFunction(function).cls.internalName;
+        return context.getFunction(function).getCls().internalName;
     }
 
     @Override
@@ -101,7 +101,7 @@ public class JavaTypeInternalNameVisitor implements ITypeVisitor<String> {
 
     @Override
     public String visitRange(RangeTypeID range) {
-		return generator.synthesizeRange(range).cls.internalName;
+		return context.getRange(range).cls.internalName;
     }
 
     @Override

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDefinitionVisitor.java

@@ -76,7 +76,7 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<Void> {
 		DefinitionTypeID thisType = typeRegistry.getForMyDefinition(definition);
 		
 		CompileScope scope = new CompileScope(module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations);
-		return new JavaSourceFileScope(file.importer, compiler.typeGenerator, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition, thisType);
+		return new JavaSourceFileScope(file.importer, compiler.helperGenerator, cls, scope, definition instanceof InterfaceDefinition, thisType, compiler.context);
 	}
 
 	@Override

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceCompiler.java

@@ -5,7 +5,6 @@
  */
 package org.openzen.zenscript.javasource;
 
-import org.openzen.zenscript.javashared.JavaContext;
 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
@@ -25,22 +24,18 @@ import org.openzen.zenscript.javashared.JavaClass;
  */
 public class JavaSourceCompiler implements ZenCodeCompiler {
 	public final JavaSourceFormattingSettings settings;
-	public final JavaSourceSyntheticTypeGenerator typeGenerator;
 	public final JavaSourceSyntheticHelperGenerator helperGenerator;
 	
 	private final File directory;
 	private final Map<File, JavaSourceFile> sourceFiles = new HashMap<>();
-	
-	private final Map<String, Integer> classNameCounters = new HashMap<>();
+	public final JavaSourceContext context;
 	
 	public JavaSourceCompiler(File directory, CompilationUnit compilationUnit) {
 		if (!directory.exists())
 			directory.mkdirs();
 		
 		settings = new JavaSourceFormattingSettings.Builder().build();
-		typeGenerator = new JavaSourceSyntheticTypeGenerator(directory, settings);
-		
-		JavaSourceContext context = new JavaSourceContext(typeGenerator);
+		context = new JavaSourceContext(compilationUnit.globalTypeRegistry, directory, settings);
 		helperGenerator = new JavaSourceSyntheticHelperGenerator(context, directory, settings);
 		
 		this.directory = directory;
@@ -68,7 +63,6 @@ public class JavaSourceCompiler implements ZenCodeCompiler {
 	
 	@Override
 	public void finish() {
-		JavaSourceContext context = new JavaSourceContext(typeGenerator);
 		for (JavaSourceFile sourceFile : sourceFiles.values()) {
 			sourceFile.prepare(context);
 		}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceContext.java

@@ -5,6 +5,8 @@
  */
 package org.openzen.zenscript.javasource;
 
+import java.io.File;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
@@ -16,13 +18,22 @@ import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
  */
 public class JavaSourceContext extends JavaContext {
 	private final JavaTypeDescriptorVisitor typeDescriptorVisitor;
+	private final JavaSyntheticClassGenerator generator;
 	
-	public JavaSourceContext(JavaSyntheticClassGenerator generator) {
-		typeDescriptorVisitor = new JavaTypeDescriptorVisitor(generator);
+	public JavaSourceContext(GlobalTypeRegistry registry, File directory, JavaSourceFormattingSettings settings) {
+		super(registry);
+		
+		typeDescriptorVisitor = new JavaTypeDescriptorVisitor(this);
+		this.generator = new JavaSourceSyntheticTypeGenerator(directory, settings, this);
 	}
 	
 	@Override
 	public String getDescriptor(ITypeID type) {
 		return type.accept(typeDescriptorVisitor);
 	}
+
+	@Override
+	protected JavaSyntheticClassGenerator getTypeGenerator() {
+		return generator;
+	}
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceExpressionFormatter.java

@@ -87,6 +87,7 @@ import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
@@ -98,6 +99,7 @@ import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaNativeTranslator;
 import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaSynthesizedFunctionInstance;
 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 /**
@@ -1196,8 +1198,9 @@ public class JavaSourceExpressionFormatter implements ExpressionVisitor<Expressi
 			case ARRAY_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
 			case FUNCTION_CALL: {
 				StringBuilder output = new StringBuilder();
+				JavaSynthesizedFunctionInstance function = scope.context.getFunction((FunctionTypeID)call.target.type);
 				output.append(call.target.accept(this).value);
-				output.append(".invoke(");
+				output.append(".").append(function.getMethod()).append("(");
 				int i = 0;
 				for (Expression argument : call.arguments.arguments) {
 					if (i > 0)
@@ -1702,6 +1705,7 @@ public class JavaSourceExpressionFormatter implements ExpressionVisitor<Expressi
 							throw new UnsupportedOperationException("Not yet supported!");
 						}
 					} else {
+						JavaSynthesizedFunctionInstance function = scope.context.getFunction((FunctionTypeID)lambda.type);
 						target.writeLine(new StringBuilder()
 								.append(scope.settings.indent)
 								.append(temp)
@@ -1709,7 +1713,7 @@ public class JavaSourceExpressionFormatter implements ExpressionVisitor<Expressi
 								.append(tempI.name)
 								.append("] = ")
 								.append(lambdaString.value)
-								.append(".invoke(")
+								.append(".").append(function.getMethod()).append("(")
 								.append(tempI.name)
 								.append(");")
 								.toString());
@@ -1776,6 +1780,7 @@ public class JavaSourceExpressionFormatter implements ExpressionVisitor<Expressi
 							throw new UnsupportedOperationException("Not yet supported!");
 						}
 					} else {
+						JavaSynthesizedFunctionInstance function = scope.context.getFunction((FunctionTypeID)lambda.type);
 						target.writeLine(new StringBuilder()
 								.append(scope.settings.indent)
 								.append(temp)
@@ -1783,7 +1788,7 @@ public class JavaSourceExpressionFormatter implements ExpressionVisitor<Expressi
 								.append(tempI.name)
 								.append("] = ")
 								.append(lambdaString.value)
-								.append(".invoke(")
+								.append(".").append(function.getMethod()).append("(")
 								.append(originalString.value)
 								.append("[")
 								.append(tempI.name)
@@ -1854,6 +1859,7 @@ public class JavaSourceExpressionFormatter implements ExpressionVisitor<Expressi
 							throw new UnsupportedOperationException("Not yet supported!");
 						}
 					} else {
+						JavaSynthesizedFunctionInstance function = scope.context.getFunction((FunctionTypeID)lambda.type);
 						target.writeLine(new StringBuilder()
 								.append(scope.settings.indent)
 								.append(temp)
@@ -1861,7 +1867,7 @@ public class JavaSourceExpressionFormatter implements ExpressionVisitor<Expressi
 								.append(tempI.name)
 								.append("] = ")
 								.append(lambdaString.value)
-								.append(".invoke(")
+								.append(".").append(function.getMethod()).append("(")
 								.append(tempI.name)
 								.append(", ")
 								.append(originalString.value)

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceObjectTypeVisitor.java

@@ -12,8 +12,8 @@ import org.openzen.zenscript.codemodel.type.BasicTypeID;
  * @author Hoofdgebruiker
  */
 public class JavaSourceObjectTypeVisitor extends JavaSourceTypeVisitor {
-	public JavaSourceObjectTypeVisitor(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator) {
-		super(importer, typeGenerator);
+	public JavaSourceObjectTypeVisitor(JavaSourceImporter importer, JavaSourceContext context) {
+		super(importer, context);
 	}
 	
 	@Override

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceSyntheticTypeGenerator.java

@@ -5,7 +5,6 @@
  */
 package org.openzen.zenscript.javasource;
 
-import org.openzen.zenscript.javashared.JavaSynthesizedClass;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
@@ -13,13 +12,10 @@ import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
-import java.util.HashMap;
-import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionParameter;
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
-import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
+import org.openzen.zenscript.javashared.JavaSynthesizedFunction;
+import org.openzen.zenscript.javashared.JavaSynthesizedRange;
 import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
 
 /**
@@ -27,42 +23,28 @@ import org.openzen.zenscript.javashared.JavaSyntheticClassGenerator;
  * @author Hoofdgebruiker
  */
 public class JavaSourceSyntheticTypeGenerator implements JavaSyntheticClassGenerator {
-	private final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
-	private final Map<String, JavaSynthesizedClass> ranges = new HashMap<>();
 	private final File directory;
 	private final JavaSourceFormattingSettings settings;
+	private final JavaSourceContext context;
 	
-	public JavaSourceSyntheticTypeGenerator(File directory, JavaSourceFormattingSettings settings) {
+	public JavaSourceSyntheticTypeGenerator(File directory, JavaSourceFormattingSettings settings, JavaSourceContext context) {
 		this.directory = new File(directory, "zsynthetic");
 		this.settings = settings;
+		this.context = context;
 	}
 	
 	@Override
-	public JavaSynthesizedClass synthesizeFunction(FunctionTypeID function) {
-		String signature = JavaSynthesizedClassNamer.getFunctionSignature(function);
-		if (functions.containsKey(signature))
-			return functions.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(function));
-		
-		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createFunctionName(function);
-		functions.put(signature, result);
-		
-		JavaSourceImporter importer = new JavaSourceImporter(result.cls);
-		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, this);
+	public void synthesizeFunction(JavaSynthesizedFunction function) {
+		JavaSourceImporter importer = new JavaSourceImporter(function.cls);
+		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, context);
 		
 		StringBuilder contents = new StringBuilder();
 		contents.append("@FunctionalInterface\n");
 		contents.append("public interface ");
-		contents.append(result.cls.getName());
-		JavaSourceUtils.formatTypeParameters(typeVisitor, contents, result.typeParameters, false);
+		contents.append(function.cls.getName());
+		JavaSourceUtils.formatTypeParameters(typeVisitor, contents, function.typeParameters, false);
 		contents.append(" {\n");
 		contents.append(settings.indent);
-		if (function.header.getNumberOfTypeParameters() > 0) {
-			contents.append('<');
-			for (int i = 0; i < function.header.getNumberOfTypeParameters(); i++) {
-				
-			}
-			contents.append("> ");
-		}
 		contents.append(function.header.getReturnType().accept(typeVisitor));
 		contents.append(' ');
 		contents.append("invoke(");
@@ -82,49 +64,40 @@ public class JavaSourceSyntheticTypeGenerator implements JavaSyntheticClassGener
 		contents.append(");\n");
 		contents.append("}\n");
 		
-		writeFile(result, importer, contents);
-		return result;
+		writeFile(function.cls, importer, contents);
 	}
 	
 	@Override
-	public JavaSynthesizedClass synthesizeRange(RangeTypeID type) {
-		String signature = JavaSynthesizedClassNamer.getRangeSignature(type);
-		if (ranges.containsKey(signature))
-			return ranges.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(type));
-		
-		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createRangeName(type);
-		functions.put(signature, result);
-		
-		JavaSourceImporter importer = new JavaSourceImporter(result.cls);
-		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, this);
+	public void synthesizeRange(JavaSynthesizedRange range) {
+		JavaSourceImporter importer = new JavaSourceImporter(range.cls);
+		JavaSourceTypeVisitor typeVisitor = new JavaSourceTypeVisitor(importer, context);
 		
 		StringBuilder contents = new StringBuilder();
-		contents.append("public final class ").append(result.cls.getName()).append(" {\n");
-		contents.append(settings.indent).append("public final ").append(type.baseType.accept(typeVisitor)).append(" from;\n");
-		contents.append(settings.indent).append("public final ").append(type.baseType.accept(typeVisitor)).append(" to;\n");
+		contents.append("public final class ").append(range.cls.getName()).append(" {\n");
+		contents.append(settings.indent).append("public final ").append(range.baseType.accept(typeVisitor)).append(" from;\n");
+		contents.append(settings.indent).append("public final ").append(range.baseType.accept(typeVisitor)).append(" to;\n");
 		contents.append(settings.indent).append("\n");
 		contents.append(settings.indent)
 				.append("public ")
-				.append(result.cls.getName())
+				.append(range.cls.getName())
 				.append("(")
-				.append(type.baseType.accept(typeVisitor))
+				.append(range.baseType.accept(typeVisitor))
 				.append(" from, ")
-				.append(type.baseType.accept(typeVisitor))
+				.append(range.baseType.accept(typeVisitor))
 				.append(" to) {\n");
 		contents.append(settings.indent).append(settings.indent).append("this.from = from;\n");
 		contents.append(settings.indent).append(settings.indent).append("this.to = to;\n");
 		contents.append(settings.indent).append("}\n");
 		contents.append("}\n");
 		
-		writeFile(result, importer, contents);
-		return result;
+		writeFile(range.cls, importer, contents);
 	}
 	
-	private void writeFile(JavaSynthesizedClass result, JavaSourceImporter importer, StringBuilder contents) {
+	private void writeFile(JavaClass cls, JavaSourceImporter importer, StringBuilder contents) {
 		if (!directory.exists())
 			directory.mkdirs();
 		
-		File file = new File(directory, result.cls.getName() + ".java");
+		File file = new File(directory, cls.getName() + ".java");
 		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file)), StandardCharsets.UTF_8)) {
 			writer.write("package zsynthetic;\n");
 			

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceTypeVisitor.java

@@ -21,6 +21,7 @@ import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaSynthesizedFunctionInstance;
 
 /**
  *
@@ -28,23 +29,23 @@ import org.openzen.zenscript.javashared.JavaClass;
  */
 public class JavaSourceTypeVisitor implements ITypeVisitor<String>, GenericParameterBoundVisitor<String> {
 	public final JavaSourceImporter importer;
-	public final JavaSourceSyntheticTypeGenerator typeGenerator;
+	public final JavaSourceContext context;
 	public final JavaSourceObjectTypeVisitor objectTypeVisitor;
 	public final JavaClass cls;
 	
-	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator) {
-		this(importer, typeGenerator, null);
+	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceContext context) {
+		this(importer, context, null);
 	}
 	
-	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator, JavaClass cls) {
+	public JavaSourceTypeVisitor(JavaSourceImporter importer, JavaSourceContext context, JavaClass cls) {
 		this.importer = importer;
-		this.typeGenerator = typeGenerator;
+		this.context = context;
 		this.cls = cls;
 		
 		if (this instanceof JavaSourceObjectTypeVisitor) {
 			objectTypeVisitor = (JavaSourceObjectTypeVisitor)this;
 		} else {
-			objectTypeVisitor = new JavaSourceObjectTypeVisitor(importer, typeGenerator);
+			objectTypeVisitor = new JavaSourceObjectTypeVisitor(importer, context);
 		}
 	}
 
@@ -92,7 +93,7 @@ public class JavaSourceTypeVisitor implements ITypeVisitor<String>, GenericParam
 	@Override
 	public String visitAssoc(AssocTypeID assoc) {
 		String map = importer.importType(JavaClass.MAP);
-		return map + "<" + assoc.keyType.accept(new JavaSourceObjectTypeVisitor(importer, typeGenerator)) + ", " + assoc.valueType.accept(new JavaSourceObjectTypeVisitor(importer, typeGenerator)) + ">";
+		return map + "<" + assoc.keyType.accept(new JavaSourceObjectTypeVisitor(importer, context)) + ", " + assoc.valueType.accept(new JavaSourceObjectTypeVisitor(importer, context)) + ">";
 	}
 
 	@Override
@@ -111,16 +112,16 @@ public class JavaSourceTypeVisitor implements ITypeVisitor<String>, GenericParam
 
 	@Override
 	public String visitFunction(FunctionTypeID function) {
-		JavaSynthesizedClass synthetic = typeGenerator.synthesizeFunction(function);
+		JavaSynthesizedFunctionInstance synthetic = context.getFunction(function);
 		StringBuilder result = new StringBuilder();
-		result.append(importer.importType(synthetic.cls));
-		if (synthetic.typeParameters.length > 0) {
+		result.append(importer.importType(synthetic.getCls()));
+		if (synthetic.typeArguments.length > 0) {
 			result.append('<');
-			for (int i = 0; i < synthetic.typeParameters.length; i++) {
+			for (int i = 0; i < synthetic.typeArguments.length; i++) {
 				if (i > 0)
 					result.append(", ");
 				
-				result.append(synthetic.typeParameters[i].name);
+				result.append(synthetic.typeArguments[i].accept(new JavaSourceObjectTypeVisitor(importer, context)));
 			}
 			result.append('>');
 		}
@@ -161,16 +162,16 @@ public class JavaSourceTypeVisitor implements ITypeVisitor<String>, GenericParam
 
 	@Override
 	public String visitRange(RangeTypeID range) {
-		JavaSynthesizedClass synthetic = typeGenerator.synthesizeRange(range);
+		JavaSynthesizedClass synthetic = context.getRange(range);
 		StringBuilder result = new StringBuilder();
 		result.append(importer.importType(synthetic.cls));
-		if (synthetic.typeParameters.length > 0) {
+		if (synthetic.typeArguments.length > 0) {
 			result.append('<');
-			for (int i = 0; i < synthetic.typeParameters.length; i++) {
+			for (int i = 0; i < synthetic.typeArguments.length; i++) {
 				if (i > 0)
 					result.append(", ");
 				
-				result.append(synthetic.typeParameters[i].name);
+				result.append(synthetic.typeArguments[i].accept(new JavaSourceObjectTypeVisitor(importer, context)));
 			}
 			result.append('>');
 		}
@@ -182,7 +183,7 @@ public class JavaSourceTypeVisitor implements ITypeVisitor<String>, GenericParam
 		if (optional.isOptional() && optional.withoutOptional() == BasicTypeID.USIZE)
 			return "int"; // usize? is an int
 		
-		return optional.baseType.accept(new JavaSourceObjectTypeVisitor(importer, typeGenerator));
+		return optional.baseType.accept(new JavaSourceObjectTypeVisitor(importer, context));
 	}
 
 	@Override

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/scope/JavaSourceFileScope.java

@@ -10,9 +10,9 @@ import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javasource.JavaSourceImporter;
 import org.openzen.zenscript.javasource.JavaSourceObjectTypeVisitor;
 import org.openzen.zenscript.javasource.JavaSourceSyntheticHelperGenerator;
-import org.openzen.zenscript.javasource.JavaSourceSyntheticTypeGenerator;
 import org.openzen.zenscript.javasource.JavaSourceTypeVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javasource.JavaSourceContext;
 
 /**
  *
@@ -20,7 +20,6 @@ import org.openzen.zenscript.javashared.JavaClass;
  */
 public class JavaSourceFileScope {
 	public final JavaSourceImporter importer;
-	public final JavaSourceSyntheticTypeGenerator typeGenerator;
 	public final JavaSourceSyntheticHelperGenerator helperGenerator;
 	public final JavaClass cls;
 	public final JavaSourceTypeVisitor typeVisitor;
@@ -28,25 +27,26 @@ public class JavaSourceFileScope {
 	public final TypeScope semanticScope;
 	public final boolean isInterface;
 	public final ITypeID thisType;
+	public final JavaSourceContext context;
 	
 	public JavaSourceFileScope(
 			JavaSourceImporter importer, 
-			JavaSourceSyntheticTypeGenerator typeGenerator,
 			JavaSourceSyntheticHelperGenerator helperGenerator,
 			JavaClass cls,
 			TypeScope semanticScope,
 			boolean isInterface,
-			ITypeID thisType)
+			ITypeID thisType,
+			JavaSourceContext context)
 	{
 		this.importer = importer;
-		this.typeGenerator = typeGenerator;
 		this.helperGenerator = helperGenerator;
 		this.cls = cls;
 		this.semanticScope = semanticScope;
 		this.isInterface = isInterface;
 		this.thisType = thisType;
+		this.context = context;
 		
-		typeVisitor = new JavaSourceTypeVisitor(importer, typeGenerator);
+		typeVisitor = new JavaSourceTypeVisitor(importer, context);
 		objectTypeVisitor = typeVisitor.objectTypeVisitor;
 	}
 	
@@ -55,6 +55,6 @@ public class JavaSourceFileScope {
 	}
 	
 	public String type(ITypeID type, JavaClass rename) {
-		return type.accept(new JavaSourceTypeVisitor(importer, typeGenerator, rename));
+		return type.accept(new JavaSourceTypeVisitor(importer, context, rename));
 	}
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/scope/JavaSourceStatementScope.java

@@ -21,6 +21,7 @@ import org.openzen.zenscript.javasource.JavaSourceFormattingSettings;
 import org.openzen.zenscript.javasource.JavaSourceExpressionFormatter;
 import org.openzen.zenscript.javasource.JavaSourceStatementFormatter;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javasource.JavaSourceContext;
 
 /**
  *
@@ -33,6 +34,7 @@ public class JavaSourceStatementScope {
 	public final LoopStatement innerLoop;
 	public final boolean isExpansion;
 	public final ITypeID thisType;
+	public final JavaSourceContext context;
 	
 	private final JavaSourceStatementScope outer;
 	private final Set<String> localVariables = new HashSet<>();
@@ -53,6 +55,7 @@ public class JavaSourceStatementScope {
 		this.outer = outer;
 		this.isExpansion = isExpansion;
 		this.thisType = fileScope.thisType;
+		this.context = fileScope.context;
 		
 		if (header != null) {
 			for (FunctionParameter parameter : header.parameters)

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

@@ -125,7 +125,7 @@ public class Main {
 	}
 	
 	private static JavaModule compileSemanticToJava(SemanticModule module) {
-		JavaCompiler compiler = new JavaCompiler(false, null);
+		JavaCompiler compiler = new JavaCompiler(module.compilationUnit.globalTypeRegistry, false, null);
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			compiler.addDefinition(definition, module);
 		}