Support constructed sum types as when expressions

1 files changed, 74 insertions, 0 deletions

diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java
index 9ed7b247..1dc0f545 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java
@@ -320,6 +320,80 @@ public class TypeCheckerWhenTests {
     }
 
     @Test
+    public void expressionCanBeConstructedSumType() {
+        var sumTypeConstructor = Types.typeConstructor(
+            List.of(TypeParam.forSumType(SUM_TYPE, "T")),
+            SUM_TYPE
+        );
+        var constructedSumType = Types.constructedType(
+            sumTypeConstructor,
+            List.of(Types.STRING)
+        );
+        var variantTypeConstructor1 = Types.typeConstructor(
+            List.of(TypeParam.forStructType(VARIANT_TYPE_1, "T")),
+            VARIANT_TYPE_1
+        );
+        var constructedVariantType1 = Types.constructedType(
+            variantTypeConstructor1,
+            List.of(Types.STRING)
+        );
+        var untyped = Untyped.when(
+            Untyped.reference("x"),
+            List.of(
+                Untyped.whenCase(
+                    Untyped.constructedType(
+                        Untyped.typeLevelReference(VARIANT_TYPE_1.name()),
+                        List.of(Untyped.typeLevelReference("String"))
+                    ),
+                    Untyped.block(List.of(
+                        Untyped.blockReturn(Untyped.stringLiteral("a"))
+                    ))
+                ),
+                Untyped.whenCase(
+                    Untyped.typeLevelReference(VARIANT_TYPE_2.name()),
+                    Untyped.block(List.of(
+                        Untyped.blockReturn(Untyped.stringLiteral("b"))
+                    ))
+                )
+            )
+        );
+        var context = TypeCheckerContext.EMPTY
+            .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet(
+                SumVariant.constructedStruct(Types.constructedType(
+                    variantTypeConstructor1,
+                    List.of(TypeParam.forSumType(SUM_TYPE, "T"))
+                )),
+                SumVariant.struct(VARIANT_TYPE_2)
+            )))
+            .enterGlobal(P.map(
+                Map.entry("String", Types.metaType(Types.STRING)),
+                Map.entry("x", constructedSumType),
+                Map.entry(VARIANT_TYPE_1.name(), Types.typeConstructorType(variantTypeConstructor1)),
+                Map.entry(VARIANT_TYPE_2.name(), Types.metaType(VARIANT_TYPE_2))
+            ));
+
+        var result = typeCheckExpression(untyped, context);
+
+        assertThat(result.value(), isTypedWhenNode(
+            isTypedReferenceNode("x", constructedSumType),
+            isSequence(
+                isTypedWhenCaseNode(
+                    equalTo(SumVariant.constructedStruct(constructedVariantType1)),
+                    isTypedBlockNode(isSequence(
+                        isTypedBlockReturnNode(isTypedStringLiteralNode("a"))
+                    ))
+                ),
+                isTypedWhenCaseNode(
+                    equalTo(SumVariant.struct(VARIANT_TYPE_2)),
+                    isTypedBlockNode(isSequence(
+                        isTypedBlockReturnNode(isTypedStringLiteralNode("b"))
+                    ))
+                )
+            )
+        ));
+    }
+
+    @Test
     public void whenCaseBodiesHaveSameTypeThenExpressionTypeIsThatType() {
         var untyped = Untyped.when(
             Untyped.reference("x"),