Introduce SumVariant

11 files changed, 112 insertions, 111 deletions

diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javapreciselymatchers/JavaPreciselyMatchersGenerator.java b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javapreciselymatchers/JavaPreciselyMatchersGenerator.java
index 61af40e..bea3f1d 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javapreciselymatchers/JavaPreciselyMatchersGenerator.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/javapreciselymatchers/JavaPreciselyMatchersGenerator.java
@@ -261,7 +261,7 @@ public class JavaPreciselyMatchersGenerator implements Generator {
             return this.typesInfo.variantOf(type);
         }
 
-        public List<Type> variants(SumType type) {
+        public List<SumVariant> variants(SumType type) {
             return this.typesInfo.sumVariants(type);
         }
     }
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 ff9bcd4..f64370c 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
@@ -606,9 +606,10 @@ public class JavaTypesGenerator implements Generator {
         seenTypes.add(sumType);
         // TODO: better error
         return context.sumVariants(sumType).stream()
-            .filter(variant -> isNonRecursivelyConstructable(variant, seenTypes, context))
+            .filter(variant -> isNonRecursivelyConstructable(variant.valueType(), seenTypes, context))
             .findFirst()
-            .orElseThrow();
+            .orElseThrow()
+            .containerType();
     }
 
     private boolean isNonRecursivelyConstructable(Type type, Set<Type> seenTypes, Context context) {
@@ -618,6 +619,7 @@ public class JavaTypesGenerator implements Generator {
 
         return switch (type) {
             case ConstructedNativeType constructedNativeType ->
+                // TODO: Handle Box and Shared
                 true;
 
             case EnumType enumType ->
@@ -638,7 +640,7 @@ public class JavaTypesGenerator implements Generator {
                 var newSeenTypes = new HashSet<>(seenTypes);
                 newSeenTypes.add(type);
                 var result = context.sumVariants(sumType).stream()
-                    .anyMatch(variant -> isNonRecursivelyConstructable(variant, seenTypes, context));
+                    .anyMatch(variant -> isNonRecursivelyConstructable(variant.valueType(), seenTypes, context));
                 yield result;
             }
 
@@ -685,7 +687,7 @@ public class JavaTypesGenerator implements Generator {
             return this.typesInfo.variantOf(type);
         }
 
-        public List<Type> sumVariants(SumType type) {
+        public List<SumVariant> sumVariants(SumType type) {
             return this.typesInfo.sumVariants(type);
         }
     }
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rust/RustGenerator.java b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rust/RustGenerator.java
index d9df4eb..ec10107 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rust/RustGenerator.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rust/RustGenerator.java
@@ -1,6 +1,5 @@
 package org.zwobble.hobgoblin.compiler.output.generators.rust;
 
-import org.zwobble.hobgoblin.compiler.builtins.NativeTypes;
 import org.zwobble.hobgoblin.compiler.output.lang.rust.RustWriter;
 import org.zwobble.hobgoblin.compiler.output.lang.rust.ast.*;
 import org.zwobble.hobgoblin.compiler.types.*;
@@ -117,16 +116,7 @@ public class RustGenerator {
         return generateTypeName(Casing.lowerCamelCaseToUpperCamelCase(enumVariantName));
     }
 
-    public RustIdentifier generateVariantName(Type type) {
-        if (type instanceof StructType structType) {
-            return generateTypeName(structType.name());
-        } else if (
-            type instanceof ConstructedNativeType constructedNativeType &&
-            constructedNativeType.constructor().equals(NativeTypes.BOX)
-        ) {
-            return generateVariantName(constructedNativeType.args().getFirst());
-        } else {
-            throw new UnsupportedOperationException("TODO");
-        }
+    public RustIdentifier generateVariantName(SumVariant variant) {
+        return generateTypeName(variant.valueType().name());
     }
 }
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 83ad2fe..20b21de 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
@@ -59,7 +59,7 @@ public class RustTransient0Generator implements Generator {
         generateBuiltins();
 
         for (var namespace : namespaces) {
-            var rustModule = generateNamespace(namespace);
+            var rustModule = generateNamespace(namespace, typesInfo);
 
             this.rustGenerator.write(rustModule);
         }
@@ -282,14 +282,17 @@ public class RustTransient0Generator implements Generator {
         );
     }
 
-    private RustModule generateNamespace(TypedNamespaceNode namespace) {
+    private RustModule generateNamespace(
+        TypedNamespaceNode namespace,
+        TypesInfo typesInfo
+    ) {
         var namespaceName = namespace.namespaceName();
         var moduleName = generateTransient0ModuleName(namespaceName);
 
         return new RustModule(
             moduleName,
             namespace.body().stream()
-                .flatMap(statement -> this.generateNamespaceStatement(statement))
+                .flatMap(statement -> this.generateNamespaceStatement(statement, typesInfo))
                 .toList()
         );
     }
@@ -301,7 +304,8 @@ public class RustTransient0Generator implements Generator {
     }
 
     private Stream<RustItem> generateNamespaceStatement(
-        TypedNamespaceStatementNode statement
+        TypedNamespaceStatementNode statement,
+        TypesInfo typesInfo
     ) {
         return switch (statement) {
             case TypedEnumDefinitionNode enumDefinition -> {
@@ -324,8 +328,8 @@ public class RustTransient0Generator implements Generator {
 
             case TypedSumDefinitionNode sumDefinition -> {
                 yield Stream.of(
-                    generateEncodeSumFunction(sumDefinition),
-                    generateDecodeSumFunction(sumDefinition)
+                    generateEncodeSumFunction(sumDefinition, typesInfo),
+                    generateDecodeSumFunction(sumDefinition, typesInfo)
                 );
             }
         };
@@ -439,18 +443,19 @@ public class RustTransient0Generator implements Generator {
         );
     }
 
-    private RustItem generateEncodeSumFunction(TypedSumDefinitionNode sumDefinition) {
+    private RustItem generateEncodeSumFunction(
+        TypedSumDefinitionNode sumDefinition,
+        TypesInfo typesInfo
+    ) {
         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();
+                    typesInfo.sumVariants(sumDefinition.type()).stream()
+                        .map(variant -> {
                             var variantPath = this.rustGenerator.generateRustTypeExpression(sumDefinition.type())
-                                .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variantType)));
+                                .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variant)));
 
                             return new RustMatchArm(
                                 new RustTupleStructPattern(variantPath, List.of(new RustIdentifierPattern(VALUE_NAME))),
@@ -459,11 +464,11 @@ public class RustTransient0Generator implements Generator {
                                         generateEncode(
                                             new RustPrefixExpression(
                                                 RustPrefixOperator.BORROW,
-                                                new RustIntegerLiteral(variantIndex, Optional.empty())
+                                                new RustIntegerLiteral(variant.tag(), Optional.empty())
                                             ),
                                             NativeTypes.INT_32
                                         ),
-                                        generateEncode(RustPath.of(VALUE_NAME), variantType)
+                                        generateEncode(RustPath.of(VALUE_NAME), variant.containerType())
                                     ),
                                     Optional.empty()
                                 )
@@ -475,18 +480,19 @@ public class RustTransient0Generator implements Generator {
         );
     }
 
-    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();
+    private RustItem generateDecodeSumFunction(
+        TypedSumDefinitionNode sumDefinition,
+        TypesInfo typesInfo
+    ) {
+        var decodeMatchArms = typesInfo.sumVariants(sumDefinition.type()).stream()
+            .map(variant -> {
                 var variantPath = this.rustGenerator.generateRustTypeExpression(sumDefinition.type())
-                    .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variantType)));
+                    .addSegment(RustPathSegment.of(this.rustGenerator.generateVariantName(variant)));
 
-                var valueExpression = generateDecode(variantType);
+                var valueExpression = generateDecode(variant.containerType());
 
                 return new RustMatchArm(
-                    new RustLiteralPattern(new RustIntegerLiteral(variantIndex, Optional.empty())),
+                    new RustLiteralPattern(new RustIntegerLiteral(variant.tag(), Optional.empty())),
                     new RustCallExpression(variantPath, List.of(valueExpression))
                 );
             })
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rusttypes/RustTypesGenerator.java b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rusttypes/RustTypesGenerator.java
index c39e9a3..4744322 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rusttypes/RustTypesGenerator.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/output/generators/rusttypes/RustTypesGenerator.java
@@ -1,15 +1,12 @@
 package org.zwobble.hobgoblin.compiler.output.generators.rusttypes;
 
 import org.zwobble.hobgoblin.compiler.ast.typed.*;
-import org.zwobble.hobgoblin.compiler.builtins.NativeTypes;
 import org.zwobble.hobgoblin.compiler.config.OutputConfig;
 import org.zwobble.hobgoblin.compiler.output.generators.Generator;
 import org.zwobble.hobgoblin.compiler.output.generators.rust.RustGenerator;
 import org.zwobble.hobgoblin.compiler.output.generators.rust.RustGeneratorConfig;
 import org.zwobble.hobgoblin.compiler.output.lang.rust.ast.*;
 import org.zwobble.hobgoblin.compiler.typechecker.TypesInfo;
-import org.zwobble.hobgoblin.compiler.types.ConstructedNativeType;
-import org.zwobble.hobgoblin.compiler.types.NamespaceName;
 import org.zwobble.hobgoblin.compiler.types.Type;
 import org.zwobble.json5.reader.Json5ObjectReader;
 
@@ -50,18 +47,17 @@ public class RustTypesGenerator implements Generator {
     @Override
     public void generate(List<TypedNamespaceNode> namespaces, TypesInfo typesInfo) throws IOException {
         for (var namespace : namespaces) {
-            var context = new Context(namespace.namespaceName());
-            var rustModule = generateNamespace(namespace, context);
+            var rustModule = generateNamespace(namespace, typesInfo);
 
             this.rustGenerator.write(rustModule);
         }
     }
 
-    private RustModule generateNamespace(TypedNamespaceNode namespace, Context context) {
+    private RustModule generateNamespace(TypedNamespaceNode namespace, TypesInfo typesInfo) {
         var rustModuleName = this.rustGenerator.namespaceNameToRustCrateModulePath(namespace.namespaceName());
 
         var rustItems = namespace.body().stream()
-            .flatMap(statement -> generateNamespaceStatement(statement, context).stream())
+            .flatMap(statement -> generateNamespaceStatement(statement, typesInfo).stream())
             .toList();
 
         return new RustModule(rustModuleName, rustItems);
@@ -69,11 +65,11 @@ public class RustTypesGenerator implements Generator {
 
     private List<RustItem> generateNamespaceStatement(
         TypedNamespaceStatementNode statement,
-        Context context
+        TypesInfo typesInfo
     ) {
         return switch (statement) {
             case TypedEnumDefinitionNode enumDefinition -> {
-                yield generateEnumDefinition(enumDefinition, context);
+                yield generateEnumDefinition(enumDefinition);
             }
 
             case TypedNativeTypeDefinitionNode nativeTypeDefinition -> {
@@ -81,18 +77,17 @@ public class RustTypesGenerator implements Generator {
             }
 
             case TypedStructDefinitionNode structDefinition -> {
-                yield generateStructDefinition(structDefinition, context);
+                yield generateStructDefinition(structDefinition);
             }
 
             case TypedSumDefinitionNode sumDefinition -> {
-                yield generateSumDefinition(sumDefinition, context);
+                yield generateSumDefinition(sumDefinition, typesInfo);
             }
         };
     }
 
     private List<RustItem> generateEnumDefinition(
-        TypedEnumDefinitionNode enumDefinition,
-        Context context
+        TypedEnumDefinitionNode enumDefinition
     ) {
         var rustAttributes = List.of(ENUM_DERIVE_ATTRIBUTE);
 
@@ -126,8 +121,7 @@ public class RustTypesGenerator implements Generator {
     );
 
     private List<RustItem> generateStructDefinition(
-        TypedStructDefinitionNode structDefinition,
-        Context context
+        TypedStructDefinitionNode structDefinition
     ) {
         var rustAttributes = List.of(STRUCT_DERIVE_ATTRIBUTE);
 
@@ -137,7 +131,7 @@ public class RustTypesGenerator implements Generator {
             fields -> fields.stream()
                 .map(field -> new RustStructField(
                     this.rustGenerator.generateFieldName(field.name()),
-                    generateRustTypeExpression(field.type(), context)
+                    generateRustTypeExpression(field.type())
                 ))
                 .toList()
         );
@@ -154,7 +148,7 @@ public class RustTypesGenerator implements Generator {
 
     private List<RustItem> generateSumDefinition(
         TypedSumDefinitionNode sumDefinition,
-        Context context
+        TypesInfo typesInfo
     ) {
         var rustAttributes = List.of(STRUCT_DERIVE_ATTRIBUTE);
 
@@ -162,12 +156,12 @@ public class RustTypesGenerator implements Generator {
 
         var rustEnumName = this.rustGenerator.generateTypeName(sumDefinition.name());
 
-        var rustVariants = sumDefinition.variants().stream()
+        var rustVariants = typesInfo.sumVariants(sumDefinition.type()).stream()
             .map(variant -> {
-                var variantType = generateRustTypeExpression(variant.type(), context);
+                var variantType = this.rustGenerator.generateRustTypeExpression(variant.containerType());
 
                 return new RustEnumVariant(
-                    this.rustGenerator.generateVariantName(variant.type().value()),
+                    this.rustGenerator.generateVariantName(variant),
                     new RustEnumVariantTuple(List.of(
                         new RustTupleField(variantType)
                     ))
@@ -183,21 +177,10 @@ public class RustTypesGenerator implements Generator {
         );
         items.add(rustEnum);
 
-        for (var variant : sumDefinition.variants()) {
-            var variantName = this.rustGenerator.generateVariantName(variant.type().value());
+        for (var variant : typesInfo.sumVariants(sumDefinition.type())) {
+            var variantName = this.rustGenerator.generateVariantName(variant);
 
-            var fromType = variant.type().value();
-            var isBox = false;
-
-            if (
-                variant.type().value() instanceof ConstructedNativeType variantConstructedNativeType &&
-                variantConstructedNativeType.constructor().equals(NativeTypes.BOX)
-            ) {
-                fromType = variantConstructedNativeType.args().getFirst();
-                isBox = true;
-            }
-
-            var fromRustType = this.rustGenerator.generateRustTypeExpression(fromType);
+            var fromRustType = this.rustGenerator.generateRustTypeExpression(variant.valueType());
 
             var innerValueName = new RustIdentifier("value");
             RustExpression innerValue = new RustPath(List.of(
@@ -207,7 +190,7 @@ public class RustTypesGenerator implements Generator {
                 )
             ));
 
-            if (isBox) {
+            if (variant.isBox()) {
                 innerValue = new RustCallExpression(
                     RustPath.global("std", "boxed", "Box", "new"),
                     List.of(innerValue)
@@ -243,17 +226,8 @@ public class RustTypesGenerator implements Generator {
     }
 
     private RustType generateRustTypeExpression(
-        TypedTypeLevelExpressionNode<Type> type,
-        Context context
+        TypedTypeLevelExpressionNode<Type> type
     ) {
         return this.rustGenerator.generateRustTypeExpression(type.value());
     }
-
-    private static class Context {
-        private final NamespaceName currentNamespaceName;
-
-        private Context(NamespaceName currentNamespaceName) {
-            this.currentNamespaceName = currentNamespaceName;
-        }
-    }
 }
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeChecker.java b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeChecker.java
index 7ac14fe..d87b7ff 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeChecker.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeChecker.java
@@ -268,7 +268,7 @@ public class TypeChecker {
         var sumType = (SumType) lookupMetaType(untyped.name(), untyped.source(), context);
 
         var typedVariants = new ArrayList<TypedSumVariantDefinitionNode>();
-        var variantTypes = new ArrayList<StructType>();
+        var variants = new ArrayList<SumVariant>();
         for (var untypedVariant : untyped.variants()) {
             var variantType = typeCheckMetaType(untypedVariant.type(), context);
             var typedVariant = new TypedSumVariantDefinitionNode(
@@ -277,28 +277,31 @@ public class TypeChecker {
             );
             typedVariants.add(typedVariant);
 
-            // TODO: handle not struct type
+            Type variantValueType;
             if (
                 variantType.value() instanceof ConstructedNativeType variantConstructedNativeType &&
                 variantConstructedNativeType.constructor().equals(NativeTypes.BOX)
             ) {
-                variantTypes.add((StructType) variantConstructedNativeType.args().getFirst());
+                variantValueType = variantConstructedNativeType.args().getFirst();
             } else {
-                variantTypes.add((StructType) variantType.value());
+                variantValueType = variantType.value();
             }
+            // TODO: handle not struct type
+            var variant = new SumVariant(variants.size(), variantType.value(), (StructType) variantValueType);
+            variants.add(variant);
         }
 
         var typeCheckedFieldDefinitions = typeCheckFieldDefinitions(untyped.fields(), context);
 
-        context.defineSumType(sumType, variantTypes, typeCheckedFieldDefinitions.fields);
+        context.defineSumType(sumType, variants, typeCheckedFieldDefinitions.fields);
 
-        for (var variantType : variantTypes) {
-            if (context.isDefined(variantType)) {
+        for (var variant : variants) {
+            if (context.isDefined(variant.valueType())) {
                 typeCheckVariantType(
                     sumType,
                     typeCheckedFieldDefinitions.fields,
-                    variantType,
-                    context.fieldsOf(variantType),
+                    variant.valueType(),
+                    context.fieldsOf(variant.valueType()),
                     context.toTypesInfo()
                 );
             }
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerNamespaceContext.java b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerNamespaceContext.java
index 5484904..804fd68 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerNamespaceContext.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerNamespaceContext.java
@@ -75,7 +75,7 @@ public class TypeCheckerNamespaceContext {
 
     public void defineSumType(
         SumType sumType,
-        List<StructType> variantTypes,
+        List<SumVariant> variantTypes,
         List<Field> fields
     ) {
         this.typesInfo.defineSumType(sumType, variantTypes, fields);
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerSubtyping.java b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerSubtyping.java
index 335fa8d..957c53b 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerSubtyping.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerSubtyping.java
@@ -14,7 +14,7 @@ class TypeCheckerSubtyping {
 
         if (supertype instanceof SumType supertypeSum) {
             return typesInfo.sumVariants(supertypeSum).stream()
-                .anyMatch(variantType -> isSubtype(variantType, subtype, typesInfo));
+                .anyMatch(variantType -> isSubtype(variantType.containerType(), subtype, typesInfo));
         }
 
         return false;
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfo.java b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfo.java
index 697be9b..97a8c74 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfo.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfo.java
@@ -12,7 +12,7 @@ public interface TypesInfo {
     Optional<List<Field>> fieldsOf(StructType structType);
 
     List<SumType> variantOf(StructType variantType);
-    List<Type> sumVariants(SumType type);
+    List<SumVariant> sumVariants(SumType type);
 
     List<EnumVariant> enumVariants(EnumType enumType);
 }
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfoInMemory.java b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfoInMemory.java
index 821238b..7da4d2c 100644
--- a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfoInMemory.java
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfoInMemory.java
@@ -1,12 +1,8 @@
 package org.zwobble.hobgoblin.compiler.typechecker;
 
 import org.zwobble.hobgoblin.compiler.types.*;
-import org.zwobble.hobgoblin.compiler.util.ManyToMany;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 
 public class TypesInfoInMemory implements TypesInfo {
     public static TypesInfoInMemory empty() {
@@ -14,25 +10,31 @@ public class TypesInfoInMemory implements TypesInfo {
             new HashMap<>(),
             new HashMap<>(),
             new HashMap<>(),
-            new ManyToMany<>()
+            new HashMap<>(),
+            new HashMap<>()
         );
     }
 
     private final Map<EnumType, List<EnumVariant>> enumVariants;
+
     private final Map<Type, Optional<List<Field>>> structFields;
+
     private final Map<Type, List<Field>> sumFields;
-    private final ManyToMany<SumType, Type> sumVariants;
+    private final Map<SumType, List<SumVariant>> sumToVariants;
+    private final Map<StructType, List<SumType>> variantToSums;
 
     public TypesInfoInMemory(
         Map<EnumType, List<EnumVariant>> enumVariants,
         Map<Type, Optional<List<Field>>> structFields,
         Map<Type, List<Field>> sumFields,
-        ManyToMany<SumType, Type> sumVariants
+        Map<SumType, List<SumVariant>> sumToVariants,
+        Map<StructType, List<SumType>> variantToSums
     ) {
         this.enumVariants = enumVariants;
         this.structFields = structFields;
         this.sumFields = sumFields;
-        this.sumVariants = sumVariants;
+        this.sumToVariants = sumToVariants;
+        this.variantToSums = variantToSums;
     }
 
     public void defineEnumType(EnumType enumType, List<EnumVariant> enumVariants) {
@@ -65,21 +67,29 @@ public class TypesInfoInMemory implements TypesInfo {
 
     public void defineSumType(
         SumType sumType,
-        List<StructType> variantTypes,
+        List<SumVariant> variants,
         List<Field> fields
     ) {
-        for (var variantType : variantTypes) {
-            this.sumVariants.add(sumType, variantType);
+        this.sumToVariants.put(sumType, variants);
+        for (var variant : variants) {
+            this.variantToSums.putIfAbsent(variant.valueType(), new ArrayList<>());
+            this.variantToSums.get(variant.valueType()).add(sumType);
         }
         this.sumFields.put(sumType, fields);
     }
 
     public List<SumType> variantOf(StructType variantType) {
-        return this.sumVariants.rightToLeft(variantType);
+        return this.variantToSums.getOrDefault(variantType, List.of());
     }
 
-    public List<Type> sumVariants(SumType type) {
-        return this.sumVariants.leftToRight(type);
+    public List<SumVariant> sumVariants(SumType type) {
+        var variants = this.sumToVariants.get(type);
+        if (variants == null) {
+            // TODO: better error
+            throw new RuntimeException("sum not defined");
+        } else {
+            return variants;
+        }
     }
 
     public List<Field> fieldsOf(SumType sumType) {
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/types/SumVariant.java b/src/main/java/org/zwobble/hobgoblin/compiler/types/SumVariant.java
new file mode 100644
index 0000000..72dbe71
--- /dev/null
+++ b/src/main/java/org/zwobble/hobgoblin/compiler/types/SumVariant.java
@@ -0,0 +1,16 @@
+package org.zwobble.hobgoblin.compiler.types;
+
+import org.zwobble.hobgoblin.compiler.builtins.NativeTypes;
+
+public record SumVariant(
+    int tag,
+    Type containerType,
+    StructType valueType
+) {
+    public boolean isBox() {
+        return (
+            containerType instanceof ConstructedNativeType containerConstructedNativeType &&
+            containerConstructedNativeType.constructor().equals(NativeTypes.BOX)
+        );
+    }
+}