Commit before merge

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

     }
 
     private static void createLambdaInterface(JavaBytecodeContext context, FunctionHeader header, JavaClass cls) {
-        ClassWriter ifaceWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+        ClassWriter ifaceWriter = new JavaClassWriter(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);
 

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

 
 import org.objectweb.asm.ClassWriter;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class JavaClassWriter extends ClassWriter {
+
+	private static final Map<String, String> super_classes = new HashMap<>();
+
+	public static void registerSuperClass(String child, String superClass) {
+		super_classes.put(child, superClass);
+	}
+
+	public static Map<String, String> getSuper_classes() {
+		return super_classes;
+	}
+
 	public JavaClassWriter(int flags) {
 		super(flags);
 	}
+
+	@Override
+	protected String getCommonSuperClass(String type1, String type2) {
+
+		//FIXME big TODO, make this more efficient!!!
+		try {
+			return super.getCommonSuperClass(type1, type2);
+		} catch (Exception ignored){}
+
+
+		if(type1.equals(type2))
+			return type1;
+
+		String newType2 = type2;
+		while(super_classes.containsKey(newType2)){
+			newType2 = super_classes.get(newType2);
+			if(type1.equals(newType2))
+				return type1;
+		}
+
+		String newType1 = type1;
+		while(super_classes.containsKey(newType1)){
+			newType1 = super_classes.get(newType1);
+			if(type2.equals(newType1))
+				return type2;
+		}
+
+		return super_classes.containsKey(type1) ? getCommonSuperClass(super_classes.get(type1), type2) : super_classes.containsKey(type2) ? getCommonSuperClass(type1, super_classes.get(type2)) : "java/lang/Object";
+
+	}
+
+
 }

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

 
 			if (!checkAndExecuteMethodInfo(expression.member))
 				throw new IllegalStateException("Call target has no method info!");
+			//if (expression.member.getHeader().returnType != expression.type)
+
+			//TODO see if the types differ (e.g. if a generic method was invoked) and only cast then
+			if(expression.type != BasicTypeID.VOID)
+				javaWriter.checkCast(context.getInternalName(expression.type));
 			return null;
 		}
 
 		final String name = CompilerUtils.getLambdaCounter();
 
 		final JavaMethodInfo methodInfo = new JavaMethodInfo(javaWriter.method.javaClass, "accept", signature, Opcodes.ACC_PUBLIC);
-		final ClassWriter lambdaCW = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		final ClassWriter lambdaCW = new JavaClassWriter(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");
 
 		javaWriter.checkCast(tag.internalName);
 		javaWriter.getField(new JavaField(tag, "Field" + expression.index, context.getDescriptor(type)));
 		return null;
-		//throw new UnsupportedOperationException(); // TODO
 	}
 
 	@Override

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

 
 	@Override
 	public Void visitStringCharacterIterator() {
-		// TODO: implement this one
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		//TODO UNTESTED!
+		javaWriter.invokeSpecial("java/lang/String", "toCharArray()", "()[C");
+		handleArray(javaWriter.local(int.class), variables[0].getTag(JavaLocalVariableInfo.class));
+		return null;
 	}
 
 	private void handleArray(final int z, final JavaLocalVariableInfo arrayTypeInfo) {

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.generic.*;
 import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 
 import java.util.Collection;
 
 public class JavaTypeGenericVisitor implements ITypeVisitor<String> {
 
-	public static final JavaTypeGenericVisitor INSTANCE = new JavaTypeGenericVisitor();
+	private final JavaBytecodeContext context;
+
+	public JavaTypeGenericVisitor(JavaBytecodeContext context) {
+		this.context = context;
+	}
 
 
-	public static String getGenericSignature(ITypeID... types) {
+	public String getGenericSignature(ITypeID... types) {
 		if (types == null || types.length == 0)
 			return "";
 		final StringBuilder builder = new StringBuilder();
 		for (ITypeID type : types) {
-			builder.append(type.accept(INSTANCE));
+			builder.append(type.accept(this));
 		}
 
 		return builder.toString();
 	}
 
 
-	public static String getGenericSignature(TypeParameter... parameters) {
+	public String getGenericSignature(TypeParameter... parameters) {
 		if (parameters == null || parameters.length == 0)
 			return "";
 
 		return builder.toString();
 	}
 
-	public static String getSignatureWithBound(ITypeID type) {
+	public String getSignatureWithBound(ITypeID type) {
 		if(type instanceof GenericTypeID){
 			final TypeParameter parameter = ((GenericTypeID) type).parameter;
 			return parameter.name + ":" + getGenericBounds(parameter.bounds);
 		throw new IllegalStateException("Type " + type + " is of the wrong class");
 	}
 
-	private static String getGenericSignature(FunctionParameter... parameters) {
+	private String getGenericSignature(FunctionParameter... parameters) {
 		if(parameters == null || parameters.length == 0)
 			return "";
 		final StringBuilder builder = new StringBuilder();
 		for (FunctionParameter parameter : parameters) {
-			builder.append(parameter.type.accept(INSTANCE));
+			builder.append(parameter.type.accept(this));
 		}
 		return builder.toString();
 	}
 
-	public static String getGenericMethodSignature(FunctionHeader header) {
+	public String getGenericMethodSignature(FunctionHeader header) {
 		return "(" + getGenericSignature(header.parameters) +
 				")" +
 				getGenericSignature(header.returnType);
 	}
 
 
-	public static String getGenericBounds(Collection<GenericParameterBound> collection) {
+	public String getGenericBounds(Collection<GenericParameterBound> collection) {
 		if (collection == null)
 			return "";
 		for (GenericParameterBound parameterBound : collection) {
 
 				@Override
 				public String visitType(ParameterTypeBound bound) {
-					return bound.type.accept(INSTANCE);
+					return bound.type.accept(JavaTypeGenericVisitor.this);
 				}
 			});
 			if (s != null)
 		return "Ljava/lang/Object;";
 	}
 
-
-	private JavaTypeGenericVisitor() {
-	}
-
 	@Override
 	public String visitBasic(BasicTypeID basic) {
-		return basic.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+		return context.getDescriptor(basic);
 	}
 
 	@Override
 	public String visitArray(ArrayTypeID array) {
-		return array.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+		return context.getDescriptor(array);
 	}
 
 	@Override
 	public String visitAssoc(AssocTypeID assoc) {
-		return assoc.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+		return context.getDescriptor(assoc);
 	}
 
 	@Override
 	public String visitGenericMap(GenericMapTypeID map) {
-		return map.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+		return context.getDescriptor(map);
 	}
 
 	@Override
 	public String visitIterator(IteratorTypeID iterator) {
-		return iterator.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+		return context.getDescriptor(iterator);
 	}
 
 	@Override
 	public String visitFunction(FunctionTypeID function) {
-		return function.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+		return context.getDescriptor(function);
 	}
 
 	@Override
 
 	@Override
 	public String visitRange(RangeTypeID range) {
-		return range.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+		return context.getDescriptor(range);
 	}
 
 	@Override

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

 
 	private final JavaClassWriter outerWriter;
 	private final JavaBytecodeContext context;
+	final JavaTypeGenericVisitor javaTypeGenericVisitor;
 
     public JavaDefinitionVisitor(JavaBytecodeContext context, JavaClassWriter outerWriter) {
 		this.context = context;
 		this.outerWriter = outerWriter;
+	    this.javaTypeGenericVisitor = new JavaTypeGenericVisitor(context);
 	}
 
 	@Override
 	@Override
 	public byte[] visitInterface(InterfaceDefinition definition) {
 		JavaClass toClass = new JavaClass(definition.pkg.fullName, definition.name, JavaClass.Kind.INTERFACE);
-		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		ClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 		//TODO: Calculate signature from generic parameters
 		//TODO: Extending Interfaces?
         else
             superType = context.getType(definition.getSuperType());
 
-		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		ClassWriter writer = new JavaClassWriter(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);
 
 		final JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 
-		final String ss = "<" + JavaTypeGenericVisitor.getGenericSignature(variant.genericParameters) + ">Ljava/lang/Object;";
-
+		final String ss = "<" + javaTypeGenericVisitor.getGenericSignature(variant.genericParameters) + ">Ljava/lang/Object;";
+		JavaClassWriter.registerSuperClass(variantName, "java/lang/Object");
 
 		writer.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, variantName, ss, "java/lang/Object", null);
 		writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "getDenominator", "()I", null, null).visitEnd();
 			final String optionClassName = variantName + "$" + option.name;
 			final JavaClass optionClass = new JavaClass("", optionClassName, JavaClass.Kind.CLASS);
 			final JavaClassWriter optionWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+			JavaClassWriter.registerSuperClass(optionClassName, variantName);
 
 			writer.visitInnerClass(optionClassName, variantName, option.name, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL);
 
 				//TODO check if this can be changed to what Stan was up to
 				builder.append("<");
 				for (final ITypeID type : option.types) {
-					builder.append(JavaTypeGenericVisitor.getSignatureWithBound(type));
+					builder.append(javaTypeGenericVisitor.getSignatureWithBound(type));
 				}
 				builder.append(">");
 				builder.append("L").append(variantName).append("<");
 							}
 						}
 					if (t)
-						builder.append(JavaTypeGenericVisitor.getGenericBounds(genericParameter.bounds));
+						builder.append(javaTypeGenericVisitor.getGenericBounds(genericParameter.bounds));
 
 				}
 
 
 			ITypeID[] types = option.types;
 			for (int i = 0; i < types.length; ++i) {
-				final String internalName = context.getInternalName(types[i]);
-				optionInitDescBuilder.append(internalName);
+				final String descriptor = context.getDescriptor(types[i]);
+				optionInitDescBuilder.append(descriptor);
 				optionInitSignatureBuilder.append("T").append(((GenericTypeID) types[i]).parameter.name).append(";");
-				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "Field" + i, internalName, "T" + ((GenericTypeID) types[i]).parameter.name + ";", null).visitEnd();
+				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "Field" + i, descriptor, "T" + ((GenericTypeID) types[i]).parameter.name + ";", null).visitEnd();
 			}
 			optionInitDescBuilder.append(")V");
 			optionInitSignatureBuilder.append(")V");

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

 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
 		//TODO see if this can be changed to Stan's changes (context call maybe?)
-		final JavaWriter methodWriter = new JavaWriter(writer, method, definition, JavaTypeGenericVisitor.getGenericMethodSignature(member.header), null);
+	    final JavaWriter methodWriter = new JavaWriter(writer, method, definition, new JavaTypeGenericVisitor(context).getGenericMethodSignature(member.header), null);
 		methodWriter.label(methodStart);
 		for (final FunctionParameter parameter : member.header.parameters) {
 			methodWriter.nameParameter(0, parameter.name);
 			if (!isAbstract)
-				methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, parameter.type.accept(JavaTypeVisitor.INSTANCE));
+				methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
 		}
 
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, methodWriter);