Simplify narrowing of type-level expression nodes

2 files changed, 35 insertions, 49 deletions

diff --git a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
index 22519ef8..08600f43 100644
--- a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
+++ b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
@@ -1712,6 +1712,24 @@ public class TypeChecker {
         UntypedTypeLevelExpressionNode untyped,
         TypeCheckerContext context
     ) {
+        var typedNode = typeCheckTypeLevelExpression(untyped, context);
+
+        // TODO: tidy this up
+        if (valueType.isInstance(typedNode.value())) {
+            return (TypedTypeLevelExpressionNode<T>) typedNode;
+        } else {
+            throw new UnexpectedTypeError(
+                valueType,
+                Types.typeLevelValueType(typedNode.value()),
+                untyped.source()
+            );
+        }
+    }
+
+    static TypedTypeLevelExpressionNode<?> typeCheckTypeLevelExpression(
+        UntypedTypeLevelExpressionNode untyped,
+        TypeCheckerContext context
+    ) {
         return switch (untyped) {
             case UntypedConstructedTypeNode constructedTypeNode -> {
                 // TODO: check number of args
@@ -1721,51 +1739,20 @@ public class TypeChecker {
                     .toList();
                 var constructedType = Types.constructedType(constructor, args);
 
-                // TODO: tidy this (and other similar checks in this function) up
-                if (valueType.isInstance(constructedType)) {
-                    yield (TypedTypeLevelExpressionNode<T>) new TypedConstructedTypeNode(
-                        constructedType,
-                        constructedTypeNode.source()
-                    );
-                } else {
-                    throw new UnexpectedTypeError(
-                        valueType,
-                        Types.metaType(constructedType),
-                        untyped.source()
-                    );
-                }
-            }
-
-            case UntypedFunctionTypeNode functionType -> {
-                var typedFunctionTypeNode = typeCheckFunctionType(functionType, context);
-
-                if (valueType.isInstance(typedFunctionTypeNode.value())) {
-                    yield (TypedTypeLevelExpressionNode<T>) typedFunctionTypeNode;
-                } else {
-                    throw new UnexpectedTypeError(
-                        valueType,
-                        Types.metaType(typedFunctionTypeNode.value()),
-                        untyped.source()
-                    );
-                }
+                yield new TypedConstructedTypeNode(
+                    constructedType,
+                    constructedTypeNode.source()
+                );
             }
 
-            case UntypedTupleTypeNode tuple -> {
-                var typedTupleTypeNode = typeCheckTupleType(tuple, context);
+            case UntypedFunctionTypeNode functionType ->
+                typeCheckFunctionType(functionType, context);
 
-                if (valueType.isInstance(typedTupleTypeNode.value())) {
-                    yield (TypedTypeLevelExpressionNode<T>) typedTupleTypeNode;
-                } else {
-                    throw new UnexpectedTypeError(
-                        valueType,
-                        Types.metaType(typedTupleTypeNode.value()),
-                        untyped.source()
-                    );
-                }
-            }
+            case UntypedTupleTypeNode tuple ->
+                typeCheckTupleType(tuple, context);
 
             case UntypedTypeLevelReferenceNode reference ->
-                typeCheckTypeLevelReference(valueType, reference, context);
+                typeCheckTypeLevelReference(reference, context);
         };
     }
 
@@ -1809,25 +1796,20 @@ public class TypeChecker {
         return new TypedTupleTypeNode(tupleType, untyped.source());
     }
 
-    @SuppressWarnings("unchecked")
-    private static <T extends TypeLevelValue> TypedTypeLevelExpressionNode<T> typeCheckTypeLevelReference(
-        TypeSetTypeLevelValue<T> valueType,
+    private static TypedTypeLevelExpressionNode<TypeLevelValue> typeCheckTypeLevelReference(
         UntypedTypeLevelReferenceNode untyped,
         TypeCheckerContext context
     ) {
         var type = compileTimeLookup(untyped.name(), untyped.source(), context);
 
         if (!(type instanceof TypeLevelValueType typeLevelValueType)) {
-            throw new UnexpectedTypeError(valueType, type, untyped.source());
-        }
-
-        if (!valueType.isInstance(typeLevelValueType.value())) {
-            throw new UnexpectedTypeError(valueType, type, untyped.source());
+            // TODO: should be type-level value, not meta-type
+            throw new UnexpectedTypeError(TypeSets.META_TYPE, type, untyped.source());
         }
 
         return new TypedTypeLevelReferenceNode<>(
             untyped.name(),
-            (T) typeLevelValueType.value(),
+            typeLevelValueType.value(),
             untyped.source()
         );
     }
diff --git a/src/main/java/org/shedlang/compiler/types/Types.java b/src/main/java/org/shedlang/compiler/types/Types.java
index 2abf4df0..8c26d890 100644
--- a/src/main/java/org/shedlang/compiler/types/Types.java
+++ b/src/main/java/org/shedlang/compiler/types/Types.java
@@ -45,6 +45,10 @@ public class Types {
         return new TypeLevelValueType(typeConstructor);
     }
 
+    public static Type typeLevelValueType(TypeLevelValue value) {
+        return new TypeLevelValueType(value);
+    }
+
     public static <T extends ConstructibleType> TypeConstructor<T> typeConstructor(
         List<TypeParam> params,
         T genericType