Improved error handling and reporting

stanhebben · stanhebben · commit 35c4731c2713 · 2026-05-22T21:49:28.000+02:00
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CompileErrors.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CompileErrors.java
@@ -54,6 +54,14 @@ public static CompileError noOperatorInType(TypeID type, OperatorType operator)
 		return new CompileError(CompileExceptionCode.NO_SUCH_MEMBER, "No operator " + operator + " in type " + type);
 	}
 
+	public static CompileError notAStaticMethod(TypeID type, String name) {
+		return new CompileError(CompileExceptionCode.MEMBER_NOT_STATIC, "No static method " + name + " in type " + type);
+	}
+
+	public static CompileError notAnInstanceMethod(TypeID type, String name) {
+		return new CompileError(CompileExceptionCode.MEMBER_IS_STATIC, "No instance method " + name + " in type " + type);
+	}
+
 	public static CompileError noThisInScope() {
 		return new CompileError(CompileExceptionCode.USING_THIS_OUTSIDE_TYPE, "Not in an instance method; cannot use this");
 	}
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CompilingExpression.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CompilingExpression.java
@@ -14,6 +14,8 @@
 public interface CompilingExpression {
 	CompilingExpression[] NONE = new CompilingExpression[0];
 
+	CodePosition getPosition();
+
 	/**
 	 * Compiles this expression. The return type is inferred from the expression.
 	 *
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/ExpressionBuilder.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/ExpressionBuilder.java
@@ -1,5 +1,6 @@
 package org.openzen.zenscript.codemodel.compilation;
 
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileError;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
@@ -63,6 +64,8 @@ public interface ExpressionBuilder {
 
 	Expression invalid(CompileError error, TypeID type);
 
+	Expression invalidAt(CompileError error, CodePosition position);
+
 	Expression is(Expression value, TypeID type);
 
 	Expression lambda(LambdaClosure closure, FunctionHeader header, Statement body);
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/MatchedCallArguments.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/MatchedCallArguments.java
@@ -77,23 +77,41 @@ private static <T extends AnyMethod> MatchedCallArguments<T> ambiguousCall(Map<C
 	private final T method;
 	private final CallArguments arguments;
 	private final CompileError error;
+	private final CodePosition position;
 
 	private MatchedCallArguments(T method, CallArguments arguments) {
 		this.method = method;
 		this.arguments = arguments;
 		this.error = null;
+		this.position = null;
+	}
+
+	private MatchedCallArguments(T method, CallArguments arguments, CompileError error) {
+		this.method = method;
+		this.arguments = arguments;
+		this.error = error;
+		this.position = null;
 	}
 
 	private MatchedCallArguments(CompileError error) {
 		this.method = null;
 		this.arguments = null;
 		this.error = error;
+		this.position = null;
 	}
 
 	private MatchedCallArguments(CompileError error, CallArguments arguments) {
 		this.method = null;
 		this.arguments = arguments;
 		this.error = error;
+		this.position = null;
+	}
+
+	private MatchedCallArguments(CompileError error, CallArguments arguments, CodePosition position) {
+		this.method = null;
+		this.arguments = arguments;
+		this.error = error;
+		this.position = position;
 	}
 
 	public boolean requiresWidenedInstance(TypeID instanceType) {
@@ -106,7 +124,11 @@ public TypeID getWidenedInstanceType() {
 
 	public Expression eval(ExpressionBuilder builder, CallEvaluator<T> evaluator) {
 		if (this.error != null) {
-			return builder.invalid(error);
+			if (position != null) {
+				return builder.invalidAt(error, position);
+			} else {
+				return builder.invalid(error);
+			}
 		} else {
 			return evaluator.eval(builder, method, arguments);
 		}
@@ -148,7 +170,12 @@ private static <T extends AnyMethod> MatchedCallArguments<T> match(
 					CastedExpression.Level.INVALID,
 					expansionTypeArguments,
 					typeArguments,
-					Expression.NONE));
+					Expression.NONE),
+					CompileErrors.invalidNumberOfArguments(
+							arguments.length,
+							arguments.length < method.getHeader().minParameters
+									? method.getHeader().minParameters
+									: method.getHeader().maxParameters));
 		}
 
 		// Type inference
@@ -256,7 +283,7 @@ private static <T extends AnyMethod> MatchedCallArguments<T> matchNormal(
 						return CastedExpression.invalid(position, CompileErrors.missingParameter(header.getParameter(false, i).name));
 					}
 					TypeID originalType = method.getHeader().getParameterType(false, i);
-					return argument.cast(CastedEval.implicit(compiler, position, header.getParameterType(false, i), originalType));
+					return argument.cast(CastedEval.implicit(compiler, argument.getPosition(), header.getParameterType(false, i), originalType));
 				})
 				.toArray(CastedExpression[]::new);
 
@@ -272,7 +299,8 @@ private static <T extends AnyMethod> MatchedCallArguments<T> matchNormal(
 					.orElseThrow(() -> new IllegalStateException("Should never happen"));
 
 			return new MatchedCallArguments<>(firstInvalid.error,
-					new CallArguments(CastedExpression.Level.INVALID, expansionTypeArguments, typeArguments, Expression.NONE));
+					new CallArguments(CastedExpression.Level.INVALID, expansionTypeArguments, typeArguments, Expression.NONE),
+					firstInvalid.value.position);
 		}
 
 		return new MatchedCallArguments<>(
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/AbstractCompilingExpression.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/AbstractCompilingExpression.java
@@ -18,6 +18,11 @@ public AbstractCompilingExpression(ExpressionCompiler compiler, CodePosition pos
 		this.position = position;
 	}
 
+	@Override
+	public CodePosition getPosition() {
+		return position;
+	}
+
 	@Override
 	public CastedExpression cast(CastedEval cast) {
 		return cast.of(eval());
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/InstanceMemberCompilingExpression.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/InstanceMemberCompilingExpression.java
@@ -74,6 +74,9 @@ public Optional<CompilingCallable> call() {
 							.findOperator(OperatorType.CALL)
 							.map(method -> method.bind(compiler, field.get(compiler.at(position), instance), name.arguments)));
 		}
+		if (resolvedType.findStaticMethod(name.name).isPresent()) {
+			return Optional.of(new InvalidCompilingExpression(compiler, position, CompileErrors.notAnInstanceMethod(instance.type, name.name)));
+		}
 
 		return Optional.of(result.orElseGet(() -> new InvalidCompilingExpression(compiler, position, CompileErrors.noMemberInType(instance.type, name.name))));
 	}
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/PackageCompilingExpression.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/PackageCompilingExpression.java
@@ -22,6 +22,11 @@ public PackageCompilingExpression(ExpressionCompiler compiler, CodePosition posi
 		this.pkg = pkg;
 	}
 
+	@Override
+	public CodePosition getPosition() {
+		return position;
+	}
+
 	@Override
 	public Expression eval() {
 		return compiler.at(position).invalid(CompileErrors.cannotUsePackageAsValue());
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/StaticMemberCompilingExpression.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/StaticMemberCompilingExpression.java
@@ -64,6 +64,10 @@ public Optional<CompilingCallable> call() {
 		if (staticMethod.isPresent())
 			return staticMethod;
 
+		if (resolvedType.findMethod(name.name).isPresent()) {
+			return Optional.of(new InvalidCompilingExpression(compiler, position, CompileErrors.notAStaticMethod(type, name.name)));
+		}
+
 		return resolvedType.getContextMember(name.name).flatMap(member -> member.compile(compiler).call());
 	}
 
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/TypeCompilingExpression.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/expression/TypeCompilingExpression.java
@@ -22,6 +22,11 @@ public TypeCompilingExpression(ExpressionCompiler compiler, CodePosition positio
 		this.type = type;
 	}
 
+	@Override
+	public CodePosition getPosition() {
+		return position;
+	}
+
 	@Override
 	public Expression eval() {
 		return compiler.at(position).invalid(CompileErrors.cannotUseTypeAsValue());
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/impl/compiler/ExpressionCompilerImpl.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/impl/compiler/ExpressionCompilerImpl.java
@@ -317,6 +317,11 @@ public Expression invalid(CompileError error, TypeID type) {
 			return new InvalidExpression(position, type, error);
 		}
 
+		@Override
+		public Expression invalidAt(CompileError error, CodePosition position) {
+			return new InvalidExpression(position, new InvalidTypeID(position, error), error);
+		}
+
 		@Override
 		public Expression is(Expression value, TypeID type) {
 			return new IsExpression(position, value, type);
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/EnumConstantMember.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/EnumConstantMember.java
@@ -9,6 +9,7 @@
 import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
 import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.ssa.CodeBlockStatement;
 import org.openzen.zenscript.codemodel.ssa.SSAVariableCollector;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
@@ -22,6 +23,7 @@ public class EnumConstantMember implements CompilableExpression {
 
 	public Expression value = null;
 	public CallStaticExpression constructor = null;
+	public InvalidExpression invalidConstructor = null;
 
 	public EnumConstantMember(CodePosition position, HighLevelDefinition definition, String name, int ordinal) {
 		this.position = position;
diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/ssa/IterateStatement.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/ssa/IterateStatement.java
@@ -53,6 +53,11 @@ public IterationValue(int index) {
 			this.index = index;
 		}
 
+		@Override
+		public CodePosition getPosition() {
+			return position;
+		}
+
 		@Override
 		public Expression eval() {
 			Expression value = list.eval();
diff --git a/Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnumConstant.java b/Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnumConstant.java
@@ -4,6 +4,8 @@
 import org.openzen.zenscript.codemodel.compilation.*;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.lexer.ParseException;
@@ -67,11 +69,16 @@ public Compiling(EnumConstantMember compiled) {
 
 		public void compileCode(TypeID type, ExpressionCompiler compiler) {
 			ResolvedType members = compiler.resolve(type);
-			compiled.constructor = (CallStaticExpression) members.getConstructor().call(
+			Expression constructor = members.getConstructor().call(
 					compiler,
 					position,
 					TypeID.NONE,
 					arguments.stream().map(arg -> arg.compile(compiler)).toArray(CompilingExpression[]::new));
+			if (constructor instanceof InvalidExpression) {
+				compiled.invalidConstructor = ((InvalidExpression) constructor);
+			} else {
+				compiled.constructor = (CallStaticExpression) constructor;
+			}
 
 			if (value != null)
 				compiled.value = value.compile(compiler).eval();
diff --git a/ScriptingEngineTester/src/main/java/org/openzen/scriptingenginetester/cases/ExpectedError.java b/ScriptingEngineTester/src/main/java/org/openzen/scriptingenginetester/cases/ExpectedError.java
@@ -6,10 +6,12 @@ public class ExpectedError {
 	public final String filename;
 	public final int line;
 	public final CompileExceptionCode error;
+	public final String message;
 
-	public ExpectedError(String filename, int line, CompileExceptionCode error) {
+	public ExpectedError(String filename, int line, CompileExceptionCode error, String message) {
 		this.filename = filename;
 		this.line = line;
 		this.error = error;
+		this.message = message;
 	}
 }
diff --git a/ScriptingEngineTester/src/main/java/org/openzen/scriptingenginetester/cases/TestAnnotations.java b/ScriptingEngineTester/src/main/java/org/openzen/scriptingenginetester/cases/TestAnnotations.java
@@ -46,9 +46,9 @@ public static TestAnnotations extractFrom(SourceFile file) throws IOException {
 	}
 
 	private static ExpectedError parseError(String filename, String errorSpecification) {
-		String[] parts = errorSpecification.split(":", 2);
+		String[] parts = errorSpecification.split(":", 3);
 		try {
-			return new ExpectedError(filename, Integer.parseInt(parts[0]), CompileExceptionCode.valueOf(parts[1]));
+			return new ExpectedError(filename, Integer.parseInt(parts[0]), CompileExceptionCode.valueOf(parts[1]), parts.length > 2 ? parts[2] : null);
 		} catch (NumberFormatException ex) {
 			throw new RuntimeException("Invalid line number in " + filename + ": " + parts[0], ex);
 		} catch (IllegalArgumentException ex) {
diff --git a/ScriptingEngineTester/src/main/java/org/openzen/scriptingenginetester/cases/TestAssertions.java b/ScriptingEngineTester/src/main/java/org/openzen/scriptingenginetester/cases/TestAssertions.java
@@ -39,6 +39,15 @@ private void validateErrors(TestOutput output) {
 				);
 
 		Assertions.assertLinesMatch(expectedErrors, actualErrors, "Test must throw errors exactly as specified as '#error:' Preprocessors");
+
+		for (int i = 0; i < this.expectedErrors.size(); i++) {
+			if (this.expectedErrors.get(i).message != null) {
+				String expectedMessage = this.expectedErrors.get(i).message;
+				String actualMessage = output.exceptions.get(i).error.description;
+				Assertions.assertEquals(expectedMessage, actualMessage, "Error message must match expected message");
+			}
+		}
+
 		Assertions.assertTrue(output.runtimeExceptions.isEmpty(), "There must be no runtime exceptions");
 	}
 
diff --git a/ScriptingEngineTester/src/main/resources/zencode_tests/enums/enum_constructor_not_called.zc b/ScriptingEngineTester/src/main/resources/zencode_tests/enums/enum_constructor_not_called.zc
@@ -1,4 +1,4 @@
-#error: 6:INVALID_CALL_ARGUMENT
+#error: 6:INVALID_ARGUMENTS
 
 public enum MyEnum {
 	A('X1'),
diff --git a/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_1.zc b/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_1.zc
@@ -0,0 +1,7 @@
+#error:7:INVALID_ARGUMENTS
+
+function a(): int {
+	return 1;
+}
+
+println(a(1));
diff --git a/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_2.zc b/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_2.zc
@@ -0,0 +1,11 @@
+#error: 10:INVALID_ARGUMENTS
+
+class Foo {
+	static bar(value: int): int {
+		return value;
+	}
+}
+
+println(
+	Foo.bar()
+);
diff --git a/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_3.zc b/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_3.zc
@@ -0,0 +1,9 @@
+#error:9:MEMBER_NOT_STATIC
+
+class Foo {
+	bar(value: int): int {
+		return value;
+	}
+}
+
+println(Foo.bar());
diff --git a/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_4.zc b/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_4.zc
@@ -0,0 +1,9 @@
+#error: 9:INVALID_ARGUMENTS:Invalid number of arguments, 1 expected but 0 given
+
+class Foo {
+	static bar(a: int, value: int? = null): int {
+		return a;
+	}
+}
+
+println(Foo.bar());
diff --git a/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_5.zc b/ScriptingEngineTester/src/main/resources/zencode_tests/expressions/error_call_5.zc
@@ -0,0 +1,10 @@
+#error: 10:MEMBER_IS_STATIC
+
+class Foo {
+	static bar(a: int): int {
+		return a;
+	}
+}
+
+val foo = new Foo();
+println(foo.bar(1));
diff --git a/ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/actual_test/java_native/expansions/GenericExpansionTests.java b/ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/actual_test/java_native/expansions/GenericExpansionTests.java
@@ -35,11 +35,9 @@ void works() {
 
 	@ZenCodeType.Expansion(value = "stdlib.List<T>", typeParameters = "<T : string>")
 	public static class ExpandStringList {
-
-
 		@ZenCodeType.Method
-		public static String join(List<String> list) {
-			return String.join(",", list);
+		public static String join(List<String> list, String delimiter) {
+			return String.join(delimiter, list);
 		}
 	}
 }
diff --git a/Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionMemberValidator.java b/Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionMemberValidator.java
@@ -153,6 +153,10 @@ public Void visitSetter(SetterMember member) {
 
 	public void visitEnumConstant(EnumConstantMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
+		if (member.invalidConstructor != null) {
+			validator.logError(member.position, member.invalidConstructor.error);
+			return;
+		}
 		if (member.constructor != null) {
 			member.constructor.accept(new ExpressionValidator(validator, new EnumConstantInitializerScope()));
 		}

Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,14 @@ public static CompileError noOperatorInType(TypeID type, OperatorType operator)`
`54`	`54`	`return new CompileError(CompileExceptionCode.NO_SUCH_MEMBER, "No operator " + operator + " in type " + type);`
`55`	`55`	`}`
`56`	`56`
	`57`	`+ public static CompileError notAStaticMethod(TypeID type, String name) {`
	`58`	`+ return new CompileError(CompileExceptionCode.MEMBER_NOT_STATIC, "No static method " + name + " in type " + type);`
	`59`	`+ }`
	`60`	`+`
	`61`	`+ public static CompileError notAnInstanceMethod(TypeID type, String name) {`
	`62`	`+ return new CompileError(CompileExceptionCode.MEMBER_IS_STATIC, "No instance method " + name + " in type " + type);`
	`63`	`+ }`
	`64`	`+`
`57`	`65`	`public static CompileError noThisInScope() {`
`58`	`66`	`return new CompileError(CompileExceptionCode.USING_THIS_OUTSIDE_TYPE, "Not in an instance method; cannot use this");`
`59`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@`
`14`	`14`	`public interface CompilingExpression {`
`15`	`15`	`CompilingExpression[] NONE = new CompilingExpression[0];`
`16`	`16`
	`17`	`+ CodePosition getPosition();`
	`18`	`+`
`17`	`19`	`/**`
`18`	`20`	`* Compiles this expression. The return type is inferred from the expression.`
`19`	`21`	`*`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,9 @@ public Optional<CompilingCallable> call() {`
`74`	`74`	`.findOperator(OperatorType.CALL)`
`75`	`75`	`.map(method -> method.bind(compiler, field.get(compiler.at(position), instance), name.arguments)));`
`76`	`76`	`}`
	`77`	`+ if (resolvedType.findStaticMethod(name.name).isPresent()) {`
	`78`	`+ return Optional.of(new InvalidCompilingExpression(compiler, position, CompileErrors.notAnInstanceMethod(instance.type, name.name)));`
	`79`	`+ }`
`77`	`80`
`78`	`81`	`return Optional.of(result.orElseGet(() -> new InvalidCompilingExpression(compiler, position, CompileErrors.noMemberInType(instance.type, name.name))));`
`79`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,10 @@ public Optional<CompilingCallable> call() {`
`64`	`64`	`if (staticMethod.isPresent())`
`65`	`65`	`return staticMethod;`
`66`	`66`
	`67`	`+ if (resolvedType.findMethod(name.name).isPresent()) {`
	`68`	`+ return Optional.of(new InvalidCompilingExpression(compiler, position, CompileErrors.notAStaticMethod(type, name.name)));`
	`69`	`+ }`
	`70`	`+`
`67`	`71`	`return resolvedType.getContextMember(name.name).flatMap(member -> member.compile(compiler).call());`
`68`	`72`	`}`
`69`	`73`