Store TypeInfos instead of context for type constraints

2 files changed, 70 insertions, 70 deletions

diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubEffectTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubEffectTests.java
index 72e0fa32..16a3ace4 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubEffectTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubEffectTests.java
@@ -14,41 +14,41 @@ public class TypeCheckerIsSubEffectTests {
     @Test
     public void effectsAreSubEffectsOfThemselves() {
         var effect = Effects.userDefined(NAMESPACE_NAME, "Effect");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubEffect(Effects.IO, Effects.IO, context), equalTo(true));
-        assertThat(isSubEffect(Effects.NONE, Effects.NONE, context), equalTo(true));
-        assertThat(isSubEffect(effect, effect, context), equalTo(true));
+        assertThat(isSubEffect(Effects.IO, Effects.IO, typeInfos), equalTo(true));
+        assertThat(isSubEffect(Effects.NONE, Effects.NONE, typeInfos), equalTo(true));
+        assertThat(isSubEffect(effect, effect, typeInfos), equalTo(true));
     }
 
     @Test
     public void unrelatedEffectsAreNotSubEffects() {
         var effect1 = Effects.userDefined(NAMESPACE_NAME, "Effect1");
         var effect2 = Effects.userDefined(NAMESPACE_NAME, "Effect2");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubEffect(effect1, effect2, context), equalTo(false));
-        assertThat(isSubEffect(effect1, Effects.IO, context), equalTo(false));
-        assertThat(isSubEffect(Effects.IO, effect2, context), equalTo(false));
+        assertThat(isSubEffect(effect1, effect2, typeInfos), equalTo(false));
+        assertThat(isSubEffect(effect1, Effects.IO, typeInfos), equalTo(false));
+        assertThat(isSubEffect(Effects.IO, effect2, typeInfos), equalTo(false));
     }
 
     @Test
     public void noneEffectIsSubEffectOfAllEffects() {
         var effect = Effects.userDefined(NAMESPACE_NAME, "Effect");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubEffect(Effects.NONE, effect, context), equalTo(true));
-        assertThat(isSubEffect(Effects.NONE, Effects.IO, context), equalTo(true));
-        assertThat(isSubEffect(Effects.NONE, Effects.NONE, context), equalTo(true));
+        assertThat(isSubEffect(Effects.NONE, effect, typeInfos), equalTo(true));
+        assertThat(isSubEffect(Effects.NONE, Effects.IO, typeInfos), equalTo(true));
+        assertThat(isSubEffect(Effects.NONE, Effects.NONE, typeInfos), equalTo(true));
     }
 
     @Test
     public void noneEffectIsOnlySuperEffectOfItself() {
         var effect = Effects.userDefined(NAMESPACE_NAME, "Effect");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubEffect(effect, Effects.NONE, context), equalTo(false));
-        assertThat(isSubEffect(Effects.IO, Effects.NONE, context), equalTo(false));
-        assertThat(isSubEffect(Effects.NONE, Effects.NONE, context), equalTo(true));
+        assertThat(isSubEffect(effect, Effects.NONE, typeInfos), equalTo(false));
+        assertThat(isSubEffect(Effects.IO, Effects.NONE, typeInfos), equalTo(false));
+        assertThat(isSubEffect(Effects.NONE, Effects.NONE, typeInfos), equalTo(true));
     }
 }
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
index 9207024f..b94185e2 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
@@ -14,14 +14,14 @@ public class TypeCheckerIsSubTypeTests {
     @Test
     public void typesAreSubTypesOfThemselves() {
         var namespaceName = NamespaceName.of("Example", "Project");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(Types.INT, Types.INT, context), equalTo(true));
+        assertThat(isSubType(Types.INT, Types.INT, typeInfos), equalTo(true));
         assertThat(
             isSubType(
                 new StructType(namespaceName, "X"),
                 new StructType(namespaceName, "X"),
-                context
+                typeInfos
             ),
             equalTo(true)
         );
@@ -30,14 +30,14 @@ public class TypeCheckerIsSubTypeTests {
     @Test
     public void unrelatedTypesAreNotSubTypes() {
         var namespaceName = NamespaceName.of("Example", "Project");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(Types.INT, Types.STRING, context), equalTo(false));
+        assertThat(isSubType(Types.INT, Types.STRING, typeInfos), equalTo(false));
         assertThat(
             isSubType(
                 new StructType(namespaceName, "X"),
                 new StructType(namespaceName, "Y"),
-                context
+                typeInfos
             ),
             equalTo(false)
         );
@@ -46,14 +46,14 @@ public class TypeCheckerIsSubTypeTests {
     @Test
     public void topTypeIsSuperTypeOfAllTypes() {
         var namespaceName = NamespaceName.of("Example", "Project");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(Types.INT, Types.TOP, context), equalTo(true));
+        assertThat(isSubType(Types.INT, Types.TOP, typeInfos), equalTo(true));
         assertThat(
             isSubType(
                 new StructType(namespaceName, "X"),
                 Types.TOP,
-                context
+                typeInfos
             ),
             equalTo(true)
         );
@@ -62,14 +62,14 @@ public class TypeCheckerIsSubTypeTests {
     @Test
     public void topTypeIsSubTypeOfNoOtherTypes() {
         var namespaceName = NamespaceName.of("Example", "Project");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(Types.TOP, Types.INT, context), equalTo(false));
+        assertThat(isSubType(Types.TOP, Types.INT, typeInfos), equalTo(false));
         assertThat(
             isSubType(
                 Types.TOP,
                 new StructType(namespaceName, "X"),
-                context
+                typeInfos
             ),
             equalTo(false)
         );
@@ -78,14 +78,14 @@ public class TypeCheckerIsSubTypeTests {
     @Test
     public void bottomTypeIsSubTypeOfAllTypes() {
         var namespaceName = NamespaceName.of("Example", "Project");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(Types.BOTTOM, Types.INT, context), equalTo(true));
+        assertThat(isSubType(Types.BOTTOM, Types.INT, typeInfos), equalTo(true));
         assertThat(
             isSubType(
                 Types.BOTTOM,
                 new StructType(namespaceName, "X"),
-                context
+                typeInfos
             ),
             equalTo(true)
         );
@@ -94,14 +94,14 @@ public class TypeCheckerIsSubTypeTests {
     @Test
     public void bottomTypeIsSuperTypeOfNoOtherTypes() {
         var namespaceName = NamespaceName.of("Example", "Project");
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(Types.INT, Types.BOTTOM, context), equalTo(false));
+        assertThat(isSubType(Types.INT, Types.BOTTOM, typeInfos), equalTo(false));
         assertThat(
             isSubType(
                 new StructType(namespaceName, "X"),
                 Types.BOTTOM,
-                context
+                typeInfos
             ),
             equalTo(false)
         );
@@ -113,14 +113,14 @@ public class TypeCheckerIsSubTypeTests {
         var sumType = Types.sum(namespaceName, "Sum");
         var variantType1 = Types.struct(namespaceName, "Variant1");
         var variantType2 = Types.struct(namespaceName, "Variant2");
-        var context = TypeCheckerContext.EMPTY
+        var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
                 SumVariant.struct(variantType1),
                 SumVariant.struct(variantType2)
             )));
 
-        assertThat(isSubType(variantType1, sumType, context), equalTo(true));
-        assertThat(isSubType(variantType2, sumType, context), equalTo(true));
+        assertThat(isSubType(variantType1, sumType, typeInfos), equalTo(true));
+        assertThat(isSubType(variantType2, sumType, typeInfos), equalTo(true));
     }
 
     @Test
@@ -129,14 +129,14 @@ public class TypeCheckerIsSubTypeTests {
         var sumType = Types.sum(namespaceName, "Sum");
         var variantType1 = Types.struct(namespaceName, "Variant1");
         var variantType2 = Types.struct(namespaceName, "Variant2");
-        var context = TypeCheckerContext.EMPTY
+        var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
                 SumVariant.struct(variantType1),
                 SumVariant.struct(variantType2)
             )));
 
-        assertThat(isSubType(sumType, variantType1, context), equalTo(false));
-        assertThat(isSubType(sumType, variantType2, context), equalTo(false));
+        assertThat(isSubType(sumType, variantType1, typeInfos), equalTo(false));
+        assertThat(isSubType(sumType, variantType2, typeInfos), equalTo(false));
     }
 
     @Test
@@ -153,14 +153,14 @@ public class TypeCheckerIsSubTypeTests {
         );
         var variantType1 = Types.struct(namespaceName, "Variant1");
         var variantType2 = Types.struct(namespaceName, "Variant2");
-        var context = TypeCheckerContext.EMPTY
+        var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
                 SumVariant.struct(variantType1),
                 SumVariant.struct(variantType2)
             )));
 
-        assertThat(isSubType(variantType1, constructedSumType, context), equalTo(true));
-        assertThat(isSubType(variantType2, constructedSumType, context), equalTo(true));
+        assertThat(isSubType(variantType1, constructedSumType, typeInfos), equalTo(true));
+        assertThat(isSubType(variantType2, constructedSumType, typeInfos), equalTo(true));
     }
 
     @Test
@@ -185,18 +185,18 @@ public class TypeCheckerIsSubTypeTests {
             List.of(Types.STRING)
         );
         var variantType2 = Types.struct(namespaceName, "Variant2");
-        var context = TypeCheckerContext.EMPTY
+        var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
                 SumVariant.constructedStruct(constructedVariantType1),
                 SumVariant.struct(variantType2)
             )));
 
-        assertThat(isSubType(constructedVariantType1, constructedSumType, context), equalTo(true));
+        assertThat(isSubType(constructedVariantType1, constructedSumType, typeInfos), equalTo(true));
         assertThat(
             isSubType(
                 Types.constructedType(variantTypeConstructor1, List.of(Types.INT)),
                 constructedSumType,
-                context
+                typeInfos
             ),
             equalTo(false)
         );
@@ -216,14 +216,14 @@ public class TypeCheckerIsSubTypeTests {
         );
         var variantType1 = Types.struct(namespaceName, "Variant1");
         var variantType2 = Types.struct(namespaceName, "Variant2");
-        var context = TypeCheckerContext.EMPTY
+        var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
                 SumVariant.struct(variantType1),
                 SumVariant.struct(variantType2)
             )));
 
-        assertThat(isSubType(constructedSumType, variantType1, context), equalTo(false));
-        assertThat(isSubType(constructedSumType, variantType2, context), equalTo(false));
+        assertThat(isSubType(constructedSumType, variantType1, typeInfos), equalTo(false));
+        assertThat(isSubType(constructedSumType, variantType2, typeInfos), equalTo(false));
     }
 
     @Test
@@ -237,10 +237,10 @@ public class TypeCheckerIsSubTypeTests {
             .addPositionalParam(Types.BOOL)
             .withReturnType(Types.UNIT)
             .build();
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(functionType2, functionType1, context), equalTo(false));
-        assertThat(isSubType(functionType1, functionType2, context), equalTo(false));
+        assertThat(isSubType(functionType2, functionType1, typeInfos), equalTo(false));
+        assertThat(isSubType(functionType1, functionType2, typeInfos), equalTo(false));
     }
 
     @Test
@@ -253,10 +253,10 @@ public class TypeCheckerIsSubTypeTests {
             .addPositionalParam(Types.TOP)
             .withReturnType(Types.UNIT)
             .build();
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(functionType2, functionType1, context), equalTo(true));
-        assertThat(isSubType(functionType1, functionType2, context), equalTo(false));
+        assertThat(isSubType(functionType2, functionType1, typeInfos), equalTo(true));
+        assertThat(isSubType(functionType1, functionType2, typeInfos), equalTo(false));
     }
 
     @Test
@@ -269,10 +269,10 @@ public class TypeCheckerIsSubTypeTests {
             .addNamedParam("y", Types.STRING)
             .withReturnType(Types.UNIT)
             .build();
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(functionType2, functionType1, context), equalTo(false));
-        assertThat(isSubType(functionType1, functionType2, context), equalTo(false));
+        assertThat(isSubType(functionType2, functionType1, typeInfos), equalTo(false));
+        assertThat(isSubType(functionType1, functionType2, typeInfos), equalTo(false));
     }
 
     @Test
@@ -285,10 +285,10 @@ public class TypeCheckerIsSubTypeTests {
             .addNamedParam("x", Types.TOP)
             .withReturnType(Types.UNIT)
             .build();
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(functionType2, functionType1, context), equalTo(true));
-        assertThat(isSubType(functionType1, functionType2, context), equalTo(false));
+        assertThat(isSubType(functionType2, functionType1, typeInfos), equalTo(true));
+        assertThat(isSubType(functionType1, functionType2, typeInfos), equalTo(false));
     }
 
     @Test
@@ -301,10 +301,10 @@ public class TypeCheckerIsSubTypeTests {
             .withEffect(Effects.NONE)
             .withReturnType(Types.UNIT)
             .build();
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(functionType2, functionType1, context), equalTo(true));
-        assertThat(isSubType(functionType1, functionType2, context), equalTo(false));
+        assertThat(isSubType(functionType2, functionType1, typeInfos), equalTo(true));
+        assertThat(isSubType(functionType1, functionType2, typeInfos), equalTo(false));
     }
 
     @Test
@@ -315,10 +315,10 @@ public class TypeCheckerIsSubTypeTests {
         var functionType2 = FunctionType.builder()
             .withReturnType(Types.STRING)
             .build();
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(functionType2, functionType1, context), equalTo(true));
-        assertThat(isSubType(functionType1, functionType2, context), equalTo(false));
+        assertThat(isSubType(functionType2, functionType1, typeInfos), equalTo(true));
+        assertThat(isSubType(functionType1, functionType2, typeInfos), equalTo(false));
     }
 
     @Test
@@ -332,9 +332,9 @@ public class TypeCheckerIsSubTypeTests {
         var functionType2 = FunctionType.builder()
             .withReturnType(Types.UNIT)
             .build();
-        var context = TypeCheckerContext.EMPTY;
+        var typeInfos = TypeInfos.EMPTY;
 
-        assertThat(isSubType(functionType2, functionType1, context), equalTo(false));
-        assertThat(isSubType(functionType1, functionType2, context), equalTo(false));
+        assertThat(isSubType(functionType2, functionType1, typeInfos), equalTo(false));
+        assertThat(isSubType(functionType1, functionType2, typeInfos), equalTo(false));
     }
 }