Some more work on Variants, still WIP

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.instancedHeader.returnType != BasicTypeID.VOID)
+				javaWriter.checkCast("java/lang/String");
 			return null;
 		}
 
 	public Void visitGetMatchingVariantField(GetMatchingVariantField expression) {
 		javaWriter.loadObject(0);
 		final ITypeID type = expression.value.option.getParameterType(expression.index);
-		javaWriter.getField(new JavaFieldInfo(expression.value.option.getTag(JavaClass.class), "Field" + expression.index, type.accept(JavaTypeVisitor.INSTANCE).getInternalName()));
+		final JavaClass tag = expression.value.option.getTag(JavaClass.class);
+		javaWriter.checkCast(tag.internalName);
+		javaWriter.getField(new JavaFieldInfo(tag, "Field" + expression.index, type.accept(JavaTypeVisitor.INSTANCE).getDescriptor()));
 		return null;
 		//throw new UnsupportedOperationException(); // TODO
 	}
 		for (MatchExpression.Case aCase : expression.cases) {
 			if (aCase.key instanceof VariantOptionSwitchValue) {
 				VariantOptionSwitchValue variantOptionSwitchValue = (VariantOptionSwitchValue) aCase.key;
-				javaWriter.invokeVirtual(new JavaMethodInfo(new JavaClass("", variantOptionSwitchValue.option.getName(), JavaClass.Kind.CLASS), "getDenominator", "()I", 0));
+				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));
 				break;
 			}
 		}
 
 	@Override
 	public Void visitVariantValue(VariantValueExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		final String internalName = expression.option.getTag(JavaClass.class).internalName;
+		javaWriter.newObject(internalName);
+		javaWriter.dup();
+
+		for (Expression argument : expression.arguments) {
+			argument.accept(this);
+		}
+
+		final StringBuilder builder = new StringBuilder("(");
+		for (ITypeID type : expression.option.getOption().types) {
+			builder.append(type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+		}
+		builder.append(")V");
+
+
+		javaWriter.invokeSpecial(internalName, "<init>", builder.toString());
+
+
+
+		return null;
 	}
 
 	@Override

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

 
 	@Override
 	public Type visitDefinition(DefinitionTypeID definition) {
-		return Type.getType("L" + definition + ";");
+		return Type.getType("L" + definition.definition.name + ";");
 	}
 
 	@Override

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

 			final JavaClass optionClass = new JavaClass("", optionClassName, JavaClass.Kind.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);
 
 
 			optionWriter.visit(Opcodes.V1_8, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, optionClassName, signature, variantName, null);
 			final JavaMemberVisitor optionVisitor = new JavaMemberVisitor(optionWriter, optionClass, variant);
 
+
+			final StringBuilder optionInitDescBuilder = new StringBuilder("(");
+
 			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();
+				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();
 			}
+			optionInitDescBuilder.append(")V");
+
+
+			final JavaWriter initWriter = new JavaWriter(optionWriter, new JavaMethodInfo(optionClass, "<init>", optionInitDescBuilder.toString(), Opcodes.ACC_PUBLIC), variant, optionInitDescBuilder.toString(), null);
+			initWriter.start();
+			initWriter.loadObject(0);
+			initWriter.dup();
+			initWriter.invokeSpecial(variantName, "<init>", "()V");
+			for (int i = 0; i < types.length; ++i) {
+				initWriter.dup();
+				initWriter.loadObject(i + 1);
+
+				final Type type = types[i].accept(JavaTypeVisitor.INSTANCE);
+				final String internalName = type.getDescriptor();
+
+				initWriter.putField(optionClassName, "Field" + i, internalName);
+			}
+			initWriter.pop();
+			initWriter.ret();
+			initWriter.end();
 
 
 			//Denominator for switch-cases
 			getDenominator.end();
 
 
-			//Print the option files, won't be in production
 			optionVisitor.end();
 			optionWriter.visitEnd();
-			JavaModule.classes.put(optionClassName, optionWriter.toByteArray());
+			final byte[] byteArray = optionWriter.toByteArray();
+			JavaModule.classes.put(optionClassName, byteArray);
+
+			//Print the option files, won't be in production
 			try (FileOutputStream out = new FileOutputStream(optionClassName + ".class")) {
-				out.write(optionWriter.toByteArray());
+				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);
+		superInitWriter.start();
+		superInitWriter.loadObject(0);
+		superInitWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
+		superInitWriter.ret();
+		superInitWriter.end();
+
 		visitor.end();
 		writer.visitEnd();