I don't think this is the correct call here.
Just that a constructor has no argument does not mean it is a propagated default constructor.

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeAnnotationDefinition.java

  */
 package org.openzen.zenscript.codemodel.annotations;
 
-import java.util.Collections;
-import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 
+import java.util.Collections;
+import java.util.List;
+
 /**
  *
  * @author Hoofdgebruiker
 public class NativeAnnotationDefinition implements AnnotationDefinition {
 	public static final NativeAnnotationDefinition INSTANCE = new NativeAnnotationDefinition();
 	
-	private static final List<FunctionHeader> INITIALIZERS = Collections.singletonList(
+	private final List<FunctionHeader> INITIALIZERS = Collections.singletonList(
 			new FunctionHeader(BasicTypeID.VOID, StringTypeID.UNIQUE));
 	
 	private NativeAnnotationDefinition() {}

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

 		} else {
 			getJavaWriter().invokeVirtual(methodInfo);
 		}
-		if (methodInfo.genericResult)
+		if (methodInfo.genericResult) {
 			getJavaWriter().checkCast(context.getInternalName(resultType));
+		}
+
+		//Make sure that method results are popped if ZC thinks its a void but it actually is not.
+		//Fixes an issue for List#add() returning void in ZC but Z in Java.
+		if(resultType.type == BasicTypeID.VOID && !methodInfo.descriptor.endsWith(")V")) {
+			final boolean isLarge = methodInfo.descriptor.endsWith(")D") && methodInfo.descriptor.endsWith(")L");
+			getJavaWriter().pop(isLarge);
+		}
 
 		return true;
 	}

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

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
-import org.openzen.zenscript.codemodel.member.MethodMember;
-import org.openzen.zenscript.javashared.*;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
-import org.openzen.zenscript.codemodel.definition.*;
+import org.openzen.zenscript.codemodel.definition.AliasDefinition;
+import org.openzen.zenscript.codemodel.definition.ClassDefinition;
+import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
-import org.openzen.zenscript.javabytecode.compiler.*;
+import org.openzen.zenscript.javabytecode.compiler.CompilerUtils;
+import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
+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.JavaMethod;
+import org.openzen.zenscript.javashared.JavaModifiers;
+import org.openzen.zenscript.javashared.JavaTypeGenericVisitor;
+import org.openzen.zenscript.javashared.JavaVariantOption;
 
-import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import org.openzen.zenscript.codemodel.member.ImplementationMember;
-import org.openzen.zenscript.codemodel.type.StoredType;
 
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
-	private static final JavaMethod CLASS_FORNAME
+	private final JavaMethod CLASS_FORNAME
 			= JavaMethod.getNativeStatic(JavaClass.CLASS, "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
-	private static final JavaMethod ENUM_VALUEOF
+	private final JavaMethod ENUM_VALUEOF
 			= JavaMethod.getNativeStatic(JavaClass.CLASS, "valueOf", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;");
-	private static final JavaMethod ARRAY_CLONE
+	private final JavaMethod ARRAY_CLONE
 			= JavaMethod.getNativeVirtual(JavaClass.ARRAYS, "clone", "()Ljava/lang/Object;");
 
 	private final JavaClassWriter outerWriter;

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

 			for (IDefinitionMember imember : member.members)
 				imember.accept(this);
 		} else {
+			//TODO: Fixme???
+			// What should I do if a native class has interfaces to be visited?
+			if(javaModule.getNativeClassInfo(member.definition) != null) {
+				return null;
+			}
+
+
 			throw new UnsupportedOperationException("Non-inline interface implementations not yet available");
 		}
 		return null;

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

  * @author Hoofdgebruiker
  */
 public interface JavaCompileSpace {
+	void register(JavaCompiledModule module);
+
 	GlobalTypeRegistry getRegistry();
 	
 	JavaCompiledModule getCompiled(Module module);

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

 	
 	public void addModule(Module module, JavaCompiledModule target) {
 		modules.put(module, target);
+
+		//TODO: can we do this here?
+		space.register(target);
 	}
 	
 	public JavaCompiledModule getJavaModule(Module module) {

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

 	public SimpleJavaCompileSpace(GlobalTypeRegistry registry) {
 		this.registry = registry;
 	}
-	
+
+	@Override
 	public void register(JavaCompiledModule module) {
 		modules.put(module.module, module);
 	}

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionMemberVisitor.java

  */
 package org.openzen.zenscript.javashared.prepare;
 
-import org.openzen.zenscript.javashared.JavaNativeClass;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.javashared.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.TypeID;
-import org.openzen.zenscript.javashared.JavaClass;
-import org.openzen.zenscript.javashared.JavaCompiledModule;
-import org.openzen.zenscript.javashared.JavaContext;
-import org.openzen.zenscript.javashared.JavaMethod;
-import org.openzen.zenscript.javashared.JavaModifiers;
 
 /**
  *
 	public JavaClass visitClass(ClassDefinition definition) {
 		if (isPrepared(definition))
 			return context.getJavaClass(definition);
-		
+
 		return visitClassCompiled(definition, true, JavaClass.Kind.CLASS);
 	}
 
 	}
 	
 	private JavaClass visitClassCompiled(HighLevelDefinition definition, boolean startsEmpty, JavaClass.Kind kind) {
+
+		for (TypeParameter typeParameter : definition.typeParameters) {
+			module.setTypeParameterInfo(typeParameter, new JavaTypeParameterInfo(-1));
+		}
+
 		if (definition.getSuperType() != null)
 			prepare(definition.getSuperType());
 		

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionVisitor.java

  * @author Hoofdgebruiker
  */
 public class JavaPrepareDefinitionVisitor implements DefinitionVisitor<JavaClass> {
-	private static final Map<String, JavaNativeClass> nativeClasses = new HashMap<>();
+	private final Map<String, JavaNativeClass> nativeClasses = new HashMap<>();
 	
-	static {
+	 {
 		{
 			JavaNativeClass cls = new JavaNativeClass(new JavaClass("java.lang", "StringBuilder", JavaClass.Kind.CLASS));
 			cls.addConstructor("constructor", "()V");

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedConstructor.java

 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
 
 	@Override
 	public void linkTypes(TypeResolutionContext context) {
-        compiled = new ConstructorMember(position, definition, modifiers, header.compile(context), header.parameters.isEmpty() ? BuiltinID.CLASS_DEFAULT_CONSTRUCTOR : null);
+		compiled = new ConstructorMember(position, definition, modifiers, header.compile(context), null);
 	}
 
 	@Override