Fix compilation of generic classes or interfaces with generic base types

CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CastedEval.java

@@ -31,7 +31,7 @@ public CastedExpression of(Expression value) {
 		if (value.type.equals(type) || type == BasicTypeID.UNDETERMINED)
 			return new CastedExpression(CastedExpression.Level.EXACT, value);
 		if (value.type.isInvalid())
-			return CastedExpression.invalid(value);
+			return CastedExpression.invalidType(value);
 
 		ResolvedType resolvedTargetType = compiler.resolve(type);
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CastedExpression.java

@@ -39,8 +39,12 @@ public static CastedExpression invalid(CodePosition position, CompileError error
 		return new CastedExpression(position, error);
 	}
 
-	public static CastedExpression invalid(Expression expression) {
-		return new CastedExpression(Level.INVALID, expression);
+	public static CastedExpression invalid(Expression expression, CompileError error) {
+		return new CastedExpression(Level.INVALID, expression, error);
+	}
+
+	public static CastedExpression invalidType(Expression expression) {
+		return new CastedExpression(Level.INVALID, expression, expression.type.asInvalid().error);
 	}
 
 	public final Level level;
@@ -59,6 +63,12 @@ public CastedExpression(CodePosition position, CompileError error) {
 		this.error = error;
 	}
 
+	private CastedExpression(Level level, Expression value, CompileError error) {
+		this.level = level;
+		this.value = value;
+		this.error = error;
+	}
+
 	public boolean isFailed() {
 		return level == Level.INVALID;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CompileErrors.java

@@ -254,6 +254,10 @@ public static CompileError invalidTypeArguments() {
 		return new CompileError(CompileExceptionCode.INVALID_TYPE_ARGUMENTS, "Invalid number of type arguments");
 	}
 
+	public static CompileError invalidType() {
+		return new CompileError(CompileExceptionCode.INVALID_TYPE, "Invalid type");
+	}
+
     public static CompileError noInnerType(TypeID type, String name) {
 		return new CompileError(CompileExceptionCode.NO_SUCH_TYPE, "No such inner type in " + type + ": " + name);
     }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/MatchedCallArguments.java

@@ -105,7 +105,7 @@ public Expression eval(ExpressionBuilder builder, CallEvaluator<T> evaluator) {
 
 	public CastedExpression cast(ExpressionBuilder builder, CastedEval eval, CallEvaluator<T> evaluator) {
 		if (this.error != null) {
-			return CastedExpression.invalid(builder.invalid(error));
+			return CastedExpression.invalid(builder.invalid(error), error);
 		} else {
 			return eval.of(evaluator.eval(builder, method, arguments));
 		}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/InvalidTypeID.java

@@ -43,6 +43,11 @@ public boolean isInvalid() {
 		return true;
 	}
 
+	@Override
+	public InvalidTypeID asInvalid() {
+		return this;
+	}
+
 	@Override
 	public ResolvingType resolve() {
 		return MemberSet.create(this).build();

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeID.java

@@ -2,6 +2,7 @@
 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
+import org.openzen.zenscript.codemodel.compilation.CompileErrors;
 import org.openzen.zenscript.codemodel.compilation.ResolvedType;
 import org.openzen.zenscript.codemodel.compilation.ResolvingType;
 import org.openzen.zenscript.codemodel.expression.Expression;
@@ -88,6 +89,10 @@ default boolean isInvalid() {
 		return false;
 	}
 
+	default InvalidTypeID asInvalid() {
+		return new InvalidTypeID(CodePosition.UNKNOWN, CompileErrors.invalidType());
+	}
+
 	default boolean canCastImplicitTo(TypeID other) {
 		return false;
 	}

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

@@ -27,7 +27,7 @@ public ArrayHelperType getWithOneDimensionLess() {
 	public void newArray(JavaWriter javaWriter) {
 		if(elementType instanceof GenericTypeID) {
 
-			elementType.accept(javaWriter, new JavaTypeExpressionVisitor(context));
+			elementType.accept(javaWriter, new JavaTypeExpressionVisitor(context, false));
 			javaWriter.swap();
 			final JavaClass arrayClass = JavaClass.fromInternalName("java/lang/reflect/Array", JavaClass.Kind.CLASS);
 			javaWriter.invokeStatic(JavaNativeMethod.getStatic(arrayClass, "newInstance", "(Ljava/lang/Class;I)Ljava/lang/Object;", 0));

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

@@ -80,7 +80,7 @@ void visitMultiDimArray(JavaWriter javaWriter, int[] sizeLocations, int[] counte
 
 		final ArrayHelperType elementType = currentArrayType.getWithOneDimensionLess();
 		if (arrayType.elementType.isGeneric()) {
-			arrayType.elementType.accept(javaWriter, new JavaTypeExpressionVisitor(context));
+			arrayType.elementType.accept(javaWriter, new JavaTypeExpressionVisitor(context, false));
 			javaWriter.loadInt(currentArraySizeLocation);
 			javaWriter.invokeStatic(ARRAY_NEWINSTANCE);
 			javaWriter.checkCast(context.getInternalName(arrayType));

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

@@ -49,7 +49,7 @@ public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
 	private final JavaUnboxingTypeVisitor unboxingTypeVisitor;
 	private final JavaUnboxingTypeVisitor optionalUnwrappingTypeVisitor;
 	private final JavaFieldBytecodeCompiler fieldCompiler;
-	private final JavaMethodBytecodeCompiler methodCompiler;
+	public final JavaMethodBytecodeCompiler methodCompiler;
 	private final CapturedExpressionVisitor<Void> capturedExpressionVisitor;
 
 	public JavaExpressionVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaWriter javaWriter, JavaMangler javaMangler) {
@@ -105,7 +105,7 @@ public Void visitAndAnd(AndAndExpression expression) {
 	public Void visitArray(ArrayExpression expression) {
 		Type type = context.getType(expression.arrayType.elementType);
 		if (expression.arrayType.elementType.isGeneric()) {
-			expression.arrayType.elementType.accept(javaWriter, new JavaTypeExpressionVisitor(context));
+			expression.arrayType.elementType.accept(javaWriter, new JavaTypeExpressionVisitor(context, false));
 			javaWriter.constant(expression.expressions.length);
 			javaWriter.invokeStatic(ARRAY_NEWINSTANCE);
 			javaWriter.checkCast(context.getInternalName(expression.arrayType));

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

@@ -149,22 +149,40 @@ public Void nativeConstructor(JavaNativeMethod method, TypeID type, CallArgument
 		AtomicInteger typeArguments = new AtomicInteger(0);
 		if (method.compile) {
 			type.asDefinition().ifPresent(definitionType -> {
-				final JavaTypeExpressionVisitor javaTypeExpressionVisitor = new JavaTypeExpressionVisitor(context);
+				final JavaTypeExpressionVisitor javaTypeExpressionVisitor = new JavaTypeExpressionVisitor(context, false);
 				typeArguments.set(definitionType.typeArguments.length);
 				for (TypeID typeParameter : definitionType.typeArguments) {
 					typeParameter.accept(javaWriter, javaTypeExpressionVisitor);
 				}
 			});
 		}
-		handleArguments(typeArguments.get(), method, arguments, false);
+		handleArguments(typeArguments.get(), method, arguments, false, false);
+		javaWriter.invokeSpecial(method);
+		return null;
+	}
+
+	@Override
+	public Void nativeBaseConstructor(JavaNativeMethod method, TypeID type, CallArguments arguments) {
+		javaWriter.loadObject(0);
+		AtomicInteger typeArguments = new AtomicInteger(0);
+		if (method.compile) {
+			type.asDefinition().ifPresent(definitionType -> {
+				final JavaTypeExpressionVisitor javaTypeExpressionVisitor = new JavaTypeExpressionVisitor(context, true);
+				typeArguments.set(definitionType.typeArguments.length);
+				for (TypeID typeParameter : definitionType.typeArguments) {
+					typeParameter.accept(javaWriter, javaTypeExpressionVisitor);
+				}
+			});
+		}
+		handleArguments(typeArguments.get(), method, arguments, false, false);
 		javaWriter.invokeSpecial(method);
 		return null;
 	}
 
 	@Override
 	public Void nativeVirtualMethod(JavaNativeMethod method, TypeID returnType, Expression target, CallArguments arguments) {
 		if (arguments.expansionTypeArguments.length > 0) {
-			final JavaTypeExpressionVisitor javaTypeExpressionVisitor = new JavaTypeExpressionVisitor(context);
+			final JavaTypeExpressionVisitor javaTypeExpressionVisitor = new JavaTypeExpressionVisitor(context, false);
 			for (int i = 0; i < arguments.expansionTypeArguments.length; i++) {
 				arguments.expansionTypeArguments[i].accept(javaWriter, javaTypeExpressionVisitor);
 			}
@@ -181,7 +199,7 @@ public Void nativeStaticMethod(JavaNativeMethod method, TypeID returnType, CallA
 	}
 
 	public void nativeMethod(JavaNativeMethod method, TypeID returnType, CallArguments arguments, boolean asStatic) {
-		handleArguments(arguments.typeArguments.length, method, arguments, asStatic);
+		handleArguments(arguments.typeArguments.length, method, arguments, asStatic, false);
 
 		if (method.kind == JavaNativeMethod.Kind.STATIC) {
 			javaWriter.invokeStatic(method);
@@ -209,14 +227,19 @@ public void nativeMethod(JavaNativeMethod method, TypeID returnType, CallArgumen
 	@Override
 	public Void nativeSpecialMethod(JavaNativeMethod method, TypeID returnType, Expression target, CallArguments arguments) {
 		target.accept(expressionVisitor);
-		handleArguments(arguments.typeArguments.length, method, arguments, false);
+		handleArguments(arguments.typeArguments.length, method, arguments, false, false);
 		javaWriter.invokeSpecial(method);
 		return null;
 	}
 
-	private void handleArguments(int typeArguments, JavaNativeMethod method, CallArguments arguments, boolean asStatic) {
+	private void handleArguments(
+			int typeArguments,
+			JavaNativeMethod method,
+			CallArguments arguments,
+			boolean asStatic,
+			boolean insideConstructor) {
 		if (method.compile) {
-			handleTypeArguments(method, arguments);
+			handleTypeArguments(method, arguments, insideConstructor);
 		}
 
 		// This happens e.g. for Strings where compareTo is a static method in zencode but a virtual one in Java
@@ -236,8 +259,8 @@ private void handleArguments(int typeArguments, JavaNativeMethod method, CallArg
 		}
 	}
 
-	private void handleTypeArguments(JavaNativeMethod method, CallArguments arguments) {
-		final JavaTypeExpressionVisitor javaTypeExpressionVisitor = new JavaTypeExpressionVisitor(context);
+	private void handleTypeArguments(JavaNativeMethod method, CallArguments arguments, boolean insideConstructor) {
+		final JavaTypeExpressionVisitor javaTypeExpressionVisitor = new JavaTypeExpressionVisitor(context, insideConstructor);
 		if (arguments.typeArguments.length != method.typeParameterArguments.length)
 			throw new IllegalArgumentException("Number of type parameters doesn't match");
 

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

@@ -14,6 +14,7 @@
 import org.openzen.zenscript.javabytecode.JavaMangler;
 import org.openzen.zenscript.javabytecode.compiler.JavaModificationExpressionVisitor.PushOption;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
+import org.openzen.zenscript.javashared.JavaNativeMethod;
 import org.openzen.zenscript.javashared.JavaParameterInfo;
 import org.openzen.zenscript.javashared.expressions.JavaFunctionInterfaceCastExpression;
 
@@ -27,14 +28,22 @@ public class JavaNonPushingExpressionVisitor implements ExpressionVisitor<Void>
 	private final JavaExpressionVisitor original;
 	private final JavaFieldBytecodeCompiler fieldCompiler;
 	private final JavaMangler mangler;
-
-	public JavaNonPushingExpressionVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaWriter javaWriter, JavaMangler mangler, JavaExpressionVisitor original) {
+	private final JavaMethodBytecodeCompiler methodCompiler;
+
+	public JavaNonPushingExpressionVisitor(
+			JavaBytecodeContext context,
+			JavaCompiledModule module,
+			JavaWriter javaWriter,
+			JavaMangler mangler,
+			JavaExpressionVisitor original
+	) {
 		this.context = context;
 		this.module = module;
 		this.javaWriter = javaWriter;
 		this.original = original;
 		this.mangler = mangler;
 		fieldCompiler = new JavaFieldBytecodeCompiler(javaWriter, original, false);
+		this.methodCompiler = original.methodCompiler;
 	}
 
 	@Override
@@ -198,27 +207,29 @@ public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
 			javaWriter.loadInt(2);
 		}
 
+		context.getJavaMethod(expression.constructor).compileBaseConstructor(
+				methodCompiler,
+				expression.constructor.getTarget(),
+				expression.arguments);
+
+		/*methodCompiler.handleArguments(0, expression.constructor.getHeader(), expression.arguments, false);
 		for (Expression argument : expression.arguments.arguments) {
 			argument.accept(original);
 		}
 		String internalName = context.getInternalName(expression.objectType);
 		javaWriter.invokeSpecial(internalName, "<init>", javaWriter.forDefinition.isEnum()
 				? context.getEnumConstructorDescriptor(expression.constructor.getHeader())
-				: context.getMethodDescriptor(expression.constructor.getHeader().withReturnType(BasicTypeID.VOID)));
+				: context.getMethodDescriptor(expression.constructor.getHeader().withReturnType(BasicTypeID.VOID)));*/
 		return null;
 	}
 
 	@Override
 	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
 		javaWriter.loadObject(0);
-		for (Expression argument : expression.arguments.arguments) {
-			argument.accept(original);
-		}
-		//No super calls in enums possible, and that's already handled in the enum constructor itself.
-		javaWriter.invokeSpecial(
-				context.getInternalName(expression.constructor.getTarget()),
-				"<init>",
-				context.getMethodDescriptor(expression.constructor.getHeader().withReturnType(BasicTypeID.VOID)));
+		context.getJavaMethod(expression.constructor).compileBaseConstructor(
+				methodCompiler,
+				expression.constructor.getTarget(),
+				expression.arguments);
 
 		CompilerUtils.writeDefaultFieldInitializers(context, javaWriter, javaWriter.forDefinition, mangler, false);
 		return null;

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

@@ -34,7 +34,12 @@ public JavaStatementVisitor(JavaBytecodeContext context, JavaExpressionVisitor e
 		this.javaWriter = expressionVisitor.getJavaWriter();
 		this.context = context;
 		this.expressionVisitor = expressionVisitor;
-		this.nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(expressionVisitor.context, expressionVisitor.module, expressionVisitor.javaWriter, javaMangler, expressionVisitor);
+		this.nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(
+				expressionVisitor.context,
+				expressionVisitor.module,
+				expressionVisitor.javaWriter,
+				javaMangler,
+				expressionVisitor);
 	}
 
 	@Override

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

@@ -15,9 +15,11 @@
  */
 public class JavaTypeExpressionVisitor implements TypeVisitorWithContext<JavaWriter, Void, RuntimeException> {
 	private final JavaBytecodeContext context;
+	private final boolean insideConstructor;
 
-	public JavaTypeExpressionVisitor(JavaBytecodeContext context) {
+	public JavaTypeExpressionVisitor(JavaBytecodeContext context, boolean insideConstructor) {
 		this.context = context;
+		this.insideConstructor = insideConstructor;
 	}
 
 	@Override
@@ -98,7 +100,7 @@ public Void visitDefinition(JavaWriter writer, DefinitionTypeID definition) {
 	@Override
 	public Void visitGeneric(JavaWriter writer, GenericTypeID generic) {
 		JavaTypeParameterInfo info = context.target.getTypeParameterInfo(generic.parameter);
-		if (info.field != null) {
+		if (info.field != null && !insideConstructor) {
 			writer.loadObject(0); // this
 			writer.getField(info.field);
 		} else {

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

@@ -94,6 +94,8 @@ public Void visitConstructor(ConstructorMember member) {
 			constructorWriter.nameParameter(0, "index");
 		}
 
+		// TODO: these must be initialized after calling the super constructor (it now ends up before it)
+		// this seems to work fine, but it might break
 		for (TypeParameter typeParameter : definition.typeParameters) {
 			constructorWriter.nameParameter(0, "typeof" + typeParameter.name);
 			constructorWriter.nameVariable(

JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java

@@ -78,15 +78,21 @@ public ScriptingEngine(ScriptingEngineLogger logger, Function<String, InputStrea
 		try {
 			ZippedPackage stdlibs = new ZippedPackage(resourceGetter.apply("/StdLibs.jar"));
 			for (String moduleName : stdLibModulesToRegister) {
-				registerModule(moduleName, root.getOrCreatePackage(moduleName), stdlibs);
+				String[] dependencies = moduleName.equals("stdlib") ? new String[0] : new String[]{"stdlib"};
+				registerModule(moduleName, root.getOrCreatePackage(moduleName), stdlibs, dependencies);
 			}
 		} catch (CompileException | ParseException | IOException ex) {
 			throw new RuntimeException(ex);
 		}
 	}
 
-	public void registerModule(String name, ZSPackage zsPackage, ModuleLoader loader) throws CompileException, ParseException {
-		SemanticModule stdlibModule = loader.loadModule(space, name, null, SemanticModule.NONE, FunctionParameter.NONE, zsPackage, logger);
+	public void registerModule(String name, ZSPackage zsPackage, ModuleLoader loader, String[] dependencies) throws CompileException, ParseException {
+		SemanticModule[] dependencyModules = new SemanticModule[dependencies.length];
+		for (int i = 0; i < dependencies.length; i++) {
+			dependencyModules[i] = space.getModule(dependencies[i]);
+		}
+
+		SemanticModule stdlibModule = loader.loadModule(space, name, null, dependencyModules, FunctionParameter.NONE, zsPackage, logger);
 		stdlibModule = Validator.validate(stdlibModule, logger);
 		space.addModule(name, stdlibModule);
 		registerCompiled(stdlibModule);

JavaIntegration/src/main/java/org/openzen/zencode/java/module/JavaRuntimeMethod.java

@@ -137,6 +137,11 @@ public <T> T compileConstructor(JavaMethodCompiler<T> compiler, TypeID type, Cal
 		return compiler.nativeConstructor(method, type, arguments);
 	}
 
+	@Override
+	public <T> T compileBaseConstructor(JavaMethodCompiler<T> compiler, TypeID type, CallArguments arguments) {
+		return compiler.nativeBaseConstructor(method, type, arguments);
+	}
+
 	@Override
 	public <T> T compileVirtual(JavaMethodCompiler<T> compiler, TypeID returnType, Expression target, CallArguments arguments) {
 		return compiler.nativeVirtualMethod(method, returnType, target, arguments);

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

@@ -18,6 +18,11 @@ public <T> T compileConstructor(JavaMethodCompiler<T> compiler, TypeID type, Cal
 		return compiler.builtinConstructor(method, type, arguments);
 	}
 
+	@Override
+	public <T> T compileBaseConstructor(JavaMethodCompiler<T> compiler, TypeID type, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported for builtin methods");
+	}
+
 	@Override
 	public <T> T compileVirtual(JavaMethodCompiler<T> compiler, TypeID returnType, Expression target, CallArguments arguments) {
 		return compiler.builtinVirtualMethod(method, target, arguments);

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

@@ -7,6 +7,7 @@
 
 public interface JavaMethod {
 	<T> T compileConstructor(JavaMethodCompiler<T> compiler, TypeID type, CallArguments arguments);
+	<T> T compileBaseConstructor(JavaMethodCompiler<T> compiler, TypeID type, CallArguments arguments);
 	<T> T compileVirtual(JavaMethodCompiler<T> compiler, TypeID returnType, Expression target, CallArguments arguments);
 	<T> T compileVirtualWithTargetOnTopOfStack(JavaMethodCompiler<T> compiler, TypeID returnType, CallArguments arguments);
 	<T> T compileStatic(JavaMethodCompiler<T> compiler, TypeID returnType, CallArguments arguments);

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

@@ -8,6 +8,8 @@
 public interface JavaMethodCompiler<T> {
 	T nativeConstructor(JavaNativeMethod method, TypeID type, CallArguments arguments);
 
+	T nativeBaseConstructor(JavaNativeMethod method, TypeID type, CallArguments arguments);
+
 	T nativeVirtualMethod(JavaNativeMethod method, TypeID returnType, Expression target, CallArguments arguments);
 
 	T nativeStaticMethod(JavaNativeMethod method, TypeID returnType, CallArguments arguments);