Some work on match cases, committing to merge Stans changes

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

 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.JavaParameterInfo;
+import org.openzen.zenscript.javabytecode.compiler.definitions.JavaOptionInfoTag;
 
 import java.io.FileOutputStream;
 import java.io.IOException;
 
 		@Override
 		public Integer acceptVariantOption(VariantOptionSwitchValue value) {
-			throw new UnsupportedOperationException("Not there yet");
+			return value.option.getTag(JavaOptionInfoTag.class).number;
 		}
 	}
 }

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

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.expression.*;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
-import org.openzen.zenscript.codemodel.type.*;
+import org.openzen.zenscript.codemodel.type.ArrayTypeID;
+import org.openzen.zenscript.codemodel.type.AssocTypeID;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.implementations.IntRange;
 import org.openzen.zenscript.javabytecode.*;
 	private static final JavaMethodInfo COLLECTION_SIZE = new JavaMethodInfo(COLLECTION, "size", "()I", PUBLIC);
 	private static final JavaMethodInfo COLLECTION_TOARRAY = new JavaMethodInfo(COLLECTION, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", PUBLIC);
 
-	private final JavaWriter javaWriter;
+	protected final JavaWriter javaWriter;
 	private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
 
 	public JavaExpressionVisitor(JavaWriter javaWriter) {
 		return null;
 	}
 
-    @Override
-    public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
-        Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
+	@Override
+	public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
+		Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
 		try {
 			type.getInternalName();
 		} catch (NullPointerException ex) {
 			javaWriter.loadInt(2);
 		}
 
-        for (Expression argument : expression.arguments.arguments) {
-            argument.accept(this);
-        }
+		for (Expression argument : expression.arguments.arguments) {
+			argument.accept(this);
+		}
 		String internalName = type.getInternalName();
-        javaWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(expression.constructor.getHeader(), javaWriter.method.javaClass.isEnum));
-        return null;
-    }
+		javaWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(expression.constructor.getHeader(), javaWriter.method.javaClass.isEnum));
+		return null;
+	}
 
 	@Override
 	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
 
 		javaWriter.label(start);
 		expression.value.accept(this);
+
+
+		//TODO replace beforeSwitch visitor or similar
 		if (expression.value.type == BasicTypeID.STRING)
 			javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo("java/lang/Object"), "hashCode", "()I", 0));
 
+		//TODO replace with beforeSwitch visitor or similar
+		for (MatchExpression.Case aCase : expression.cases) {
+			if (aCase.key instanceof VariantOptionSwitchValue) {
+				VariantOptionSwitchValue variantOptionSwitchValue = (VariantOptionSwitchValue) aCase.key;
+				javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClassInfo(variantOptionSwitchValue.option.getName()), "getDenominator", "()I", 0));
+				break;
+			}
+		}
+
+
 		final boolean hasNoDefault = hasNoDefault(expression);
 
 		final MatchExpression.Case[] cases = expression.cases;
 				javaWriter.label(defaultLabel);
 			}
 			//switchCase.value.body.setTag(MatchExpression.class, expression);
-			switchCase.value.accept(this);
+			switchCase.value.accept(new MatchExpressionVisitor(this.javaWriter));
 			javaWriter.goTo(end);
 		}
 
 		if (hasNoDefault) {
 			javaWriter.label(defaultLabel);
+			if (Object.class.isAssignableFrom(expression.type.accept(JavaTypeClassVisitor.INSTANCE)))
+				javaWriter.aConstNull();
+			else
+				javaWriter.iConst0();
 		}
 
 		javaWriter.label(end);
 		expression.value.accept(this);
 
 		//i.e. if it was a primitive
-		if(info != null)
+		if (info != null)
 			javaWriter.invokeSpecial(info);
 		return null;
 	}
 		}
 		return true;
 	}
+
+
+	private static final class MatchExpressionVisitor extends JavaExpressionVisitor {
+		public MatchExpressionVisitor(JavaWriter javaWriter) {
+			super(javaWriter);
+		}
+
+		@Override
+		public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
+			final Label label = new Label();
+			final JavaLocalVariableInfo tag = expression.variable.getTag(JavaLocalVariableInfo.class);
+			if (tag != null) {
+				tag.end = label;
+				javaWriter.load(tag.type, tag.local);
+				javaWriter.label(label);
+				return null;
+			}
+
+			javaWriter.aConstNull();
+			return null;
+
+		}
+	}
 }

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

 	@Override
 	public Boolean visitReturn(ReturnStatement statement) {
 		statement.value.accept(expressionVisitor);
-		javaWriter.returnType(Type.getType(statement.value.type.accept(JavaTypeClassVisitor.INSTANCE)));
+		javaWriter.returnType(statement.value.type.accept(JavaTypeVisitor.INSTANCE));
 		return true;
 	}
 

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

 
 	@Override
 	public Class visitGeneric(GenericTypeID generic) {
-		return null;
+		return Object.class;
 	}
 
 	@Override

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

 
 	@Override
 	public Type visitGeneric(GenericTypeID generic) {
-		return Type.getType(generic.accept(JavaTypeClassVisitor.INSTANCE));
+		final Class<?> clazz = generic.accept(JavaTypeClassVisitor.INSTANCE);
+		return Type.getType(clazz == null ? Object.class : clazz);
 	}
 
 	@Override

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

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
 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.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.javabytecode.JavaModule;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.List;
+
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 	private static final JavaClassInfo T_CLASS = new JavaClassInfo("java/lang/Class");
 	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 = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
+		final Type superType;
+		if (definition.getSuperType() == null)
+			superType = Type.getType(Object.class);
+		else
+			superType = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
 
 		JavaClassInfo toClass = new JavaClassInfo(definition.name);
 		JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 	@Override
 	public byte[] visitEnum(EnumDefinition definition) {
 		System.out.println("Compiling enum " + definition.name + " in " + definition.position.filename);
-		
-        final Type superType;
-        if (definition.getSuperType() == null)
-            superType = Type.getType(Object.class);
-        else
-            superType = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
+
+		final Type superType;
+		if (definition.getSuperType() == null)
+			superType = Type.getType(Object.class);
+		else
+			superType = Type.getType(definition.getSuperType().accept(JavaTypeClassVisitor.INSTANCE));
 
 		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
 
 	@Override
 	public byte[] visitVariant(VariantDefinition variant) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+
+		final String variantName = variant.name;
+		final JavaClassInfo toClass = new JavaClassInfo(variantName);
+		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.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "getDenominator", "()I", null, null).visitEnd();
+
+
+		final JavaMemberVisitor visitor = new JavaMemberVisitor(writer, toClass, variant);
+
+
+		final List<VariantDefinition.Option> options = variant.options;
+		for (int optionNo = 0, optionsSize = options.size(); optionNo < optionsSize; optionNo++) {
+			final VariantDefinition.Option option = options.get(optionNo);
+			option.setTag(JavaOptionInfoTag.class, new JavaOptionInfoTag(optionNo));
+		}
+
+		for (final IDefinitionMember member : variant.members) {
+			member.accept(visitor);
+		}
+
+
+
+
+		//Each option is one of the possible child classes
+		for (int optionNo = 0, optionsSize = options.size(); optionNo < optionsSize; ++optionNo) {
+			final VariantDefinition.Option option = options.get(optionNo);
+
+			final String optionClassName = variantName + "$" + option.name;
+			final JavaClassInfo optionClass = new JavaClassInfo(variantName);
+			final JavaClassWriter optionWriter = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
+
+
+			//Generic option signature
+			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(">");
+				builder.append("L").append(variantName).append(";");
+
+
+				signature = builder.toString();
+			}
+
+			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionClassName, signature, variantName, null);
+			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(optionWriter, optionClass, variant);
+
+			ITypeID[] types = option.types;
+			for (int i = 0; i < types.length; ++i) {
+				final ITypeID type = types[i];
+				final String internalName = type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
+				optionWriter.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "Field" + i, internalName, "TT" + i + ";", null).visitEnd();
+			}
+
+
+			//Denominator for switch-cases
+			final JavaWriter getDenominator = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "getDenominator", "()I", Modifiers.PUBLIC), null,null, null, "java/lang/Override");
+			getDenominator.start();
+			getDenominator.constant(optionNo);
+			getDenominator.returnInt();
+			getDenominator.end();
+
+
+
+			//Print the option files, won't be in production
+			optionVisitor.end();
+			optionWriter.visitEnd();
+			JavaModule.classes.put(optionClassName, optionWriter.toByteArray());
+			try (FileOutputStream out = new FileOutputStream(optionClassName + ".class")) {
+				out.write(optionWriter.toByteArray());
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		visitor.end();
+		writer.visitEnd();
+
+
+		return writer.toByteArray();
 	}
 }

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

 		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, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+				methodWriter.nameVariable(parameter.getTag(JavaParameterInfo.class).index, parameter.name, methodStart, methodEnd, parameter.type.accept(JavaTypeVisitor.INSTANCE));
 		}
 
 		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(methodWriter);

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

+package org.openzen.zenscript.javabytecode.compiler.definitions;
+
+public class JavaOptionInfoTag {
+	public final int number;
+
+	public JavaOptionInfoTag(int number) {
+		this.number = number;
+	}
+}