Combine assign, val and var statements

17 files changed, 121 insertions, 138 deletions

diff --git a/src/test/java/org/shedlang/compiler/ast/typed/Typed.java b/src/test/java/org/shedlang/compiler/ast/typed/Typed.java
index 2fb3c66c..ca4e251a 100644
--- a/src/test/java/org/shedlang/compiler/ast/typed/Typed.java
+++ b/src/test/java/org/shedlang/compiler/ast/typed/Typed.java
@@ -185,8 +185,16 @@ public class Typed {
         );
     }
 
-    public static TypedTargetNode targetVariable(String name) {
-        return new TypedTargetNode.Variable(name, Sources.NULL);
+    public static TypedTargetNode targetReassign(String name) {
+        return new TypedTargetNode.Reassign(name, Sources.NULL);
+    }
+
+    public static TypedTargetNode targetVal(String name) {
+        return new TypedTargetNode.Val(name, Sources.NULL);
+    }
+
+    public static TypedTargetNode targetVar(String name) {
+        return new TypedTargetNode.Var(name, Sources.NULL);
     }
 
     public static <T extends TypeLevelValue> TypedTypeLevelExpressionNode<T> typeLevelReference(
@@ -196,18 +204,18 @@ public class Typed {
         return new TypedTypeLevelReferenceNode<>(name, value, Sources.NULL);
     }
 
-    public static TypedValNode val(
-        TypedTargetNode target,
+    public static TypedAssignNode val(
+        String targetName,
         TypedExpressionNode expression
     ) {
-        return new TypedValNode(target, expression, Sources.NULL);
+        return new TypedAssignNode(targetVal(targetName), expression, Sources.NULL);
     }
 
-    public static TypedVarNode var(
-        TypedTargetNode target,
+    public static TypedAssignNode var(
+        String targetName,
         TypedExpressionNode expression
     ) {
-        return new TypedVarNode(target, expression, Sources.NULL);
+        return new TypedAssignNode(targetVar(targetName), expression, Sources.NULL);
     }
 
     public static TypedWhileNode while_(
diff --git a/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java b/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java
index 5b841f4f..95caa13e 100644
--- a/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java
+++ b/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java
@@ -220,9 +220,23 @@ public class TypedNodeMatchers {
         );
     }
 
-    public static Matcher<TypedTargetNode> isTypedTargetVariable(String name) {
+    public static Matcher<TypedTargetNode> isTypedTargetReassign(String name) {
         return instanceOf(
-            TypedTargetNode.Variable.class,
+            TypedTargetNode.Reassign.class,
+            has("name", x -> x.name(), equalTo(name))
+        );
+    }
+
+    public static Matcher<TypedTargetNode> isTypedTargetVal(String name) {
+        return instanceOf(
+            TypedTargetNode.Val.class,
+            has("name", x -> x.name(), equalTo(name))
+        );
+    }
+
+    public static Matcher<TypedTargetNode> isTypedTargetVar(String name) {
+        return instanceOf(
+            TypedTargetNode.Var.class,
             has("name", x -> x.name(), equalTo(name))
         );
     }
@@ -239,23 +253,12 @@ public class TypedNodeMatchers {
     }
 
     public static Matcher<TypedNode> isTypedValNode(
-        Matcher<? super TypedTargetNode> target,
+        String targetName,
         Matcher<? super TypedExpressionNode> expression
     ) {
         return instanceOf(
-            TypedValNode.class,
-            has("target", x -> x.target(), target),
-            has("expression", x -> x.expression(), expression)
-        );
-    }
-
-    public static Matcher<TypedNode> isTypedVarNode(
-        Matcher<? super TypedTargetNode> target,
-        Matcher<? super TypedExpressionNode> expression
-    ) {
-        return instanceOf(
-            TypedVarNode.class,
-            has("target", x -> x.target(), target),
+            TypedAssignNode.class,
+            has("target", x -> x.target(), isTypedTargetVal(targetName)),
             has("expression", x -> x.expression(), expression)
         );
     }
diff --git a/src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java b/src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java
index 753bec1a..0915841c 100644
--- a/src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java
+++ b/src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java
@@ -150,26 +150,27 @@ public class Untyped {
         );
     }
 
-    public static UntypedTargetNode targetVariable(String name) {
-        return new UntypedTargetNode.Variable(name, Sources.NULL);
+    public static UntypedTargetNode targetReassign(String name) {
+        return new UntypedTargetNode.Reassign(name, Sources.NULL);
     }
 
-    public static UntypedTypeLevelReferenceNode typeLevelReference(String name) {
-        return new UntypedTypeLevelReferenceNode(name, Sources.NULL);
+    public static UntypedTargetNode targetVal(String name) {
+        return new UntypedTargetNode.Val(name, Sources.NULL);
     }
 
-    public static UntypedValNode val(
-        UntypedTargetNode target,
-        UntypedExpressionNode expression
-    ) {
-        return new UntypedValNode(target, expression, Sources.NULL);
+    public static UntypedTargetNode targetVar(String name) {
+        return new UntypedTargetNode.Var(name, Sources.NULL);
     }
 
-    public static UntypedVarNode var(
-        UntypedTargetNode target,
+    public static UntypedTypeLevelReferenceNode typeLevelReference(String name) {
+        return new UntypedTypeLevelReferenceNode(name, Sources.NULL);
+    }
+
+    public static UntypedAssignNode val(
+        String targetName,
         UntypedExpressionNode expression
     ) {
-        return new UntypedVarNode(target, expression, Sources.NULL);
+        return new UntypedAssignNode(targetVal(targetName), expression, Sources.NULL);
     }
 
     public static UntypedWhileNode while_(
diff --git a/src/test/java/org/shedlang/compiler/ast/untyped/UntypedNodeMatchers.java b/src/test/java/org/shedlang/compiler/ast/untyped/UntypedNodeMatchers.java
index a5d4e693..1af0a613 100644
--- a/src/test/java/org/shedlang/compiler/ast/untyped/UntypedNodeMatchers.java
+++ b/src/test/java/org/shedlang/compiler/ast/untyped/UntypedNodeMatchers.java
@@ -190,39 +190,31 @@ public class UntypedNodeMatchers {
         return isUntypedBinaryOperationNode(UntypedBinaryOperator.SUB, left, right);
     }
 
-    public static Matcher<UntypedTargetNode> isUntypedTargetVariableNode(String name) {
+    public static Matcher<UntypedTargetNode> isUntypedTargetReassignNode(String name) {
         return instanceOf(
-            UntypedTargetNode.Variable.class,
+            UntypedTargetNode.Reassign.class,
             has("name", x -> x.name(), equalTo(name))
         );
     }
 
-    public static Matcher<UntypedTypeLevelExpressionNode> isUntypedTypeLevelReferenceNode(String name) {
+    public static Matcher<UntypedTargetNode> isUntypedTargetValNode(String name) {
         return instanceOf(
-            UntypedTypeLevelReferenceNode.class,
+            UntypedTargetNode.Val.class,
             has("name", x -> x.name(), equalTo(name))
         );
     }
 
-    public static Matcher<UntypedNode> isUntypedValNode(
-        Matcher<UntypedTargetNode> target,
-        Matcher<UntypedExpressionNode> expression
-    ) {
+    public static Matcher<UntypedTargetNode> isUntypedTargetVarNode(String name) {
         return instanceOf(
-            UntypedValNode.class,
-            has("target", x -> x.target(), target),
-            has("expression", x -> x.expression(), expression)
+            UntypedTargetNode.Var.class,
+            has("name", x -> x.name(), equalTo(name))
         );
     }
 
-    public static Matcher<UntypedNode> isUntypedVarNode(
-        Matcher<UntypedTargetNode> target,
-        Matcher<UntypedExpressionNode> expression
-    ) {
+    public static Matcher<UntypedTypeLevelExpressionNode> isUntypedTypeLevelReferenceNode(String name) {
         return instanceOf(
-            UntypedVarNode.class,
-            has("target", x -> x.target(), target),
-            has("expression", x -> x.expression(), expression)
+            UntypedTypeLevelReferenceNode.class,
+            has("name", x -> x.name(), equalTo(name))
         );
     }
 
diff --git a/src/test/java/org/shedlang/compiler/parser/ParserAssignTests.java b/src/test/java/org/shedlang/compiler/parser/ParserAssignTests.java
index ce8c68d3..3640db47 100644
--- a/src/test/java/org/shedlang/compiler/parser/ParserAssignTests.java
+++ b/src/test/java/org/shedlang/compiler/parser/ParserAssignTests.java
@@ -9,12 +9,12 @@ import static org.zwobble.precisely.AssertThat.assertThat;
 public class ParserAssignTests {
     @Test
     public void canParseAssignAsFunctionStatement() {
-        var source = "assign x := y;";
+        var source = "assign x = y;";
 
         var node = parseString(source, Parser::parseFunctionStatement);
 
         assertThat(node, isUntypedAssignNode(
-            isUntypedTargetVariableNode("x"),
+            isUntypedTargetReassignNode("x"),
             isUntypedReferenceNode("y")
         ));
     }
diff --git a/src/test/java/org/shedlang/compiler/parser/ParserValTests.java b/src/test/java/org/shedlang/compiler/parser/ParserValTests.java
index 00d2ef62..6b01fc17 100644
--- a/src/test/java/org/shedlang/compiler/parser/ParserValTests.java
+++ b/src/test/java/org/shedlang/compiler/parser/ParserValTests.java
@@ -13,8 +13,8 @@ public class ParserValTests {
 
         var node = parseString(source, Parser::parseFunctionStatement);
 
-        assertThat(node, isUntypedValNode(
-            isUntypedTargetVariableNode("x"),
+        assertThat(node, isUntypedAssignNode(
+            isUntypedTargetValNode("x"),
             isUntypedReferenceNode("y")
         ));
     }
@@ -25,8 +25,8 @@ public class ParserValTests {
 
         var node = parseString(source, Parser::parseNamespaceStatement);
 
-        assertThat(node, isUntypedValNode(
-            isUntypedTargetVariableNode("x"),
+        assertThat(node, isUntypedAssignNode(
+            isUntypedTargetValNode("x"),
             isUntypedReferenceNode("y")
         ));
     }
diff --git a/src/test/java/org/shedlang/compiler/parser/ParserVarTests.java b/src/test/java/org/shedlang/compiler/parser/ParserVarTests.java
index 74649cc7..d43b4ca6 100644
--- a/src/test/java/org/shedlang/compiler/parser/ParserVarTests.java
+++ b/src/test/java/org/shedlang/compiler/parser/ParserVarTests.java
@@ -13,8 +13,8 @@ public class ParserVarTests {
 
         var node = parseString(source, Parser::parseFunctionStatement);
 
-        assertThat(node, isUntypedVarNode(
-            isUntypedTargetVariableNode("x"),
+        assertThat(node, isUntypedAssignNode(
+            isUntypedTargetVarNode("x"),
             isUntypedReferenceNode("y")
         ));
     }
diff --git a/src/test/java/org/shedlang/compiler/stackir/StackCompilerAssignTests.java b/src/test/java/org/shedlang/compiler/stackir/StackCompilerAssignTests.java
index 5b138e7d..20abbff3 100644
--- a/src/test/java/org/shedlang/compiler/stackir/StackCompilerAssignTests.java
+++ b/src/test/java/org/shedlang/compiler/stackir/StackCompilerAssignTests.java
@@ -12,7 +12,7 @@ public class StackCompilerAssignTests {
     @Test
     public void expressionIsEvaluatedAndStoredAsVar() {
         var node = Typed.assign(
-            Typed.targetVariable("x"),
+            Typed.targetReassign("x"),
             Typed.stringLiteral("hello")
         );
         var context = StackCompiler.Context.EMPTY
diff --git a/src/test/java/org/shedlang/compiler/stackir/StackCompilerReferenceTests.java b/src/test/java/org/shedlang/compiler/stackir/StackCompilerReferenceTests.java
index 1e98c35e..f00631c3 100644
--- a/src/test/java/org/shedlang/compiler/stackir/StackCompilerReferenceTests.java
+++ b/src/test/java/org/shedlang/compiler/stackir/StackCompilerReferenceTests.java
@@ -27,7 +27,7 @@ public class StackCompilerReferenceTests {
         var context = StackCompiler.Context.EMPTY
             .addShedVariable("x");
         context = StackCompiler.compileFunctionStatement(
-            Typed.var(Typed.targetVariable("x"), Typed.intLiteral(0)),
+            Typed.var("x", Typed.intLiteral(0)),
             context
         );
 
diff --git a/src/test/java/org/shedlang/compiler/stackir/StackCompilerValTests.java b/src/test/java/org/shedlang/compiler/stackir/StackCompilerValTests.java
index 6424f649..b72055fd 100644
--- a/src/test/java/org/shedlang/compiler/stackir/StackCompilerValTests.java
+++ b/src/test/java/org/shedlang/compiler/stackir/StackCompilerValTests.java
@@ -13,10 +13,7 @@ import static org.zwobble.precisely.Matchers.isSequence;
 public class StackCompilerValTests {
     @Test
     public void whenValIsFunctionStatementThenExpressionIsEvaluatedAndStoredAsLocal() {
-        var node = Typed.val(
-            Typed.targetVariable("x"),
-            Typed.stringLiteral("hello")
-        );
+        var node = Typed.val("x", Typed.stringLiteral("hello"));
         var context = StackCompiler.Context.EMPTY
             .addShedVariable("x");
 
@@ -30,10 +27,7 @@ public class StackCompilerValTests {
 
     @Test
     public void whenValIsNamespaceStatementThenExpressionIsEvaluatedAndStoredAsLocal() {
-        var node = Typed.val(
-            Typed.targetVariable("x"),
-            Typed.stringLiteral("hello")
-        );
+        var node = Typed.val("x", Typed.stringLiteral("hello"));
         var context = StackCompiler.Context.EMPTY
             .addShedVariable("x");
 
@@ -48,7 +42,7 @@ public class StackCompilerValTests {
     @Test
     public void valsInDifferentBlocksAssignToDifferentLocals() {
         var nodes = List.of(
-            Typed.val(Typed.targetVariable("x"), Typed.intLiteral(10)),
+            Typed.val("x", Typed.intLiteral(10)),
             Typed.expressionStatement(Typed.reference("x")),
             Typed.expressionStatement(Typed.if_(
                 List.of(
@@ -56,7 +50,7 @@ public class StackCompilerValTests {
                         Typed.boolLiteral(true),
                         Typed.block(
                             List.of(
-                                Typed.val(Typed.targetVariable("x"), Typed.intLiteral(11)),
+                                Typed.val("x", Typed.intLiteral(11)),
                                 Typed.expressionStatement(Typed.reference("x"))
                             ),
                             List.of("x")
@@ -65,7 +59,7 @@ public class StackCompilerValTests {
                 ),
                 Typed.block(
                     List.of(
-                        Typed.val(Typed.targetVariable("x"), Typed.intLiteral(12)),
+                        Typed.val("x", Typed.intLiteral(12)),
                         Typed.expressionStatement(Typed.reference("x"))
                     ),
                     List.of("x")
diff --git a/src/test/java/org/shedlang/compiler/stackir/StackCompilerVarTests.java b/src/test/java/org/shedlang/compiler/stackir/StackCompilerVarTests.java
index 414f20d9..fc133877 100644
--- a/src/test/java/org/shedlang/compiler/stackir/StackCompilerVarTests.java
+++ b/src/test/java/org/shedlang/compiler/stackir/StackCompilerVarTests.java
@@ -10,10 +10,7 @@ import static org.zwobble.precisely.Matchers.isSequence;
 public class StackCompilerVarTests {
     @Test
     public void expressionIsEvaluatedAndStoredAsVar() {
-        var node = Typed.var(
-            Typed.targetVariable("x"),
-            Typed.stringLiteral("hello")
-        );
+        var node = Typed.var("x", Typed.stringLiteral("hello"));
         var context = StackCompiler.Context.EMPTY
             .addShedVariable("x");
 
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java
index c9d904c5..df18c0bb 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java
@@ -22,7 +22,7 @@ import static org.zwobble.precisely.Matchers.equalTo;
 public class TypeCheckerAssignTests {
     @Test
     public void canTypeCheckAssign() {
-        var untyped = Untyped.assign(Untyped.targetVariable("x"), Untyped.stringLiteral("hello"));
+        var untyped = Untyped.assign(Untyped.targetReassign("x"), Untyped.stringLiteral("hello"));
         var context = TypeCheckerContext.EMPTY
             .enterNamespace(P.map(
                 Map.entry("x", Variable.defined(Types.STRING, VariableType.VAR))
@@ -31,14 +31,14 @@ public class TypeCheckerAssignTests {
         var typed = typeCheckFunctionStatement(untyped, context);
 
         assertThat(typed.value(), isTypedAssignNode(
-            isTypedTargetVariable("x"),
+            isTypedTargetReassign("x"),
             isTypedStringLiteralNode("hello")
         ));
     }
 
     @Test
     public void whenExpressionIsNotSubTypeOfTargetVariableThenErrorIsThrown() {
-        var untyped = Untyped.assign(Untyped.targetVariable("x"), Untyped.stringLiteral("hello"));
+        var untyped = Untyped.assign(Untyped.targetReassign("x"), Untyped.stringLiteral("hello"));
         var context = TypeCheckerContext.EMPTY
             .enterNamespace(P.map(
                 Map.entry("x", Variable.defined(Types.INT, VariableType.VAR))
@@ -55,7 +55,7 @@ public class TypeCheckerAssignTests {
 
     @Test
     public void whenTargetIsNotVarThenErrorIsThrown() {
-        var untyped = Untyped.assign(Untyped.targetVariable("x"), Untyped.stringLiteral("hello"));
+        var untyped = Untyped.assign(Untyped.targetReassign("x"), Untyped.stringLiteral("hello"));
         var context = TypeCheckerContext.EMPTY
             .enterNamespace(P.map(
                 Map.entry("x", Variable.defined(Types.STRING, VariableType.VAL))
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerFunctionDefinitionTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerFunctionDefinitionTests.java
index 7a81b5ac..136dce36 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerFunctionDefinitionTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerFunctionDefinitionTests.java
@@ -354,20 +354,14 @@ public class TypeCheckerFunctionDefinitionTests {
             .addPositionalParam("argPositional", Untyped.typeLevelReference("Unit"))
             .addNamedParam("argNamed", Untyped.typeLevelReference("Unit"))
             .withReturnType(Untyped.typeLevelReference("Unit"))
-            .addStatement(Untyped.val(
-                Untyped.targetVariable("local1"),
-                Untyped.intLiteral(1)
-            ))
+            .addStatement(Untyped.val("local1", Untyped.intLiteral(1)))
             .addStatement(Untyped.expressionStatement(Untyped.reference("y")))
             .addStatement(Untyped.expressionStatement(Untyped.if_(
                 List.of(
                     Untyped.conditionalBranch(
                         Untyped.boolLiteral(true),
                         Untyped.block(List.of(
-                            Untyped.val(
-                                Untyped.targetVariable("local2"),
-                                Untyped.intLiteral(2)
-                            )
+                            Untyped.val("local2", Untyped.intLiteral(2))
                         ))
                     )
                 ),
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIfTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIfTests.java
index c178c2e9..adb5968c 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIfTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIfTests.java
@@ -119,12 +119,12 @@ public class TypeCheckerIfTests {
                 Untyped.conditionalBranch(
                     Untyped.boolLiteral(true),
                     Untyped.block(List.of(
-                        Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("a"))
+                        Untyped.val("x", Untyped.stringLiteral("a"))
                     ))
                 )
             ),
             Untyped.block(List.of(
-                Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("b"))
+                Untyped.val("x", Untyped.stringLiteral("b"))
             ))
         );
         var context = TypeCheckerContext.EMPTY
@@ -139,12 +139,12 @@ public class TypeCheckerIfTests {
                 isTypedConditionalBranchNode(
                     isTypedBoolLiteralNode(true),
                     isTypedBlockNode(isSequence(
-                        isTypedValNode(isTypedTargetVariable("x"), isTypedStringLiteralNode("a"))
+                        isTypedValNode("x", isTypedStringLiteralNode("a"))
                     ))
                 )
             ),
             isTypedBlockNode(isSequence(
-                isTypedValNode(isTypedTargetVariable("x"), isTypedStringLiteralNode("b"))
+                isTypedValNode("x", isTypedStringLiteralNode("b"))
             ))
         ));
     }
@@ -156,18 +156,12 @@ public class TypeCheckerIfTests {
                 Untyped.conditionalBranch(
                     Untyped.boolLiteral(true),
                     Untyped.block(List.of(
-                        Untyped.val(
-                            Untyped.targetVariable("local1"),
-                            Untyped.intLiteral(1)
-                        )
+                        Untyped.val("local1", Untyped.intLiteral(1))
                     ))
                 )
             ),
             Untyped.block(List.of(
-                Untyped.val(
-                    Untyped.targetVariable("local2"),
-                    Untyped.intLiteral(2)
-                )
+                Untyped.val("local2", Untyped.intLiteral(2))
             ))
         );
         var context = TypeCheckerContext.EMPTY;
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerNamespaceTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerNamespaceTests.java
index 6f338803..36e1ee5d 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerNamespaceTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerNamespaceTests.java
@@ -121,7 +121,7 @@ public class TypeCheckerNamespaceTests {
     @Test
     public void functionCanReferenceValDefinedEarlier() {
         var untyped = Untyped.namespace(List.of(
-            Untyped.val(Untyped.targetVariable("x"), Untyped.boolLiteral(true)),
+            Untyped.val("x", Untyped.boolLiteral(true)),
             UntypedFunctionDefinitionNode.builder()
                 .withName("f")
                 .withReturnType(Untyped.typeLevelReference("Unit"))
@@ -137,7 +137,7 @@ public class TypeCheckerNamespaceTests {
             result.value(),
             isTypedNamespaceNode()
                 .withBody(isSequence(
-                        isTypedValNode(isTypedTargetVariable("x"), isTypedBoolLiteralNode(true)),
+                    isTypedAssignNode(isTypedTargetVal("x"), isTypedBoolLiteralNode(true)),
                         isTypedFunctionDefinitionNode().withName("f")
                     )
                 )
@@ -152,7 +152,7 @@ public class TypeCheckerNamespaceTests {
                 .withReturnType(Untyped.typeLevelReference("Unit"))
                 .addStatement(Untyped.expressionStatement(Untyped.reference("x")))
                 .build(),
-            Untyped.val(Untyped.targetVariable("x"), Untyped.boolLiteral(true))
+            Untyped.val("x", Untyped.boolLiteral(true))
         ));
         var context = TypeCheckerContext.EMPTY
             .enterGlobal(P.map(Map.entry("Unit", Types.metaType(Types.UNIT))));
@@ -172,7 +172,7 @@ public class TypeCheckerNamespaceTests {
                 .withName("f")
                 .withReturnType(Untyped.typeLevelReference("Unit"))
                 .build(),
-            Untyped.val(Untyped.targetVariable("x"), Untyped.call(Untyped.reference("f"), List.of()))
+            Untyped.val("x", Untyped.call(Untyped.reference("f"), List.of()))
         ));
         var context = TypeCheckerContext.EMPTY
             .enterGlobal(P.map(Map.entry("Unit", Types.metaType(Types.UNIT))));
@@ -184,7 +184,7 @@ public class TypeCheckerNamespaceTests {
             isTypedNamespaceNode()
                 .withBody(isSequence(
                     isTypedFunctionDefinitionNode().withName("f"),
-                    isTypedValNode(isTypedTargetVariable("x"), anything())
+                    isTypedAssignNode(isTypedTargetVal("x"), anything())
                 ))
         );
     }
@@ -192,7 +192,7 @@ public class TypeCheckerNamespaceTests {
     @Test
     public void valCanReferenceFunctionDefinedLater() {
         var untyped = Untyped.namespace(List.of(
-            Untyped.val(Untyped.targetVariable("x"), Untyped.call(Untyped.reference("f"), List.of())),
+            Untyped.val("x", Untyped.call(Untyped.reference("f"), List.of())),
             UntypedFunctionDefinitionNode.builder()
                 .withName("f")
                 .withReturnType(Untyped.typeLevelReference("Unit"))
@@ -207,7 +207,7 @@ public class TypeCheckerNamespaceTests {
             result.value(),
             isTypedNamespaceNode()
                 .withBody(isSequence(
-                    isTypedValNode(isTypedTargetVariable("x"), anything()),
+                    isTypedAssignNode(isTypedTargetVal("x"), anything()),
                     isTypedFunctionDefinitionNode().withName("f")
                 ))
         );
@@ -216,8 +216,8 @@ public class TypeCheckerNamespaceTests {
     @Test
     public void valCanReferenceFunctionThatUsesValDefinedEarlier() {
         var untyped = Untyped.namespace(List.of(
-            Untyped.val(Untyped.targetVariable("x"), Untyped.boolLiteral(true)),
-            Untyped.val(Untyped.targetVariable("y"), Untyped.call(Untyped.reference("f"), List.of())),
+            Untyped.val("x", Untyped.boolLiteral(true)),
+            Untyped.val("y", Untyped.call(Untyped.reference("f"), List.of())),
             UntypedFunctionDefinitionNode.builder()
                 .withName("f")
                 .withReturnType(Untyped.typeLevelReference("Unit"))
@@ -233,8 +233,8 @@ public class TypeCheckerNamespaceTests {
             result.value(),
             isTypedNamespaceNode()
                 .withBody(isSequence(
-                    isTypedValNode(isTypedTargetVariable("x"), anything()),
-                    isTypedValNode(isTypedTargetVariable("y"), anything()),
+                    isTypedAssignNode(isTypedTargetVal("x"), anything()),
+                    isTypedAssignNode(isTypedTargetVal("y"), anything()),
                     isTypedFunctionDefinitionNode().withName("f")
                 ))
         );
@@ -243,7 +243,7 @@ public class TypeCheckerNamespaceTests {
     @Test
     public void valCannotReferenceFunctionThatUsesThatVal() {
         var untyped = Untyped.namespace(List.of(
-            Untyped.val(Untyped.targetVariable("x"), Untyped.call(Untyped.reference("f"), List.of())),
+            Untyped.val("x", Untyped.call(Untyped.reference("f"), List.of())),
             UntypedFunctionDefinitionNode.builder()
                 .withName("f")
                 .withReturnType(Untyped.typeLevelReference("Unit"))
@@ -264,8 +264,8 @@ public class TypeCheckerNamespaceTests {
     @Test
     public void valCannotReferenceFunctionThatUsesValDefinedLater() {
         var untyped = Untyped.namespace(List.of(
-            Untyped.val(Untyped.targetVariable("x"), Untyped.call(Untyped.reference("f"), List.of())),
-            Untyped.val(Untyped.targetVariable("y"), Untyped.boolLiteral(true)),
+            Untyped.val("x", Untyped.call(Untyped.reference("f"), List.of())),
+            Untyped.val("y", Untyped.boolLiteral(true)),
             UntypedFunctionDefinitionNode.builder()
                 .withName("f")
                 .withReturnType(Untyped.typeLevelReference("Unit"))
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerValTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerValTests.java
index c760a82e..6cb02e1b 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerValTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerValTests.java
@@ -19,24 +19,24 @@ import static org.zwobble.precisely.Matchers.*;
 public class TypeCheckerValTests {
     @Test
     public void canTypeCheckAsFunctionStatement() {
-        var untyped = Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("hello"));
+        var untyped = Untyped.assign(Untyped.targetVal("x"), Untyped.stringLiteral("hello"));
 
         var typed = typeCheckFunctionStatement(untyped, TypeCheckerContext.EMPTY);
 
-        assertThat(typed.value(), isTypedValNode(
-            isTypedTargetVariable("x"),
+        assertThat(typed.value(), isTypedAssignNode(
+            isTypedTargetVal("x"),
             isTypedStringLiteralNode("hello")
         ));
     }
 
     @Test
     public void canTypeCheckAsNamespaceStatement() {
-        var untyped = Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("hello"));
+        var untyped = Untyped.assign(Untyped.targetVal("x"), Untyped.stringLiteral("hello"));
 
         var typed = typeCheckNamespaceStatement(untyped, TypeCheckerContext.EMPTY);
 
-        assertThat(typed.value(), isTypedValNode(
-            isTypedTargetVariable("x"),
+        assertThat(typed.value(), isTypedAssignNode(
+            isTypedTargetVal("x"),
             isTypedStringLiteralNode("hello")
         ));
     }
@@ -44,7 +44,7 @@ public class TypeCheckerValTests {
     @Test
     public void valCanBeReferencedAfterDefinitionInFunction() {
         var untyped = UntypedFunctionDefinitionNode.builder()
-            .addStatement(Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("hello")))
+            .addStatement(Untyped.assign(Untyped.targetVal("x"), Untyped.stringLiteral("hello")))
             .addStatement(Untyped.expressionStatement(Untyped.reference("x")))
             .build();
         var context = TypeCheckerContext.EMPTY
@@ -58,7 +58,7 @@ public class TypeCheckerValTests {
             typed.value(),
             isTypedFunctionDefinitionNode()
                 .withBody(isTypedBlockNode(isSequence(
-                    isTypedValNode(anything(), anything()),
+                    isTypedAssignNode(anything(), anything()),
                     isTypedExpressionStatementNode(isTypedReferenceNode("x", Types.STRING))
                 )))
         );
@@ -67,8 +67,8 @@ public class TypeCheckerValTests {
     @Test
     public void valCanBeReferencedAfterDefinitionInNamespace() {
         var untyped = UntypedNamespaceNode.builder()
-            .addStatement(Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("hello")))
-            .addStatement(Untyped.val(Untyped.targetVariable("y"), Untyped.reference("x")))
+            .addStatement(Untyped.assign(Untyped.targetVal("x"), Untyped.stringLiteral("hello")))
+            .addStatement(Untyped.assign(Untyped.targetVal("y"), Untyped.reference("x")))
             .build();
         var context = TypeCheckerContext.EMPTY
             .enterGlobal(P.map(
@@ -81,8 +81,8 @@ public class TypeCheckerValTests {
             typed.value(),
             isTypedNamespaceNode()
                 .withBody(isSequence(
-                    isTypedValNode(anything(), anything()),
-                    isTypedValNode(anything(), isTypedReferenceNode("x", Types.STRING))
+                    isTypedAssignNode(anything(), anything()),
+                    isTypedAssignNode(anything(), isTypedReferenceNode("x", Types.STRING))
                 ))
         );
     }
@@ -91,7 +91,7 @@ public class TypeCheckerValTests {
     public void valCannotBeReferencedBeforeDefinition() {
         var untyped = UntypedFunctionDefinitionNode.builder()
             .addStatement(Untyped.expressionStatement(Untyped.reference("x")))
-            .addStatement(Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("hello")))
+            .addStatement(Untyped.assign(Untyped.targetVal("x"), Untyped.stringLiteral("hello")))
             .build();
         var context = TypeCheckerContext.EMPTY
             .enterGlobal(P.map(
@@ -110,7 +110,7 @@ public class TypeCheckerValTests {
     public void whenValShadowsExistingVariableThenValCannotBeReferencedBeforeDefinition() {
         var untyped = UntypedFunctionDefinitionNode.builder()
             .addStatement(Untyped.expressionStatement(Untyped.reference("x")))
-            .addStatement(Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("hello")))
+            .addStatement(Untyped.assign(Untyped.targetVal("x"), Untyped.stringLiteral("hello")))
             .build();
         var context = TypeCheckerContext.EMPTY
             .enterGlobal(P.map(
@@ -129,8 +129,8 @@ public class TypeCheckerValTests {
     @Test
     public void duplicateVariableNamesAreNotAllowed() {
         var untyped = UntypedFunctionDefinitionNode.builder()
-            .addStatement(Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("hello")))
-            .addStatement(Untyped.val(Untyped.targetVariable("x"), Untyped.stringLiteral("hello")))
+            .addStatement(Untyped.assign(Untyped.targetVal("x"), Untyped.stringLiteral("hello")))
+            .addStatement(Untyped.assign(Untyped.targetVal("x"), Untyped.stringLiteral("hello")))
             .build();
         var context = TypeCheckerContext.EMPTY
             .enterGlobal(P.map(
diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerVarTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerVarTests.java
index 865d01eb..21f5502e 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerVarTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerVarTests.java
@@ -20,12 +20,12 @@ import static org.zwobble.precisely.Matchers.isSequence;
 public class TypeCheckerVarTests {
     @Test
     public void canTypeCheckAsFunctionStatement() {
-        var untyped = Untyped.var(Untyped.targetVariable("x"), Untyped.stringLiteral("hello"));
+        var untyped = Untyped.assign(Untyped.targetVar("x"), Untyped.stringLiteral("hello"));
 
         var typed = typeCheckFunctionStatement(untyped, TypeCheckerContext.EMPTY);
 
-        assertThat(typed.value(), isTypedVarNode(
-            isTypedTargetVariable("x"),
+        assertThat(typed.value(), isTypedAssignNode(
+            isTypedTargetVar("x"),
             isTypedStringLiteralNode("hello")
         ));
     }
@@ -33,7 +33,7 @@ public class TypeCheckerVarTests {
     @Test
     public void varCanBeReferencedAfterDefinitionInFunction() {
         var untyped = UntypedFunctionDefinitionNode.builder()
-            .addStatement(Untyped.var(Untyped.targetVariable("x"), Untyped.stringLiteral("hello")))
+            .addStatement(Untyped.assign(Untyped.targetVar("x"), Untyped.stringLiteral("hello")))
             .addStatement(Untyped.expressionStatement(Untyped.reference("x")))
             .build();
         var context = TypeCheckerContext.EMPTY
@@ -47,7 +47,7 @@ public class TypeCheckerVarTests {
             typed.value(),
             isTypedFunctionDefinitionNode()
                 .withBody(isTypedBlockNode(isSequence(
-                    isTypedVarNode(anything(), anything()),
+                    isTypedAssignNode(anything(), anything()),
                     isTypedExpressionStatementNode(isTypedReferenceNode("x", Types.STRING))
                 )))
         );