Feat(wip): Allow Expansions with generic parameters in Java

JavaAnnotations/src/main/java/org/openzen/zencode/java/ZenCodeType.java

@@ -56,7 +56,7 @@ enum OperatorType {
 	@interface Expansion {
 		String value();
 
-		//String[] typeParameters() default {};
+		String typeParameters() default "";
 	}
 
 	@Retention(RetentionPolicy.RUNTIME)

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

@@ -7,5 +7,5 @@
 public interface JavaRuntimeTypeConverter {
 	TypeID getType(TypeVariableContext context, AnnotatedType type);
 
-	TypeID parseType(String type);
+	TypeID parseType(ZenCodeType.Expansion type);
 }

JavaIntegration/src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java

@@ -29,6 +29,7 @@
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.parser.definitions.ParsedTypeParameter;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 import java.io.IOException;
@@ -75,7 +76,9 @@ public TypeID getType(TypeVariableContext context, AnnotatedType type) {
 	}
 
 	@Override
-	public TypeID parseType(String type) {
+	public TypeID parseType(ZenCodeType.Expansion expansion) {
+		String type = expansion.value();
+
 		for (TypeID value : this.typeByClass.values()) {
 			if (value.toString().equals(type))
 				return value;
@@ -92,7 +95,17 @@ public TypeID parseType(String type) {
 			IParsedType parsed = IParsedType.parse(tokens);
 
 			CompileContext context = new CompileContext(relative ? packageInfo.getPkg() : packageInfo.getRoot(), packageInfo.getPkg(), Collections.emptyList(), Collections.emptyMap(), Collections.emptyList());
-			return parsed.compile(context);
+
+			final ZSTokenParser typeBoundsTokens = ZSTokenParser.create(new LiteralSourceFile("internal", expansion.typeParameters()), null);
+			TypeParameter[] typeParameters = Optional.ofNullable(ParsedTypeParameter.parseAll(typeBoundsTokens))
+					.map(parsedTypeParameters -> {
+						TypeParameter[] compiled = ParsedTypeParameter.getCompiled(parsedTypeParameters);
+						ParsedTypeParameter.compile(context, compiled, parsedTypeParameters);
+						return compiled;
+					})
+					.orElse(TypeParameter.NONE);
+
+			return parsed.compile(context.withGeneric(typeParameters));
 		} catch (IOException ex) {
 			throw new AssertionError("Not supposed to happen");
 		} catch (ParseException ex) {
@@ -391,6 +404,7 @@ private Method getFunctionalInterfaceMethod(Class<?> functionalInterface) {
 
 	private void fillClassMaps() {
 		typeByClass.put(void.class, BasicTypeID.VOID);
+		typeByClass.put(Void.class, BasicTypeID.VOID);
 		typeByClass.put(boolean.class, BasicTypeID.BOOL);
 		typeByClass.put(byte.class, BasicTypeID.SBYTE);
 		typeByClass.put(char.class, BasicTypeID.CHAR);

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

@@ -103,7 +103,7 @@ public JavaRuntimeClass addClass(Class<?> cls) {
 		TypeID target = null;
 		if (kind == JavaClass.Kind.EXPANSION) {
 			ZenCodeType.Expansion expansion = cls.getAnnotation(ZenCodeType.Expansion.class);
-			target = typeConverter.parseType(expansion.value());
+			target = typeConverter.parseType(expansion);
 		}
 
 		ParsedName name = getClassName(cls);

ScriptingExample/src/test/java/org/openzen/zenscript/scriptingexample/tests/actual_test/java_native/expansions/GenericExpansionTests.java

@@ -0,0 +1,45 @@
+package org.openzen.zenscript.scriptingexample.tests.actual_test.java_native.expansions;
+
+import org.junit.jupiter.api.Test;
+import org.openzen.zencode.java.ZenCodeType;
+import org.openzen.zenscript.scriptingexample.tests.helpers.ScriptBuilder;
+import org.openzen.zenscript.scriptingexample.tests.helpers.ZenCodeTest;
+
+import java.util.Collections;
+import java.util.List;
+
+class GenericExpansionTests extends ZenCodeTest {
+
+	@Override
+	public List<String> getRequiredStdLibModules() {
+		return Collections.singletonList("stdlib");
+	}
+
+	@Override
+	public List<Class<?>> getRequiredClasses() {
+		List<Class<?>> requiredClasses = super.getRequiredClasses();
+		requiredClasses.add(ExpandStringList.class);
+		return requiredClasses;
+	}
+
+	@Test
+	void works() {
+		ScriptBuilder.create()
+				.add("import stdlib.List;")
+				.add("var list = ['one', 'two', 'three'] as List<string>;")
+				.add("println(list.join(','));")
+				.execute(this);
+		logger.assertPrintOutputSize(1);
+		logger.assertPrintOutput(0, "one,two,three");
+	}
+
+	@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);
+		}
+	}
+}