From 7367e30043ab9de09fafdb72e5fab6bac4debb9a Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Fri, 28 Jul 2023 22:30:40 +0100 Subject: Type check assignments --- .../compiler/ast/typed/TypedAssignNode.java | 14 ++++ .../ast/typed/TypedFunctionStatementNode.java | 2 +- .../shedlang/compiler/stackir/StackCompiler.java | 3 + .../shedlang/compiler/typechecker/TypeChecker.java | 74 ++++++++++++++++++-- .../compiler/ast/typed/TypedNodeMatchers.java | 11 +++ .../org/shedlang/compiler/ast/untyped/Untyped.java | 7 ++ .../typechecker/TypeCheckerAssignTests.java | 78 ++++++++++++++++++++++ 7 files changed, 181 insertions(+), 8 deletions(-) create mode 100644 src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java create mode 100644 src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java (limited to 'src') diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java new file mode 100644 index 00000000..24bc4532 --- /dev/null +++ b/src/main/java/org/shedlang/compiler/ast/typed/TypedAssignNode.java @@ -0,0 +1,14 @@ +package org.shedlang.compiler.ast.typed; + +import org.shedlang.compiler.sources.Source; + +public record TypedAssignNode( + 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/typed/TypedFunctionStatementNode.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedFunctionStatementNode.java index b1fcd49b..843d8c3e 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 TypedBlockReturnNode, TypedExpressionStatementNode, TypedFunctionReturnNode, TypedValNode, TypedVarNode { +public sealed interface TypedFunctionStatementNode extends TypedNode permits TypedAssignNode, TypedBlockReturnNode, TypedExpressionStatementNode, TypedFunctionReturnNode, TypedValNode, TypedVarNode { TypedFunctionStatementBehaviour behaviour(); } diff --git a/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java b/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java index 2be8480d..8863253c 100644 --- a/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java +++ b/src/main/java/org/shedlang/compiler/stackir/StackCompiler.java @@ -201,6 +201,9 @@ public class StackCompiler { Context context ) { return switch (node) { + case TypedAssignNode assign -> + throw new UnsupportedOperationException(); + case TypedBlockReturnNode blockReturn -> compileBlockReturn(blockReturn, context); diff --git a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java index 8cf38fc1..ee35fa1f 100644 --- a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java +++ b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java @@ -20,11 +20,15 @@ public class TypeChecker { } private static void checkExpressionType(TypedExpressionNode expression, Type expectedType, TypeCheckerContext context) { - if (!isSubType(expression.type(), expectedType, context)) { + checkIsSubType(expression.type(), expectedType, expression.source(), context); + } + + private static void checkIsSubType(Type actualType, Type expectedType, Source source, TypeCheckerContext context) { + if (!isSubType(actualType, expectedType, context)) { throw new UnexpectedTypeError( TypeSets.type(expectedType), - expression.type(), - expression.source() + actualType, + source ); } } @@ -129,6 +133,26 @@ public class TypeChecker { return context.toResult(new TypedArgsNode(typedPositionalArgs, typedNamedArgs, args.source())); } + private static TypeCheckerResult typeCheckAssign( + UntypedAssignNode untyped, + TypeCheckerContext context + ) { + var expressionResult = typeCheckExpression(untyped.expression(), context); + var expression = expressionResult.value(); + context = expressionResult.context(); + + var targetResult = typeCheckTarget( + untyped.target(), + expression.type(), + TargetType.ASSIGN, + context + ); + var target = targetResult.value(); + context = targetResult.context(); + + return context.toResult(new TypedAssignNode(target, expression, untyped.source())); + } + private static TypeCheckerResult typeCheckBinaryOperation( UntypedBinaryOperationNode untyped, TypeCheckerContext context @@ -526,7 +550,7 @@ public class TypeChecker { ) { return switch (untyped) { case UntypedAssignNode assign -> - throw new UnsupportedOperationException(); + typeCheckAssign(assign, context); case UntypedBlockReturnNode blockReturn -> typeCheckBlockReturn(blockReturn, context); @@ -795,7 +819,12 @@ public class TypeChecker { var expression = expressionResult.value(); context = expressionResult.context(); - var targetResult = typeCheckTarget(untyped.target(), expression.type(), context); + var targetResult = typeCheckTarget( + untyped.target(), + expression.type(), + TargetType.DEFINE, + context + ); var target = targetResult.value(); context = targetResult.context(); @@ -810,7 +839,12 @@ public class TypeChecker { var expression = expressionResult.value(); context = expressionResult.context(); - var targetResult = typeCheckTarget(untyped.target(), expression.type(), context); + var targetResult = typeCheckTarget( + untyped.target(), + expression.type(), + TargetType.DEFINE, + context + ); var target = targetResult.value(); context = targetResult.context(); @@ -820,14 +854,40 @@ public class TypeChecker { private static TypeCheckerResult typeCheckTarget( UntypedTargetNode target, Type expressionType, + TargetType targetType, TypeCheckerContext context ) { return switch (target) { case UntypedTargetNode.Variable variable -> { - context = context.define(variable.name(), expressionType, target.source()); + switch (targetType) { + case ASSIGN -> { + var variableTypeResult = runtimeLookup( + variable.name(), + variable.source(), + context + ); + var variableType = variableTypeResult.value(); + context = variableTypeResult.context(); + + checkIsSubType( + expressionType, + variableType, + target.source(), + context + ); + } + case DEFINE -> { + context = context.define(variable.name(), expressionType, target.source()); + } + } yield context.toResult(new TypedTargetNode.Variable(variable.name(), target.source())); } }; } + + private enum TargetType { + ASSIGN, + DEFINE, + } } 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 ef2e4686..9ee8c8fa 100644 --- a/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java +++ b/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java @@ -16,6 +16,17 @@ public class TypedNodeMatchers { return TypedArgsNodeMatcher.empty(); } + public static Matcher isTypedAssignNode( + Matcher target, + Matcher expression + ) { + return instanceOf( + TypedAssignNode.class, + has("target", x -> x.target(), target), + has("expression", x -> x.expression(), expression) + ); + } + public static Matcher isTypedBinaryOperationNode( TypedBinaryOperator operator, Matcher left, 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 141212cc..1fe48649 100644 --- a/src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java +++ b/src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java @@ -22,6 +22,13 @@ public class Untyped { ); } + public static UntypedAssignNode assign( + UntypedTargetNode target, + UntypedExpressionNode expression + ) { + return new UntypedAssignNode(target, expression, Sources.NULL); + } + public static UntypedBlockNode block(List statements) { return new UntypedBlockNode(statements, Sources.NULL); } diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java new file mode 100644 index 00000000..21ebfbc3 --- /dev/null +++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerAssignTests.java @@ -0,0 +1,78 @@ +package org.shedlang.compiler.typechecker; + +import org.junit.jupiter.api.Test; +import org.shedlang.compiler.ast.typed.TypedFunctionStatementNode; +import org.shedlang.compiler.ast.typed.TypedNamespaceStatementNode; +import org.shedlang.compiler.ast.untyped.Untyped; +import org.shedlang.compiler.ast.untyped.UntypedFunctionStatementNode; +import org.shedlang.compiler.ast.untyped.UntypedNamespaceStatementNode; +import org.shedlang.compiler.typechecker.errors.UnexpectedTypeError; +import org.shedlang.compiler.typechecker.typesets.TypeSets; +import org.shedlang.compiler.types.Types; +import org.shedlang.compiler.util.P; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.shedlang.compiler.ast.typed.TypedNodeMatchers.*; +import static org.zwobble.precisely.AssertThat.assertThat; +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 context = TypeCheckerContext.EMPTY + .enterNamespace(P.map( + Map.entry("x", TypeCheckerContext.defined(Types.STRING)) + )); + + var typed = typeCheckFunctionStatement(untyped, context); + + assertThat(typed.value(), isTypedAssignNode( + isTypedTargetVariable("x"), + isTypedStringLiteralNode("hello") + )); + } + + @Test + public void whenExpressionIsNotSubTypeOfTargetVariableThenErrorIsThrown() { + var untyped = Untyped.assign(Untyped.targetVariable("x"), Untyped.stringLiteral("hello")); + var context = TypeCheckerContext.EMPTY + .enterNamespace(P.map( + Map.entry("x", TypeCheckerContext.defined(Types.INT)) + )); + + var error = assertThrows( + UnexpectedTypeError.class, + () -> typeCheckFunctionStatement(untyped, context) + ); + + assertThat(error.expected(), equalTo(TypeSets.type(Types.INT))); + assertThat(error.actual(), equalTo(Types.STRING)); + } + + private static TypeCheckerResult typeCheckFunctionStatement( + UntypedFunctionStatementNode untyped, + TypeCheckerContext context + ) { + var declaredVariables = DeclaredVariables.forFunctionStatement(untyped, P.vector()); + var environment = EnvironmentBuilder.EMPTY.addUndefined(declaredVariables); + + context = context.enterNamespace(environment.build()); + + return TypeChecker.typeCheckFunctionStatement(untyped, context); + } + + private static TypeCheckerResult typeCheckNamespaceStatement( + UntypedNamespaceStatementNode untyped, + TypeCheckerContext context + ) { + var declaredVariables = DeclaredVariables.forNamespaceStatement(untyped, P.vector()); + var environment = EnvironmentBuilder.EMPTY.addUndefined(declaredVariables); + + context = context.enterNamespace(environment.build()); + + return TypeChecker.typeCheckNamespaceStatement(untyped).typeCheckAllPhases(context); + } +} -- cgit v1.2.3