Extract encode/decode function generation

1 files changed, 181 insertions, 165 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 8c84909..3dca1bd 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
@@ -295,67 +295,9 @@ public class RustTransient0Generator implements Generator {
     ) {
         return switch (statement) {
             case TypedEnumDefinitionNode enumDefinition -> {
-                var ordinalExpression = new RustMatchExpression(
-                    RustPath.of(VALUE_NAME),
-                    IntStream.range(0, enumDefinition.variants().size())
-                        .mapToObj(variantIndex -> {
-                            var variant = enumDefinition.variants().get(variantIndex);
-                            var variantPath = this.rustGenerator.generateRustTypeExpression(enumDefinition.type())
-                                .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variant.name())));
-
-                            return new RustMatchArm(
-                                new RustPathPattern(variantPath),
-                                new RustIntegerLiteral(variantIndex, Optional.empty())
-                            );
-                        })
-                        .toList()
-                );
-
-                var encodeFunction = generateEncodeFunction(
-                    enumDefinition.type(),
-                    List.of(
-                        generateEncode(new RustPrefixExpression(
-                            RustPrefixOperator.BORROW,
-                            ordinalExpression
-                        ), NativeTypes.INT_32)
-                    )
-                );
-
-                var decodeMatchArms = IntStream.range(0, enumDefinition.variants().size())
-                    .mapToObj(variantIndex -> {
-                        var variant = enumDefinition.variants().get(variantIndex);
-                        var variantPath = this.rustGenerator.generateRustTypeExpression(enumDefinition.type())
-                            .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variant.name())));
-
-                        return new RustMatchArm(
-                            new RustLiteralPattern(new RustIntegerLiteral(variantIndex, Optional.empty())),
-                            variantPath
-                        );
-                    })
-                    .collect(toArrayList());
-
-                decodeMatchArms.add(new RustMatchArm(
-                    new RustWildcardPattern(),
-                    generateTodo()
-                ));
-
-                var decodeFunction = generateDecodeFunction(
-                    enumDefinition.type(),
-                    new RustBlockExpression(
-                        List.of(),
-                        Optional.of(new RustMatchExpression(
-                            new RustPrefixExpression(
-                                RustPrefixOperator.BORROW,
-                                generateDecode(NativeTypes.INT_32)
-                            ),
-                            decodeMatchArms
-                        ))
-                    )
-                );
-
                 yield Stream.of(
-                    encodeFunction,
-                    decodeFunction
+                    generateEncodeEnumFunction(enumDefinition),
+                    generateDecodeEnumFunction(enumDefinition)
                 );
             }
 
@@ -364,122 +306,196 @@ public class RustTransient0Generator implements Generator {
             }
 
             case TypedStructDefinitionNode structDefinition -> {
-                var rustType = this.rustGenerator.generateRustTypeExpression(structDefinition.type());
-
                 yield Stream.of(
-                    generateEncodeFunction(
-                        structDefinition.type(),
-                        structDefinition.fields().stream()
-                            .map(field -> generateEncode(
-                                new RustPrefixExpression(
-                                    RustPrefixOperator.BORROW,
-                                    new RustFieldExpression(
-                                        RustPath.of(VALUE_NAME),
-                                        this.rustGenerator.generateFieldName(field.name())
-                                    )
-                                ),
-                                field.type().value()
-                            ))
-                            .toList()
-                    ),
-                    generateDecodeFunction(
-                        structDefinition.type(),
-                        new RustBlockExpression(
-                            structDefinition.fields().stream()
-                                .<RustStatement>map(field -> new RustLetStatement(
-                                    this.rustGenerator.generateFieldName(field.name()),
-                                    false,
-                                    generateDecode(field.type().value())
-                                ))
-                                .toList(),
-                            Optional.of(new RustStructExpression(
-                                rustType,
-                                structDefinition.fields().stream()
-                                    .map(field -> new RustStructExprField(
-                                        this.rustGenerator.generateFieldName(field.name()),
-                                        RustPath.of(this.rustGenerator.generateFieldName(field.name()))
-                                    ))
-                                    .toList()
-                            ))
-                        )
-                    )
+                    generateEncodeStructFunction(structDefinition),
+                    generateDecodeStructFunction(structDefinition)
                 );
             }
 
             case TypedSumDefinitionNode sumDefinition -> {
-                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(
-                                                generateEncode(
-                                                    new RustPrefixExpression(
-                                                        RustPrefixOperator.BORROW,
-                                                        new RustIntegerLiteral(variantIndex, Optional.empty())
-                                                    ),
-                                                    NativeTypes.INT_32
-                                                ),
-                                                generateEncode(RustPath.of(VALUE_NAME), variantType)
-                                            ),
-                                            Optional.empty()
-                                        )
-                                    );
-                                })
-                                .toList()
-                        ))
-                    )
+                yield Stream.of(
+                    generateEncodeSumFunction(sumDefinition),
+                    generateDecodeSumFunction(sumDefinition)
                 );
+            }
+        };
+    }
 
-                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()
-                ));
+    private RustItem generateEncodeEnumFunction(TypedEnumDefinitionNode enumDefinition) {
+        var ordinalExpression = new RustMatchExpression(
+            RustPath.of(VALUE_NAME),
+            IntStream.range(0, enumDefinition.variants().size())
+                .mapToObj(variantIndex -> {
+                    var variant = enumDefinition.variants().get(variantIndex);
+                    var variantPath = this.rustGenerator.generateRustTypeExpression(enumDefinition.type())
+                        .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variant.name())));
+
+                    return new RustMatchArm(
+                        new RustPathPattern(variantPath),
+                        new RustIntegerLiteral(variantIndex, Optional.empty())
+                    );
+                })
+                .toList()
+        );
 
-                var decodeFunction = generateDecodeFunction(
-                    sumDefinition.type(),
-                    new RustBlockExpression(
-                        List.of(),
-                        Optional.of(new RustMatchExpression(
-                            new RustPrefixExpression(
-                                RustPrefixOperator.BORROW,
-                                generateDecode(NativeTypes.INT_32)
-                            ),
-                            decodeMatchArms
-                        ))
-                    )
+        return generateEncodeFunction(
+            enumDefinition.type(),
+            List.of(
+                generateEncode(new RustPrefixExpression(
+                    RustPrefixOperator.BORROW,
+                    ordinalExpression
+                ), NativeTypes.INT_32)
+            )
+        );
+    }
+
+    private RustItem generateDecodeEnumFunction(TypedEnumDefinitionNode enumDefinition) {
+        var decodeMatchArms = IntStream.range(0, enumDefinition.variants().size())
+            .mapToObj(variantIndex -> {
+                var variant = enumDefinition.variants().get(variantIndex);
+                var variantPath = this.rustGenerator.generateRustTypeExpression(enumDefinition.type())
+                    .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variant.name())));
+
+                return new RustMatchArm(
+                    new RustLiteralPattern(new RustIntegerLiteral(variantIndex, Optional.empty())),
+                    variantPath
                 );
+            })
+            .collect(toArrayList());
 
-                yield Stream.of(
-                    encodeFunction,
-                    decodeFunction
+        decodeMatchArms.add(new RustMatchArm(
+            new RustWildcardPattern(),
+            generateTodo()
+        ));
+
+        return generateDecodeFunction(
+            enumDefinition.type(),
+            new RustBlockExpression(
+                List.of(),
+                Optional.of(new RustMatchExpression(
+                    new RustPrefixExpression(
+                        RustPrefixOperator.BORROW,
+                        generateDecode(NativeTypes.INT_32)
+                    ),
+                    decodeMatchArms
+                ))
+            )
+        );
+    }
+
+    private RustItem generateEncodeStructFunction(TypedStructDefinitionNode structDefinition) {
+        return generateEncodeFunction(
+            structDefinition.type(),
+            structDefinition.fields().stream()
+                .map(field -> generateEncode(
+                    new RustPrefixExpression(
+                        RustPrefixOperator.BORROW,
+                        new RustFieldExpression(
+                            RustPath.of(VALUE_NAME),
+                            this.rustGenerator.generateFieldName(field.name())
+                        )
+                    ),
+                    field.type().value()
+                ))
+                .toList()
+        );
+    }
+
+    private RustItem generateDecodeStructFunction(TypedStructDefinitionNode structDefinition) {
+        var rustType = this.rustGenerator.generateRustTypeExpression(structDefinition.type());
+
+        return generateDecodeFunction(
+            structDefinition.type(),
+            new RustBlockExpression(
+                structDefinition.fields().stream()
+                    .<RustStatement>map(field -> new RustLetStatement(
+                        this.rustGenerator.generateFieldName(field.name()),
+                        false,
+                        generateDecode(field.type().value())
+                    ))
+                    .toList(),
+                Optional.of(new RustStructExpression(
+                    rustType,
+                    structDefinition.fields().stream()
+                        .map(field -> new RustStructExprField(
+                            this.rustGenerator.generateFieldName(field.name()),
+                            RustPath.of(this.rustGenerator.generateFieldName(field.name()))
+                        ))
+                        .toList()
+                ))
+            )
+        );
+    }
+
+    private RustItem generateEncodeSumFunction(TypedSumDefinitionNode sumDefinition) {
+        return 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(
+                                        generateEncode(
+                                            new RustPrefixExpression(
+                                                RustPrefixOperator.BORROW,
+                                                new RustIntegerLiteral(variantIndex, Optional.empty())
+                                            ),
+                                            NativeTypes.INT_32
+                                        ),
+                                        generateEncode(RustPath.of(VALUE_NAME), variantType)
+                                    ),
+                                    Optional.empty()
+                                )
+                            );
+                        })
+                        .toList()
+                ))
+            )
+        );
+    }
+
+    private RustItem generateDecodeSumFunction(TypedSumDefinitionNode sumDefinition) {
+        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()
+        ));
+
+        return generateDecodeFunction(
+            sumDefinition.type(),
+            new RustBlockExpression(
+                List.of(),
+                Optional.of(new RustMatchExpression(
+                    new RustPrefixExpression(
+                        RustPrefixOperator.BORROW,
+                        generateDecode(NativeTypes.INT_32)
+                    ),
+                    decodeMatchArms
+                ))
+            )
+        );
     }
 
     private RustItem generateEncodeFunction(