WIP - Expansion methods

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

             String signature,
             String[] exceptions,
             String... annotations) {
+        this(visitor, nameVariables, method, forDefinition, false, signature, method.descriptor, exceptions, annotations);
+    }
+
+
+    public JavaWriter(
+            ClassVisitor visitor,
+            boolean nameVariables,
+            JavaMethod method,
+            HighLevelDefinition forDefinition,
+            boolean isExtension,
+            String signature,
+            String descriptor,
+            String[] exceptions,
+            String... annotations) {
         this.clazzVisitor = visitor;
         this.method = method;
         this.forDefinition = forDefinition;
 
-        final MethodVisitor methodVisitor = visitor.visitMethod(method.modifiers, method.name, method.descriptor, signature, exceptions);
+        final MethodVisitor methodVisitor = visitor.visitMethod(isExtension ? method.modifiers | Opcodes.ACC_STATIC : method.modifiers, method.name, descriptor, signature, exceptions);
 
         for (String annotation : annotations) {
             methodVisitor.visitAnnotation(annotation, true).visitEnd();
         }
 
-        this.visitor = new LocalVariablesSorter(method.modifiers, method.descriptor, methodVisitor);
+        this.visitor = new LocalVariablesSorter(isExtension ? method.modifiers | Opcodes.ACC_STATIC : method.modifiers, descriptor, methodVisitor);
         this.nameVariables = nameVariables;
     }
 
+
+
+
     public JavaWriter(ClassVisitor visitor, JavaMethod method, HighLevelDefinition forDefinition, String signature, String[] exceptions, String... annotations) {
         this(visitor, true, method, forDefinition, signature, exceptions, annotations);
     }

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

 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
+import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 		final String internalName = expansionClassInfo.internalName;
 
 		writer.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC |Opcodes.ACC_STATIC, internalName, null, "java/lang/Object", null);
-		JavaExpansionMemberVisitor memberVisitor = new JavaExpansionMemberVisitor(context, writer, expansionClassInfo, definition);
+		JavaExpansionMemberVisitor memberVisitor = new JavaExpansionMemberVisitor(context, writer, definition.target, definition);
 
 		for (IDefinitionMember member : definition.members) {
 			member.accept(memberVisitor);
 		memberVisitor.end();
 		writer.visitEnd();
 
-		return writer.toByteArray();
+
+		final byte[] classBytes = writer.toByteArray();
+
+		try (FileOutputStream out = new FileOutputStream("ttt.class")) {
+			out.write(classBytes);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+		return classBytes;
 	}
 
 	@Override

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

 
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.*;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javabytecode.compiler.CompilerUtils;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
-import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
 import org.openzen.zenscript.javashared.JavaMethod;
 
 	private final ClassWriter writer;
 	private final JavaBytecodeContext context;
-	private final JavaClass toClass;
+	private final StoredType expandedClass;
 	private final HighLevelDefinition definition;
 	private final JavaCompiledModule javaModule;
 
-	public JavaExpansionMemberVisitor(JavaBytecodeContext context, ClassWriter writer, JavaClass toClass, HighLevelDefinition definition) {
+	public JavaExpansionMemberVisitor(JavaBytecodeContext context, ClassWriter writer, StoredType expandedClass, HighLevelDefinition definition) {
 		this.writer = writer;
-		this.toClass = toClass;
+		this.expandedClass = expandedClass;
 		this.definition = definition;
 		this.context = context;
 		javaModule = context.getJavaModule(definition.module);
 	public Void visitMethod(MethodMember member) {
 		final boolean isStatic = member.isStatic();
 		final JavaMethod method = context.getJavaMethod(member);
-		if(!method.compile)
+		if (!method.compile)
 			return null;
 
 
 		CompilerUtils.tagMethodParameters(context, javaModule, member.header, member.isStatic());
 
-
+		final String expandedClassDescriptor = context.getDescriptor(expandedClass);
 		final Label methodStart = new Label();
 		final Label methodEnd = new Label();
-		final JavaWriter methodWriter = new JavaWriter(writer, method, definition, context.getMethodSignature(member.header), null);
+		final String methodSignature;
+
+		if (!isStatic) {
+			methodSignature = "(" + expandedClassDescriptor + context.getMethodSignature(member.header).substring(1);
+		} else {
+			methodSignature = context.getMethodSignature(member.header);
+		}
+
+
+		final JavaWriter methodWriter = new JavaWriter(writer, true, method, definition, true, methodSignature, methodSignature, null);
+		methodWriter.label(methodStart);
+
+		if (!isStatic) {
+			methodWriter.nameVariable(0, "expandedObj", methodStart, methodEnd, Type.getType(expandedClassDescriptor));
+			for (final FunctionParameter parameter : member.header.parameters) {
+				methodWriter.nameParameter(0, parameter.name);
+				methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index + 1, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
+			}
+		} else {
+			for (final FunctionParameter parameter : member.header.parameters) {
+				methodWriter.nameParameter(0, parameter.name);
+				methodWriter.nameVariable(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
+			}
+		}
+
+
+		{
+			final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);
+			statementVisitor.start();
+			member.body.accept(statementVisitor);
+			methodWriter.label(methodEnd);
+			statementVisitor.end();
+		}
 
 		return null;
 	}
 
+
 	@Override
 	public Void visitGetter(GetterMember member) {
-		throw new IllegalStateException("Cannot add getters via expansions");
+		return null;
 	}
 
 	@Override
 	public Void visitSetter(SetterMember member) {
-		throw new IllegalStateException("Cannot add setters via expansions");
+		return null;
 	}
 
 	@Override

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

 		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(javaModule.getParameterInfo(parameter).index, parameter.name, methodStart, methodEnd, context.getType(parameter.type));
-		}
 
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(context, javaModule, methodWriter);