- Fixed ranges, all range types should be supported now

- Cleaned up unused code
- Refactored the JavaMethodInfo class to the shared JavaMethod one
- Use valueOf for boxing instead of the boxed type constructors

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ConstructorMember.java

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.ConcatMap;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+
+	@Override
+	public void normalize(TypeScope scope) {
+		if (definition instanceof EnumDefinition)
+			modifiers |= Modifiers.PRIVATE;
+		
+		super.normalize(scope);
+	}
 }

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/implementations/IntRange.java

-package org.openzen.zenscript.implementations;
-
-public class IntRange {
-	public final int from;
-	public final int to;
-
-
-	public IntRange(int from, int to) {
-		this.from = from;
-		this.to = to;
-	}
-}

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
-import org.openzen.zenscript.javabytecode.compiler.CompilerUtils;
+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.JavaSyntheticClassGenerator;
 import org.openzen.zenscript.javashared.JavaTypeDescriptorVisitor;
 import org.openzen.zenscript.javashared.JavaTypeInternalNameVisitor;
 	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) {
 		this.module = module;
 	public void register(String name, byte[] bytecode) {
 		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.from, type.to, result.cls);
+		return result;
+	}
+
+    private void createLambdaInterface(FunctionHeader header, JavaClass cls) {
+        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
+				.visitMethod(
+					Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT,
+					"accept",
+					getMethodDescriptor(header),
+					getMethodSignature(header),
+					null)
+				.visitEnd();
+
+        register(cls.internalName, ifaceWriter.toByteArray());
+    }
+	
+	private void createRangeClass(ITypeID from, ITypeID to, JavaClass cls) {
+		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(from), null, null).visitEnd();
+		rangeWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "to", getDescriptor(to), null, null).visitEnd();
+		
+		JavaMethod method = JavaMethod.getConstructor(cls, "(" + getDescriptor(from) + getDescriptor(to) + ")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(from), 1);
+		constructorWriter.putField(cls.internalName, "from", getDescriptor(from));
+		constructorWriter.loadObject(0);
+		constructorWriter.load(getType(to), 2);
+		constructorWriter.putField(cls.internalName, "to", getDescriptor(from));
+		constructorWriter.ret();
+		constructorWriter.end();
+		
+		rangeWriter.visitEnd();
+		
+		register(cls.internalName, rangeWriter.toByteArray());
+	}
+
+    public String getLambdaCounter() {
+        return "lambda" + ++lambdaCounter;
+    }
 	
 	private class TypeGenerator implements JavaSyntheticClassGenerator {
 
 		@Override
 		public JavaSynthesizedClass synthesizeFunction(FunctionTypeID type) {
-			return CompilerUtils.getLambdaInterface(JavaBytecodeContext.this, type);
+			return getLambdaInterface(type);
 		}
 
 		@Override
 		public JavaSynthesizedClass synthesizeRange(RangeTypeID type) {
-			throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+			return getRangeType(type);
 		}
 	}
 }

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

-/*
- * 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.javabytecode;
-
-import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
-
-/**
- * @author Hoofdgebruiker
- */
-public interface JavaBytecodeImplementation {
-	void compile(JavaWriter writer);
-}

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

-/*
- * 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.javabytecode;
-
-import org.objectweb.asm.Type;
-import org.openzen.zenscript.javashared.JavaClass;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class JavaCompileUtils {
-	private JavaCompileUtils() {}
-	
-	public static JavaClass get(Class<?> cls) {
-		return JavaClass.fromInternalName(
-				Type.getInternalName(cls),
-				cls.isInterface() ? JavaClass.Kind.INTERFACE : (cls.isEnum() ? JavaClass.Kind.ENUM : JavaClass.Kind.CLASS));
-	}
-}

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

 
 import java.io.File;
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
 
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 
 		finished = true;
 		
 		for (HighLevelDefinition definition : definitions) {
-			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context, definition.position.getFilename());
+			JavaPrepareDefinitionMemberVisitor memberPreparer = new JavaPrepareDefinitionMemberVisitor(context);
 			definition.accept(memberPreparer);
 		}
 		
 			// convert scripts into methods (add them to a Scripts class?)
 			// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
 			final JavaClassWriter visitor = scriptFile.classWriter;
-			JavaMethodInfo method = new JavaMethodInfo(new JavaClass(script.pkg.fullName, className, JavaClass.Kind.CLASS), methodName, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+			JavaMethod method = new JavaMethod(new JavaClass(script.pkg.fullName, className, JavaClass.Kind.CLASS), JavaMethod.Kind.STATIC, methodName, true, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 			scriptFile.scriptMethods.add(method);
 
 			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, new JavaWriter(visitor, method, null, null, null));
 			statementVisitor.end();
 		}
 		
-		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		JavaMethod runMethod = new JavaMethod(new JavaClass("script", "Scripts", JavaClass.Kind.CLASS), JavaMethod.Kind.STATIC, "run", true, "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
 		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null, null);
 		runWriter.start();
 		for (Map.Entry<String, JavaScriptFile> entry : scriptBlocks.entrySet()) {
-			for (JavaMethodInfo method : entry.getValue().scriptMethods)
+			for (JavaMethod method : entry.getValue().scriptMethods)
 				runWriter.invokeStatic(method);
 
 			entry.getValue().classWriter.visitEnd();

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

-/*
- * 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.javabytecode;
-
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.openzen.zenscript.javashared.JavaClass;
-
-/**
- * @author Hoofdgebruiker
- */
-public class JavaMethodInfo {
-	public static JavaMethodInfo get(int modifiers, Class owner, String name, Class result, Class... arguments) {
-		StringBuilder descriptor = new StringBuilder();
-		descriptor.append('(');
-		for (Class argument : arguments) {
-			descriptor.append(Type.getDescriptor(argument));
-		}
-		descriptor.append(')');
-		descriptor.append(result == null ? 'V' : Type.getDescriptor(result));
-		return new JavaMethodInfo(JavaCompileUtils.get(owner), name, descriptor.toString(), modifiers);
-	}
-
-	public final JavaClass javaClass;
-	public final String name;
-	public final String descriptor;
-	public final int modifiers;
-
-	public JavaMethodInfo(JavaClass javaClass, String name, String signature, int modifiers) {
-		this.javaClass = javaClass;
-		this.name = name;
-		this.descriptor = signature;
-		this.modifiers = modifiers;
-	}
-
-	public boolean isStatic() {
-		return (modifiers & Opcodes.ACC_STATIC) > 0;
-	}
-}

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

  */
 public class JavaModule {
 	private final Map<String, byte[]> classes = new HashMap<>();
-
+	private final File debugOutput;
+	
 	public JavaModule() {
-
+		debugOutput = null;
 	}
-
+	
+	public JavaModule(File debugOutput) {
+		this.debugOutput = debugOutput;
+	}
+	
 	public void register(String classname, byte[] bytecode) {
 		if (bytecode == null)
 			return;
 		
+		classname = classname.replace('/', '.');
 		classes.put(classname, bytecode);
 		
-		try (FileOutputStream writer = new FileOutputStream(new File(classname.replace('/', '_') + ".class"))) {
-			writer.write(bytecode);
-		} catch (IOException e) {
-			e.printStackTrace();
+		if (debugOutput != null) {
+			try (FileOutputStream writer = new FileOutputStream(new File(debugOutput, classname + ".class"))) {
+				writer.write(bytecode);
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 	}
 

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

 package org.openzen.zenscript.javabytecode.compiler;
 
-import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.Map;
-import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaSynthesizedClass;
-import org.openzen.zenscript.javashared.JavaSynthesizedClassNamer;
 
 public class CompilerUtils {
 	private CompilerUtils() {}
 		return out;
 	}
 
-	public static String calcClasName(CodePosition position) {
-		return position.getFilename().substring(0, position.getFilename().lastIndexOf('.')).replace("/", "_");
-	}
-
     public static void tagMethodParameters(JavaBytecodeContext context, FunctionHeader header, boolean isStatic) {
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
-            Type parameterType = context.getType(parameter.type);
+            String parameterType = context.getDescriptor(parameter.type);
             parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isStatic ? i : i + 1, parameterType));
         }
     }
     public static void tagConstructorParameters(JavaBytecodeContext context, FunctionHeader header, boolean isEnum) {
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
-            Type parameterType = context.getType(parameter.type);
+            String parameterType = context.getDescriptor(parameter.type);
             parameter.setTag(JavaParameterInfo.class, new JavaParameterInfo(isEnum ? i + 3 : i + 1, parameterType));
         }
     }
         }
     }
 
-	private static final Map<String, JavaSynthesizedClass> functions = new HashMap<>();
-	
-    public static JavaSynthesizedClass getLambdaInterface(JavaBytecodeContext context, FunctionTypeID function) {
-		String signature = JavaSynthesizedClassNamer.getFunctionSignature(function);
-		if (functions.containsKey(signature))
-			return functions.get(signature).withTypeParameters(JavaSynthesizedClassNamer.extractTypeParameters(function));
-		
-		System.out.println("Generating function " + signature);
-		
-		JavaSynthesizedClass result = JavaSynthesizedClassNamer.createFunctionName(function);
-		functions.put(signature, result);
-		
-        createLambdaInterface(context, function.header, result.cls);
-        return result;
-    }
-
-    private static void createLambdaInterface(JavaBytecodeContext context, FunctionHeader header, JavaClass cls) {
-        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
-				.visitMethod(
-					Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT,
-					"accept",
-					context.getMethodDescriptor(header),
-					context.getMethodSignature(header),
-					null)
-				.visitEnd();
-
-        context.register(cls.internalName.replace('/', '.'), ifaceWriter.toByteArray());
-
-        try (FileOutputStream out = new FileOutputStream(cls.getClassName() + ".class")){
-            out.write(ifaceWriter.toByteArray());
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-	private static int lambdaCounter = 0;
-    public static String getLambdaCounter() {
-        return "lambda" + ++lambdaCounter;
-    }
-
 	public static int getKeyForSwitch(SwitchValue expression) {
-		return expression.accept(new SwitchKeyVisitor());
-	}
-
-	private static class SwitchKeyVisitor implements SwitchValueVisitor<Integer> {
-
-		@Override
-		public Integer acceptInt(IntSwitchValue value) {
-			return value.value;
-		}
-
-		@Override
-		public Integer acceptChar(CharSwitchValue value) {
-			return (int) value.value;
-		}
-
-		@Override
-		public Integer acceptString(StringSwitchValue value) {
-			return value.value.hashCode();
-		}
-
-		@Override
-		public Integer acceptEnumConstant(EnumConstantSwitchValue value) {
-			return value.constant.ordinal;
-		}
-
-		@Override
-		public Integer acceptVariantOption(VariantOptionSwitchValue value) {
-			return value.option.getOrdinal();
-		}
+		return expression.accept(JavaSwitchKeyVisitor.INSTANCE);
 	}
 }

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

 package org.openzen.zenscript.javabytecode.compiler;
 
 import org.openzen.zenscript.codemodel.type.*;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaMethod;
 
-public class JavaBoxingTypeVisitor implements ITypeVisitor<JavaMethodInfo> {
+public class JavaBoxingTypeVisitor implements ITypeVisitor<Void> {
+	private static final JavaMethod BOOLEAN_VALUEOF = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "valueOf", "(Z)Ljava/lang/Boolean;");
+	private static final JavaMethod BYTE_VALUEOF = JavaMethod.getNativeStatic(JavaClass.BYTE, "valueOf", "(B)Ljava/lang/Byte;");
+	private static final JavaMethod SHORT_VALUEOF = JavaMethod.getNativeStatic(JavaClass.SHORT, "valueOf", "(S)Ljava/lang/Short;");
+	private static final JavaMethod INTEGER_VALUEOF = JavaMethod.getNativeStatic(JavaClass.INTEGER, "valueOf", "(I)Ljava/lang/Integer;");
+	private static final JavaMethod LONG_VALUEOF = JavaMethod.getNativeStatic(JavaClass.LONG, "valueOf", "(J)Ljava/lang/Long;");
+	private static final JavaMethod FLOAT_VALUEOF = JavaMethod.getNativeStatic(JavaClass.FLOAT, "valueOf", "(F)Ljava/lang/Float;");
+	private static final JavaMethod DOUBLE_VALUEOF = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "valueOf", "(D)Ljava/lang/Double;");
+	private static final JavaMethod CHARACTER_VALUEOF = JavaMethod.getNativeStatic(JavaClass.CHARACTER, "valueOf", "(C)Ljava/lang/Character;");
 
 	private final JavaWriter writer;
 
 	}
 
 	@Override
-	public JavaMethodInfo visitBasic(BasicTypeID basic) {
-		final JavaMethodInfo info;
+	public Void visitBasic(BasicTypeID basic) {
+		final JavaMethod method;
 		switch (basic) {
 			case BOOL:
-				writer.newObject(Boolean.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Boolean", JavaClass.Kind.CLASS), "<init>", "(Z)V", -1);
+				method = BOOLEAN_VALUEOF;
 				break;
 			case BYTE:
+				method = INTEGER_VALUEOF;
+				break;
 			case SBYTE:
-				writer.newObject(Byte.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Byte", JavaClass.Kind.CLASS), "<init>", "(B)V", -1);
+				method = BYTE_VALUEOF;
 				break;
 			case SHORT:
+				method = SHORT_VALUEOF;
+				break;
 			case USHORT:
-				writer.newObject(Short.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Short", JavaClass.Kind.CLASS), "<init>", "(S)V", -1);
+				method = INTEGER_VALUEOF;
 				break;
 			case INT:
 			case UINT:
-				writer.newObject(Byte.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Byte", JavaClass.Kind.CLASS), "<init>", "(B)V", -1);
+				method = INTEGER_VALUEOF;
 				break;
 			case LONG:
 			case ULONG:
-				writer.newObject(Long.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Long", JavaClass.Kind.CLASS), "<init>", "(S)V", -1);
+				method = LONG_VALUEOF;
 				break;
 			case FLOAT:
-				writer.newObject(Float.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Float", JavaClass.Kind.CLASS), "<init>", "(F)V", -1);
+				method = FLOAT_VALUEOF;
 				break;
 			case DOUBLE:
-				writer.newObject(Double.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Double", JavaClass.Kind.CLASS), "<init>", "(D)V", -1);
+				method = DOUBLE_VALUEOF;
 				break;
 			case CHAR:
-				writer.newObject(Character.class);
-				info = new JavaMethodInfo(new JavaClass("java.lang", "Character", JavaClass.Kind.CLASS), "<init>", "(C)V", -1);
+				method = CHARACTER_VALUEOF;
 				break;
 			default:
 				return null;
 		}
 		writer.dup();
-		return info;
+		
+		if (method != null)
+			writer.invokeStatic(method);
+		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitArray(ArrayTypeID array) {
+	public Void visitArray(ArrayTypeID array) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitAssoc(AssocTypeID assoc) {
+	public Void visitAssoc(AssocTypeID assoc) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitGenericMap(GenericMapTypeID map) {
+	public Void visitGenericMap(GenericMapTypeID map) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitIterator(IteratorTypeID iterator) {
+	public Void visitIterator(IteratorTypeID iterator) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitFunction(FunctionTypeID function) {
+	public Void visitFunction(FunctionTypeID function) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitDefinition(DefinitionTypeID definition) {
+	public Void visitDefinition(DefinitionTypeID definition) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitGeneric(GenericTypeID generic) {
+	public Void visitGeneric(GenericTypeID generic) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitRange(RangeTypeID range) {
+	public Void visitRange(RangeTypeID range) {
 		//NO-OP
 		return null;
 	}
 
 	@Override
-	public JavaMethodInfo visitModified(ModifiedTypeID type) {
+	public Void visitModified(ModifiedTypeID type) {
 		//NO-OP
 		return null;
 	}

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

 package org.openzen.zenscript.javabytecode.compiler;
 
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.StringJoiner;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 import org.openzen.zenscript.codemodel.type.*;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.implementations.IntRange;
 import org.openzen.zenscript.javabytecode.*;
 
 import java.io.FileOutputStream;
 import java.io.IOException;
 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> {
 	private static final int PUBLIC = Opcodes.ACC_PUBLIC;
 	private static final int STATIC = Opcodes.ACC_STATIC;
 	private static final int PUBLIC_STATIC = PUBLIC | STATIC;
 
-	private static final JavaMethodInfo BOOLEAN_PARSE = new JavaMethodInfo(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo BOOLEAN_TO_STRING = new JavaMethodInfo(JavaClass.BOOLEAN, "toString", "(Z)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo BYTE_PARSE = new JavaMethodInfo(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;)B", PUBLIC_STATIC);
-	private static final JavaMethodInfo BYTE_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;I)B", PUBLIC_STATIC);
+	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
+	private static final JavaMethod BOOLEAN_TO_STRING = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "toString", "(Z)Ljava/lang/String;");
+	private static final JavaMethod BYTE_PARSE = JavaMethod.getNativeStatic(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;)B");
+	private static final JavaMethod BYTE_PARSE_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;I)B");
 	private static final JavaField BYTE_MIN_VALUE = new JavaField(JavaClass.BYTE, "MIN_VALUE", "B");
 	private static final JavaField BYTE_MAX_VALUE = new JavaField(JavaClass.BYTE, "MAX_VALUE", "B");
-	private static final JavaMethodInfo BYTE_TO_STRING = new JavaMethodInfo(JavaClass.BYTE, "toString", "(B)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo SHORT_PARSE = new JavaMethodInfo(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;)S", PUBLIC_STATIC);
-	private static final JavaMethodInfo SHORT_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;I)S", PUBLIC_STATIC);
+	private static final JavaMethod BYTE_TO_STRING = JavaMethod.getNativeStatic(JavaClass.BYTE, "toString", "(B)Ljava/lang/String;");
+	private static final JavaMethod SHORT_PARSE = JavaMethod.getNativeStatic(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;)S");
+	private static final JavaMethod SHORT_PARSE_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.SHORT, "parseShort", "(Ljava/lang/String;I)S");
 	private static final JavaField SHORT_MIN_VALUE = new JavaField(JavaClass.SHORT, "MIN_VALUE", "S");
 	private static final JavaField SHORT_MAX_VALUE = new JavaField(JavaClass.SHORT, "MAX_VALUE", "S");
-	private static final JavaMethodInfo SHORT_TO_STRING = new JavaMethodInfo(JavaClass.SHORT, "toString", "(S)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_COMPARE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "compareUnsigned", "(II)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_DIVIDE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "divideUnsigned", "(II)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_REMAINDER_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "remainderUnsigned", "(II)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_NUMBER_OF_TRAILING_ZEROS = new JavaMethodInfo(JavaClass.INTEGER, "numberOfTrailingZeros", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_NUMBER_OF_LEADING_ZEROS = new JavaMethodInfo(JavaClass.INTEGER, "numberOfLeadingZeros", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE = new JavaMethodInfo(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_UNSIGNED = new JavaMethodInfo(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_PARSE_UNSIGNED_WITH_BASE = new JavaMethodInfo(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_HIGHEST_ONE_BIT = new JavaMethodInfo(JavaClass.INTEGER, "highestOneBit", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_LOWEST_ONE_BIT = new JavaMethodInfo(JavaClass.INTEGER, "lowestOneBit", "(I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_BIT_COUNT = new JavaMethodInfo(JavaClass.INTEGER, "bitCount", "(I)I", PUBLIC_STATIC);
+	private static final JavaMethod SHORT_TO_STRING = JavaMethod.getNativeStatic(JavaClass.SHORT, "toString", "(S)Ljava/lang/String;");
+	private static final JavaMethod INTEGER_COMPARE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.INTEGER, "compareUnsigned", "(II)I");
+	private static final JavaMethod INTEGER_DIVIDE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.INTEGER, "divideUnsigned", "(II)I");
+	private static final JavaMethod INTEGER_REMAINDER_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.INTEGER, "remainderUnsigned", "(II)I");
+	private static final JavaMethod INTEGER_NUMBER_OF_TRAILING_ZEROS = JavaMethod.getNativeStatic(JavaClass.INTEGER, "numberOfTrailingZeros", "(I)I");
+	private static final JavaMethod INTEGER_NUMBER_OF_LEADING_ZEROS = JavaMethod.getNativeStatic(JavaClass.INTEGER, "numberOfLeadingZeros", "(I)I");
+	private static final JavaMethod INTEGER_PARSE = JavaMethod.getNativeStatic(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;)I");
+	private static final JavaMethod INTEGER_PARSE_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.INTEGER, "parseInt", "(Ljava/lang/String;I)I");
+	private static final JavaMethod INTEGER_PARSE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;)I");
+	private static final JavaMethod INTEGER_PARSE_UNSIGNED_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.INTEGER, "parseUnsignedInt", "(Ljava/lang/String;I)I");
+	private static final JavaMethod INTEGER_HIGHEST_ONE_BIT = JavaMethod.getNativeStatic(JavaClass.INTEGER, "highestOneBit", "(I)I");
+	private static final JavaMethod INTEGER_LOWEST_ONE_BIT = JavaMethod.getNativeStatic(JavaClass.INTEGER, "lowestOneBit", "(I)I");
+	private static final JavaMethod INTEGER_BIT_COUNT = JavaMethod.getNativeStatic(JavaClass.INTEGER, "bitCount", "(I)I");
 	private static final JavaField INTEGER_MIN_VALUE = new JavaField(JavaClass.INTEGER, "MIN_VALUE", "I");
 	private static final JavaField INTEGER_MAX_VALUE = new JavaField(JavaClass.INTEGER, "MAX_VALUE", "I");
-	private static final JavaMethodInfo INTEGER_TO_STRING = new JavaMethodInfo(JavaClass.INTEGER, "toString", "(I)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo INTEGER_TO_UNSIGNED_STRING = new JavaMethodInfo(JavaClass.INTEGER, "toUnsignedString", "(I)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_COMPARE = new JavaMethodInfo(JavaClass.LONG, "compare", "(JJ)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_COMPARE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "compareUnsigned", "(JJ)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_DIVIDE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "divideUnsigned", "(JJ)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_REMAINDER_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "remainderUnsigned", "(JJ)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_NUMBER_OF_TRAILING_ZEROS = new JavaMethodInfo(JavaClass.LONG, "numberOfTrailingZeros", "(J)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_NUMBER_OF_LEADING_ZEROS = new JavaMethodInfo(JavaClass.LONG, "numberOfLeadingZeros", "(J)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE = new JavaMethodInfo(JavaClass.LONG, "parseLong", "(Ljava/lang/String;)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_WITH_BASE = new JavaMethodInfo(JavaClass.LONG, "parseLong", "(Ljava/lang/String;I)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_UNSIGNED = new JavaMethodInfo(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_PARSE_UNSIGNED_WITH_BASE = new JavaMethodInfo(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;I)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_HIGHEST_ONE_BIT = new JavaMethodInfo(JavaClass.LONG, "highestOneBit", "(J)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_LOWEST_ONE_BIT = new JavaMethodInfo(JavaClass.LONG, "lowestOneBit", "(J)J", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_BIT_COUNT = new JavaMethodInfo(JavaClass.LONG, "bitCount", "(J)I", PUBLIC_STATIC);
+	private static final JavaMethod INTEGER_TO_STRING = JavaMethod.getNativeStatic(JavaClass.INTEGER, "toString", "(I)Ljava/lang/String;");
+	private static final JavaMethod INTEGER_TO_UNSIGNED_STRING = JavaMethod.getNativeStatic(JavaClass.INTEGER, "toUnsignedString", "(I)Ljava/lang/String;");
+	private static final JavaMethod LONG_COMPARE = JavaMethod.getNativeStatic(JavaClass.LONG, "compare", "(JJ)I");
+	private static final JavaMethod LONG_COMPARE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.LONG, "compareUnsigned", "(JJ)I");
+	private static final JavaMethod LONG_DIVIDE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.LONG, "divideUnsigned", "(JJ)J");
+	private static final JavaMethod LONG_REMAINDER_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.LONG, "remainderUnsigned", "(JJ)J");
+	private static final JavaMethod LONG_NUMBER_OF_TRAILING_ZEROS = JavaMethod.getNativeStatic(JavaClass.LONG, "numberOfTrailingZeros", "(J)I");
+	private static final JavaMethod LONG_NUMBER_OF_LEADING_ZEROS = JavaMethod.getNativeStatic(JavaClass.LONG, "numberOfLeadingZeros", "(J)I");
+	private static final JavaMethod LONG_PARSE = JavaMethod.getNativeStatic(JavaClass.LONG, "parseLong", "(Ljava/lang/String;)J");
+	private static final JavaMethod LONG_PARSE_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.LONG, "parseLong", "(Ljava/lang/String;I)J");
+	private static final JavaMethod LONG_PARSE_UNSIGNED = JavaMethod.getNativeStatic(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;)J");
+	private static final JavaMethod LONG_PARSE_UNSIGNED_WITH_BASE = JavaMethod.getNativeStatic(JavaClass.LONG, "parseUnsignedLong", "(Ljava/lang/String;I)J");
+	private static final JavaMethod LONG_HIGHEST_ONE_BIT = JavaMethod.getNativeStatic(JavaClass.LONG, "highestOneBit", "(J)J");
+	private static final JavaMethod LONG_LOWEST_ONE_BIT = JavaMethod.getNativeStatic(JavaClass.LONG, "lowestOneBit", "(J)J");
+	private static final JavaMethod LONG_BIT_COUNT = JavaMethod.getNativeStatic(JavaClass.LONG, "bitCount", "(J)I");
 	private static final JavaField LONG_MIN_VALUE = new JavaField(JavaClass.LONG, "MIN_VALUE", "J");
 	private static final JavaField LONG_MAX_VALUE = new JavaField(JavaClass.LONG, "MAX_VALUE", "J");
-	private static final JavaMethodInfo LONG_TO_STRING = new JavaMethodInfo(JavaClass.LONG, "toString", "(J)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo LONG_TO_UNSIGNED_STRING = new JavaMethodInfo(JavaClass.LONG, "toUnsignedString", "(J)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo FLOAT_COMPARE = new JavaMethodInfo(JavaClass.FLOAT, "compare", "(FF)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo FLOAT_PARSE = new JavaMethodInfo(JavaClass.FLOAT, "parseFloat", "(Ljava/lang/String;)F", PUBLIC_STATIC);
-	private static final JavaMethodInfo FLOAT_FROM_BITS = new JavaMethodInfo(JavaClass.FLOAT, "intBitsToFloat", "(I)F", PUBLIC_STATIC);
-	private static final JavaMethodInfo FLOAT_BITS = new JavaMethodInfo(JavaClass.FLOAT, "floatToRawIntBits", "(F)I", PUBLIC_STATIC);
+	private static final JavaMethod LONG_TO_STRING = JavaMethod.getNativeStatic(JavaClass.LONG, "toString", "(J)Ljava/lang/String;");
+	private static final JavaMethod LONG_TO_UNSIGNED_STRING = JavaMethod.getNativeStatic(JavaClass.LONG, "toUnsignedString", "(J)Ljava/lang/String;");
+	private static final JavaMethod FLOAT_COMPARE = JavaMethod.getNativeStatic(JavaClass.FLOAT, "compare", "(FF)I");
+	private static final JavaMethod FLOAT_PARSE = JavaMethod.getNativeStatic(JavaClass.FLOAT, "parseFloat", "(Ljava/lang/String;)F");
+	private static final JavaMethod FLOAT_FROM_BITS = JavaMethod.getNativeStatic(JavaClass.FLOAT, "intBitsToFloat", "(I)F");
+	private static final JavaMethod FLOAT_BITS = JavaMethod.getNativeStatic(JavaClass.FLOAT, "floatToRawIntBits", "(F)I");
 	private static final JavaField FLOAT_MIN_VALUE = new JavaField(JavaClass.FLOAT, "MIN_VALUE", "F");
 	private static final JavaField FLOAT_MAX_VALUE = new JavaField(JavaClass.FLOAT, "MAX_VALUE", "F");
-	private static final JavaMethodInfo FLOAT_TO_STRING = new JavaMethodInfo(JavaClass.FLOAT, "toString", "(F)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo DOUBLE_COMPARE = new JavaMethodInfo(JavaClass.DOUBLE, "compare", "(DD)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo DOUBLE_PARSE = new JavaMethodInfo(JavaClass.DOUBLE, "parseDouble", "(Ljava/lang/String;)D", PUBLIC_STATIC);
-	private static final JavaMethodInfo DOUBLE_FROM_BITS = new JavaMethodInfo(JavaClass.DOUBLE, "longBitsToDouble", "(J)D", PUBLIC_STATIC);
-	private static final JavaMethodInfo DOUBLE_BITS = new JavaMethodInfo(JavaClass.DOUBLE, "doubleToRawLongBits", "(D)J", PUBLIC_STATIC);
+	private static final JavaMethod FLOAT_TO_STRING = JavaMethod.getNativeStatic(JavaClass.FLOAT, "toString", "(F)Ljava/lang/String;");
+	private static final JavaMethod DOUBLE_COMPARE = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "compare", "(DD)I");
+	private static final JavaMethod DOUBLE_PARSE = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "parseDouble", "(Ljava/lang/String;)D");
+	private static final JavaMethod DOUBLE_FROM_BITS = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "longBitsToDouble", "(J)D");
+	private static final JavaMethod DOUBLE_BITS = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "doubleToRawLongBits", "(D)J");
 	private static final JavaField DOUBLE_MIN_VALUE = new JavaField(JavaClass.DOUBLE, "MIN_VALUE", "D");
 	private static final JavaField DOUBLE_MAX_VALUE = new JavaField(JavaClass.DOUBLE, "MAX_VALUE", "D");
-	private static final JavaMethodInfo DOUBLE_TO_STRING = new JavaMethodInfo(JavaClass.DOUBLE, "toString", "(D)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo CHARACTER_TO_LOWER_CASE = new JavaMethodInfo(JavaClass.CHARACTER, "toLowerCase", "()C", PUBLIC);
-	private static final JavaMethodInfo CHARACTER_TO_UPPER_CASE = new JavaMethodInfo(JavaClass.CHARACTER, "toUpperCase", "()C", PUBLIC);
+	private static final JavaMethod DOUBLE_TO_STRING = JavaMethod.getNativeStatic(JavaClass.DOUBLE, "toString", "(D)Ljava/lang/String;");
+	private static final JavaMethod CHARACTER_TO_LOWER_CASE = JavaMethod.getNativeVirtual(JavaClass.CHARACTER, "toLowerCase", "()C");
+	private static final JavaMethod CHARACTER_TO_UPPER_CASE = JavaMethod.getNativeVirtual(JavaClass.CHARACTER, "toUpperCase", "()C");
 	private static final JavaField CHARACTER_MIN_VALUE = new JavaField(JavaClass.CHARACTER, "MIN_VALUE", "C");
 	private static final JavaField CHARACTER_MAX_VALUE = new JavaField(JavaClass.CHARACTER, "MAX_VALUE", "C");
-	private static final JavaMethodInfo CHARACTER_TO_STRING = new JavaMethodInfo(JavaClass.CHARACTER, "toString", "(C)Ljava/lang/String;", PUBLIC_STATIC);
-	private static final JavaMethodInfo STRING_COMPARETO = new JavaMethodInfo(JavaClass.STRING, "compareTo", "(Ljava/lang/String;)I", PUBLIC);
-	private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(JavaClass.STRING, "concat", "(Ljava/lang/String;)Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_CHAR_AT = new JavaMethodInfo(JavaClass.STRING, "charAt", "(I)C", PUBLIC);
-	private static final JavaMethodInfo STRING_SUBSTRING = new JavaMethodInfo(JavaClass.STRING, "substring", "(II)Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TRIM = new JavaMethodInfo(JavaClass.STRING, "trim", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TO_LOWER_CASE = new JavaMethodInfo(JavaClass.STRING, "toLowerCase", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_TO_UPPER_CASE = new JavaMethodInfo(JavaClass.STRING, "toUpperCase", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo STRING_LENGTH = new JavaMethodInfo(JavaClass.STRING, "length", "()I", PUBLIC);
-	private static final JavaMethodInfo STRING_CHARACTERS = new JavaMethodInfo(JavaClass.STRING, "toCharArray", "()[C", PUBLIC);
-	private static final JavaMethodInfo STRING_ISEMPTY = new JavaMethodInfo(JavaClass.STRING, "isEmpty", "()Z", PUBLIC);
-	private static final JavaMethodInfo ENUM_COMPARETO = new JavaMethodInfo(JavaClass.ENUM, "compareTo", "(Ljava/lang/Enum;)I", PUBLIC);
-	private static final JavaMethodInfo ENUM_NAME = new JavaMethodInfo(JavaClass.ENUM, "name", "()Ljava/lang/String;", PUBLIC);
-	private static final JavaMethodInfo ENUM_ORDINAL = new JavaMethodInfo(JavaClass.ENUM, "ordinal", "()I", PUBLIC);
-	private static final JavaMethodInfo MAP_GET = new JavaMethodInfo(JavaClass.MAP, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", PUBLIC);
-	private static final JavaMethodInfo MAP_PUT = new JavaMethodInfo(JavaClass.MAP, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", PUBLIC);
-	private static final JavaMethodInfo MAP_CONTAINS_KEY = new JavaMethodInfo(JavaClass.MAP, "containsKey", "(Ljava/lang/Object;)Z", PUBLIC);
-	private static final JavaMethodInfo MAP_SIZE = new JavaMethodInfo(JavaClass.MAP, "size", "()I", PUBLIC);
-	private static final JavaMethodInfo MAP_ISEMPTY = new JavaMethodInfo(JavaClass.MAP, "isEmpty", "()Z", PUBLIC);
-	private static final JavaMethodInfo MAP_KEYS = new JavaMethodInfo(JavaClass.MAP, "keys", "()Ljava/lang/Object;", PUBLIC);
-	private static final JavaMethodInfo MAP_VALUES = new JavaMethodInfo(JavaClass.MAP, "values", "()Ljava/lang/Object;", PUBLIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_OBJECTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([Ljava/lang/Object;II)[Ljava/lang/Object;", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([ZII)[Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([BII)[B", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([SII)[S", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([III)[I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([JII)[J", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([FII)[F", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([DII)[D", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_COPY_OF_RANGE_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "copyOfRange", "([CII)[C", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_OBJECTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([Ljava/lang/Object[Ljava/lang/Object)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([Z[Z)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([B[B)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([S[S)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([I[I)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([L[L)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([F[F)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([D[D)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_EQUALS_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "equals", "([C[C)Z", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_DEEPHASHCODE = new JavaMethodInfo(JavaClass.ARRAYS, "deepHashCode", "([Ljava/lang/Object;)", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_BOOLS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([Z)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_BYTES = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([B)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_SHORTS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([S)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_INTS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([I)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_LONGS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([L)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_FLOATS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([F)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_DOUBLES = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([D)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo ARRAYS_HASHCODE_CHARS = new JavaMethodInfo(JavaClass.ARRAYS, "hashCode", "([C)I", PUBLIC_STATIC);
-	private static final JavaMethodInfo OBJECT_HASHCODE = new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", PUBLIC);
-	private static final JavaMethodInfo COLLECTION_SIZE = new JavaMethodInfo(JavaClass.COLLECTION, "size", "()I", PUBLIC);
-	private static final JavaMethodInfo COLLECTION_TOARRAY = new JavaMethodInfo(JavaClass.COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", PUBLIC);
+	private static final JavaMethod CHARACTER_TO_STRING = JavaMethod.getNativeStatic(JavaClass.CHARACTER, "toString", "(C)Ljava/lang/String;");
+	private static final JavaMethod STRING_COMPARETO = JavaMethod.getNativeVirtual(JavaClass.STRING, "compareTo", "(Ljava/lang/String;)I");
+	private static final JavaMethod STRING_CONCAT = JavaMethod.getNativeVirtual(JavaClass.STRING, "concat", "(Ljava/lang/String;)Ljava/lang/String;");
+	private static final JavaMethod STRING_CHAR_AT = JavaMethod.getNativeVirtual(JavaClass.STRING, "charAt", "(I)C");
+	private static final JavaMethod STRING_SUBSTRING = JavaMethod.getNativeVirtual(JavaClass.STRING, "substring", "(II)Ljava/lang/String;");
+	private static final JavaMethod STRING_TRIM = JavaMethod.getNativeVirtual(JavaClass.STRING, "trim", "()Ljava/lang/String;");
+	private static final JavaMethod STRING_TO_LOWER_CASE = JavaMethod.getNativeVirtual(JavaClass.STRING, "toLowerCase", "()Ljava/lang/String;");
+	private static final JavaMethod STRING_TO_UPPER_CASE = JavaMethod.getNativeVirtual(JavaClass.STRING, "toUpperCase", "()Ljava/lang/String;");
+	private static final JavaMethod STRING_LENGTH = JavaMethod.getNativeVirtual(JavaClass.STRING, "length", "()I");
+	private static final JavaMethod STRING_CHARACTERS = JavaMethod.getNativeVirtual(JavaClass.STRING, "toCharArray", "()[C");
+	private static final JavaMethod STRING_ISEMPTY = JavaMethod.getNativeVirtual(JavaClass.STRING, "isEmpty", "()Z");
+	private static final JavaMethod ENUM_COMPARETO = JavaMethod.getNativeVirtual(JavaClass.ENUM, "compareTo", "(Ljava/lang/Enum;)I");
+	private static final JavaMethod ENUM_NAME = JavaMethod.getNativeVirtual(JavaClass.ENUM, "name", "()Ljava/lang/String;");
+	private static final JavaMethod ENUM_ORDINAL = JavaMethod.getNativeVirtual(JavaClass.ENUM, "ordinal", "()I");
+	private static final JavaMethod MAP_GET = JavaMethod.getNativeVirtual(JavaClass.MAP, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
+	private static final JavaMethod MAP_PUT = JavaMethod.getNativeVirtual(JavaClass.MAP, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+	private static final JavaMethod MAP_CONTAINS_KEY = JavaMethod.getNativeVirtual(JavaClass.MAP, "containsKey", "(Ljava/lang/Object;)Z");
+	private static final JavaMethod MAP_SIZE = JavaMethod.getNativeVirtual(JavaClass.MAP, "size", "()I");
+	private static final JavaMethod MAP_ISEMPTY = JavaMethod.getNativeVirtual(JavaClass.MAP, "isEmpty", "()Z");
+	private static final JavaMethod MAP_KEYS = JavaMethod.getNativeVirtual(JavaClass.MAP, "keys", "()Ljava/lang/Object;");
+	private static final JavaMethod MAP_VALUES = JavaMethod.getNativeVirtual(JavaClass.MAP, "values", "()Ljava/lang/Object;");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_OBJECTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([Ljava/lang/Object;II)[Ljava/lang/Object;");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_BOOLS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([ZII)[Z");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_BYTES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([BII)[B");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_SHORTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([SII)[S");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_INTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([III)[I");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_LONGS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([JII)[J");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_FLOATS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([FII)[F");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_DOUBLES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([DII)[D");
+	private static final JavaMethod ARRAYS_COPY_OF_RANGE_CHARS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "copyOfRange", "([CII)[C");
+	private static final JavaMethod ARRAYS_EQUALS_OBJECTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([Ljava/lang/Object[Ljava/lang/Object)Z");
+	private static final JavaMethod ARRAYS_EQUALS_BOOLS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([Z[Z)Z");
+	private static final JavaMethod ARRAYS_EQUALS_BYTES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([B[B)Z");
+	private static final JavaMethod ARRAYS_EQUALS_SHORTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([S[S)Z");
+	private static final JavaMethod ARRAYS_EQUALS_INTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([I[I)Z");
+	private static final JavaMethod ARRAYS_EQUALS_LONGS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([L[L)Z");
+	private static final JavaMethod ARRAYS_EQUALS_FLOATS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([F[F)Z");
+	private static final JavaMethod ARRAYS_EQUALS_DOUBLES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([D[D)Z");
+	private static final JavaMethod ARRAYS_EQUALS_CHARS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "equals", "([C[C)Z");
+	private static final JavaMethod ARRAYS_DEEPHASHCODE = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "deepHashCode", "([Ljava/lang/Object;)");
+	private static final JavaMethod ARRAYS_HASHCODE_BOOLS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([Z)I");
+	private static final JavaMethod ARRAYS_HASHCODE_BYTES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([B)I");
+	private static final JavaMethod ARRAYS_HASHCODE_SHORTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([S)I");
+	private static final JavaMethod ARRAYS_HASHCODE_INTS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([I)I");
+	private static final JavaMethod ARRAYS_HASHCODE_LONGS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([L)I");
+	private static final JavaMethod ARRAYS_HASHCODE_FLOATS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([F)I");
+	private static final JavaMethod ARRAYS_HASHCODE_DOUBLES = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([D)I");
+	private static final JavaMethod ARRAYS_HASHCODE_CHARS = JavaMethod.getNativeStatic(JavaClass.ARRAYS, "hashCode", "([C)I");
+	public static final JavaMethod OBJECT_HASHCODE = JavaMethod.getNativeVirtual(JavaClass.OBJECT, "hashCode", "()I");
+	private static final JavaMethod COLLECTION_SIZE = JavaMethod.getNativeVirtual(JavaClass.COLLECTION, "size", "()I");
+	private static final JavaMethod COLLECTION_TOARRAY = JavaMethod.getNativeVirtual(JavaClass.COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;");
 
 	protected final JavaWriter javaWriter;
 	private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
 			}
 			case FUNCTION_CALL:
 				javaWriter.invokeInterface(
-						new JavaMethodInfo(
+						JavaMethod.getNativeVirtual(
 								JavaClass.fromInternalName(context.getInternalName(expression.target.type), JavaClass.Kind.INTERFACE),
 								"accept",
-								context.getMethodSignature(expression.instancedHeader),
-								Opcodes.ACC_PUBLIC));
+								context.getMethodSignature(expression.instancedHeader)));
 				break;
 			case AUTOOP_NOTEQUALS:
 				throw new UnsupportedOperationException("Not yet supported!");
 
 		BuiltinID builtin = expression.member.member.builtin;
 		if (builtin == null) {
-			if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
+			if (!checkAndExecuteMethodInfo(expression.member))
 				throw new IllegalStateException("Call target has no method info!");
 
 			return null;
         javaWriter.dup();
         javaWriter.ifNonNull(end);
         javaWriter.pop();
-        javaWriter.newObject(NullPointerException.class);
+        javaWriter.newObject("java/lang/NullPointerException");
         javaWriter.dup();
         javaWriter.constant("Tried to convert a null value to nonnull type " + context.getType(expression.type).getClassName());
         javaWriter.invokeSpecial(NullPointerException.class, "<init>", "(Ljava/lang/String;)V");
 			case ENUM_VALUES: {
 				DefinitionTypeID type = (DefinitionTypeID) expression.type;
 				JavaClass cls = type.definition.getTag(JavaClass.class);
-				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalName + ";", PUBLIC_STATIC));
+				javaWriter.invokeStatic(JavaMethod.getNativeStatic(cls, "values", "()[L" + cls.internalName + ";"));
 				break;
 			}
 			default:
     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
 		javaWriter.loadObject(0);
-		if (javaWriter.method.javaClass.isEnum()) {
+		if (javaWriter.method.cls.isEnum()) {
 			javaWriter.loadObject(1);
 			javaWriter.loadInt(2);
 		}
 			argument.accept(this);
 		}
 		String internalName = context.getInternalName(expression.objectType);
-        javaWriter.invokeSpecial(internalName, "<init>", javaWriter.method.javaClass.isEnum()
+        javaWriter.invokeSpecial(internalName, "<init>", javaWriter.method.cls.isEnum()
 				? context.getEnumConstructorDescriptor(expression.constructor.getHeader())
 				: context.getMethodDescriptor(expression.constructor.getHeader()));
         return null;
             return null;
         }
         final String signature = context.getMethodSignature(expression.header);
-		final String name = CompilerUtils.getLambdaCounter();
+		final String name = context.getLambdaCounter();
 
-		final JavaMethodInfo methodInfo = new JavaMethodInfo(javaWriter.method.javaClass, "accept", signature, Opcodes.ACC_PUBLIC);
+		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", signature);
 		final ClassWriter lambdaCW = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{JavaSynthesizedClassNamer.createFunctionName(new FunctionTypeID(null, expression.header)).cls.internalName});
 		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
 		final String constructorDesc = calcFunctionSignature(expression.closure);
 
 
-		final JavaWriter constructorWriter = new JavaWriter(lambdaCW, new JavaMethodInfo(javaWriter.method.javaClass, "<init>", constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
+		final JavaWriter constructorWriter = new JavaWriter(lambdaCW, JavaMethod.getConstructor(javaWriter.method.cls, constructorDesc, Opcodes.ACC_PUBLIC), null, null, null);
 		constructorWriter.start();
 		constructorWriter.loadObject(0);
 		constructorWriter.dup();
 		javaWriter.loadObject(0);
 		final ITypeID type = expression.value.option.getParameterType(expression.index);
 		final JavaClass tag = expression.value.option.getTag(JavaClass.class);
-		javaWriter.checkCast(tag.internalName);
-		javaWriter.getField(new JavaField(tag, "Field" + expression.index, context.getDescriptor(type)));
+		javaWriter.checkCast("L" + tag.internalName + ";");
+		javaWriter.getField(new JavaField(tag, "field" + expression.index, context.getDescriptor(type)));
 		return null;
-		//throw new UnsupportedOperationException(); // TODO
 	}
 
 	@Override
 			case OBJECT_HASHCODE:
 				javaWriter.invokeVirtual(OBJECT_HASHCODE);
 				break;
-			case RANGE_FROM:
-				// TODO: range types
-				javaWriter.getField(IntRange.class, "from", int.class);
+			case RANGE_FROM: {
+				RangeTypeID type = (RangeTypeID)expression.target.type;
+				JavaClass cls = context.getTypeGenerator().synthesizeRange(type).cls;
+				javaWriter.getField(cls.internalName, "from", context.getDescriptor(type.from));
 				break;
+			}
 			case RANGE_TO:
-				// TODO: range types
-				javaWriter.getField(IntRange.class, "to", int.class);
+				RangeTypeID type = (RangeTypeID)expression.target.type;
+				JavaClass cls = context.getTypeGenerator().synthesizeRange(type).cls;
+				javaWriter.getField(cls.internalName, "to", context.getDescriptor(type.to));
 				break;
 		}
 
 
 	@Override
 	public Void visitMatch(MatchExpression expression) {
-
 		final Label start = new Label();
 		final Label end = new Label();
 
-
 		javaWriter.label(start);
 		expression.value.accept(this);
 
-
 		//TODO replace beforeSwitch visitor or similar
 		if (expression.value.type == BasicTypeID.STRING)
-			javaWriter.invokeVirtual(new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", 0));
+			javaWriter.invokeVirtual(OBJECT_HASHCODE);
 
 		//TODO replace with beforeSwitch visitor or similar
 		for (MatchExpression.Case aCase : expression.cases) {
 			if (aCase.key instanceof VariantOptionSwitchValue) {
 				VariantOptionSwitchValue variantOptionSwitchValue = (VariantOptionSwitchValue) aCase.key;
-				final String className = variantOptionSwitchValue.option.getTag(JavaClass.class).internalName;
-				javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClass("", className.substring(0, className.lastIndexOf('$')), JavaClass.Kind.CLASS), "getDenominator", "()I", 0));
+				JavaVariantOption option = variantOptionSwitchValue.option.getTag(JavaVariantOption.class);
+				javaWriter.invokeVirtual(JavaMethod.getNativeVirtual(option.variantClass, "getDenominator", "()I"));
 				break;
 			}
 		}
 
-
 		final boolean hasNoDefault = hasNoDefault(expression);
 
 		final MatchExpression.Case[] cases = expression.cases;
     @Override
     public Void visitNew(NewExpression expression) {
 		// TODO: this code is incorrect!
+		JavaMethod method = expression.constructor.getTag(JavaMethod.class);
 		
         final String type;
         if (expression.type instanceof DefinitionTypeID)
 
         javaWriter.newObject(type);
         javaWriter.dup();
-        StringBuilder signatureBuilder = new StringBuilder("(");
-        for (Expression argument : expression.arguments.arguments) {
-            argument.accept(this);
-            signatureBuilder.append(context.getDescriptor(argument.type));
-        }
-        signatureBuilder.append(")V");
-        javaWriter.invokeSpecial(type, "<init>", signatureBuilder.toString());
-
-		//throw new UnsupportedOperationException("Not yet implemented!");
+		
+		for (Expression argument : expression.arguments.arguments) {
+			argument.accept(this);
+		}
+		
+        javaWriter.invokeSpecial(method);
 		return null;
 	}
 
 
 	@Override
 	public Void visitPanic(PanicExpression expression) {
-		javaWriter.newObject(AssertionError.class);
+		javaWriter.newObject("java/lang/AssertionError");
 		javaWriter.dup();
 		expression.value.accept(this);
 		javaWriter.invokeSpecial(AssertionError.class, "<init>", "(Ljava/lang/String;)V");
 	public Void visitPostCall(PostCallExpression expression) {
 		expression.target.accept(this);
 		javaWriter.dup(context.getType(expression.type));
-		if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
+		if (!checkAndExecuteMethodInfo(expression.member))
 			throw new IllegalStateException("Call target has no method info!");
 
 		return null;
 
     @Override
     public Void visitRange(RangeExpression expression) {
-        // TODO: there are other kinds of ranges also; there should be a Range<T, T> type with creation of synthetic types
-        if (!context.getDescriptor(expression.from.type).equals("I"))
-            throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
-
-		javaWriter.newObject(IntRange.class);
+		RangeTypeID type = (RangeTypeID)expression.type;
+		JavaSynthesizedClass cls = context.getTypeGenerator().synthesizeRange(type);
+		javaWriter.newObject(cls.cls.internalName);
 		javaWriter.dup();
 		expression.from.accept(this);
 		expression.to.accept(this);
-		javaWriter.invokeSpecial("org/openzen/zenscript/implementations/IntRange", "<init>", "(II)V");
+		javaWriter.invokeSpecial(cls.cls.internalName, "<init>", "(" + context.getDescriptor(type.from) + context.getDescriptor(type.to) + ")V");
 
 		return null;
 	}
 			case ENUM_VALUES: {
 				DefinitionTypeID type = (DefinitionTypeID) expression.type;
 				JavaClass cls = type.definition.getTag(JavaClass.class);
-				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalName + ";", PUBLIC_STATIC));
+				javaWriter.invokeStatic(JavaMethod.getNativeStatic(cls, "values", "()[L" + cls.internalName + ";"));
 				break;
 			}
 			default:
 	@Override
 	public Void visitWrapOptional(WrapOptionalExpression expression) {
 		//Does nothing if not required to be wrapped
-		final JavaMethodInfo info = expression.value.type.accept(new JavaBoxingTypeVisitor(javaWriter));
 		expression.value.accept(this);
-
-		//i.e. if it was a primitive
-		if (info != null)
-			javaWriter.invokeSpecial(info);
+		expression.value.type.accept(new JavaBoxingTypeVisitor(javaWriter));
 		return null;
 	}
 
         return javaWriter;
     }
 
-
-    //Will return true if a JavaBytecodeImplementation.class tag exists, and will compile that tag
-    private boolean checkAndExecuteByteCodeImplementation(DefinitionMemberRef member) {
-        JavaBytecodeImplementation implementation = member.getTag(JavaBytecodeImplementation.class);
-        if (implementation != null) {
-            implementation.compile(getJavaWriter());
-            return true;
-        }
-        return false;
-    }
-
     //Will return true if a JavaMethodInfo.class tag exists, and will compile that tag
     private boolean checkAndExecuteMethodInfo(DefinitionMemberRef member) {
-        JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
+        JavaMethod methodInfo = member.getTag(JavaMethod.class);
         if (methodInfo == null)
             return false;
 
-        if (methodInfo.isStatic()) {
+        if (methodInfo.kind == JavaMethod.Kind.STATIC) {
             getJavaWriter().invokeStatic(methodInfo);
         } else {
             getJavaWriter().invokeVirtual(methodInfo);

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

 	@Override
 	public Void visitIntRange() {
 		javaWriter.dup();
-		javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "to", "I");
+		javaWriter.getField("zsynthetic/IntRange", "to", "I");
 		javaWriter.swap();
-		javaWriter.getField("org/openzen/zenscript/implementations/IntRange", "from", "I");
+		javaWriter.getField("zsynthetic/IntRange", "from", "I");
 
 		final int z = variables[0].getTag(JavaLocalVariableInfo.class).local;
 		javaWriter.storeInt(z);

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

 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 /**
  *

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

 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 
 /**
  *

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

  */
 package org.openzen.zenscript.javabytecode.compiler;
 
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaScriptFile {
 	public final JavaClassWriter classWriter;
-	public final List<JavaMethodInfo> scriptMethods;
+	public final List<JavaMethod> scriptMethods;
 
 	public JavaScriptFile(JavaClassWriter classWriter) {
 		this.classWriter = classWriter;

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

 import org.openzen.zenscript.codemodel.statement.*;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 
 import java.util.Arrays;
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javashared.JavaClass;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
 		javaWriter.label(start);
 		statement.value.accept(expressionVisitor);
 		if (statement.value.type == BasicTypeID.STRING)
-			javaWriter.invokeVirtual(new JavaMethodInfo(JavaClass.OBJECT, "hashCode", "()I", 0));
+			javaWriter.invokeVirtual(JavaExpressionVisitor.OBJECT_HASHCODE);
 		boolean out = false;
 
 		final boolean hasNoDefault = hasNoDefault(statement);

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

+/*
+ * 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.javabytecode.compiler;
+
+import org.openzen.zenscript.codemodel.expression.switchvalue.CharSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.StringSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValueVisitor;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSwitchKeyVisitor implements SwitchValueVisitor<Integer> {
+	public static final JavaSwitchKeyVisitor INSTANCE = new JavaSwitchKeyVisitor();
+	
+	private JavaSwitchKeyVisitor() {}
+	
+	@Override
+	public Integer acceptInt(IntSwitchValue value) {
+		return value.value;
+	}
+
+	@Override
+	public Integer acceptChar(CharSwitchValue value) {
+		return (int) value.value;
+	}
+
+	@Override
+	public Integer acceptString(StringSwitchValue value) {
+		return value.value.hashCode();
+	}
+
+	@Override
+	public Integer acceptEnumConstant(EnumConstantSwitchValue value) {
+		return value.constant.ordinal;
+	}
+
+	@Override
+	public Integer acceptVariantOption(VariantOptionSwitchValue value) {
+		return value.option.getOrdinal();
+	}
+}

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 public class JavaWriter {
-    private static final JavaMethodInfo STRING_CONCAT = new JavaMethodInfo(
+    private static final JavaMethod STRING_CONCAT = JavaMethod.getNativeStatic(
             JavaClass.STRING,
             "concat",
-            "(Ljava/lang/String;)Ljava/lang/String;",
-            Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+            "(Ljava/lang/String;)Ljava/lang/String;");
 
-    public final JavaMethodInfo method;
+    public final JavaMethod method;
     public final HighLevelDefinition forDefinition;
 
     private final LocalVariablesSorter visitor;
     public JavaWriter(
             ClassVisitor visitor,
             boolean nameVariables,
-            JavaMethodInfo method,
+            JavaMethod method,
             HighLevelDefinition forDefinition,
             String signature,
             String[] exceptions,
         this.nameVariables = nameVariables;
     }
 
-    public JavaWriter(ClassVisitor visitor, JavaMethodInfo method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
+    public JavaWriter(ClassVisitor visitor, JavaMethod method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
         this(visitor, true, method, forDefinition, signature, exceptions, annotations);
     }
 
-    private static String signature(Class aClass) {
-        return Type.getDescriptor(aClass);
-    }
-
     private static String internal(Class aClass) {
         return Type.getInternalName(aClass);
     }
         if (debug)
             System.out.println("load " + parameter.index);
 
-        visitor.visitVarInsn(parameter.type.getOpcode(ILOAD), parameter.index);
+        visitor.visitVarInsn(Type.getType(parameter.typeDescriptor).getOpcode(ILOAD), parameter.index);
     }
 
     public void load(JavaLocalVariableInfo localVariable) {
         if (debug)
             System.out.println("store " + parameter.index);
 
-        visitor.visitVarInsn(parameter.type.getOpcode(ISTORE), parameter.index);
+        visitor.visitVarInsn(Type.getType(parameter.typeDescriptor).getOpcode(ISTORE), parameter.index);
     }
 
     public void store(JavaLocalVariableInfo localVariable) {
         }
     }
 
-    public void newArray(Class componentType) {
-        if (debug)
-            System.out.println("newArray " + componentType.getName());
-
-        visitor.visitTypeInsn(NEWARRAY, internal(componentType));
-    }
-
-    public void checkCast(Class newClass) {
-        if (debug)
-            System.out.println("checkCast " + newClass.getName());
-
-        visitor.visitTypeInsn(CHECKCAST, signature(newClass));
-    }
-
     public void checkCast(String descriptor) {
         if (debug)
             System.out.println("checkCast " + descriptor);
         visitor.visitTypeInsn(INSTANCEOF, type.getDescriptor());
     }
 	
-	public void invokeStatic(JavaMethodInfo method) {
+	public void invokeStatic(JavaMethod method) {
 		visitor.visitMethodInsn(
 				INVOKESTATIC,
-				method.javaClass.internalName,
+				method.cls.internalName,
 				method.name,
 				method.descriptor,
 				false);
         invokeSpecial(Type.getInternalName(owner), name, descriptor);
     }
 
-	public void invokeSpecial (JavaMethodInfo method) {
-		invokeSpecial(method.javaClass.internalName, method.name, method.descriptor);
+	public void invokeSpecial(JavaMethod method) {
+		invokeSpecial(method.cls.internalName, method.name, method.descriptor);
 	}
 
-    public void invokeVirtual(JavaMethodInfo method) {
+    public void invokeVirtual(JavaMethod method) {
         if (debug)
-            System.out.println("invokeVirtual " + method.javaClass.internalName + '.' + method.name + method.descriptor);
+            System.out.println("invokeVirtual " + method.cls.internalName + '.' + method.name + method.descriptor);
 
-        visitor.visitMethodInsn(INVOKEVIRTUAL, method.javaClass.internalName, method.name, method.descriptor, false);
+        visitor.visitMethodInsn(INVOKEVIRTUAL, method.cls.internalName, method.name, method.descriptor, false);
     }
 
-    public void invokeInterface(JavaMethodInfo method) {
+    public void invokeInterface(JavaMethod method) {
         if (debug)
-            System.out.println("invokeInterface " + method.javaClass.internalName + '.' + method.name + method.descriptor);
+            System.out.println("invokeInterface " + method.cls.internalName + '.' + method.name + method.descriptor);
 
-        visitor.visitMethodInsn(INVOKEINTERFACE, method.javaClass.internalName, method.name, method.descriptor, true);
-    }
-
-    public void newObject(Class type) {
-        if (debug)
-            System.out.println("newObject " + type.getName());
-
-        visitor.visitTypeInsn(NEW, internal(type));
+        visitor.visitMethodInsn(INVOKEINTERFACE, method.cls.internalName, method.name, method.descriptor, true);
     }
 
     public void newObject(String internalName) {
         visitor.visitTypeInsn(NEW, internalName);
     }
 
-    public void construct(Class type, Class... arguments) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-        for (Class argument : arguments) {
-            descriptor.append(signature(argument));
-        }
-        descriptor.append(")V");
-
-        if (debug)
-            System.out.println("invokeSpecial " + internal(type) + ".<init>" + descriptor);
-
-        visitor.visitMethodInsn(INVOKESPECIAL, internal(type), "<init>", descriptor.toString(), false);
-    }
-
-    public void construct(String type, String... arguments) {
-        StringBuilder descriptor = new StringBuilder();
-        descriptor.append('(');
-        for (String argument : arguments) {
-            descriptor.append(argument);
-        }
-        descriptor.append(")V");
-
-        if (debug)
-            System.out.println("invokeSpecial " + type + ".<init>" + descriptor);
-
-        visitor.visitMethodInsn(INVOKESPECIAL, type, "<init>", descriptor.toString(), false);
-    }
-
     public void goTo(Label lbl) {
         if (debug)
             System.out.println("goTo " + getLabelName(lbl));
 
         visitor.visitFieldInsn(GETFIELD, owner, name, descriptor);
     }
-
-    public void getField(Class owner, String name, Class descriptor) {
-        if (debug)
-            System.out.println("getField " + owner.getName() + '.' + name + ":" + descriptor.getName());
-
-        visitor.visitFieldInsn(GETFIELD, internal(owner), name, signature(descriptor));
-    }
 	
 	public void getField(JavaField field) {
         if (debug)
-            System.out.println("getField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("getField " + field.cls.internalName + '.' + field.name + ":" + field.descriptor);
 		
-		visitor.visitFieldInsn(GETFIELD, field.cls.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(GETFIELD, field.cls.internalName, field.name, field.descriptor);
 	}
 
     public void putField(String owner, String name, String descriptor) {
 
         visitor.visitFieldInsn(PUTFIELD, owner, name, descriptor);
     }
-
-    public void putField(Class owner, String name, Class descriptor) {
-        if (debug)
-            System.out.println("putField " + owner.getName() + '.' + name + ":" + descriptor.getName());
-
-        visitor.visitFieldInsn(PUTFIELD, internal(owner), name, signature(descriptor));
-    }
 	
 	public void putField(JavaField field) {
         if (debug)
-            System.out.println("putField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("putField " + field.cls.internalName + '.' + field.name + ":" + field.descriptor);
 		
-		visitor.visitFieldInsn(PUTFIELD, field.cls.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(PUTFIELD, field.cls.internalName, field.name, field.descriptor);
 	}
 
     public void getStaticField(String owner, String name, String descriptor) {
 	
 	public void getStaticField(JavaField field) {
         if (debug)
-            System.out.println("getStaticField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("getStaticField " + field.cls.internalName + '.' + field.name + ":" + field.descriptor);
 		
-		visitor.visitFieldInsn(GETSTATIC, field.cls.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(GETSTATIC, field.cls.internalName, field.name, field.descriptor);
 	}
 
     public void putStaticField(String owner, String name, String descriptor) {
 
         visitor.visitFieldInsn(PUTSTATIC, owner, name, descriptor);
     }
-
-    public void putStaticField(Class owner, Field field) {
-        if (debug)
-            System.out.println("putStatic " + owner.getName() + '.' + field.getName() + ":" + signature(field.getType()));
-
-        visitor.visitFieldInsn(PUTSTATIC, internal(owner), field.getName(), signature(field.getType()));
-    }
 	
 	public void putStaticField(JavaField field) {
         if (debug)
-            System.out.println("putStaticField " + field.cls.internalName + '.' + field.name + ":" + field.signature);
+            System.out.println("putStaticField " + field.cls.internalName + '.' + field.name + ":" + field.descriptor);
 		
-		visitor.visitFieldInsn(PUTSTATIC, field.cls.internalName, field.name, field.signature);
+		visitor.visitFieldInsn(PUTSTATIC, field.cls.internalName, field.name, field.descriptor);
 	}
 
     public void aThrow() {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java

 
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.Type;
-import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.definition.*;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.compiler.*;
 import org.openzen.zenscript.javashared.JavaClass;
 
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.javashared.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
+import org.openzen.zenscript.javashared.JavaVariantOption;
 
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
-	private static final JavaMethodInfo CLASS_FORNAME = new JavaMethodInfo(
-			JavaClass.CLASS,
-			"forName",
-			"(Ljava/lang/String;)Ljava/lang/Class;",
-			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-
-
-	private static final JavaMethodInfo ENUM_VALUEOF = new JavaMethodInfo(
-			JavaClass.ENUM,
-			"valueOf",
-			"(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;",
-			Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-
+	private static final JavaMethod CLASS_FORNAME
+			= JavaMethod.getNativeStatic(JavaClass.CLASS, "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
+	private static final JavaMethod ENUM_VALUEOF
+			= JavaMethod.getNativeStatic(JavaClass.CLASS, "valueOf", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;");
+	private static final JavaMethod ARRAY_CLONE
+			= JavaMethod.getNativeVirtual(JavaClass.ARRAYS, "clone", "()Ljava/lang/Object;");
+	
 	private final JavaClassWriter outerWriter;
 	private final JavaBytecodeContext context;
 
 
 	@Override
 	public byte[] visitClass(ClassDefinition definition) {
-		//Classes will always be created in a new File/Class
-
-        final Type superType;
-        if (definition.getSuperType() == null)
-            superType = Type.getType(Object.class);
-        else
-            superType = context.getType(definition.getSuperType());
+        final String superTypeInternalName = definition.getSuperType() == null ? "java/lang/Object" : context.getInternalName(definition.getSuperType());
 
-		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.CLASS);
+		JavaClass toClass = definition.getTag(JavaClass.class);
 		JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
-        //TODO: Interfaces?
+		List<String> interfaces = new ArrayList<>();
+		for (IDefinitionMember member : definition.members) {
+			if (member instanceof ImplementationMember)
+				interfaces.add(context.getInternalName(((ImplementationMember) member).type));
+		}
         String signature = null;
 		
-        writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
+        writer.visit(Opcodes.V1_8, definition.modifiers, toClass.internalName, signature, superTypeInternalName, interfaces.toArray(new String[interfaces.size()]));
 		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition); 
         for (IDefinitionMember member : definition.members) {
             member.accept(memberVisitor);
 
 	@Override
 	public byte[] visitInterface(InterfaceDefinition definition) {
-		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.INTERFACE);
+		JavaClass toClass = definition.getTag(JavaClass.class);
 		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 		//TODO: Calculate signature from generic parameters
-		//TODO: Extending Interfaces?
 		String signature = null;
-		writer.visit(Opcodes.V1_8, definition.modifiers | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, definition.name, signature, Type.getInternalName(Object.class), null);
+		String[] baseInterfaces = new String[definition.baseInterfaces.size()];
+		for (int i = 0; i < baseInterfaces.length; i++)
+			baseInterfaces[i] = context.getInternalName(definition.baseInterfaces.get(i));
+		
+		writer.visit(Opcodes.V1_8, definition.modifiers | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, toClass.internalName, signature, "java/lang/Object", baseInterfaces);
 		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(memberVisitor);
 	public byte[] visitEnum(EnumDefinition definition) {
 		System.out.println("Compiling enum " + definition.name + " in " + definition.position.getFilename());
 		
-        final Type superType;
-        if (definition.getSuperType() == null)
-            superType = Type.getType(Object.class);
-        else
-            superType = context.getType(definition.getSuperType());
+		String superTypeInternalName = definition.getSuperType() == null ? "java/lang/Object" : context.getInternalName(definition.getSuperType());
 
 		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-		writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, definition.name, "Ljava/lang/Enum<L" + definition.name + ";>;", superType.getInternalName(), null);
-
-		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.ENUM);
+		JavaClass toClass = definition.getTag(JavaClass.class);
+		writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, toClass.internalName, "Ljava/lang/Enum<L" + toClass.internalName + ";>;", superTypeInternalName, null);
 
 		//Enum Stuff(required!)
-		writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
+		writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + toClass.internalName + ";", null, null).visitEnd();
 
         final JavaMemberVisitor visitor = new JavaMemberVisitor(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
             member.accept(visitor);
         }
 		
-		JavaClass arrayClass = JavaClass.fromInternalName("[L" + definition.name + ";", JavaClass.Kind.ARRAY);
-		JavaMethodInfo arrayClone = new JavaMethodInfo(arrayClass, "clone", "()Ljava/lang/Object;", Opcodes.ACC_PUBLIC);
-
-		JavaMethodInfo valuesMethodInfo = new JavaMethodInfo(toClass, "values", "()[L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethodInfo, definition, null, null);
+		JavaMethod valuesMethod = new JavaMethod(toClass, JavaMethod.Kind.STATIC, "values", true, "()[L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+		JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethod, definition, null, null);
 		valuesWriter.start();
-		valuesWriter.getStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
-		valuesWriter.invokeVirtual(arrayClone);
-		valuesWriter.checkCast("[L" + definition.name + ";");
+		valuesWriter.getStaticField(toClass.internalName, "$VALUES", "[L" + toClass.internalName + ";");
+		valuesWriter.invokeVirtual(ARRAY_CLONE);
+		valuesWriter.checkCast("[L" + toClass.internalName + ";");
 		valuesWriter.returnObject();
 		valuesWriter.end();
 
-		JavaMethodInfo valueOfMethodInfo = new JavaMethodInfo(toClass, "valueOf", "(Ljava/lang/String;)L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
-		JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethodInfo, definition, null, null);
+		JavaMethod valueOfMethod = new JavaMethod(toClass, JavaMethod.Kind.STATIC, "valueOf", true, "(Ljava/lang/String;)L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+		JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethod, definition, null, null);
 		valueOfWriter.start();
 		valueOfWriter.invokeStatic(CLASS_FORNAME);
 		valueOfWriter.loadObject(0);
 		valueOfWriter.invokeStatic(ENUM_VALUEOF);
-		valueOfWriter.checkCast("L" + definition.name + ";");
+		valueOfWriter.checkCast("L" + toClass.internalName + ";");
 		valueOfWriter.returnObject();
 		valueOfWriter.end();
-
-
+		
 		writer.visitEnd();
 		return writer.toByteArray();
 	}
 		
         final String signature = context.getMethodSignature(definition.header);
 		
-		final JavaClass toClass = new JavaClass(definition.pkg.fullName, CompilerUtils.calcClasName(definition.position), JavaClass.Kind.CLASS);
-		final JavaMethodInfo methodInfo = new JavaMethodInfo(toClass, definition.name, context.getMethodDescriptor(definition.header), CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC);
+		final JavaMethod method = definition.caller.getTag(JavaMethod.class);
 
-		final JavaWriter writer = new JavaWriter(outerWriter, true, methodInfo, definition, signature, null);
+		final JavaWriter writer = new JavaWriter(outerWriter, true, method, definition, signature, null);
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, writer);
         statementVisitor.start();
 		boolean returns = definition.statement.accept(statementVisitor);
 		}
 
 		statementVisitor.end();
-
-		definition.setTag(JavaMethodInfo.class, methodInfo);
-		definition.caller.setTag(JavaMethodInfo.class, methodInfo);
 		return null;
 	}
 
 
 	@Override
 	public byte[] visitVariant(VariantDefinition variant) {
-
-		final String variantName = variant.name;
-		final JavaClass toClass = new JavaClass("", variantName, JavaClass.Kind.CLASS);
+		final JavaClass toClass = variant.getTag(JavaClass.class);
 		final JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-		writer.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, variantName, null, "java/lang/Object", null);
+		writer.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, toClass.internalName, null, "java/lang/Object", null);
 		writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "getDenominator", "()I", null, null).visitEnd();
 
-
 		final JavaMemberVisitor visitor = new JavaMemberVisitor(context, writer, toClass, variant);
 
 		final List<VariantDefinition.Option> options = variant.options;
 		//Each option is one of the possible child classes
 		for (final VariantDefinition.Option option : options) {
-			final String optionClassName = variantName + "$" + option.name;
-			final JavaClass optionClass = new JavaClass("", optionClassName, JavaClass.Kind.CLASS);
+			JavaVariantOption optionTag = option.getTag(JavaVariantOption.class);
 			final JavaClassWriter optionWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-			writer.visitInnerClass(optionClassName, variantName, option.name, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL);
-
-
-			option.setTag(JavaClass.class, optionClass);
-
+			writer.visitInnerClass(optionTag.variantOptionClass.internalName, optionTag.variantClass.internalName, option.name, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL);
 
 			//Generic option signature
 			final String signature;
 					builder.append(context.getDescriptor(option.types[i]));
 				}
 				builder.append(">");
-				builder.append("L").append(variantName).append(";");
-
-
+				builder.append("L").append(toClass.internalName).append(";");
+				
 				signature = builder.toString();
 			}
 
-			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionClassName, signature, variantName, null);
-			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(context, optionWriter, optionClass, variant);
+			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionTag.variantOptionClass.internalName, signature, optionTag.variantClass.internalName, null);
+			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(context, optionWriter, optionTag.variantOptionClass, variant);
 			final StringBuilder optionInitDescBuilder = new StringBuilder("(");
 
 			ITypeID[] types = option.types;
 			for (int i = 0; i < types.length; ++i) {
 				final String internalName = context.getInternalName(types[i]);
 				optionInitDescBuilder.append(internalName);
-				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "Field" + i, internalName, "TT" + i + ";", null).visitEnd();
+				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "field" + i, internalName, "TT" + i + ";", null).visitEnd();
 			}
 			optionInitDescBuilder.append(")V");
-
-
-			final JavaWriter initWriter = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "<init>", optionInitDescBuilder.toString(), Opcodes.ACC_PUBLIC), variant, optionInitDescBuilder.toString(), null);
+			
+			JavaMethod constructorMethod = new JavaMethod(optionTag.variantOptionClass, JavaMethod.Kind.CONSTRUCTOR, "<init>", true, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
+			final JavaWriter initWriter = new JavaWriter(optionWriter, constructorMethod, variant, optionInitDescBuilder.toString(), null);
 			initWriter.start();
 			initWriter.loadObject(0);
 			initWriter.dup();
-			initWriter.invokeSpecial(variantName, "<init>", "()V");
+			initWriter.invokeSpecial(toClass.internalName, "<init>", "()V");
 			for (int i = 0; i < types.length; ++i) {
 				initWriter.dup();
 				initWriter.loadObject(i + 1);
 
 				final String descriptor = context.getDescriptor(types[i]);
-				initWriter.putField(optionClassName, "Field" + i, descriptor);
+				initWriter.putField(optionTag.variantOptionClass.internalName, "field" + i, descriptor);
 			}
 			initWriter.pop();
 			initWriter.ret();
 			initWriter.end();
-
-
+			
 			//Denominator for switch-cases
-			final JavaWriter getDenominator = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "getDenominator", "()I", Modifiers.PUBLIC), null, null, null, "java/lang/Override");
+			JavaMethod denominator = new JavaMethod(optionTag.variantOptionClass, JavaMethod.Kind.INSTANCE, "getDenominator", true, "()I", JavaModifiers.PUBLIC);
+			final JavaWriter getDenominator = new JavaWriter(optionWriter, denominator, null, null, null, "java/lang/Override");
 			getDenominator.start();
 			getDenominator.constant(option.ordinal);
 			getDenominator.returnInt();
 			getDenominator.end();
-
-
+			
 			optionVisitor.end();
 			optionWriter.visitEnd();
 			final byte[] byteArray = optionWriter.toByteArray();
-			context.register(optionClassName, byteArray);
+			context.register(optionTag.variantOptionClass.internalName, byteArray);
 
 			//Print the option files, won't be in production
-			try (FileOutputStream out = new FileOutputStream(optionClassName + ".class")) {
+			try (FileOutputStream out = new FileOutputStream(optionTag.variantOptionClass.internalName.replace('/', '_') + ".class")) {
 				out.write(byteArray);
 			} catch (IOException e) {
 				e.printStackTrace();
 			member.accept(visitor);
 		}
 
-		final JavaWriter superInitWriter = new JavaWriter(writer, new JavaMethodInfo(toClass, "<init>", "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
+		final JavaWriter superInitWriter = new JavaWriter(writer, new JavaMethod(toClass, JavaMethod.Kind.CONSTRUCTOR, "<init>", true, "()V", Opcodes.ACC_PUBLIC), variant, "()V", null);
 		superInitWriter.start();
 		superInitWriter.loadObject(0);
 		superInitWriter.invokeSpecial("java/lang/Object", "<init>", "()V");

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.*;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javashared.JavaParameterInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 import java.util.List;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
     private final ClassWriter writer;
         this.definition = definition;
 		this.context = context;
 
-        final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethodInfo(toClass, "<clinit>", "()V", 0), definition, null, null);
+        final JavaWriter javaWriter = new JavaWriter(writer, new JavaMethod(toClass, JavaMethod.Kind.STATICINIT, "<clinit>", true, "()V", 0), definition, null, null);
         this.clinitStatementVisitor = new JavaStatementVisitor(context, javaWriter);
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
 	
 	@Override
 	public Void visitConst(ConstMember member) {
-        //TODO calc signature
-        String signature = null;
-        final String descriptor = context.getDescriptor(member.type);
-        writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
-        member.setTag(JavaField.class, new JavaField(toClass, member.name, descriptor));
+		JavaField field = member.getTag(JavaField.class);
+        writer.visitField(CompilerUtils.calcAccess(member.modifiers), field.name, field.descriptor, field.signature, null).visitEnd();
         return null;
 	}
 
 	@Override
 	public Void visitField(FieldMember member) {
-
-        //TODO calc signature
-        String signature = null;
-        final String descriptor = context.getDescriptor(member.type);
-        writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
-        member.setTag(JavaField.class, new JavaField(toClass, member.name, descriptor));
+		JavaField field = member.getTag(JavaField.class);
+        writer.visitField(CompilerUtils.calcAccess(member.modifiers), field.name, field.descriptor, field.signature, null).visitEnd();
         return null;
     }
 
     @Override
     public Void visitConstructor(ConstructorMember member) {
         final boolean isEnum = definition instanceof EnumDefinition;
-        String descriptor = isEnum ? context.getEnumConstructorDescriptor(member.header) : context.getMethodDescriptor(member.header);
-        final JavaMethodInfo method = new JavaMethodInfo(toClass, "<init>", descriptor, isEnum ? Opcodes.ACC_PRIVATE : CompilerUtils.calcAccess(member.modifiers));
+        final JavaMethod method = member.getTag(JavaMethod.class);
 
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
 				constructorWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
 			} else if (definition.getSuperType() == null) {
 				System.out.println("Writing regular constructor");
-				constructorWriter.load(Type.getType(Object.class), 0);
+				constructorWriter.loadObject(0);
 				constructorWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
 			}
-
         }
 
 		member.body.accept(statementVisitor);
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		final JavaMethodInfo method = new JavaMethodInfo(toClass, "close", "()V", Opcodes.ACC_PUBLIC);
+		final JavaMethod method = new JavaMethod(toClass, JavaMethod.Kind.INSTANCE, "close", true, "()V", Opcodes.ACC_PUBLIC);
 
 		final Label constructorStart = new Label();
 		final Label constructorEnd = new Label();
         CompilerUtils.tagMethodParameters(context, member.header, member.isStatic());
 
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
-        int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
-                | (member.isStatic() ? Opcodes.ACC_STATIC : 0)
-                | CompilerUtils.calcAccess(member.modifiers);
-        final JavaMethodInfo method = new JavaMethodInfo(
-                toClass,
-                member.name,
-                context.getMethodSignature(member.header),
-                modifiers);
+        final JavaMethod method = member.getTag(JavaMethod.class);
 
         final Label methodStart = new Label();
         final Label methodEnd = new Label();
 			methodWriter.label(methodEnd);
 			statementVisitor.end();
 		}
-
-		member.setTag(JavaMethodInfo.class, method);
 		return null;
 	}
 

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

 		return new JavaClass(pkg, internalName, kind, nameParts);
 	}
 	
+	public static String getNameFromFile(String filename) {
+		if (filename.indexOf('.') > 0)
+			return filename.substring(0, filename.indexOf('.'));
+		else
+			return filename;
+	}
+	
 	public final JavaClass outer;
 	
 	public final String pkg;

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

 public class JavaField {
 	public final JavaClass cls;
 	public final String name;
-	public final String signature;
+	public final String descriptor;
+	public final String signature = null; // TODO: calculate signature too
 	
-	public JavaField(JavaClass cls, String name, String signature) {
+	public JavaField(JavaClass cls, String name, String descriptor) {
 		this.cls = cls;
 		this.name = name;
-		this.signature = signature;
+		this.descriptor = descriptor;
 	}
 }

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

  * @author Hoofdgebruiker
  */
 public class JavaMethod {
+	public static JavaMethod getConstructor(JavaClass cls, String descriptor, int modifiers) {
+		return new JavaMethod(cls, Kind.CONSTRUCTOR, "<init>", true, descriptor, modifiers);
+	}
+	
+	public static JavaMethod getNativeConstructor(JavaClass cls, String descriptor) {
+		return new JavaMethod(cls, Kind.CONSTRUCTOR, "<init>", false, descriptor, JavaModifiers.PUBLIC);
+	}
+	
+	public static JavaMethod getDestructor(JavaClass cls, int modifiers) {
+		return new JavaMethod(cls, Kind.INSTANCE, "close", true, "()V", modifiers);
+	}
+	
+	public static JavaMethod getStatic(JavaClass cls, String name, String descriptor, int modifiers) {
+		return new JavaMethod(cls, Kind.STATIC, name, true, descriptor, modifiers | JavaModifiers.STATIC);
+	}
+	
+	public static JavaMethod getNativeStatic(JavaClass cls, String name, String descriptor) {
+		return new JavaMethod(cls, Kind.STATIC, name, false, descriptor, JavaModifiers.STATIC | JavaModifiers.PUBLIC);
+	}
+	
+	public static JavaMethod getVirtual(JavaClass cls, String name, String descriptor, int modifiers) {
+		return new JavaMethod(cls, Kind.INSTANCE, name, true, descriptor, modifiers);
+	}
+	
+	public static JavaMethod getNativeVirtual(JavaClass cls, String name, String descriptor) {
+		return new JavaMethod(cls, Kind.INSTANCE, name, false, descriptor, JavaModifiers.PUBLIC);
+	}
+	
 	public final JavaClass cls;
 	public final Kind kind;
 	public final String name;
 	
 	public enum Kind {
 		STATIC,
+		STATICINIT,
 		INSTANCE,
 		EXPANSION,
 		CONSTRUCTOR,

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaParameterInfo.java → JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaParameterInfo.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.javabytecode;
-
-import org.objectweb.asm.Type;
+package org.openzen.zenscript.javashared;
 
 /**
  * @author Hoofdgebruiker
  */
 public class JavaParameterInfo {
 	public final int index;
-	public final Type type;
+	public final String typeDescriptor;
 
-	public JavaParameterInfo(int index, Type type) {
+	public JavaParameterInfo(int index, String typeDescriptor) {
 		this.index = index;
-		this.type = type;
+		this.typeDescriptor = typeDescriptor;
 	}
 }

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

 	
 	public static JavaSynthesizedClass createRangeName(RangeTypeID range) {
 		String signature = getRangeSignature(range);
-		String className = signature + "Range";
+		String className = signature;
 		JavaClass cls = new JavaClass("zsynthetic", className, JavaClass.Kind.CLASS);
 		return new JavaSynthesizedClass(cls, extractTypeParameters(range));
 	}

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

 
 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 	private static final boolean DEBUG_EMPTY = true;
 	
 	private final JavaContext context;
-	private final String filename;
 	private final JavaClass cls;
 	private final JavaNativeClass nativeClass;
 	private final JavaPrepareDefinitionMemberVisitor memberPreparer;
 	
 	public JavaPrepareClassMethodVisitor(
 			JavaContext context,
-			String filename,
 			JavaClass cls,
 			JavaNativeClass nativeClass,
 			JavaPrepareDefinitionMemberVisitor memberPreparer,
 			boolean startsEmpty) {
 		this.context = context;
-		this.filename = filename;
 		this.cls = cls;
 		this.nativeClass = nativeClass;
 		this.memberPreparer = memberPreparer;
 			JavaClass implementationClass = new JavaClass(cls, member.type.accept(new JavaTypeNameVisitor()) + "Implementation", JavaClass.Kind.CLASS);
 			member.setTag(JavaImplementation.class, new JavaImplementation(false, implementationClass));
 			
-			JavaPrepareClassMethodVisitor visitor = new JavaPrepareClassMethodVisitor(context, filename, implementationClass, null, memberPreparer, true);
+			JavaPrepareClassMethodVisitor visitor = new JavaPrepareClassMethodVisitor(context, implementationClass, null, memberPreparer, true);
 			for (IDefinitionMember m : member.members)
 				m.accept(visitor);
 		}
 
 	@Override
 	public Void visitInnerDefinition(InnerDefinitionMember member) {
-		JavaPrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaPrepareDefinitionMemberVisitor(context, filename);
+		JavaPrepareDefinitionMemberVisitor innerDefinitionPrepare = new JavaPrepareDefinitionMemberVisitor(context);
 		member.innerDefinition.accept(innerDefinitionPrepare);
 		
 		if (DEBUG_EMPTY && cls.empty)

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionMemberVisitor.java

  */
 public class JavaPrepareDefinitionMemberVisitor implements DefinitionVisitor<JavaClass> {
 	private final JavaContext context;
-	private final String filename;
 	
-	public JavaPrepareDefinitionMemberVisitor(JavaContext context, String filename) {
+	public JavaPrepareDefinitionMemberVisitor(JavaContext context) {
 		this.context = context;
-		this.filename = filename;
 	}
 	
 	private boolean isPrepared(HighLevelDefinition definition) {
 			return definition.getTag(JavaClass.class);
 		
 		JavaClass cls = definition.getTag(JavaClass.class);
-		JavaMethod method = new JavaMethod(cls, JavaMethod.Kind.STATIC, definition.name, true, context.getMethodDescriptor(definition.header), JavaModifiers.getJavaModifiers(definition.modifiers));
+		JavaMethod method = JavaMethod.getStatic(cls, definition.name, context.getMethodDescriptor(definition.header), JavaModifiers.getJavaModifiers(definition.modifiers));
 		definition.caller.setTag(JavaMethod.class, method);
 		return cls;
 	}
 	
 	private void visitClassMembers(HighLevelDefinition definition, JavaClass cls, JavaNativeClass nativeClass, boolean startsEmpty) {
 		System.out.println("Preparing " + cls.internalName);
-		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, filename, cls, nativeClass, this, startsEmpty);
+		JavaPrepareClassMethodVisitor methodVisitor = new JavaPrepareClassMethodVisitor(context, cls, nativeClass, this, startsEmpty);
 		for (IDefinitionMember member : definition.members) {
 			member.accept(methodVisitor);
 		}

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionVisitor.java

 		if (isPrepared(definition))
 			return definition.getTag(JavaClass.class);
 		
-		JavaClass cls = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(definition.pkg.fullName, JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
 		definition.setTag(JavaClass.class, cls);
 		return cls;
 	}
 			definition.setTag(JavaNativeClass.class, nativeClasses.get(nativeTag.value));
 		}
 		
-		JavaClass cls = new JavaClass(definition.pkg.fullName, filename, JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(definition.pkg.fullName, JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
 		definition.setTag(JavaClass.class, cls);
 		return cls;
 	}

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

 	}
 	
 	public void prepare(JavaContext context) {
-		JavaPrepareDefinitionMemberVisitor visitor = new JavaPrepareDefinitionMemberVisitor(context, file.getName());
+		JavaPrepareDefinitionMemberVisitor visitor = new JavaPrepareDefinitionMemberVisitor(context);
 		
 		if (mainDefinition != null)
 			mainDefinition.accept(visitor);

ScriptingExample/build.gradle

 dependencies {
 	compile project(':Parser')
 	compile project(':JavaBytecodeCompiler')
+	compile project(':JavaShared')
 	compile project(':CodeFormatter')
 	compile project(':Validator')
 	compile project(':Constructor')

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.objectweb.asm.Opcodes;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaField;
+import org.openzen.zenscript.javashared.JavaMethod;
 
 /**
  *
 	
 	public GlobalRegistry(ZSPackage globals) {
 		JavaClass jPrintStream = new JavaClass("java.io", "PrintStream", JavaClass.Kind.CLASS);
-		JavaMethodInfo printstreamPrintln = new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V", Opcodes.ACC_PUBLIC);
-		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, printstreamPrintln);
+		JavaMethod printstreamPrintln = JavaMethod.getNativeVirtual(jPrintStream, "println", "(Ljava/lang/String;)V");
+		PRINTSTREAM_PRINTLN.setTag(JavaMethod.class, printstreamPrintln);
 		
 		JavaClass jSystem = new JavaClass("java.lang", "System", JavaClass.Kind.CLASS);
 		SYSTEM_OUT.setTag(JavaField.class, new JavaField(jSystem, "out", "Ljava/io/PrintStream;"));
 		{
 			// eg. package my.package with a class MyClass with a single native method test() returning a string
 			// the visitors can then during compilation check if a method is an instance of NativeMethodMember and treat it accordingly
-			ZSPackage packageMyPackage = rootPackage.getOrCreatePackage("my").getOrCreatePackage("package");
+			ZSPackage packageMyPackage = rootPackage.getOrCreatePackage("my").getOrCreatePackage("test");
 			ClassDefinition myClassDefinition = new ClassDefinition(CodePosition.NATIVE, packageMyPackage, "MyClass", Modifiers.PUBLIC, null);
 			JavaClass myClassInfo = new JavaClass("my.test", "MyClass", JavaClass.Kind.CLASS);
 			
 			MethodMember member = new MethodMember(CodePosition.NATIVE, myClassDefinition, Modifiers.PUBLIC, "test", new FunctionHeader(BasicTypeID.STRING), null);
-			member.setTag(JavaMethodInfo.class, new JavaMethodInfo(myClassInfo, "test", "()Ljava/lang/String;", Opcodes.ACC_PUBLIC));
+			member.setTag(JavaMethod.class, JavaMethod.getNativeVirtual(myClassInfo, "test", "()Ljava/lang/String;"));
 			myClassDefinition.addMember(member);
 			
 			packageMyPackage.register(myClassDefinition);