diff options
| author | Michael Williamson <mike@zwobble.org> | 2023-09-16 16:35:38 +0100 |
|---|---|---|
| committer | Michael Williamson <mike@zwobble.org> | 2023-09-16 16:35:38 +0100 |
| commit | 02bd64dfdbfa8134cb93165ee606817b2e6737b5 (patch) | |
| tree | 9a2e463a79150fc90a1481b768c89b2158481dfc /src | |
| parent | 904f02af5e2965f73b037e4b3c5d97f57af81987 (diff) | |
Combine assign, val and var statements
Diffstat (limited to 'src')
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)) ))) ); |
