From 3a2f65b6758d6357f25adde09fc0d641a8768d4c Mon Sep 17 00:00:00 2001 From: Jared Date: Fri, 29 Nov 2024 14:02:59 -0700 Subject: [PATCH 1/8] Fixed checking the equality of the same object in DTID equals --- .../org/openzen/zenscript/codemodel/type/DefinitionTypeID.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java index f2387e99..c03f5001 100644 --- a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java +++ b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java @@ -158,7 +158,7 @@ public boolean equals(Object obj) { final DefinitionTypeID other = (DefinitionTypeID) obj; return this.definition == other.definition && Arrays.deepEquals(this.typeArguments, other.typeArguments) - && Objects.equals(outer, this.outer); + && Objects.equals(outer, other.outer); } @Override From c5ef0ba10df8f16d0710fe3931eb1d0cb652b78d Mon Sep 17 00:00:00 2001 From: Jared Date: Fri, 29 Nov 2024 14:05:44 -0700 Subject: [PATCH 2/8] Add the javalib to the scripting engine --- .../src/main/java/org/openzen/zencode/java/ScriptingEngine.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java b/JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java index 853cceed..4b43f021 100644 --- a/JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java +++ b/JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java @@ -63,7 +63,7 @@ public ScriptingEngine(ScriptingEngineLogger logger) { } public ScriptingEngine(ScriptingEngineLogger logger, Function resourceGetter) { - this(logger, resourceGetter, "stdlib", "math", "collections", "uuid"); + this(logger, resourceGetter, "stdlib", "math", "collections", "uuid", "javalib"); } public ScriptingEngine(ScriptingEngineLogger logger, Function resourceGetter, String... stdLibModulesToRegister) { From 490aa7757195b8068fab6806ce0bdf8cfae9a5d1 Mon Sep 17 00:00:00 2001 From: Jared Date: Fri, 29 Nov 2024 14:06:01 -0700 Subject: [PATCH 3/8] Fix optional type parameters --- .../JavaRuntimeTypeConverterImpl.java | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java b/JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java index 9a3ab1f0..40bd9d01 100644 --- a/JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java +++ b/JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java @@ -68,15 +68,10 @@ public TypeID getType(TypeVariableContext context, AnnotatedType type) { } else if (type.isAnnotationPresent(ZenCodeType.USize.class)) { result = BasicTypeID.USIZE; } else { - boolean unsigned = type.isAnnotationPresent(ZenCodeType.Unsigned.class); - result = loadType(context, JavaAnnotatedType.of(type), unsigned); + result = loadType(context, JavaAnnotatedType.of(type), false); } - boolean isOptional = type.isAnnotationPresent(ZenCodeType.Nullable.class); - if (isOptional && !result.isOptional()) - result = new OptionalTypeID(result); - - return result; + return optionallyWrap(type, result); } @Override @@ -172,7 +167,8 @@ private TypeID loadAnnotatedParameterizedType(TypeVariableContext context, Annot private TypeID loadAnnotatedType(TypeVariableContext context, AnnotatedType type, boolean unsigned) { final JavaAnnotatedType annotatedType = JavaAnnotatedType.of(type.getType()); - return this.loadType(context, annotatedType, unsigned); + TypeID result = this.loadType(context, annotatedType, unsigned); + return optionallyWrap(type, result); } private TypeID loadClass(TypeVariableContext context, Class type, boolean unsigned) { @@ -469,4 +465,11 @@ private void fillSpecialTypes() { specialTypes.put(ToLongFunction.class, args -> new FunctionTypeID(new FunctionHeader(BasicTypeID.LONG, args[0]))); specialTypes.put(UnaryOperator.class, args -> new FunctionTypeID(new FunctionHeader(args[0], args[0]))); } + + private TypeID optionallyWrap(AnnotatedType type, TypeID result) { + boolean isOptional = type.isAnnotationPresent(ZenCodeType.Nullable.class); + if (isOptional && !result.isOptional()) + result = new OptionalTypeID(result); + return result; + } } From 2a3d22d119e53f808f585751825c8bcd78333749 Mon Sep 17 00:00:00 2001 From: Jared Date: Fri, 29 Nov 2024 14:08:40 -0700 Subject: [PATCH 4/8] Fixed OTID equals check --- .../org/openzen/zenscript/codemodel/type/OptionalTypeID.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/OptionalTypeID.java b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/OptionalTypeID.java index 39dc04e3..2b24cbb6 100644 --- a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/OptionalTypeID.java +++ b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/OptionalTypeID.java @@ -89,7 +89,7 @@ public boolean equals(Object obj) { if (getClass() != obj.getClass()) return false; final OptionalTypeID other = (OptionalTypeID) obj; - return this.baseType == other.baseType; + return this.baseType.equals(other.baseType); } @Override From d48175ce837a6f267f6d2b5be88485624afd28ef Mon Sep 17 00:00:00 2001 From: Jared Date: Fri, 29 Nov 2024 14:10:47 -0700 Subject: [PATCH 5/8] Fixed MatchedCallArguments picking the wrong method for default values --- .../codemodel/compilation/MatchedCallArguments.java | 2 +- .../functions/varargs_default_values_1.zc | 11 +++++++++++ .../functions/varargs_default_values_2.zc | 11 +++++++++++ 3 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 ScriptingEngineTester/src/main/resources/zencode_tests/functions/varargs_default_values_1.zc create mode 100644 ScriptingEngineTester/src/main/resources/zencode_tests/functions/varargs_default_values_2.zc 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 index 1b1cca03..d8116641 100644 --- a/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/MatchedCallArguments.java +++ b/CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/MatchedCallArguments.java @@ -168,7 +168,7 @@ private static MatchedCallArguments match( if (!matchedVarArg.isPresent()) { return matchedWidening; } else { - return Stream.of(matchedVarArg.get(), matchedWidening).min(Comparator.comparing(match -> match.arguments.level)).orElseThrow(() -> new IllegalStateException("Should never happen")); + return Stream.of(matchedWidening, matchedVarArg.get()).min(Comparator.comparing(match -> match.arguments.level)).orElseThrow(() -> new IllegalStateException("Should never happen")); } } diff --git a/ScriptingEngineTester/src/main/resources/zencode_tests/functions/varargs_default_values_1.zc b/ScriptingEngineTester/src/main/resources/zencode_tests/functions/varargs_default_values_1.zc new file mode 100644 index 00000000..a39c9afb --- /dev/null +++ b/ScriptingEngineTester/src/main/resources/zencode_tests/functions/varargs_default_values_1.zc @@ -0,0 +1,11 @@ +#output: ======== +#output: default value here +#output: ======== +#debug +function test(args...: string[] = ["default value here"]): void { + for item in args println(item); +} + +println("========"); +test(); +println("========"); diff --git a/ScriptingEngineTester/src/main/resources/zencode_tests/functions/varargs_default_values_2.zc b/ScriptingEngineTester/src/main/resources/zencode_tests/functions/varargs_default_values_2.zc new file mode 100644 index 00000000..31466367 --- /dev/null +++ b/ScriptingEngineTester/src/main/resources/zencode_tests/functions/varargs_default_values_2.zc @@ -0,0 +1,11 @@ +#output: ======== +#output: provided value +#output: ======== +#debug +function test(args...: string[] = ["default value here"]): void { + for item in args println(item); +} + +println("========"); +test("provided value"); +println("========"); \ No newline at end of file From ce3cf51ba544938c79d42d233b8c55cdc053a6e3 Mon Sep 17 00:00:00 2001 From: Jared Date: Fri, 29 Nov 2024 14:11:27 -0700 Subject: [PATCH 6/8] Fully implemented static member eval --- .../StaticMemberCompilingExpression.java | 32 ++++++++----------- 1 file changed, 14 insertions(+), 18 deletions(-) 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 index faf15a3a..fef24765 100644 --- 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 @@ -31,28 +31,24 @@ public Expression eval() { ResolvedType resolved = compiler.resolve(type); - /*Optional asGetter = resolved.findStaticGetter(name.name) - .map(getter -> getter.call(compiler, position, TypeID.NONE)); - if (asGetter.isPresent()) { - return asGetter.get(); - }*/ - - Optional staticGetter = resolved.findStaticGetter(name.name); - if(staticGetter.isPresent()){ - return staticGetter.get().call(compiler, position, TypeID.NONE); + Optional byGetter = resolved + .findStaticGetter(name.name) + .map(getter -> getter.call(compiler, position, TypeID.NONE)); + + if (byGetter.isPresent()) { + return byGetter.get(); } + Optional contextMember = resolved.getContextMember(name.name); - if(contextMember.isPresent()){ + if (contextMember.isPresent()) { return contextMember.get().compile(compiler).eval(); } - return compiler.at(position).invalid(CompileErrors.noMemberInType(type, name.name)); - -// return resolved.findStaticGetter(name.name) -// .map(getter -> getter.call(compiler, position, TypeID.NONE)) -// .orElseGet(() -> -// resolved.getContextMember(name.name) -// .map(member -> member.compile(compiler).eval()) -// .orElseGet(() -> compiler.at(position).invalid(CompileErrors.noMemberInType(type, name.name)))); + + return resolved + .findField(name.name) + .filter(ResolvedType.Field::isStatic) + .map(field -> field.getStatic(compiler.at(position))) + .orElseGet(() -> compiler.at(position).invalid(CompileErrors.noMemberInType(type, name.name))); } @Override From e782c6a51b1cae60a604b3ce35a2a1c59730c3ca Mon Sep 17 00:00:00 2001 From: Jared Date: Fri, 29 Nov 2024 14:33:03 -0700 Subject: [PATCH 7/8] register Enum#compareTo correctly --- .../java/module/JavaNativeTypeTemplate.java | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/JavaIntegration/src/main/java/org/openzen/zencode/java/module/JavaNativeTypeTemplate.java b/JavaIntegration/src/main/java/org/openzen/zencode/java/module/JavaNativeTypeTemplate.java index 8bd2a942..bd9ec2ac 100644 --- a/JavaIntegration/src/main/java/org/openzen/zencode/java/module/JavaNativeTypeTemplate.java +++ b/JavaIntegration/src/main/java/org/openzen/zencode/java/module/JavaNativeTypeTemplate.java @@ -19,6 +19,7 @@ import org.openzen.zenscript.codemodel.ssa.CodeBlockStatement; import org.openzen.zenscript.codemodel.ssa.SSAVariableCollector; import org.openzen.zenscript.codemodel.type.ArrayTypeID; +import org.openzen.zenscript.codemodel.type.BasicTypeID; import org.openzen.zenscript.codemodel.type.TypeID; import org.openzen.zenscript.codemodel.type.builtin.BuiltinMethodSymbol; import org.openzen.zenscript.javashared.JavaClass; @@ -213,9 +214,9 @@ private void loadMethods() { if (class_.cls.isEnum()) { Stream.of( BuiltinMethodSymbol.ENUM_NAME, - BuiltinMethodSymbol.ENUM_ORDINAL, + BuiltinMethodSymbol.ENUM_ORDINAL //BuiltinMethodSymbol.ENUM_VALUES, - BuiltinMethodSymbol.ENUM_COMPARE +// BuiltinMethodSymbol.ENUM_COMPARE ).forEach(method -> methods .computeIfAbsent(method.getID(), x -> new ArrayList<>()) .add(method) @@ -232,6 +233,18 @@ private void loadMethods() { throw new IllegalStateException("We found an enum class without values() method: " + class_.cls.getCanonicalName(), exception); } + try { + MethodID id = MethodID.operator(OperatorType.COMPARE); + FunctionHeader header = new FunctionHeader(BasicTypeID.INT, target); + Method method = class_.cls.getMethod("compareTo", Enum.class); + JavaRuntimeMethod runtimeMethod = new JavaRuntimeMethod(class_, target, method, id, header, false, false); + methods.computeIfAbsent(id, x -> new ArrayList<>()).add(runtimeMethod); + class_.module.getCompiled().setMethodInfo(runtimeMethod, runtimeMethod); + } catch (ReflectiveOperationException exception) { + throw new IllegalStateException("Error while registering Enum#compareTo for: " + class_.cls.getCanonicalName(), exception); + } + + } } From 2382bab9b097c1308b1e4eb0fa8b40803a090f1d Mon Sep 17 00:00:00 2001 From: Stan Hebben Date: Fri, 31 Jan 2025 20:16:19 +0100 Subject: [PATCH 8/8] Removed the unnecessary unsigned parameters --- .../JavaRuntimeTypeConverterImpl.java | 55 ++++++++----------- 1 file changed, 24 insertions(+), 31 deletions(-) diff --git a/JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java b/JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java index 40bd9d01..f467a2be 100644 --- a/JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java +++ b/JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java @@ -7,13 +7,11 @@ import org.openzen.zencode.java.TypeVariableContext; import org.openzen.zencode.java.module.JavaAnnotatedType; import org.openzen.zencode.java.module.JavaNativePackageInfo; -import org.openzen.zencode.java.module.JavaRuntimeClass; import org.openzen.zencode.shared.CodePosition; import org.openzen.zencode.shared.LiteralSourceFile; import org.openzen.zenscript.codemodel.FunctionHeader; import org.openzen.zenscript.codemodel.GenericMapper; import org.openzen.zenscript.codemodel.Modifiers; -import org.openzen.zenscript.codemodel.ModuleSpace; import org.openzen.zenscript.codemodel.compilation.CompileContext; import org.openzen.zenscript.codemodel.definition.ClassDefinition; import org.openzen.zenscript.codemodel.definition.ZSPackage; @@ -68,7 +66,7 @@ public TypeID getType(TypeVariableContext context, AnnotatedType type) { } else if (type.isAnnotationPresent(ZenCodeType.USize.class)) { result = BasicTypeID.USIZE; } else { - result = loadType(context, JavaAnnotatedType.of(type), false); + result = loadType(context, JavaAnnotatedType.of(type)); } return optionallyWrap(type, result); @@ -101,19 +99,19 @@ public TypeID parseType(String type) { } } - private TypeID loadType(TypeVariableContext context, JavaAnnotatedType type, boolean unsigned) { + private TypeID loadType(TypeVariableContext context, JavaAnnotatedType type) { final JavaAnnotatedType.ElementType elementType = type.getElementType(); try { switch (elementType) { case ANNOTATED_PARAMETERIZED_TYPE: - return loadAnnotatedParameterizedType(context, (AnnotatedParameterizedType) type.getAnnotatedElement(), unsigned); + return loadAnnotatedParameterizedType(context, (AnnotatedParameterizedType) type.getAnnotatedElement()); case ANNOTATED_TYPE: - return loadAnnotatedType(context, (AnnotatedType) type.getAnnotatedElement(), unsigned); + return loadAnnotatedType(context, (AnnotatedType) type.getAnnotatedElement()); case CLASS: - return loadClass(context, (Class) type.getType(), unsigned); + return loadClass(context, (Class) type.getType()); case GENERIC_ARRAY: - return loadGenericArray(context, (GenericArrayType) type.getType(), unsigned); + return loadGenericArray(context, (GenericArrayType) type.getType()); case PARAMETERIZED_TYPE: return loadParameterizedType(context, (ParameterizedType) type.getType()); case TYPE_VARIABLE: @@ -128,22 +126,20 @@ private TypeID loadType(TypeVariableContext context, JavaAnnotatedType type, boo throw new IllegalArgumentException("Invalid type " + elementType + ": not yet implemented or foolery"); } - private TypeSymbol loadRawType(TypeVariableContext context, JavaAnnotatedType type, boolean unsigned) { + private TypeSymbol loadRawType(JavaAnnotatedType type) { final JavaAnnotatedType.ElementType elementType = type.getElementType(); try { - switch (elementType) { - case CLASS: - return findType((Class) type.getType()); - default: - throw new IllegalArgumentException("Didn't expect to get this kind of type: " + type); + if (Objects.requireNonNull(elementType) == JavaAnnotatedType.ElementType.CLASS) { + return findType((Class) type.getType()); } + throw new IllegalArgumentException("Didn't expect to get this kind of type: " + type); } catch (final IllegalArgumentException e) { throw new IllegalArgumentException("Unable to analyze type: " + type, e); } } - private TypeID loadAnnotatedParameterizedType(TypeVariableContext context, AnnotatedParameterizedType type, boolean unsigned) { + private TypeID loadAnnotatedParameterizedType(TypeVariableContext context, AnnotatedParameterizedType type) { final ParameterizedType parameterizedType = this.getTypeIfValid(JavaAnnotatedType.of(type.getType()), JavaAnnotatedType.ElementType.PARAMETERIZED_TYPE); final JavaAnnotatedType rawType = JavaAnnotatedType.of(parameterizedType.getRawType()); @@ -151,34 +147,31 @@ private TypeID loadAnnotatedParameterizedType(TypeVariableContext context, Annot final TypeID[] codeParameters = new TypeID[actualTypeArguments.length]; for (int i = 0; i < actualTypeArguments.length; i++) { - codeParameters[i] = this.loadType(context, actualTypeArguments[i], false); + codeParameters[i] = this.loadType(context, actualTypeArguments[i]); } if (rawType.getElementType() == JavaAnnotatedType.ElementType.CLASS) { + //noinspection SuspiciousMethodCalls if (specialTypes.containsKey(rawType.getType())) { + //noinspection SuspiciousMethodCalls return specialTypes.get(rawType.getType()).apply(codeParameters); } - final TypeSymbol rawTypeSymbol = loadRawType(context, rawType, unsigned); + final TypeSymbol rawTypeSymbol = loadRawType(rawType); return DefinitionTypeID.create(rawTypeSymbol, codeParameters); } - return this.loadType(context, JavaAnnotatedType.of(type), unsigned); + return this.loadType(context, JavaAnnotatedType.of(type)); } - private TypeID loadAnnotatedType(TypeVariableContext context, AnnotatedType type, boolean unsigned) { + private TypeID loadAnnotatedType(TypeVariableContext context, AnnotatedType type) { final JavaAnnotatedType annotatedType = JavaAnnotatedType.of(type.getType()); - TypeID result = this.loadType(context, annotatedType, unsigned); + TypeID result = this.loadType(context, annotatedType); return optionallyWrap(type, result); } - private TypeID loadClass(TypeVariableContext context, Class type, boolean unsigned) { - if (unsigned) { - return unsignedByClass.computeIfAbsent(type, it -> { - throw new IllegalArgumentException("This class cannot be used as unsigned: " + it); - }); - } + private TypeID loadClass(TypeVariableContext context, Class type) { if (type.isArray()) { - final TypeID baseType = this.loadType(context, JavaAnnotatedType.of(type.getComponentType()), false); + final TypeID baseType = this.loadType(context, JavaAnnotatedType.of(type.getComponentType())); return new ArrayTypeID(baseType); } if (type.isAnnotationPresent(FunctionalInterface.class)) { @@ -201,9 +194,9 @@ private TypeID loadClass(TypeVariableContext context, Class type, boolean uns return DefinitionTypeID.create(definition, typeParameters.toArray(TypeID.NONE)); } - private TypeID loadGenericArray(TypeVariableContext context, GenericArrayType type, boolean unsigned) { + private TypeID loadGenericArray(TypeVariableContext context, GenericArrayType type) { final JavaAnnotatedType componentType = JavaAnnotatedType.of(type.getGenericComponentType()); - final TypeID baseType = this.loadType(context, componentType, unsigned); + final TypeID baseType = this.loadType(context, componentType); return new ArrayTypeID(baseType); } @@ -217,7 +210,7 @@ private TypeID loadParameterizedType(TypeVariableContext context, ParameterizedT TypeID[] codeParameters = new TypeID[typeArguments.length]; for (int i = 0; i < typeArguments.length; i++) { - codeParameters[i] = this.loadType(context, typeArguments[i], false); + codeParameters[i] = this.loadType(context, typeArguments[i]); } if (rawType == Map.class) { @@ -338,7 +331,7 @@ private TypeID loadFunctionalInterface(TypeVariableContext loadContext, Class Map mapping = new HashMap<>(); TypeVariable[] javaParameters = cls.getTypeParameters(); for (int i = 0; i < parameters.length; i++) { - mapping.put(context.get(javaParameters[i]), loadType(loadContext, parameters[i], false)); + mapping.put(context.get(javaParameters[i]), loadType(loadContext, parameters[i])); } header = header.withGenericArguments(new GenericMapper(mapping, TypeID.NONE));