Introduce type arg as distinct from type param

1 files changed, 46 insertions, 31 deletions

diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
index 8f6af248..7821c68e 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java
@@ -121,45 +121,49 @@ public class TypeCheckerIsSubTypeTests {
     // == Type params ==
 
     @Test
-    public void whenSupertypeIsBoundTypeParamThenLowerBoundIsAddedToType() {
+    public void whenSupertypeIsTypeArgThenLowerBoundIsAddedToTypeArg() {
         var typeParam = TypeParam.forStructType(
             Types.struct(NamespaceName.of("Example"), "Struct"),
             "T"
         );
+        var typeArg = new TypeArg(typeParam);
 
         var constraints = TypeCheckerSubTyping.addSubtypeConstraint(
             Types.INT,
-            typeParam,
+            typeArg,
             Sources.NULL,
-            TypeCheckerSubTyping.constraints(List.of(typeParam), TypeInfos.EMPTY)
+            TypeCheckerSubTyping.constraints(List.of(typeArg), TypeInfos.EMPTY)
         );
 
-        assertThat(constraints.typeBounds().get(typeParam), allOf(
+        assertThat(constraints.typeBounds().get(typeArg), allOf(
             has("lower", x -> x.lower(), isSequence(equalTo(Types.INT))),
             has("upper", x -> x.upper(), isSequence())
         ));
     }
 
     @Test
-    public void whenSubtypeIsBoundTypeParamThenUpperBoundIsAddedToType() {
+    public void whenSubtypeIsTypeArgThenUpperBoundIsAddedToTypeArg() {
         var typeParam = TypeParam.forStructType(
             Types.struct(NamespaceName.of("Example"), "Struct"),
             "T"
         );
+        var typeArg = new TypeArg(typeParam);
 
         var constraints = TypeCheckerSubTyping.addSubtypeConstraint(
-            typeParam,
+            typeArg,
             Types.INT,
             Sources.NULL,
-            TypeCheckerSubTyping.constraints(List.of(typeParam), TypeInfos.EMPTY)
+            TypeCheckerSubTyping.constraints(List.of(typeArg), TypeInfos.EMPTY)
         );
 
-        assertThat(constraints.typeBounds().get(typeParam), allOf(
+        assertThat(constraints.typeBounds().get(typeArg), allOf(
             has("lower", x -> x.lower(), isSequence()),
             has("upper", x -> x.upper(), isSequence(equalTo(Types.INT)))
         ));
     }
 
+    // TODO: handling of unexpected type args
+
     @Test
     public void whenSupertypeIsFreeTypeParamThenOtherTypesAreNotSubtype() {
         var typeParam = TypeParam.forStructType(
@@ -356,17 +360,19 @@ public class TypeCheckerIsSubTypeTests {
             List.of(TypeParam.forStructType(variantType2, "T")),
             variantType2
         );
+        var sumTypeParam = TypeParam.forSumType(sumType, "T");
+        var sumTypeArg = new TypeArg(sumTypeParam);
         var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
                 variantType1,
                 Types.constructedStructType(
                     variantTypeConstructor2,
-                    List.of(TypeParam.forSumType(sumType, "T"))
+                    List.of(sumTypeArg)
                 )
             )));
 
         var constraints = TypeCheckerSubTyping.constraints(
-            List.of(TypeParam.forSumType(sumType, "T")),
+            List.of(sumTypeArg),
             typeInfos
         );
         constraints = TypeCheckerSubTyping.addSubtypeConstraint(
@@ -379,7 +385,7 @@ public class TypeCheckerIsSubTypeTests {
             constraints
         );
 
-        assertThat(constraints.typeBounds().get(TypeParam.forSumType(sumType, "T")), allOf(
+        assertThat(constraints.typeBounds().get(sumTypeArg), allOf(
             has("lower", x -> x.lower(), isSequence(equalTo(Types.STRING))),
             has("upper", x -> x.upper(), isSequence(equalTo(Types.STRING)))
         ));
@@ -394,16 +400,18 @@ public class TypeCheckerIsSubTypeTests {
             List.of(TypeParam.forStructType(variantType, "T")),
             variantType
         );
+        var sumTypeParam = TypeParam.forSumType(sumType, "T");
+        var sumTypeArg = new TypeArg(sumTypeParam);
         var typeInfos = TypeInfos.EMPTY
             .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet(
                 Types.constructedStructType(
                     variantTypeConstructor,
-                    List.of(TypeParam.forSumType(sumType, "T"))
+                    List.of(sumTypeArg)
                 )
             )));
 
         var constraints = TypeCheckerSubTyping.constraints(
-            List.of(TypeParam.forSumType(sumType, "T")),
+            List.of(sumTypeArg),
             typeInfos
         );
         constraints = TypeCheckerSubTyping.addSubtypeConstraint(
@@ -416,7 +424,7 @@ public class TypeCheckerIsSubTypeTests {
             constraints
         );
 
-        assertThat(constraints.typeBounds().get(TypeParam.forSumType(sumType, "T")), allOf(
+        assertThat(constraints.typeBounds().get(sumTypeArg), allOf(
             has("lower", x -> x.lower(), isSequence(equalTo(Types.STRING))),
             has("upper", x -> x.upper(), isSequence(equalTo(Types.STRING)))
         ));
@@ -426,9 +434,11 @@ public class TypeCheckerIsSubTypeTests {
     // == Constructed types ==
 
     @Test
-    public void constructedTypeCanBeSubtypeOfConstructedTypeWithBoundTypeParam() {
+    public void constructedTypeCanBeSubtypeOfConstructedTypeWithTypeArg() {
         var namespaceName = NamespaceName.of("Example", "Project");
         var sumType = Types.sum(namespaceName, "Sum");
+        var sumTypeParam = TypeParam.forSumType(sumType, "T");
+        var sumTypeArg = new TypeArg(sumTypeParam);
         var structType = Types.struct(namespaceName, "Struct");
         var typeConstructor = Types.typeConstructor(
             List.of(TypeParam.forStructType(structType, "T")),
@@ -437,7 +447,7 @@ public class TypeCheckerIsSubTypeTests {
         var typeInfos = TypeInfos.EMPTY;
 
         var constraints = TypeCheckerSubTyping.constraints(
-            List.of(TypeParam.forSumType(sumType, "T")),
+            List.of(sumTypeArg),
             typeInfos
         );
         constraints = TypeCheckerSubTyping.addSubtypeConstraint(
@@ -447,13 +457,13 @@ public class TypeCheckerIsSubTypeTests {
             ),
             Types.constructedStructType(
                 typeConstructor,
-                List.of(TypeParam.forSumType(sumType, "T"))
+                List.of(sumTypeArg)
             ),
             Sources.NULL,
             constraints
         );
 
-        assertThat(constraints.typeBounds().get(TypeParam.forSumType(sumType, "T")), allOf(
+        assertThat(constraints.typeBounds().get(sumTypeArg), allOf(
             has("lower", x -> x.lower(), isSequence(equalTo(Types.STRING))),
             has("upper", x -> x.upper(), isSequence(equalTo(Types.STRING)))
         ));
@@ -581,9 +591,10 @@ public class TypeCheckerIsSubTypeTests {
             Types.struct(NamespaceName.of("Example"), "Struct"),
             "T"
         );
+        var typeArg = new TypeArg(typeParam);
 
-        var constraints = TypeCheckerSubTyping.constraints(List.of(typeParam), TypeInfos.EMPTY)
-            .addUpperBound(typeParam, Types.INT);
+        var constraints = TypeCheckerSubTyping.constraints(List.of(typeArg), TypeInfos.EMPTY)
+            .addUpperBound(typeArg, Types.INT);
         var result = constraints.solve(Sources.NULL);
 
         assertThat(result, equalTo(TypeSubstitutionMap.of(
@@ -597,9 +608,10 @@ public class TypeCheckerIsSubTypeTests {
             Types.struct(NamespaceName.of("Example"), "Struct"),
             "T"
         );
+        var typeArg = new TypeArg(typeParam);
 
-        var constraints = TypeCheckerSubTyping.constraints(List.of(typeParam), TypeInfos.EMPTY)
-            .addLowerBound(typeParam, Types.INT);
+        var constraints = TypeCheckerSubTyping.constraints(List.of(typeArg), TypeInfos.EMPTY)
+            .addLowerBound(typeArg, Types.INT);
         var result = constraints.solve(Sources.NULL);
 
         assertThat(result, equalTo(TypeSubstitutionMap.of(
@@ -613,10 +625,11 @@ public class TypeCheckerIsSubTypeTests {
             Types.struct(NamespaceName.of("Example"), "Struct"),
             "T"
         );
+        var typeArg = new TypeArg(typeParam);
 
-        var constraints = TypeCheckerSubTyping.constraints(List.of(typeParam), TypeInfos.EMPTY)
-            .addLowerBound(typeParam, Types.INT)
-            .addLowerBound(typeParam, Types.STRING);
+        var constraints = TypeCheckerSubTyping.constraints(List.of(typeArg), TypeInfos.EMPTY)
+            .addLowerBound(typeArg, Types.INT)
+            .addLowerBound(typeArg, Types.STRING);
         var result = constraints.solve(Sources.NULL);
 
         assertThat(result, equalTo(TypeSubstitutionMap.of(
@@ -630,6 +643,7 @@ public class TypeCheckerIsSubTypeTests {
             Types.struct(NamespaceName.of("Example"), "Struct"),
             "T"
         );
+        var typeArg = new TypeArg(typeParam);
         var namespaceName = NamespaceName.of("Example", "Project");
         var sumType = Types.sum(namespaceName, "Sum");
         var variantType1 = Types.struct(namespaceName, "Variant1");
@@ -640,9 +654,9 @@ public class TypeCheckerIsSubTypeTests {
                 variantType2
             )));
 
-        var constraints = TypeCheckerSubTyping.constraints(List.of(typeParam), typeInfos)
-            .addLowerBound(typeParam, variantType1)
-            .addUpperBound(typeParam, sumType);
+        var constraints = TypeCheckerSubTyping.constraints(List.of(typeArg), typeInfos)
+            .addLowerBound(typeArg, variantType1)
+            .addUpperBound(typeArg, sumType);
         var result = constraints.solve(Sources.NULL);
 
         assertThat(result, equalTo(TypeSubstitutionMap.of(
@@ -656,6 +670,7 @@ public class TypeCheckerIsSubTypeTests {
             Types.struct(NamespaceName.of("Example"), "Struct"),
             "T"
         );
+        var typeArg = new TypeArg(typeParam);
         var namespaceName = NamespaceName.of("Example", "Project");
         var sumType = Types.sum(namespaceName, "Sum");
         var variantType1 = Types.struct(namespaceName, "Variant1");
@@ -666,9 +681,9 @@ public class TypeCheckerIsSubTypeTests {
                 variantType2
             )));
 
-        var constraints = TypeCheckerSubTyping.constraints(List.of(typeParam), typeInfos)
-            .addLowerBound(typeParam, sumType)
-            .addUpperBound(typeParam, variantType1);
+        var constraints = TypeCheckerSubTyping.constraints(List.of(typeArg), typeInfos)
+            .addLowerBound(typeArg, sumType)
+            .addUpperBound(typeArg, variantType1);
         var error = assertThrows(
             // TODO: more specific error
             IllegalStateException.class,