Type-check val as namespace statement

6 files changed, 48 insertions, 21 deletions

diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionDefinitionNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionDefinitionNode.java
index 42783224..9867c726 100644
--- a/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionDefinitionNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionDefinitionNode.java
@@ -15,7 +15,7 @@ public record TypedFunctionDefinitionNode(
     Optional<TypedTypeLevelExpressionNode<Effect>> effect,
     TypedTypeLevelExpressionNode<Type> returnType,
     FreeVariables freeVariables,
-    List<TypedFunctionStatementNode> body,
+    List<? extends TypedFunctionStatementNode> body,
     FunctionType type,
     Source source
 ) implements TypedNamespaceStatementNode {
@@ -25,7 +25,7 @@ public record TypedFunctionDefinitionNode(
         Optional<TypedTypeLevelExpressionNode<Effect>> effect,
         TypedTypeLevelExpressionNode<Type> returnType,
         FreeVariables freeVariables,
-        List<TypedFunctionStatementNode> body,
+        List<? extends TypedFunctionStatementNode> body,
         Source source
     ) {
         this(
diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedNamespaceStatementNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedNamespaceStatementNode.java
index 6b9e63d9..112d14bc 100644
--- a/src/main/java/org/shedlang/compiler/ast/typed/TypedNamespaceStatementNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/typed/TypedNamespaceStatementNode.java
@@ -1,4 +1,4 @@
 package org.shedlang.compiler.ast.typed;
 
-public sealed interface TypedNamespaceStatementNode extends TypedNode permits TypedFunctionDefinitionNode {
+public sealed interface TypedNamespaceStatementNode extends TypedNode permits TypedFunctionDefinitionNode, TypedValNode {
 }
diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedValNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedValNode.java
index e543312f..f2e59ffe 100644
--- a/src/main/java/org/shedlang/compiler/ast/typed/TypedValNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/typed/TypedValNode.java
@@ -6,5 +6,5 @@ public record TypedValNode(
     TypedTargetNode target,
     TypedExpressionNode expression,
     Source source
-) implements TypedFunctionStatementNode {
+) implements TypedFunctionStatementNode, TypedNamespaceStatementNode {
 }
diff --git a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceNode.java b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceNode.java
index 8b3e175b..f661e2ea 100644
--- a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceNode.java
@@ -1,7 +1,10 @@
 package org.shedlang.compiler.ast.untyped;
 
+import org.pcollections.PVector;
 import org.shedlang.compiler.sources.Source;
+import org.shedlang.compiler.sources.Sources;
 import org.shedlang.compiler.types.NamespaceName;
+import org.shedlang.compiler.util.P;
 
 import java.util.List;
 
@@ -10,4 +13,20 @@ public record UntypedNamespaceNode(
     List<UntypedNamespaceStatementNode> body,
     Source source
 ) implements UntypedNode {
+    public static Builder builder() {
+        return new Builder(NamespaceName.of("Default"), P.vector());
+    }
+
+    public record Builder(
+        NamespaceName namespaceName,
+        PVector<UntypedNamespaceStatementNode> body
+    ) {
+        public UntypedNamespaceNode build() {
+            return new UntypedNamespaceNode(namespaceName, body, Sources.NULL);
+        }
+
+        public Builder addStatement(UntypedNamespaceStatementNode statement) {
+            return new Builder(namespaceName, body.plus(statement));
+        }
+    }
 }
diff --git a/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java b/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java
index c0d1b04b..e09e4d29 100644
--- a/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java
+++ b/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java
@@ -136,6 +136,9 @@ public class StackCompiler {
         return switch (node) {
             case TypedFunctionDefinitionNode functionDefinition ->
                 compileFunctionDefinition(functionDefinition);
+
+            case TypedValNode val ->
+                throw new UnsupportedOperationException("TODO");
         };
     }
 
diff --git a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
index 489f2c3e..626f1f92 100644
--- a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
+++ b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
@@ -9,10 +9,7 @@ import org.shedlang.compiler.typechecker.typesets.TypeSets;
 import org.shedlang.compiler.types.*;
 import org.shedlang.compiler.util.PCollectors;
 
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 import java.util.stream.Stream;
 
 public class TypeChecker {
@@ -244,7 +241,7 @@ public class TypeChecker {
         });
     }
 
-    private static TypedNamespaceStatementNode typeCheckFunctionDefinition(
+    private static TypeCheckerResult<TypedNamespaceStatementNode> typeCheckFunctionDefinition(
         UntypedFunctionDefinitionNode untyped,
         TypeCheckerContext context
     ) {
@@ -289,7 +286,7 @@ public class TypeChecker {
         var typedBody = bodyResult.value();
         bodyContext = bodyResult.context();
 
-        return new TypedFunctionDefinitionNode(
+        var typed = new TypedFunctionDefinitionNode(
             untyped.name(),
             typedParams,
             typedEffect,
@@ -298,9 +295,11 @@ public class TypeChecker {
             typedBody,
             untyped.source()
         );
+
+        return context.toResult(typed);
     }
 
-    public static TypeCheckerResult<TypedFunctionStatementNode> typeCheckFunctionStatement(
+    public static TypeCheckerResult<? extends TypedFunctionStatementNode> typeCheckFunctionStatement(
         UntypedFunctionStatementNode untyped,
         TypeCheckerContext context
     ) {
@@ -327,9 +326,15 @@ public class TypeChecker {
         UntypedNamespaceNode untyped,
         TypeCheckerContext context
     ) {
-        var typedBody = untyped.body().stream()
-            .map(statement -> typeCheckNamespaceStatement(statement, context))
-            .toList();
+        var typedBody = new ArrayList<TypedNamespaceStatementNode>();
+
+        for (var untypedStatement : untyped.body()) {
+            var typedStatementResult = typeCheckNamespaceStatement(untypedStatement, context);
+            var typedStatement = typedStatementResult.value();
+            context = typedStatementResult.context();
+
+            typedBody.add(typedStatement);
+        }
 
         var fieldTypes = typedBody.stream()
             .flatMap(bodyStatement ->
@@ -351,7 +356,7 @@ public class TypeChecker {
         return context.addNamespaceFields(typed.namespaceName(), fieldTypes).toResult(typed);
     }
 
-    static TypedNamespaceStatementNode typeCheckNamespaceStatement(
+    static TypeCheckerResult<? extends TypedNamespaceStatementNode> typeCheckNamespaceStatement(
         UntypedNamespaceStatementNode untyped,
         TypeCheckerContext context
     ) {
@@ -360,7 +365,7 @@ public class TypeChecker {
                 typeCheckFunctionDefinition(functionDefinition, context);
 
             case UntypedValNode val ->
-                throw new UnsupportedOperationException("TODO");
+                typeCheckVal(val, context);
         };
     }
 
@@ -446,19 +451,19 @@ public class TypeChecker {
         );
     }
 
-    private static TypeCheckerResult<TypedFunctionStatementNode> typeCheckVal(
-        UntypedValNode val,
+    private static TypeCheckerResult<TypedValNode> typeCheckVal(
+        UntypedValNode untyped,
         TypeCheckerContext context
     ) {
-        var expressionResult = typeCheckExpression(val.expression(), context);
+        var expressionResult = typeCheckExpression(untyped.expression(), context);
         var expression = expressionResult.value();
         context = expressionResult.context();
         
-        var targetResult = typeCheckTarget(val.target(), expression.type(), context);
+        var targetResult = typeCheckTarget(untyped.target(), expression.type(), context);
         var target = targetResult.value();
         context = targetResult.context();
         
-        return context.toResult(new TypedValNode(target, expression, val.source()));
+        return context.toResult(new TypedValNode(target, expression, untyped.source()));
     }
 
     private static TypeCheckerResult<TypedTargetNode> typeCheckTarget(