aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorMichael Williamson <mike@zwobble.org>2023-09-16 16:35:38 +0100
committerMichael Williamson <mike@zwobble.org>2023-09-16 16:35:38 +0100
commit02bd64dfdbfa8134cb93165ee606817b2e6737b5 (patch)
tree9a2e463a79150fc90a1481b768c89b2158481dfc /src
parent904f02af5e2965f73b037e4b3c5d97f57af81987 (diff)
Combine assign, val and var statements
Diffstat (limited to 'src')
-rw-r--r--src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java2
-rw-r--r--src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionStatementNode.java2
-rw-r--r--src/main/java/org/shedlang/compiler/ast/typed/TypedNamespaceStatementNode.java2
-rw-r--r--src/main/java/org/shedlang/compiler/ast/typed/TypedTargetNode.java4
-rw-r--r--src/main/java/org/shedlang/compiler/ast/typed/TypedValNode.java14
-rw-r--r--src/main/java/org/shedlang/compiler/ast/typed/TypedVarNode.java14
-rw-r--r--src/main/java/org/shedlang/compiler/ast/untyped/UntypedAssignNode.java2
-rw-r--r--src/main/java/org/shedlang/compiler/ast/untyped/UntypedFunctionStatementNode.java4
-rw-r--r--src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceStatementNode.java2
-rw-r--r--src/main/java/org/shedlang/compiler/ast/untyped/UntypedTargetNode.java4
-rw-r--r--src/main/java/org/shedlang/compiler/ast/untyped/UntypedValNode.java14
-rw-r--r--src/main/java/org/shedlang/compiler/ast/untyped/UntypedVarNode.java14
-rw-r--r--src/main/java/org/shedlang/compiler/parser/Parser.java71
-rw-r--r--src/main/java/org/shedlang/compiler/stackir/StackCompiler.java63
-rw-r--r--src/main/java/org/shedlang/compiler/typechecker/DeclaredVariables.java54
-rw-r--r--src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java159
-rw-r--r--src/test/java/org/shedlang/compiler/ast/typed/Typed.java24
-rw-r--r--src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java35
-rw-r--r--src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java25
-rw-r--r--src/test/java/org/shedlang/compiler/ast/untyped/UntypedNodeMatchers.java28
-rw-r--r--src/test/java/org/shedlang/compiler/parser/ParserAssignTests.java4
-rw-r--r--src/test/java/org/shedlang/compiler/parser/ParserValTests.java8
-rw-r--r--src/test/java/org/shedlang/compiler/parser/ParserVarTests.java4
-rw-r--r--src/test/java/org/shedlang/compiler/stackir/StackCompilerAssignTests.java2
-rw-r--r--src/test/java/org/shedlang/compiler/stackir/StackCompilerReferenceTests.java2
-rw-r--r--src/test/java/org/shedlang/compiler/stackir/StackCompilerValTests.java16
-rw-r--r--src/test/java/org/shedlang/compiler/stackir/StackCompilerVarTests.java5
-rw-r--r--src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java8
-rw-r--r--src/test/java/org/shedlang/compiler/typechecker/TypeCheckerFunctionDefinitionTests.java10
-rw-r--r--src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIfTests.java18
-rw-r--r--src/test/java/org/shedlang/compiler/typechecker/TypeCheckerNamespaceTests.java28
-rw-r--r--src/test/java/org/shedlang/compiler/typechecker/TypeCheckerValTests.java32
-rw-r--r--src/test/java/org/shedlang/compiler/typechecker/TypeCheckerVarTests.java10
33 files changed, 278 insertions, 406 deletions
diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java
index 24bc4532..c543ee30 100644
--- a/src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java
@@ -6,7 +6,7 @@ public record TypedAssignNode(
TypedTargetNode target,
TypedExpressionNode expression,
Source source
-) implements TypedFunctionStatementNode {
+) implements TypedFunctionStatementNode, TypedNamespaceStatementNode {
@Override
public TypedFunctionStatementBehaviour behaviour() {
return TypedFunctionStatementBehaviour.CONTINUE;
diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionStatementNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionStatementNode.java
index b2995bff..57a585a0 100644
--- a/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionStatementNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionStatementNode.java
@@ -1,5 +1,5 @@
package org.shedlang.compiler.ast.typed;
-public sealed interface TypedFunctionStatementNode extends TypedNode permits TypedWhileNode, TypedAssignNode, TypedBlockReturnNode, TypedExpressionStatementNode, TypedFunctionReturnNode, TypedValNode, TypedVarNode {
+public sealed interface TypedFunctionStatementNode extends TypedNode permits TypedWhileNode, TypedAssignNode, TypedBlockReturnNode, TypedExpressionStatementNode, TypedFunctionReturnNode {
TypedFunctionStatementBehaviour behaviour();
}
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 112d14bc..f2186711 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, TypedValNode {
+public sealed interface TypedNamespaceStatementNode extends TypedNode permits TypedAssignNode, TypedFunctionDefinitionNode {
}
diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedTargetNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedTargetNode.java
index 7af7203f..4a86975b 100644
--- a/src/main/java/org/shedlang/compiler/ast/typed/TypedTargetNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/typed/TypedTargetNode.java
@@ -3,5 +3,7 @@ package org.shedlang.compiler.ast.typed;
import org.shedlang.compiler.sources.Source;
public sealed interface TypedTargetNode extends TypedNode {
- record Variable(String name, Source source) implements TypedTargetNode {}
+ record Reassign(String name, Source source) implements TypedTargetNode {}
+ record Val(String name, Source source) implements TypedTargetNode {}
+ record Var(String name, Source source) implements TypedTargetNode {}
}
diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedValNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedValNode.java
deleted file mode 100644
index c25b9d2d..00000000
--- a/src/main/java/org/shedlang/compiler/ast/typed/TypedValNode.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.shedlang.compiler.ast.typed;
-
-import org.shedlang.compiler.sources.Source;
-
-public record TypedValNode(
- TypedTargetNode target,
- TypedExpressionNode expression,
- Source source
-) implements TypedFunctionStatementNode, TypedNamespaceStatementNode {
- @Override
- public TypedFunctionStatementBehaviour behaviour() {
- return TypedFunctionStatementBehaviour.CONTINUE;
- }
-}
diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedVarNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedVarNode.java
deleted file mode 100644
index 3c698b52..00000000
--- a/src/main/java/org/shedlang/compiler/ast/typed/TypedVarNode.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.shedlang.compiler.ast.typed;
-
-import org.shedlang.compiler.sources.Source;
-
-public record TypedVarNode(
- TypedTargetNode target,
- TypedExpressionNode expression,
- Source source
-) implements TypedFunctionStatementNode {
- @Override
- public TypedFunctionStatementBehaviour behaviour() {
- return TypedFunctionStatementBehaviour.CONTINUE;
- }
-}
diff --git a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedAssignNode.java b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedAssignNode.java
index 9e6827f8..6b28bd89 100644
--- a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedAssignNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedAssignNode.java
@@ -6,7 +6,7 @@ public record UntypedAssignNode(
UntypedTargetNode target,
UntypedExpressionNode expression,
Source source
-) implements UntypedFunctionStatementNode {
+) implements UntypedFunctionStatementNode, UntypedNamespaceStatementNode {
@Override
public UntypedFunctionStatementBehaviour behaviour() {
return UntypedFunctionStatementBehaviour.CONTINUE;
diff --git a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedFunctionStatementNode.java b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedFunctionStatementNode.java
index 5fadfcaf..90b0c29b 100644
--- a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedFunctionStatementNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedFunctionStatementNode.java
@@ -1,7 +1,5 @@
package org.shedlang.compiler.ast.untyped;
-import java.util.List;
-
-public sealed interface UntypedFunctionStatementNode extends UntypedNode permits UntypedAssignNode, UntypedBlockReturnNode, UntypedExpressionStatementNode, UntypedFunctionReturnNode, UntypedValNode, UntypedVarNode, UntypedWhileNode {
+public sealed interface UntypedFunctionStatementNode extends UntypedNode permits UntypedAssignNode, UntypedBlockReturnNode, UntypedExpressionStatementNode, UntypedFunctionReturnNode, UntypedWhileNode {
UntypedFunctionStatementBehaviour behaviour();
}
diff --git a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceStatementNode.java b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceStatementNode.java
index 9e4a9395..90e7142f 100644
--- a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceStatementNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedNamespaceStatementNode.java
@@ -1,4 +1,4 @@
package org.shedlang.compiler.ast.untyped;
-public sealed interface UntypedNamespaceStatementNode extends UntypedNode permits UntypedFunctionDefinitionNode, UntypedValNode {
+public sealed interface UntypedNamespaceStatementNode extends UntypedNode permits UntypedAssignNode, UntypedFunctionDefinitionNode {
}
diff --git a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedTargetNode.java b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedTargetNode.java
index a70965bf..b7e9153c 100644
--- a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedTargetNode.java
+++ b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedTargetNode.java
@@ -3,5 +3,7 @@ package org.shedlang.compiler.ast.untyped;
import org.shedlang.compiler.sources.Source;
public sealed interface UntypedTargetNode extends UntypedNode {
- record Variable(String name, Source source) implements UntypedTargetNode, UntypedVariableDeclarationNode {}
+ record Reassign(String name, Source source) implements UntypedTargetNode, UntypedVariableDeclarationNode {}
+ record Val(String name, Source source) implements UntypedTargetNode, UntypedVariableDeclarationNode {}
+ record Var(String name, Source source) implements UntypedTargetNode, UntypedVariableDeclarationNode {}
}
diff --git a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedValNode.java b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedValNode.java
deleted file mode 100644
index e1353ab9..00000000
--- a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedValNode.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.shedlang.compiler.ast.untyped;
-
-import org.shedlang.compiler.sources.Source;
-
-public record UntypedValNode(
- UntypedTargetNode target,
- UntypedExpressionNode expression,
- Source source
-) implements UntypedFunctionStatementNode, UntypedNamespaceStatementNode {
- @Override
- public UntypedFunctionStatementBehaviour behaviour() {
- return UntypedFunctionStatementBehaviour.CONTINUE;
- }
-}
diff --git a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedVarNode.java b/src/main/java/org/shedlang/compiler/ast/untyped/UntypedVarNode.java
deleted file mode 100644
index 3cd533b9..00000000
--- a/src/main/java/org/shedlang/compiler/ast/untyped/UntypedVarNode.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.shedlang.compiler.ast.untyped;
-
-import org.shedlang.compiler.sources.Source;
-
-public record UntypedVarNode(
- UntypedTargetNode target,
- UntypedExpressionNode expression,
- Source source
-) implements UntypedFunctionStatementNode {
- @Override
- public UntypedFunctionStatementBehaviour behaviour() {
- return UntypedFunctionStatementBehaviour.CONTINUE;
- }
-}
diff --git a/src/main/java/org/shedlang/compiler/parser/Parser.java b/src/main/java/org/shedlang/compiler/parser/Parser.java
index a5a48756..c7ab639f 100644
--- a/src/main/java/org/shedlang/compiler/parser/Parser.java
+++ b/src/main/java/org/shedlang/compiler/parser/Parser.java
@@ -107,11 +107,9 @@ public class Parser {
private static UntypedAssignNode parseAssign(TokenIterator<TokenType> tokens) {
var start = tokens.position();
- tokens.skip(TokenType.KEYWORD_ASSIGN);
-
var target = parseTarget(tokens);
- tokens.skip(TokenType.SYMBOL_COLON_EQUALS);
+ tokens.skip(TokenType.SYMBOL_EQUALS);
var expression = parseTopLevelExpression(tokens);
@@ -303,18 +301,12 @@ public class Parser {
static UntypedFunctionStatementNode parseFunctionStatement(TokenIterator<TokenType> tokens) {
return switch (tokens.peek().tokenType()) {
- case KEYWORD_ASSIGN ->
+ case KEYWORD_ASSIGN, KEYWORD_VAL, KEYWORD_VAR ->
parseAssign(tokens);
case KEYWORD_RETURN ->
parseFunctionReturn(tokens);
- case KEYWORD_VAL ->
- parseVal(tokens);
-
- case KEYWORD_VAR ->
- parseVar(tokens);
-
case KEYWORD_WHILE ->
parseWhile(tokens);
@@ -407,7 +399,7 @@ public class Parser {
parseFunctionDefinition(tokens);
case KEYWORD_VAL ->
- parseVal(tokens);
+ parseAssign(tokens);
default ->
throw new UnexpectedTokenException("namespace statement", tokens.peek());
@@ -559,50 +551,43 @@ public class Parser {
private static UntypedTargetNode parseTarget(TokenIterator<TokenType> tokens) {
var start = tokens.position();
- var name = tokens.nextValue(TokenType.IDENTIFIER);
-
- var end = tokens.position();
- var source = start.to(end);
-
- return new UntypedTargetNode.Variable(name, source);
- }
-
- private static UntypedValNode parseVal(TokenIterator<TokenType> tokens) {
- var start = tokens.position();
-
- tokens.skip(TokenType.KEYWORD_VAL);
-
- var target = parseTarget(tokens);
-
- tokens.skip(TokenType.SYMBOL_EQUALS);
+ return switch (tokens.peek().tokenType()) {
+ case KEYWORD_ASSIGN -> {
+ tokens.skip(TokenType.KEYWORD_ASSIGN);
- var expression = parseTopLevelExpression(tokens);
+ var name = tokens.nextValue(TokenType.IDENTIFIER);
- tokens.skip(TokenType.SYMBOL_SEMICOLON);
+ var end = tokens.position();
+ var source = start.to(end);
- var end = tokens.position();
- var source = start.to(end);
+ yield new UntypedTargetNode.Reassign(name, source);
+ }
- return new UntypedValNode(target, expression, source);
- }
+ case KEYWORD_VAL -> {
+ tokens.skip(TokenType.KEYWORD_VAL);
- private static UntypedVarNode parseVar(TokenIterator<TokenType> tokens) {
- var start = tokens.position();
+ var name = tokens.nextValue(TokenType.IDENTIFIER);
- tokens.skip(TokenType.KEYWORD_VAR);
+ var end = tokens.position();
+ var source = start.to(end);
- var target = parseTarget(tokens);
+ yield new UntypedTargetNode.Val(name, source);
+ }
- tokens.skip(TokenType.SYMBOL_EQUALS);
+ case KEYWORD_VAR -> {
+ tokens.skip(TokenType.KEYWORD_VAR);
- var expression = parseTopLevelExpression(tokens);
+ var name = tokens.nextValue(TokenType.IDENTIFIER);
- tokens.skip(TokenType.SYMBOL_SEMICOLON);
+ var end = tokens.position();
+ var source = start.to(end);
- var end = tokens.position();
- var source = start.to(end);
+ yield new UntypedTargetNode.Var(name, source);
+ }
- return new UntypedVarNode(target, expression, source);
+ default ->
+ throw new UnexpectedTokenException("namespace statement", tokens.peek());
+ };
}
private static UntypedFunctionStatementNode parseWhile(
diff --git a/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java b/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java
index 1621a50c..2c9d6065 100644
--- a/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java
+++ b/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java
@@ -3,12 +3,10 @@ package org.shedlang.compiler.stackir;
import org.pcollections.*;
import org.shedlang.compiler.ShedBuiltins;
import org.shedlang.compiler.ast.typed.*;
-import org.shedlang.compiler.sources.Source;
import org.shedlang.compiler.stackir.instructions.*;
import org.shedlang.compiler.util.P;
import java.util.List;
-import java.util.function.BiFunction;
public class StackCompiler {
private StackCompiler() {
@@ -16,7 +14,7 @@ public class StackCompiler {
private static Context compileAssign(TypedAssignNode node, Context context) {
context = compileExpression(node.expression(), context);
- context = compileTarget(node.target(), VarStoreInstruction::new, context);
+ context = compileTarget(node.target(), context);
return context;
}
@@ -239,12 +237,6 @@ public class StackCompiler {
case TypedFunctionReturnNode functionReturn ->
compileFunctionReturn(functionReturn, context);
- case TypedValNode val ->
- compileVal(val, context);
-
- case TypedVarNode var ->
- compileVar(var, context);
-
case TypedWhileNode while_ ->
compileWhile(while_, context);
};
@@ -340,11 +332,11 @@ public class StackCompiler {
public static Context compileNamespaceStatement(TypedNamespaceStatementNode node, Context context) {
return switch (node) {
+ case TypedAssignNode assign ->
+ compileAssign(assign, context);
+
case TypedFunctionDefinitionNode functionDefinition ->
compileFunctionDefinition(functionDefinition, context);
-
- case TypedValNode val ->
- compileVal(val, context);
};
}
@@ -374,40 +366,45 @@ public class StackCompiler {
private static Context compileTarget(
TypedTargetNode target,
- BiFunction<String, Source, Instruction> store,
Context context
) {
return switch (target) {
- case TypedTargetNode.Variable variable -> {
+ case TypedTargetNode.Reassign reassign -> {
context = context.addInstruction(
- store.apply(
- context.shedVariableToLocal(variable.name()),
- variable.source()
+ new VarStoreInstruction(
+ context.shedVariableToLocal(reassign.name()),
+ reassign.source()
)
);
yield context;
}
- };
- }
- private static Context compileVal(TypedValNode val, Context context) {
- context = compileExpression(val.expression(), context);
- context = compileTarget(val.target(), LocalStoreInstruction::new, context);
- return context;
- }
+ case TypedTargetNode.Val val -> {
+ context = context.addInstruction(
+ new LocalStoreInstruction(
+ context.shedVariableToLocal(val.name()),
+ val.source()
+ )
+ );
- private static Context compileVar(TypedVarNode var, Context context) {
- context = compileExpression(var.expression(), context);
- context = compileTarget(var.target(), VarStoreInstruction::new, context);
+ yield context;
+ }
- // TODO: better to store this information in the block node with the bound variables?
- switch (var.target()) {
- case TypedTargetNode.Variable variable ->
- context = context.markShedVariableAsVar(variable.name());
- }
+ case TypedTargetNode.Var var -> {
+ context = context.addInstruction(
+ new VarStoreInstruction(
+ context.shedVariableToLocal(var.name()),
+ var.source()
+ )
+ );
- return context;
+ // TODO: better to store this information in the block node with the bound variables?
+ context = context.markShedVariableAsVar(var.name());
+
+ yield context;
+ }
+ };
}
private static Context compileWhile(TypedWhileNode node, Context context) {
diff --git a/src/main/java/org/shedlang/compiler/typechecker/DeclaredVariables.java b/src/main/java/org/shedlang/compiler/typechecker/DeclaredVariables.java
index 485aa8fa..87823b46 100644
--- a/src/main/java/org/shedlang/compiler/typechecker/DeclaredVariables.java
+++ b/src/main/java/org/shedlang/compiler/typechecker/DeclaredVariables.java
@@ -6,6 +6,13 @@ import org.shedlang.compiler.ast.untyped.*;
import java.util.List;
class DeclaredVariables {
+ static PVector<DeclaredVariable> forAssign(
+ UntypedAssignNode statement,
+ PVector<DeclaredVariable> variables
+ ) {
+ return forTarget(statement.target(), variables);
+ }
+
static PVector<DeclaredVariable> forFunctionStatements(
List<UntypedFunctionStatementNode> statements,
PVector<DeclaredVariable> variables
@@ -23,7 +30,7 @@ class DeclaredVariables {
) {
return switch (statement) {
case UntypedAssignNode assign ->
- variables;
+ forAssign(assign, variables);
case UntypedBlockReturnNode blockReturn ->
variables;
@@ -34,12 +41,6 @@ class DeclaredVariables {
case UntypedFunctionReturnNode functionReturn ->
variables;
- case UntypedValNode val ->
- forVal(val, variables);
-
- case UntypedVarNode var ->
- forVar(var, variables);
-
case UntypedWhileNode while_ ->
variables;
};
@@ -61,43 +62,38 @@ class DeclaredVariables {
PVector<DeclaredVariable> variables
) {
return switch (statement) {
+ case UntypedAssignNode assign ->
+ forAssign(assign, variables);
+
case UntypedFunctionDefinitionNode functionDefinition ->
variables.plus(new DeclaredVariable(
functionDefinition.name(),
VariableType.CONSTANT,
functionDefinition.source()
));
-
- case UntypedValNode val ->
- forVal(val, variables);
};
}
- static PVector<DeclaredVariable> forVal(
- UntypedValNode statement,
- PVector<DeclaredVariable> variables
- ) {
- return forTarget(statement.target(), VariableType.VAL, variables);
- }
-
- static PVector<DeclaredVariable> forVar(
- UntypedVarNode statement,
- PVector<DeclaredVariable> variables
- ) {
- return forTarget(statement.target(), VariableType.VAR, variables);
- }
-
private static PVector<DeclaredVariable> forTarget(
UntypedTargetNode target,
- VariableType variableType,
PVector<DeclaredVariable> variables
) {
return switch (target) {
- case UntypedTargetNode.Variable variable ->
+ case UntypedTargetNode.Reassign reassign ->
+ variables;
+
+ case UntypedTargetNode.Var var ->
+ variables.plus(new DeclaredVariable(
+ var.name(),
+ VariableType.VAR,
+ var.source()
+ ));
+
+ case UntypedTargetNode.Val val ->
variables.plus(new DeclaredVariable(
- variable.name(),
- variableType,
- variable.source()
+ val.name(),
+ VariableType.VAL,
+ val.source()
));
};
}
diff --git a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
index 5302ee6c..5db00b44 100644
--- a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
+++ b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
@@ -125,6 +125,17 @@ public class TypeChecker {
return context.toResult(new TypedArgsNode(typedPositionalArgs, typedNamedArgs, args.source()));
}
+ private static TypeCheckSteps<TypedAssignNode> typeCheckStepsAssign(
+ UntypedAssignNode untyped
+ ) {
+ return new TypeCheckSteps<>() {
+ @Override
+ public TypeCheckerResult<TypedAssignNode> define(TypeCheckerContext context) {
+ return typeCheckAssign(untyped, context);
+ }
+ };
+ }
+
private static TypeCheckerResult<TypedAssignNode> typeCheckAssign(
UntypedAssignNode untyped,
TypeCheckerContext context
@@ -136,7 +147,6 @@ public class TypeChecker {
var targetResult = typeCheckTarget(
untyped.target(),
expression.type(),
- Optional.empty(),
context
);
var target = targetResult.value();
@@ -376,7 +386,7 @@ public class TypeChecker {
});
}
- private static TypeCheckSteps<TypedFunctionDefinitionNode> typeCheckFunctionDefinition(
+ private static TypeCheckSteps<TypedFunctionDefinitionNode> typeCheckStepsFunctionDefinition(
UntypedFunctionDefinitionNode untyped
) {
return new TypeCheckSteps<TypedFunctionDefinitionNode>() {
@@ -553,12 +563,6 @@ public class TypeChecker {
case UntypedFunctionReturnNode functionReturn ->
typeCheckFunctionReturn(functionReturn, context);
- case UntypedValNode val ->
- typeCheckVal(val).typeCheckAllPhases(context);
-
- case UntypedVarNode var ->
- typeCheckVar(var, context);
-
case UntypedWhileNode while_ ->
typeCheckWhile(while_, context);
};
@@ -656,15 +660,16 @@ public class TypeChecker {
.collect(Collectors.toSet());
switch (untypedStatement) {
- case UntypedFunctionDefinitionNode untypedFunctionDefinition -> {
- dependencyChecker = dependencyChecker.addDeferredDependencies(
- untypedFunctionDefinition.name(),
+ case UntypedAssignNode untypedAssign -> {
+ // TODO: prevent var/assign at top-level (or just prevent capture, which we need to do anyway?)
+ dependencyChecker = dependencyChecker.addImmediateDependencies(
+ DeclaredVariables.forAssign(untypedAssign, P.vector()),
dependencies
);
}
- case UntypedValNode untypedVal -> {
- dependencyChecker = dependencyChecker.addImmediateDependencies(
- DeclaredVariables.forVal(untypedVal, P.vector()),
+ case UntypedFunctionDefinitionNode untypedFunctionDefinition -> {
+ dependencyChecker = dependencyChecker.addDeferredDependencies(
+ untypedFunctionDefinition.name(),
dependencies
);
}
@@ -705,11 +710,11 @@ public class TypeChecker {
UntypedNamespaceStatementNode untyped
) {
return switch (untyped) {
- case UntypedFunctionDefinitionNode functionDefinition ->
- typeCheckFunctionDefinition(functionDefinition);
+ case UntypedAssignNode assign ->
+ typeCheckStepsAssign(assign);
- case UntypedValNode val ->
- typeCheckVal(val);
+ case UntypedFunctionDefinitionNode functionDefinition ->
+ typeCheckStepsFunctionDefinition(functionDefinition);
};
}
@@ -795,93 +800,53 @@ public class TypeChecker {
);
}
- private static TypeCheckSteps<TypedValNode> typeCheckVal(
- UntypedValNode untyped
- ) {
- return new TypeCheckSteps<>() {
- @Override
- public TypeCheckerResult<TypedValNode> define(TypeCheckerContext context) {
- return defineVal(untyped, context);
- }
- };
- }
-
- private static TypeCheckerResult<TypedValNode> defineVal(
- UntypedValNode untyped,
- TypeCheckerContext context
- ) {
- var expressionResult = typeCheckExpression(untyped.expression(), context);
- var expression = expressionResult.value();
- context = expressionResult.context();
-
- var targetResult = typeCheckTarget(
- untyped.target(),
- expression.type(),
- Optional.of(VariableType.VAL),
- context
- );
- var target = targetResult.value();
- context = targetResult.context();
-
- return context.toResult(new TypedValNode(target, expression, untyped.source()));
- }
-
- private static TypeCheckerResult<TypedVarNode> typeCheckVar(
- UntypedVarNode untyped,
- TypeCheckerContext context
- ) {
- var expressionResult = typeCheckExpression(untyped.expression(), context);
- var expression = expressionResult.value();
- context = expressionResult.context();
-
- var targetResult = typeCheckTarget(
- untyped.target(),
- expression.type(),
- Optional.of(VariableType.VAR),
- context
- );
- var target = targetResult.value();
- context = targetResult.context();
-
- return context.toResult(new TypedVarNode(target, expression, untyped.source()));
- }
-
private static TypeCheckerResult<TypedTargetNode> typeCheckTarget(
UntypedTargetNode target,
Type expressionType,
- Optional<VariableType> variableType,
TypeCheckerContext context
) {
return switch (target) {
- case UntypedTargetNode.Variable variable -> {
- if (variableType.isEmpty()) {
- var targetVariableResult = runtimeLookup(
- variable.name(),
- variable.source(),
- context
- );
- var targetVariable = targetVariableResult.value();
- context = targetVariableResult.context();
-
- if (targetVariable.variableType() != VariableType.VAR) {
- throw new CanOnlyAssignToVarError(target.source());
- }
-
- checkIsSubType(
- expressionType,
- targetVariable.type().orElseThrow(),
- target.source(),
- context
- );
- } else {
- context = context.define(
- variable.name(),
- expressionType,
- target.source()
- );
+ case UntypedTargetNode.Reassign reassign -> {
+ var targetVariableResult = runtimeLookup(
+ reassign.name(),
+ reassign.source(),
+ context
+ );
+ var targetVariable = targetVariableResult.value();
+ context = targetVariableResult.context();
+
+ if (targetVariable.variableType() != VariableType.VAR) {
+ throw new CanOnlyAssignToVarError(target.source());
}
- yield context.toResult(new TypedTargetNode.Variable(variable.name(), target.source()));
+ checkIsSubType(
+ expressionType,
+ targetVariable.type().orElseThrow(),
+ target.source(),
+ context
+ );
+
+ yield context.toResult(new TypedTargetNode.Reassign(reassign.name(), target.source()));
+ }
+
+ case UntypedTargetNode.Val val -> {
+ context = context.define(
+ val.name(),
+ expressionType,
+ target.source()
+ );
+
+ yield context.toResult(new TypedTargetNode.Val(val.name(), target.source()));
+ }
+
+ case UntypedTargetNode.Var var -> {
+ context = context.define(
+ var.name(),
+ expressionType,
+ target.source()
+ );
+
+ yield context.toResult(new TypedTargetNode.Var(var.name(), target.source()));
}
};
}
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))
)))
);