From fa0a1df409c3cce6301fdda0d5a3ccc3cc25d625 Mon Sep 17 00:00:00 2001
From: Michael Williamson <mike@zwobble.org>
Date: Sun, 14 Jan 2024 10:33:24 +0000
Subject: Simplify narrowing of type-level expression nodes

---
 .../shedlang/compiler/typechecker/TypeChecker.java | 80 +++++++++-------------
 .../java/org/shedlang/compiler/types/Types.java    |  4 ++
 2 files changed, 35 insertions(+), 49 deletions(-)

(limited to 'src/main/java')

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
@@ -1711,6 +1711,24 @@ public class TypeChecker {
         TypeSetTypeLevelValue<T> valueType,
         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 -> {
@@ -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
-- 
cgit v1.2.3