Add basic support for generic structs in java-transient-0

2 files changed, 54 insertions, 34 deletions

diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/java/JavaGenerator.java b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/java/JavaGenerator.java
index 1bb256c..901171c 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/java/JavaGenerator.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/java/JavaGenerator.java
@@ -201,7 +201,7 @@ public class JavaGenerator {
                 throw new UnsupportedOperationException("TODO");
 
             case TypeParam typeParam ->
-                throw new UnsupportedOperationException("TODO");
+                JavaTypeRef.local(this.generateTypeName(typeParam.name()));
         };
     }
 
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javatypes/JavaTypesGenerator.java b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javatypes/JavaTypesGenerator.java
index 62f24b6..270683d 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javatypes/JavaTypesGenerator.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javatypes/JavaTypesGenerator.java
@@ -123,7 +123,17 @@ public class JavaTypesGenerator implements Generator {
         TypedStructDefinitionNode structDefinition,
         Context context
     ) {
-        var javaTypeRef = generateTypeRef(structDefinition.typeOrThrow(), context);
+        var javaRawTypeRef = generateTypeRef(structDefinition.typeOrConstructor().unboundType(), context);
+
+        var javaTypeParams = switch (structDefinition.typeOrConstructor()) {
+            case TypeOrConstructor.Constructor<SimpleStructType> constructor ->
+                constructor.value().params().stream()
+                    .map(param -> new JavaTypeParameter(this.javaGenerator.generateTypeName(param.name())))
+                    .toList();
+
+            case TypeOrConstructor.Type<SimpleStructType> _ ->
+                List.<JavaTypeParameter>of();
+        };
 
         var components = structDefinition.fields().orElse(List.of()).stream()
             .map(field -> new JavaRecordComponent(
@@ -132,48 +142,58 @@ public class JavaTypesGenerator implements Generator {
             ))
             .toList();
 
-        var implementsTypes = context.variantOf(structDefinition.typeOrThrow()).stream()
-            .map(sumType -> this.generateTypeRef(sumType, context))
-            .toList();
-
-        var builderJavaTypeRef = generateBuilderTypeRef(structDefinition.typeOrThrow());
+        // TODO: handle generic types
+        var implementsTypes = switch (structDefinition.typeOrConstructor()) {
+            case TypeOrConstructor.Constructor<SimpleStructType> _ ->
+                List.<JavaTypeRef>of();
 
-        var arbitraryValueExpression = new JavaNewExpression(
-            builderJavaTypeRef,
-            structDefinition.fields().orElse(List.of()).stream()
-                .map(field -> arbitraryValue(field.type(), context))
-                .toList()
-        );
+            case TypeOrConstructor.Type<SimpleStructType> type ->
+                context.variantOf(type.value()).stream()
+                    .map(sumType -> this.generateTypeRef(sumType, context))
+                    .toList();
+        };
 
         var body = new ArrayList<JavaClassBodyDeclaration>();
 
         if (structDefinition.fields().isEmpty()) {
-            body.add(generateStructSingletonInstanceField(javaTypeRef));
-            body.add(generateStructSingletonConstructor(javaTypeRef));
+            body.add(generateStructSingletonInstanceField(javaRawTypeRef));
+            body.add(generateStructSingletonConstructor(javaRawTypeRef));
         }
 
-        body.add(new JavaMethodDeclaration(
-            ARBITRARY_METHOD_NAME,
-            JavaVisibility.PUBLIC,
-            JavaMemberKind.STATIC,
-            builderJavaTypeRef,
-            List.of(),
-            List.of(),
-            new JavaBlock(List.of(
-                new JavaReturn(arbitraryValueExpression)
-            ))
-        ));
+        // TODO: handle generic types
+        if (structDefinition.typeOrConstructor() instanceof TypeOrConstructor.Type<SimpleStructType>) {
+            var builderJavaTypeRef = generateBuilderTypeRef(structDefinition.typeOrThrow());
 
-        body.add(generateStructDefinitionBuilder(
-            structDefinition,
-            components,
-            context
-        ));
+            var arbitraryValueExpression = new JavaNewExpression(
+                builderJavaTypeRef,
+                structDefinition.fields().orElse(List.of()).stream()
+                    .map(field -> arbitraryValue(field.type(), context))
+                    .toList()
+            );
+
+            body.add(new JavaMethodDeclaration(
+                ARBITRARY_METHOD_NAME,
+                JavaVisibility.PUBLIC,
+                JavaMemberKind.STATIC,
+                builderJavaTypeRef,
+                List.of(),
+                List.of(),
+                new JavaBlock(List.of(
+                    new JavaReturn(arbitraryValueExpression)
+                ))
+            ));
+
+            body.add(generateStructDefinitionBuilder(
+                structDefinition,
+                components,
+                context
+            ));
+        }
 
         if (structDefinition.fields().isPresent()) {
             return new JavaRecordDeclaration(
-                javaTypeRef,
-                List.of(),
+                javaRawTypeRef,
+                javaTypeParams,
                 components,
                 implementsTypes,
                 body,
@@ -181,7 +201,7 @@ public class JavaTypesGenerator implements Generator {
             );
         } else {
             return new JavaClassDeclaration(
-                javaTypeRef,
+                javaRawTypeRef,
                 implementsTypes,
                 body,
                 structDefinition.docComment()