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

# Conflicts:
#	JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaSynthesizedClassNamer.java

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

 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javashared.JavaTypeGenericVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.javashared.JavaContext;
 import org.openzen.zenscript.javashared.JavaMethod;

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, expression.type))
 				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;
 		}
 
 				context.getInternalName(expression.objectType),
 				"<init>",
 				context.getMethodDescriptor(expression.constructor.getHeader()));
-			
+
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, javaWriter.forDefinition, false);
         return null;
     }
 		final String name = context.getLambdaCounter();
 
 		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", signature);
-		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[]{context.getInternalName(new FunctionTypeID(null, expression.header))});
 		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
-		
+
 		javaWriter.newObject(name);
 		javaWriter.dup();
 
 			constructorWriter.dup();
 			Type type = context.getType(capture.type);
 			lambdaCW.visitField(Opcodes.ACC_FINAL | Opcodes.ACC_PRIVATE, "captured" + ++i, type.getDescriptor(), null, null).visitEnd();
-			
+
 			capture.accept(this);
 
 			constructorWriter.load(type, i);
 				return null;
 			}
 		});
-		
+
 		expression.body.accept(CSV);
-		
+
         functionWriter.ret();
 		functionWriter.end();
 		lambdaCW.visitEnd();
     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)
             type = ((DefinitionTypeID) expression.type).definition.name;
 
         javaWriter.newObject(type);
         javaWriter.dup();
-		
+
 		for (Expression argument : expression.arguments.arguments) {
 			argument.accept(this);
 		}
-		
+
         javaWriter.invokeSpecial(method);
 		return null;
 	}
         }
 		if (methodInfo.genericResult)
 			getJavaWriter().checkCast(context.getInternalName(resultType));
-		
+
         return true;
     }
 

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

 		this.startLabel = start;
 		this.endLabel = end;
 	}
-	
+
 	public void visitIntRange() {
 		javaWriter.dup();
 		javaWriter.getField("zsynthetic/IntRange", "to", "I");
 	}
 
 	public void visitStringCharacterIterator() {
-		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));
 	}
 
 	private void handleArray(final int z, final JavaLocalVariableInfo arrayTypeInfo) {

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

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
+import org.openzen.zenscript.javashared.JavaTypeGenericVisitor;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.openzen.zenscript.codemodel.definition.*;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.compiler.*;
 			= 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;
+	final JavaTypeGenericVisitor javaTypeGenericVisitor;
 
     public JavaDefinitionVisitor(JavaBytecodeContext context, JavaClassWriter outerWriter) {
 		this.context = context;
 		this.outerWriter = outerWriter;
+	    this.javaTypeGenericVisitor = new JavaTypeGenericVisitor(context);
 	}
 
 	@Override
 				interfaces.add(context.getInternalName(((ImplementationMember) member).type));
 		}
         String signature = 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); 
+		JavaMemberVisitor memberVisitor = new JavaMemberVisitor(context, writer, toClass, definition);
         for (IDefinitionMember member : definition.members) {
             member.accept(memberVisitor);
         }
 	@Override
 	public byte[] visitInterface(InterfaceDefinition definition) {
 		JavaClass toClass = definition.getTag(JavaClass.class);
-		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		ClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 		//TODO: Calculate signature from generic parameters
 		String signature = 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) {
 	@Override
 	public byte[] visitEnum(EnumDefinition definition) {
 		System.out.println("Compiling enum " + definition.name + " in " + definition.position.getFilename());
-		
+
 		String superTypeInternalName = definition.getSuperType() == null ? "java/lang/Object" : context.getInternalName(definition.getSuperType());
 
-		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+		ClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 		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);
         for (IDefinitionMember member : definition.members) {
             member.accept(visitor);
         }
-		
+
 		JavaMethod valuesMethod = JavaMethod.getStatic(toClass, "values", "()[L" + toClass.internalName + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
 		JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethod, definition, null, null);
 		valuesWriter.start();
 		valueOfWriter.checkCast(toClass.internalName);
 		valueOfWriter.returnObject();
 		valueOfWriter.end();
-		
+
 		writer.visitEnd();
 		return writer.toByteArray();
 	}
 	@Override
 	public byte[] visitFunction(FunctionDefinition definition) {
 		CompilerUtils.tagMethodParameters(context, definition.header, true);
-		
+
         final String signature = context.getMethodSignature(definition.header);
-		
+
 		final JavaMethod method = definition.caller.getTag(JavaMethod.class);
 
 		final JavaWriter writer = new JavaWriter(outerWriter, true, method, definition, signature, null);
 		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, toClass.internalName, null, "java/lang/Object", null);
+		final String variantName = variant.name;
+
+
+		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, toClass.internalName, ss, "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);
 		for (final VariantDefinition.Option option : options) {
 			JavaVariantOption optionTag = option.getTag(JavaVariantOption.class);
 			final JavaClassWriter optionWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+			final String optionClassName = variantName + "$" + option.name;
+			JavaClassWriter.registerSuperClass(optionClassName, variantName);
 
 			writer.visitInnerClass(optionTag.variantOptionClass.internalName, optionTag.variantClass.internalName, option.name, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL);
 
 			final String signature;
 			{
 				StringBuilder builder = new StringBuilder();
-				for (int i = 0; i < option.types.length; ++i) {
-					builder.append("<T").append(i).append(":");
-					builder.append(context.getDescriptor(option.types[i]));
+				//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(">");
-				builder.append("L").append(toClass.internalName).append(";");
-				
-				signature = builder.toString();
+				builder.append("L").append(toClass.internalName).append("<");
+
+				for (final TypeParameter genericParameter : variant.genericParameters) {
+					boolean t = true;
+					for (final ITypeID type : option.types)
+						if (type instanceof GenericTypeID) {
+							final GenericTypeID genericTypeID = (GenericTypeID) type;
+							if (genericParameter == genericTypeID.parameter) {
+								builder.append("T").append(genericParameter.name).append(";");
+								t = false;
+							}
+						}
+					if (t)
+						builder.append(javaTypeGenericVisitor.getGenericBounds(genericParameter.bounds));
+
+				}
+
+
+				signature = builder.append(">;").toString();
 			}
 
 			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("(");
+			final StringBuilder optionInitSignatureBuilder = new StringBuilder("(");
 
 			ITypeID[] types = option.types;
 			for (int i = 0; i < types.length; ++i) {
 				final String descriptor = context.getDescriptor(types[i]);
 				optionInitDescBuilder.append(descriptor);
-				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "field" + i, descriptor, "TT" + i + ";", null).visitEnd();
+				optionInitSignatureBuilder.append("T").append(((GenericTypeID) types[i]).parameter.name).append(";");
+				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "field" + i, descriptor, "T" + ((GenericTypeID) types[i]).parameter.name + ";", null).visitEnd();
 			}
 			optionInitDescBuilder.append(")V");
-			
-			JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOptionClass, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
-			final JavaWriter initWriter = new JavaWriter(optionWriter, constructorMethod, variant, optionInitDescBuilder.toString(), null);
+			optionInitSignatureBuilder.append(")V");
+
+JavaMethod constructorMethod = JavaMethod.getConstructor(optionTag.variantOptionClass, optionInitDescBuilder.toString(), JavaModifiers.PUBLIC);
+			final JavaWriter initWriter = new JavaWriter(optionWriter, constructorMethod, variant, optionInitSignatureBuilder.toString(), null);
 			initWriter.start();
 			initWriter.loadObject(0);
 			initWriter.dup();
 			initWriter.pop();
 			initWriter.ret();
 			initWriter.end();
-			
+
 			//Denominator for switch-cases
 			JavaMethod denominator = JavaMethod.getVirtual(optionTag.variantOptionClass, "getDenominator", "()I", JavaModifiers.PUBLIC);
 			final JavaWriter getDenominator = new JavaWriter(optionWriter, denominator, null, null, null, "java/lang/Override");
 			getDenominator.constant(option.ordinal);
 			getDenominator.returnInt();
 			getDenominator.end();
-			
+
 			optionVisitor.end();
 			optionWriter.visitEnd();
 			final byte[] byteArray = optionWriter.toByteArray();

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

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
+import org.openzen.zenscript.javashared.JavaTypeGenericVisitor;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, definition, true);
     }
-	
+
 	@Override
 	public Void visitConst(ConstMember member) {
 		JavaField field = member.getTag(JavaField.class);
         final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
         final JavaMethod method = member.getTag(JavaMethod.class);
 
-        final Label methodStart = new Label();
-        final Label methodEnd = new Label();
-        final JavaWriter methodWriter = new JavaWriter(writer, method, definition, context.getMethodSignature(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, context.getType(parameter.type));
-        }
+		final Label methodStart = new Label();
+		final Label methodEnd = new Label();
+	    final JavaWriter methodWriter = new JavaWriter(writer, method, definition, context.getMethodSignature(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, context.getType(parameter.type));
+		}
 
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, methodWriter);
 

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

 	}
 	
     public String getMethodSignature(FunctionHeader header) {
-        StringBuilder signatureBuilder = new StringBuilder("(");
-        for (FunctionParameter parameter : header.parameters) {
-            signatureBuilder.append(getDescriptor(parameter.type));
-        }
-        signatureBuilder.append(")").append(getDescriptor(header.getReturnType()));
-        return signatureBuilder.toString();
+        return new JavaTypeGenericVisitor(this).getGenericMethodSignature(header);
     }
 	
 	public String getEnumConstructorDescriptor(FunctionHeader header) {

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

+package org.openzen.zenscript.javashared;
+
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.generic.*;
+import org.openzen.zenscript.codemodel.type.*;
+
+import java.util.Collection;
+
+public class JavaTypeGenericVisitor implements ITypeVisitor<String> {
+
+	private final JavaContext context;
+
+	public JavaTypeGenericVisitor(JavaContext context) {
+		this.context = context;
+	}
+
+
+	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(this));
+		}
+
+		return builder.toString();
+	}
+
+
+	public String getGenericSignature(TypeParameter... parameters) {
+		if (parameters == null || parameters.length == 0)
+			return "";
+
+		final StringBuilder builder = new StringBuilder();
+		for (TypeParameter parameter : parameters) {
+			builder.append(parameter.name).append(":").append(getGenericBounds(parameter.bounds));
+		}
+		return builder.toString();
+	}
+
+	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 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(this));
+		}
+		return builder.toString();
+	}
+
+	public String getGenericMethodSignature(FunctionHeader header) {
+		return "(" + getGenericSignature(header.parameters) +
+				")" +
+				getGenericSignature(header.getReturnType());
+	}
+
+
+	public String getGenericBounds(Collection<TypeParameterBound> collection) {
+		if (collection == null)
+			return "";
+		for (TypeParameterBound parameterBound : collection) {
+			String s = parameterBound.accept(new GenericParameterBoundVisitor<String>() {
+				@Override
+				public String visitSuper(ParameterSuperBound bound) {
+					return null;
+				}
+
+				@Override
+				public String visitType(ParameterTypeBound bound) {
+					return bound.type.accept(JavaTypeGenericVisitor.this);
+				}
+			});
+			if (s != null)
+				return s;
+		}
+		return "Ljava/lang/Object;";
+	}
+
+	@Override
+	public String visitBasic(BasicTypeID basic) {
+		return context.getDescriptor(basic);
+	}
+
+	@Override
+	public String visitArray(ArrayTypeID array) {
+		return context.getDescriptor(array);
+	}
+
+	@Override
+	public String visitAssoc(AssocTypeID assoc) {
+		return context.getDescriptor(assoc);
+	}
+
+	@Override
+	public String visitGenericMap(GenericMapTypeID map) {
+		return context.getDescriptor(map);
+	}
+
+	@Override
+	public String visitIterator(IteratorTypeID iterator) {
+		return context.getDescriptor(iterator);
+	}
+
+	@Override
+	public String visitFunction(FunctionTypeID function) {
+		return context.getDescriptor(function);
+	}
+
+	@Override
+	public String visitDefinition(DefinitionTypeID definition) {
+		StringBuilder builder = new StringBuilder("L").append(definition.definition.name);
+
+		if (definition.typeParameters.length > 0) {
+			builder.append("<");
+			for (ITypeID typeParameter : definition.typeParameters) {
+				builder.append(typeParameter.accept(this));
+			}
+			builder.append(">");
+		}
+
+		return builder.append(";").toString();
+	}
+
+	@Override
+	public String visitGeneric(GenericTypeID generic) {
+		return "T" + generic.parameter.name + ";";
+		//return generic.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+	}
+
+	@Override
+	public String visitRange(RangeTypeID range) {
+		return context.getDescriptor(range);
+	}
+
+	@Override
+	public String visitModified(ModifiedTypeID type) {
+		return type.baseType.accept(this);
+	}
+}

ScriptingExample/build.gradle

 	compile project(':JavaBytecodeCompiler')
 	compile project(':JavaShared')
 	compile project(':CodeFormatter')
-	//compile project(':ScriptingHost')
+    //compile project(':ScriptingHost')
 }