More work for Variants and generics, WIP

push to merge stan's changes

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

@@ -2046,7 +2046,8 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 
 		if (hasNoDefault) {
 			javaWriter.label(defaultLabel);
-			if (Object.class.isAssignableFrom(expression.type.accept(JavaTypeClassVisitor.INSTANCE)))
+			final Type type = expression.type.accept(JavaTypeVisitor.INSTANCE);
+			if (type == null || type.getOpcode(Opcodes.ISTORE) == Opcodes.ASTORE)
 				javaWriter.aConstNull();
 			else
 				javaWriter.iConst0();

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

@@ -0,0 +1,148 @@
+package org.openzen.zenscript.javabytecode.compiler;
+
+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> {
+
+	public static final JavaTypeGenericVisitor INSTANCE = new JavaTypeGenericVisitor();
+
+
+	public static 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));
+		}
+
+		return builder.toString();
+	}
+
+
+	public static 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 static 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) {
+		if(parameters == null || parameters.length == 0)
+			return "";
+		final StringBuilder builder = new StringBuilder();
+		for (FunctionParameter parameter : parameters) {
+			builder.append(parameter.type.accept(INSTANCE));
+		}
+		return builder.toString();
+	}
+
+	public static String getGenericMethodSignature(FunctionHeader header) {
+		return "(" + getGenericSignature(header.parameters) +
+				")" +
+				getGenericSignature(header.returnType);
+	}
+
+
+	public static String getGenericBounds(Collection<GenericParameterBound> collection) {
+		if (collection == null)
+			return "";
+		for (GenericParameterBound 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(INSTANCE);
+				}
+			});
+			if (s != null)
+				return s;
+		}
+		return "Ljava/lang/Object;";
+	}
+
+
+	private JavaTypeGenericVisitor() {
+	}
+
+	@Override
+	public String visitBasic(BasicTypeID basic) {
+		return basic.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+	}
+
+	@Override
+	public String visitArray(ArrayTypeID array) {
+		return array.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+	}
+
+	@Override
+	public String visitAssoc(AssocTypeID assoc) {
+		return assoc.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+	}
+
+	@Override
+	public String visitGenericMap(GenericMapTypeID map) {
+		return map.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+	}
+
+	@Override
+	public String visitIterator(IteratorTypeID iterator) {
+		return iterator.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+	}
+
+	@Override
+	public String visitFunction(FunctionTypeID function) {
+		return function.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+	}
+
+	@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 range.accept(JavaTypeVisitor.INSTANCE).getDescriptor();
+	}
+
+	@Override
+	public String visitModified(ModifiedTypeID type) {
+		return type.baseType.accept(this);
+	}
+}

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

@@ -5,8 +5,10 @@ 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.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.JavaMethodInfo;
 import org.openzen.zenscript.javabytecode.JavaModule;
@@ -187,7 +189,11 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 		final JavaClass toClass = new JavaClass("", variantName, JavaClass.Kind.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);
+
+		final String ss = "<" + JavaTypeGenericVisitor.getGenericSignature(variant.genericParameters) + ">Ljava/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();
 
 
@@ -210,15 +216,30 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 			final String signature;
 			{
 				StringBuilder builder = new StringBuilder();
-				for (int i = 0; i < option.types.length; ++i) {
-					builder.append("<T").append(i).append(":");
-					builder.append(option.types[i].accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+				builder.append("<");
+				for (final ITypeID type : option.types) {
+					builder.append(JavaTypeGenericVisitor.getSignatureWithBound(type));
 				}
 				builder.append(">");
-				builder.append("L").append(variantName).append(";");
+				builder.append("L").append(variantName).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.toString();
+				signature = builder.append(">;").toString();
 			}
 
 			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionClassName, signature, variantName, null);
@@ -226,18 +247,21 @@ public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 
 
 			final StringBuilder optionInitDescBuilder = new StringBuilder("(");
+			final StringBuilder optionInitSignatureBuilder = new StringBuilder("(");
 
 			ITypeID[] types = option.types;
 			for (int i = 0; i < types.length; ++i) {
 				final Type type = types[i].accept(JavaTypeVisitor.INSTANCE);
 				final String internalName = type.getDescriptor();
 				optionInitDescBuilder.append(internalName);
-				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "Field" + i, internalName, "TT" + i + ";", null).visitEnd();
+				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();
 			}
 			optionInitDescBuilder.append(")V");
+			optionInitSignatureBuilder.append(")V");
 
 
-			final JavaWriter initWriter = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "<init>", optionInitDescBuilder.toString(), Opcodes.ACC_PUBLIC), variant, optionInitDescBuilder.toString(), null);
+			final JavaWriter initWriter = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "<init>", optionInitDescBuilder.toString(), Opcodes.ACC_PUBLIC), variant, optionInitSignatureBuilder.toString(), null);
 			initWriter.start();
 			initWriter.loadObject(0);
 			initWriter.dup();

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

@@ -138,7 +138,7 @@ public class JavaMemberVisitor implements MemberVisitor<Void> {
 
 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
-		final JavaWriter methodWriter = new JavaWriter(writer, method, definition, CompilerUtils.calcSign(member.header, false), null);
+		final JavaWriter methodWriter = new JavaWriter(writer, method, definition, JavaTypeGenericVisitor.getGenericMethodSignature(member.header), null);
 		methodWriter.label(methodStart);
 		for (final FunctionParameter parameter : member.header.parameters) {
 			methodWriter.nameParameter(0, parameter.name);