Introduce base types for struct types and sum types respectively

12 files changed, 75 insertions, 77 deletions

diff --git a/src/test/java/org/shedlang/compiler/ast/typed/Typed.java b/src/test/java/org/shedlang/compiler/ast/typed/Typed.java
index b501007e..bfa2564b 100644
--- a/src/test/java/org/shedlang/compiler/ast/typed/Typed.java
+++ b/src/test/java/org/shedlang/compiler/ast/typed/Typed.java
@@ -225,7 +225,7 @@ public class Typed {
         return new TypedStructFieldDefinitionNode(name, type, Sources.NULL);
     }
 
-    public static TypedSumTypeDefinitionNode sumTypeDefinition(SumType sumType) {
+    public static TypedSumTypeDefinitionNode sumTypeDefinition(SimpleSumType sumType) {
         return new TypedSumTypeDefinitionNode(
             TypeOrConstructor.type(sumType),
             Sources.NULL
@@ -296,7 +296,7 @@ public class Typed {
     }
 
     public static TypedWhenCaseNode whenCase(
-        SumVariant caseType,
+        StructType caseType,
         TypedBlockNode body
     ) {
         return new TypedWhenCaseNode(caseType, body, Sources.NULL);
diff --git a/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java b/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java
index f01c82c1..2b63f11c 100644
--- a/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java
+++ b/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java
@@ -302,7 +302,7 @@ public class TypedNodeMatchers {
     }
 
     public static Matcher<TypedNamespaceStatementNode> isTypedSumTypeDefinitionNode(
-        Matcher<TypeOrConstructor<SumType>> typeOrConstructor
+        Matcher<TypeOrConstructor<SimpleSumType>> typeOrConstructor
     ) {
         return instanceOf(
             TypedSumTypeDefinitionNode.class,
@@ -421,7 +421,7 @@ public class TypedNodeMatchers {
     }
 
     public static Matcher<TypedWhenCaseNode> isTypedWhenCaseNode(
-        Matcher<SumVariant> caseType,
+        Matcher<StructType> caseType,
         Matcher<TypedBlockNode> body
     ) {
         return allOf(
diff --git a/src/test/java/org/shedlang/compiler/ast/typed/TypedStructDefinitionNodeMatcher.java b/src/test/java/org/shedlang/compiler/ast/typed/TypedStructDefinitionNodeMatcher.java
index 6bf0dcb9..aeb8d3ee 100644
--- a/src/test/java/org/shedlang/compiler/ast/typed/TypedStructDefinitionNodeMatcher.java
+++ b/src/test/java/org/shedlang/compiler/ast/typed/TypedStructDefinitionNodeMatcher.java
@@ -2,7 +2,7 @@ package org.shedlang.compiler.ast.typed;
 
 import org.pcollections.PVector;
 import org.shedlang.compiler.testing.MatcherBuilder;
-import org.shedlang.compiler.types.StructType;
+import org.shedlang.compiler.types.SimpleStructType;
 import org.shedlang.compiler.types.TypeConstructor;
 import org.shedlang.compiler.util.P;
 import org.zwobble.precisely.Matcher;
@@ -34,7 +34,7 @@ public class TypedStructDefinitionNodeMatcher extends MatcherBuilder<
         return new TypedStructDefinitionNodeMatcher(submatchers);
     }
 
-    public TypedStructDefinitionNodeMatcher withType(Matcher<? super StructType> type) {
+    public TypedStructDefinitionNodeMatcher withType(Matcher<? super SimpleStructType> type) {
         return with(has(
             "typeOrConstructor",
             x -> x.typeOrConstructor(),
diff --git a/src/test/java/org/shedlang/compiler/shid/ShidCodeGenWhenTests.java b/src/test/java/org/shedlang/compiler/shid/ShidCodeGenWhenTests.java
index e9c243f6..c13b0e13 100644
--- a/src/test/java/org/shedlang/compiler/shid/ShidCodeGenWhenTests.java
+++ b/src/test/java/org/shedlang/compiler/shid/ShidCodeGenWhenTests.java
@@ -3,7 +3,6 @@ package org.shedlang.compiler.shid;
 import org.junit.jupiter.api.Test;
 import org.shedlang.compiler.ast.typed.Typed;
 import org.shedlang.compiler.types.NamespaceName;
-import org.shedlang.compiler.types.SumVariant;
 import org.shedlang.compiler.types.Types;
 
 import java.util.List;
@@ -21,13 +20,13 @@ public class ShidCodeGenWhenTests {
             Typed.reference("x"),
             List.of(
                 Typed.whenCase(
-                    SumVariant.struct(Types.struct(NAMESPACE_NAME, "A")),
+                    Types.struct(NAMESPACE_NAME, "A"),
                     Typed.block(List.of(
                         Typed.blockReturn(Typed.stringLiteral("a"))
                     ))
                 ),
                 Typed.whenCase(
-                    SumVariant.struct(Types.struct(NAMESPACE_NAME, "B")),
+                    Types.struct(NAMESPACE_NAME, "B"),
                     Typed.block(List.of(
                         Typed.blockReturn(Typed.stringLiteral("b"))
                     ))
diff --git a/src/test/java/org/shedlang/compiler/shid/instructions/Shid.java b/src/test/java/org/shedlang/compiler/shid/instructions/Shid.java
index 11eaa62d..ee78a3e3 100644
--- a/src/test/java/org/shedlang/compiler/shid/instructions/Shid.java
+++ b/src/test/java/org/shedlang/compiler/shid/instructions/Shid.java
@@ -2,7 +2,7 @@ package org.shedlang.compiler.shid.instructions;
 
 import org.shedlang.compiler.sources.Sources;
 import org.shedlang.compiler.types.NamespaceName;
-import org.shedlang.compiler.types.StructType;
+import org.shedlang.compiler.types.SimpleStructType;
 import org.shedlang.compiler.types.UserDefinedEffect;
 
 import java.math.BigInteger;
@@ -29,7 +29,7 @@ public class Shid {
     }
 
     public static ShidInstruction defineStruct(
-        StructType type,
+        SimpleStructType type,
         List<ShidDefineStruct.Field> fields
     ) {
         return new ShidDefineStruct(
@@ -63,7 +63,7 @@ public class Shid {
         );
     }
 
-    public static ShidInstruction fieldLoad(StructType type, String fieldName) {
+    public static ShidInstruction fieldLoad(SimpleStructType type, String fieldName) {
         return new ShidFieldLoad(
             new ShidFieldLoad.Receiver.Struct(type),
             fieldName,
@@ -172,7 +172,7 @@ public class Shid {
     }
 
     public static ShidSwitch.Case switchCase(
-        StructType type,
+        SimpleStructType type,
         ShidBlock body
     ) {
         return new ShidSwitch.Case(type, body, Sources.NULL);
diff --git a/src/test/java/org/shedlang/compiler/shid/instructions/ShidMatchers.java b/src/test/java/org/shedlang/compiler/shid/instructions/ShidMatchers.java
index d1dc4130..51736459 100644
--- a/src/test/java/org/shedlang/compiler/shid/instructions/ShidMatchers.java
+++ b/src/test/java/org/shedlang/compiler/shid/instructions/ShidMatchers.java
@@ -1,7 +1,7 @@
 package org.shedlang.compiler.shid.instructions;
 
 import org.shedlang.compiler.types.NamespaceName;
-import org.shedlang.compiler.types.StructType;
+import org.shedlang.compiler.types.SimpleStructType;
 import org.shedlang.compiler.types.UserDefinedEffect;
 import org.zwobble.precisely.Matcher;
 
@@ -67,7 +67,7 @@ public class ShidMatchers {
     }
 
     public static Matcher<ShidInstruction> isShidFieldLoad(
-        StructType receiverType,
+        SimpleStructType receiverType,
         String fieldName
     ) {
         return isShidFieldLoad(
@@ -207,7 +207,7 @@ public class ShidMatchers {
     }
 
     public static Matcher<ShidSwitch.Case> isShidSwitchCase(
-        StructType caseType,
+        SimpleStructType caseType,
         Matcher<? super ShidBlock> body
     ) {
         return allOf(
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
index d86e0ed2..580be580 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
@@ -26,8 +26,8 @@ public class TypeCheckerIsSubTypeTests {
         assertThat(isSubType(Types.INT, Types.INT, typeInfos), equalTo(true));
         assertThat(
             isSubType(
-                new StructType(namespaceName, "X"),
-                new StructType(namespaceName, "X"),
+                new SimpleStructType(namespaceName, "X"),
+                new SimpleStructType(namespaceName, "X"),
                 typeInfos
             ),
             equalTo(true)
@@ -42,8 +42,8 @@ public class TypeCheckerIsSubTypeTests {
         assertThat(isSubType(Types.INT, Types.STRING, typeInfos), equalTo(false));
         assertThat(
             isSubType(
-                new StructType(namespaceName, "X"),
-                new StructType(namespaceName, "Y"),
+                new SimpleStructType(namespaceName, "X"),
+                new SimpleStructType(namespaceName, "Y"),
                 typeInfos
             ),
             equalTo(false)
@@ -60,7 +60,7 @@ public class TypeCheckerIsSubTypeTests {
         assertThat(isSubType(Types.INT, Types.TOP, typeInfos), equalTo(true));
         assertThat(
             isSubType(
-                new StructType(namespaceName, "X"),
+                new SimpleStructType(namespaceName, "X"),
                 Types.TOP,
                 typeInfos
             ),
@@ -77,7 +77,7 @@ public class TypeCheckerIsSubTypeTests {
         assertThat(
             isSubType(
                 Types.TOP,
-                new StructType(namespaceName, "X"),
+                new SimpleStructType(namespaceName, "X"),
                 typeInfos
             ),
             equalTo(false)
@@ -95,7 +95,7 @@ public class TypeCheckerIsSubTypeTests {
         assertThat(
             isSubType(
                 Types.BOTTOM,
-                new StructType(namespaceName, "X"),
+                new SimpleStructType(namespaceName, "X"),
                 typeInfos
             ),
             equalTo(true)
@@ -110,7 +110,7 @@ public class TypeCheckerIsSubTypeTests {
         assertThat(isSubType(Types.INT, Types.BOTTOM, typeInfos), equalTo(false));
         assertThat(
             isSubType(
-                new StructType(namespaceName, "X"),
+                new SimpleStructType(namespaceName, "X"),
                 Types.BOTTOM,
                 typeInfos
             ),
@@ -171,8 +171,8 @@ public class TypeCheckerIsSubTypeTests {
         var variantType2 = Types.struct(namespaceName, "Variant2");
         var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(variantType1),
-                SumVariant.struct(variantType2)
+                variantType1,
+                variantType2
             )));
 
         assertThat(isSubType(variantType1, sumType, typeInfos), equalTo(true));
@@ -187,8 +187,8 @@ public class TypeCheckerIsSubTypeTests {
         var variantType2 = Types.struct(namespaceName, "Variant2");
         var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(variantType1),
-                SumVariant.struct(variantType2)
+                variantType1,
+                variantType2
             )));
 
         assertThat(isSubType(sumType, variantType1, typeInfos), equalTo(false));
@@ -211,8 +211,8 @@ public class TypeCheckerIsSubTypeTests {
         var variantType2 = Types.struct(namespaceName, "Variant2");
         var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(variantType1),
-                SumVariant.struct(variantType2)
+                variantType1,
+                variantType2
             )));
 
         assertThat(isSubType(variantType1, constructedSumType, typeInfos), equalTo(true));
@@ -243,8 +243,8 @@ public class TypeCheckerIsSubTypeTests {
         var variantType2 = Types.struct(namespaceName, "Variant2");
         var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
-                SumVariant.constructedStruct(constructedVariantType1),
-                SumVariant.struct(variantType2)
+                constructedVariantType1,
+                variantType2
             )));
 
         assertThat(isSubType(constructedVariantType1, constructedSumType, typeInfos), equalTo(true));
@@ -274,8 +274,8 @@ public class TypeCheckerIsSubTypeTests {
         var variantType2 = Types.struct(namespaceName, "Variant2");
         var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(variantType1),
-                SumVariant.struct(variantType2)
+                variantType1,
+                variantType2
             )));
 
         assertThat(isSubType(constructedSumType, variantType1, typeInfos), equalTo(false));
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerSumTypeDefinitionTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerSumTypeDefinitionTests.java
index a605e029..0585625a 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerSumTypeDefinitionTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerSumTypeDefinitionTests.java
@@ -6,7 +6,6 @@ import org.shedlang.compiler.ast.untyped.UntypedSumTypeDefinitionNode;
 import org.shedlang.compiler.typechecker.errors.CannotDefineSumTypeOutsideOfNamespaceError;
 import org.shedlang.compiler.typechecker.errors.VariantTypeIsNotStructError;
 import org.shedlang.compiler.types.NamespaceName;
-import org.shedlang.compiler.types.SumVariant;
 import org.shedlang.compiler.types.TypeParam;
 import org.shedlang.compiler.types.Types;
 import org.shedlang.compiler.util.P;
@@ -157,8 +156,8 @@ public class TypeCheckerSumTypeDefinitionTests {
         assertThat(
             sumTypeInfo,
             has("variants", x -> x.variants(), isSequence(
-                equalTo(SumVariant.struct(variantType1)),
-                equalTo(SumVariant.struct(variantType2))
+                equalTo(variantType1),
+                equalTo(variantType2)
             ))
         );
     }
@@ -227,20 +226,20 @@ public class TypeCheckerSumTypeDefinitionTests {
         assertThat(
             sumTypeInfo,
             has("variants", x -> x.variants(), isSequence(
-                equalTo(SumVariant.constructedStruct(Types.constructedStructType(
+                equalTo(Types.constructedStructType(
                     variantTypeConstructor1,
                     List.of(TypeParam.forSumType(
                         Types.sum(NAMESPACE_NAME, "ExampleSumType"),
                         "T1"
                     ))
-                ))),
-                equalTo(SumVariant.constructedStruct(Types.constructedStructType(
+                )),
+                equalTo(Types.constructedStructType(
                     variantTypeConstructor2,
                     List.of(TypeParam.forSumType(
                         Types.sum(NAMESPACE_NAME, "ExampleSumType"),
                         "T2"
                     ))
-                )))
+                ))
             ))
         );
     }
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java
index 0db2546f..107bc9c4 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java
@@ -20,9 +20,9 @@ import static org.zwobble.precisely.Matchers.*;
 
 public class TypeCheckerWhenTests {
     private static final NamespaceName NAMESPACE_NAME = NamespaceName.of("Example", "Project");
-    private static final SumType SUM_TYPE = Types.sum(NAMESPACE_NAME, "SumType");
-    private static final StructType VARIANT_TYPE_1 = Types.struct(NAMESPACE_NAME, "Variant1");
-    private static final StructType VARIANT_TYPE_2 = Types.struct(NAMESPACE_NAME, "Variant2");
+    private static final SimpleSumType SUM_TYPE = Types.sum(NAMESPACE_NAME, "SumType");
+    private static final SimpleStructType VARIANT_TYPE_1 = Types.struct(NAMESPACE_NAME, "Variant1");
+    private static final SimpleStructType VARIANT_TYPE_2 = Types.struct(NAMESPACE_NAME, "Variant2");
 
     @Test
     public void whenExpressionIsNotInstanceOfSumTypeThenErrorIsThrown() {
@@ -58,8 +58,8 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(VARIANT_TYPE_1),
-                SumVariant.struct(VARIANT_TYPE_2)
+                VARIANT_TYPE_1,
+                VARIANT_TYPE_2
             )))
             .enterGlobal(P.map(
                 Map.entry("x", SUM_TYPE),
@@ -72,7 +72,7 @@ public class TypeCheckerWhenTests {
             () -> typeCheckExpression(untyped, context)
         );
 
-        assertThat(error.unhandledVariant(), equalTo(SumVariant.struct(VARIANT_TYPE_2)));
+        assertThat(error.unhandledVariant(), equalTo(VARIANT_TYPE_2));
     }
 
     @Test
@@ -97,7 +97,7 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(VARIANT_TYPE_1)
+                VARIANT_TYPE_1
             )))
             .enterGlobal(P.map(
                 Map.entry("x", SUM_TYPE),
@@ -134,7 +134,7 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(VARIANT_TYPE_1)
+                VARIANT_TYPE_1
             )))
             .enterGlobal(P.map(
                 Map.entry("x", SUM_TYPE),
@@ -170,8 +170,8 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(VARIANT_TYPE_1),
-                SumVariant.struct(VARIANT_TYPE_2)
+                VARIANT_TYPE_1,
+                VARIANT_TYPE_2
             )))
             .enterGlobal(P.map(
                 Map.entry("x", SUM_TYPE),
@@ -185,13 +185,13 @@ public class TypeCheckerWhenTests {
             isTypedReferenceNode("x", SUM_TYPE),
             isSequence(
                 isTypedWhenCaseNode(
-                    equalTo(SumVariant.struct(VARIANT_TYPE_1)),
+                    equalTo(VARIANT_TYPE_1),
                     isTypedBlockNode(isSequence(
                         isTypedBlockReturnNode(isTypedStringLiteralNode("a"))
                     ))
                 ),
                 isTypedWhenCaseNode(
-                    equalTo(SumVariant.struct(VARIANT_TYPE_2)),
+                    equalTo(VARIANT_TYPE_2),
                     isTypedBlockNode(isSequence(
                         isTypedBlockReturnNode(isTypedStringLiteralNode("b"))
                     ))
@@ -232,8 +232,8 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.constructedStruct(constructedVariantType1),
-                SumVariant.struct(VARIANT_TYPE_2)
+                constructedVariantType1,
+                VARIANT_TYPE_2
             )))
             .enterGlobal(P.map(
                 Map.entry("String", Types.metaType(Types.STRING)),
@@ -248,13 +248,13 @@ public class TypeCheckerWhenTests {
             isTypedReferenceNode("x", SUM_TYPE),
             isSequence(
                 isTypedWhenCaseNode(
-                    equalTo(SumVariant.constructedStruct(constructedVariantType1)),
+                    equalTo(constructedVariantType1),
                     isTypedBlockNode(isSequence(
                         isTypedBlockReturnNode(isTypedStringLiteralNode("a"))
                     ))
                 ),
                 isTypedWhenCaseNode(
-                    equalTo(SumVariant.struct(VARIANT_TYPE_2)),
+                    equalTo(VARIANT_TYPE_2),
                     isTypedBlockNode(isSequence(
                         isTypedBlockReturnNode(isTypedStringLiteralNode("b"))
                     ))
@@ -295,8 +295,8 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.constructedStruct(constructedVariantType1),
-                SumVariant.struct(VARIANT_TYPE_2)
+                constructedVariantType1,
+                VARIANT_TYPE_2
             )))
             .enterGlobal(P.map(
                 Map.entry("Int", Types.metaType(Types.INT)),
@@ -359,11 +359,11 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.constructedStruct(Types.constructedStructType(
+                Types.constructedStructType(
                     variantTypeConstructor1,
                     List.of(TypeParam.forSumType(SUM_TYPE, "T"))
-                )),
-                SumVariant.struct(VARIANT_TYPE_2)
+                ),
+                VARIANT_TYPE_2
             )))
             .enterGlobal(P.map(
                 Map.entry("String", Types.metaType(Types.STRING)),
@@ -378,13 +378,13 @@ public class TypeCheckerWhenTests {
             isTypedReferenceNode("x", constructedSumType),
             isSequence(
                 isTypedWhenCaseNode(
-                    equalTo(SumVariant.constructedStruct(constructedVariantType1)),
+                    equalTo(constructedVariantType1),
                     isTypedBlockNode(isSequence(
                         isTypedBlockReturnNode(isTypedStringLiteralNode("a"))
                     ))
                 ),
                 isTypedWhenCaseNode(
-                    equalTo(SumVariant.struct(VARIANT_TYPE_2)),
+                    equalTo(VARIANT_TYPE_2),
                     isTypedBlockNode(isSequence(
                         isTypedBlockReturnNode(isTypedStringLiteralNode("b"))
                     ))
@@ -414,8 +414,8 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(VARIANT_TYPE_1),
-                SumVariant.struct(VARIANT_TYPE_2)
+                VARIANT_TYPE_1,
+                VARIANT_TYPE_2
             )))
             .enterGlobal(P.map(
                 Map.entry("x", SUM_TYPE),
@@ -449,8 +449,8 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(VARIANT_TYPE_1),
-                SumVariant.struct(VARIANT_TYPE_2)
+                VARIANT_TYPE_1,
+                VARIANT_TYPE_2
             )))
             .enterGlobal(P.map(
                 Map.entry("x", SUM_TYPE),
@@ -490,8 +490,8 @@ public class TypeCheckerWhenTests {
         );
         var context = TypeCheckerContext.EMPTY
             .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
-                SumVariant.struct(VARIANT_TYPE_1),
-                SumVariant.struct(VARIANT_TYPE_2)
+                VARIANT_TYPE_1,
+                VARIANT_TYPE_2
             )))
             .addStructTypeInfo(
                 VARIANT_TYPE_1,
@@ -517,11 +517,11 @@ public class TypeCheckerWhenTests {
             isTypedReferenceNode("x", SUM_TYPE),
             isSequence(
                 isTypedWhenCaseNode(
-                    equalTo(SumVariant.struct(VARIANT_TYPE_1)),
+                    equalTo(VARIANT_TYPE_1),
                     has("type", x -> x.type(), equalTo(Types.STRING))
                 ),
                 isTypedWhenCaseNode(
-                    equalTo(SumVariant.struct(VARIANT_TYPE_2)),
+                    equalTo(VARIANT_TYPE_2),
                     has("type", x -> x.type(), equalTo(Types.INT))
                 )
             )
diff --git a/src/test/java/org/shedlang/compiler/types/ConstructedTypeTests.java b/src/test/java/org/shedlang/compiler/types/ConstructedTypeTests.java
index 1c3d90db..524da258 100644
--- a/src/test/java/org/shedlang/compiler/types/ConstructedTypeTests.java
+++ b/src/test/java/org/shedlang/compiler/types/ConstructedTypeTests.java
@@ -10,7 +10,7 @@ import static org.zwobble.precisely.Matchers.equalTo;
 public class ConstructedTypeTests {
     @Test
     public void descriptionIsNameOfTypePlusArgsInSquareBrackets() {
-        var structType = new StructType(
+        var structType = new SimpleStructType(
             NamespaceName.of("Example", "Project"),
             "Map"
         );
diff --git a/src/test/java/org/shedlang/compiler/types/TypeMatchers.java b/src/test/java/org/shedlang/compiler/types/TypeMatchers.java
index c9a37a7d..1112ff64 100644
--- a/src/test/java/org/shedlang/compiler/types/TypeMatchers.java
+++ b/src/test/java/org/shedlang/compiler/types/TypeMatchers.java
@@ -12,7 +12,7 @@ public class TypeMatchers {
 
     public static Matcher<TypeLevelValue> isStructType(NamespaceName namespaceName, String name) {
         return instanceOf(
-            StructType.class,
+            SimpleStructType.class,
             has("namespaceName", x -> x.namespaceName(), equalTo(namespaceName)),
             has("name", x -> x.name(), equalTo(name))
         );
@@ -20,7 +20,7 @@ public class TypeMatchers {
 
     public static Matcher<TypeLevelValue> isSumType(NamespaceName namespaceName, String name) {
         return instanceOf(
-            SumType.class,
+            SimpleSumType.class,
             has("namespaceName", x -> x.namespaceName(), equalTo(namespaceName)),
             has("name", x -> x.name(), equalTo(name))
         );
diff --git a/src/test/java/org/shedlang/compiler/types/TypeSubstitutionTests.java b/src/test/java/org/shedlang/compiler/types/TypeSubstitutionTests.java
index dd115564..064012f9 100644
--- a/src/test/java/org/shedlang/compiler/types/TypeSubstitutionTests.java
+++ b/src/test/java/org/shedlang/compiler/types/TypeSubstitutionTests.java
@@ -10,8 +10,8 @@ import static org.zwobble.precisely.Matchers.equalTo;
 
 public class TypeSubstitutionTests {
     private static final NamespaceName NAMESPACE_NAME = NamespaceName.of("Example", "Project");
-    private static final StructType STRUCT_TYPE = Types.struct(NAMESPACE_NAME, "Struct");
-    private static final StructType STRUCT_TYPE_2 = Types.struct(NAMESPACE_NAME, "Struct2");
+    private static final SimpleStructType STRUCT_TYPE = Types.struct(NAMESPACE_NAME, "Struct");
+    private static final SimpleStructType STRUCT_TYPE_2 = Types.struct(NAMESPACE_NAME, "Struct2");
 
     @Test
     public void substitutingBoolDoesNothing() {