Support sums in rust-transient-0

1 files changed, 77 insertions, 1 deletions

diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rusttransient0/RustTransient0Generator.java b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rusttransient0/RustTransient0Generator.java
index f2b8254..fd7bd34 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rusttransient0/RustTransient0Generator.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rusttransient0/RustTransient0Generator.java
@@ -406,7 +406,83 @@ public class RustTransient0Generator implements Generator {
             }
 
             case TypedSumDefinitionNode sumDefinition -> {
-                yield Stream.of();
+                var encodeFunction = generateEncodeFunction(
+                    sumDefinition.type(),
+                    List.of(
+                        new RustExpressionStatement(new RustMatchExpression(
+                            RustPath.of(VALUE_NAME),
+                            IntStream.range(0, sumDefinition.variants().size())
+                                .mapToObj(variantIndex -> {
+                                    var variant = sumDefinition.variants().get(variantIndex);
+                                    var variantType = variant.type().value();
+                                    var variantPath = this.rustGenerator.generateRustTypeExpression(sumDefinition.type())
+                                        .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variantType)));
+
+                                    return new RustMatchArm(
+                                        new RustTupleStructPattern(variantPath, List.of(new RustIdentifierPattern(VALUE_NAME))),
+                                        new RustBlockExpression(
+                                            List.of(
+                                                new RustExpressionStatement(new RustBlockExpression(
+                                                    generateEncode(
+                                                        new RustPrefixExpression(
+                                                            RustPrefixOperator.BORROW,
+                                                            new RustIntegerLiteral(variantIndex, Optional.empty())
+                                                        ),
+                                                        NativeTypes.INT_32
+                                                    ),
+                                                    Optional.empty()
+                                                )),
+                                                new RustExpressionStatement(new RustBlockExpression(
+                                                    generateEncode(RustPath.of(VALUE_NAME), variantType),
+                                                    Optional.empty()
+                                                ))
+                                            ),
+                                            Optional.empty()
+                                        )
+                                    );
+                                })
+                                .toList()
+                        ))
+                    )
+                );
+
+                var decodeMatchArms = IntStream.range(0, sumDefinition.variants().size())
+                    .mapToObj(variantIndex -> {
+                        var variant = sumDefinition.variants().get(variantIndex);
+                        var variantType = variant.type().value();
+                        var variantPath = this.rustGenerator.generateRustTypeExpression(sumDefinition.type())
+                            .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variantType)));
+
+                        return new RustMatchArm(
+                            new RustLiteralPattern(new RustIntegerLiteral(variantIndex, Optional.empty())),
+                            new RustCallExpression(variantPath, List.of(generateDecode(variantType)))
+                        );
+                    })
+                    .collect(toArrayList());
+
+                decodeMatchArms.add(new RustMatchArm(
+                    new RustWildcardPattern(),
+                    generateTodo()
+                ));
+
+                var decodeFunction = generateDecodeFunction(
+                    sumDefinition.type(),
+                    new RustBlockExpression(
+                        List.of(),
+                        Optional.of(new RustMatchExpression(
+                            new RustPrefixExpression(
+                                RustPrefixOperator.BORROW,
+                                generateDecode(NativeTypes.INT_32)
+                            ),
+                            decodeMatchArms
+                        ))
+                    )
+                );
+
+                yield Stream.of(
+                    encodeFunction,
+                    decodeFunction
+                );
             }
         };
     }