Support sum types in Java transient-0

1 files changed, 79 insertions, 3 deletions

diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javatransient0/JavaTransient0Generator.java b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javatransient0/JavaTransient0Generator.java
index be04982..0c7d62d 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javatransient0/JavaTransient0Generator.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javatransient0/JavaTransient0Generator.java
@@ -406,7 +406,75 @@ public class JavaTransient0Generator implements Generator {
             }
 
             case TypedSumDefinitionNode sumDefinition -> {
-                yield Stream.of();
+                var encodeStatements = List.<JavaBlockStatement>of(new JavaSwitchStatement(
+                    new JavaRef(VALUE_NAME),
+                    IntStream.range(0, sumDefinition.variants().size())
+                        .mapToObj(variantIndex -> {
+                            var variant = sumDefinition.variants().get(variantIndex);
+                            var variantVariable = JavaIdentifier.of(VALUE_NAME.value() + "$" + variantIndex);
+
+                            var statements = new ArrayList<JavaBlockStatement>();
+
+                            statements.addAll(generateEncode(
+                                new JavaIntegerLiteral(variantIndex),
+                                NativeTypes.INT_32
+                            ));
+
+                            statements.addAll(generateEncode(
+                                new JavaRef(variantVariable),
+                                variant.type().value()
+                            ));
+
+                            return new JavaSwitchRule(
+                                new JavaCasePattern(
+                                    this.javaGenerator.generateTypeRef(variant.type().value()),
+                                    variantVariable
+                                ),
+                                new JavaBlock(statements)
+                            );
+                        })
+                        .toList()
+                ));
+
+                var decodeStatements = new ArrayList<JavaBlockStatement>();
+
+                var variantTag = JavaIdentifier.of("variantTag");
+
+                decodeStatements.addAll(generateDecode(variantTag, NativeTypes.INT_32));
+
+                decodeStatements.add(new JavaSwitchStatement(
+                    new JavaRef(variantTag),
+                    IntStream.range(0, sumDefinition.variants().size())
+                        .mapToObj(variantIndex -> {
+                            var variantType = sumDefinition.variants().get(variantIndex).type().value();
+                            var variantVariable = JavaIdentifier.of(VALUE_NAME.value() + "$" + variantIndex);
+
+                            var statements = new ArrayList<JavaBlockStatement>();
+
+                            statements.addAll(generateDecode(variantVariable, variantType));
+
+                            statements.add(new JavaReturn(new JavaRef(variantVariable)));
+
+                            return new JavaSwitchRule(
+                                new JavaCaseConstant(new JavaIntegerLiteral(variantIndex)),
+                                new JavaBlock(statements)
+                            );
+                        }).toList()
+                ));
+
+                // TODO: handle this more elegantly
+                decodeStatements.add(new JavaReturn(new JavaNullLiteral()));
+
+                yield Stream.of(
+                    generateEncodeMethod(
+                        sumDefinition.type(),
+                        new JavaBlock(encodeStatements)
+                    ),
+                    generateDecodeMethod(
+                        sumDefinition.type(),
+                        new JavaBlock(decodeStatements)
+                    )
+                );
             }
         };
     }
@@ -493,7 +561,11 @@ public class JavaTransient0Generator implements Generator {
             }
 
             case SumType sumType ->  {
-                throw new UnsupportedOperationException("TODO");
+                yield List.of(generateEncode(
+                    value,
+                    sumType.namespaceName(),
+                    sumType
+                ));
             }
 
             case TypeLevelValueType typeLevelValueType ->  {
@@ -557,7 +629,11 @@ public class JavaTransient0Generator implements Generator {
             }
 
             case SumType sumType ->  {
-                throw new UnsupportedOperationException("TODO");
+                yield List.of(generateDecode(
+                    target,
+                    sumType.namespaceName(),
+                    sumType
+                ));
             }
 
             case TypeLevelValueType typeLevelValueType ->  {