From 037fd3fee47b0fd94e8f7a3cff25ab7578a6e5da Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Sun, 2 Feb 2025 18:48:30 +0000 Subject: Type check relational operations for integers --- .../compiler/ast/typed/TypedBinaryOperator.java | 4 ++ .../org/shedlang/compiler/shid/ShidCodeGen.java | 2 + .../shedlang/compiler/typechecker/TypeChecker.java | 8 ++-- .../compiler/ast/typed/TypedNodeMatchers.java | 28 ++++++++++++ .../org/shedlang/compiler/ast/untyped/Untyped.java | 48 ++++++++++++++++++++ .../TypeCheckerBinaryOperationTests.java | 53 +++++++++++++++++++++- 6 files changed, 138 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/main/java/org/shedlang/compiler/ast/typed/TypedBinaryOperator.java b/src/main/java/org/shedlang/compiler/ast/typed/TypedBinaryOperator.java index 2f2e5929..d1f32073 100644 --- a/src/main/java/org/shedlang/compiler/ast/typed/TypedBinaryOperator.java +++ b/src/main/java/org/shedlang/compiler/ast/typed/TypedBinaryOperator.java @@ -6,6 +6,10 @@ import org.shedlang.compiler.types.Types; public enum TypedBinaryOperator { INT_ADD(Types.INT), INT_EQUALS(Types.BOOL), + INT_GREATER_THAN(Types.BOOL), + INT_GREATER_THAN_OR_EQUAL(Types.BOOL), + INT_LESS_THAN(Types.BOOL), + INT_LESS_THAN_OR_EQUAL(Types.BOOL), INT_NOT_EQUAL(Types.BOOL), INT_SUB(Types.INT), STRING_ADD(Types.STRING); diff --git a/src/main/java/org/shedlang/compiler/shid/ShidCodeGen.java b/src/main/java/org/shedlang/compiler/shid/ShidCodeGen.java index 350ed118..1d7c94b6 100644 --- a/src/main/java/org/shedlang/compiler/shid/ShidCodeGen.java +++ b/src/main/java/org/shedlang/compiler/shid/ShidCodeGen.java @@ -45,6 +45,8 @@ public class ShidCodeGen { new ShidIntSub(node.source()); case STRING_ADD -> new ShidStringAdd(node.source()); + default -> + throw new UnsupportedOperationException("TODO"); }); return context; diff --git a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java index db249c0d..d4b52aa4 100644 --- a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java +++ b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java @@ -239,16 +239,16 @@ public class TypeChecker { TypedBinaryOperator.INT_EQUALS; case GREATER_THAN -> - throw new UnsupportedOperationException("TODO"); + TypedBinaryOperator.INT_GREATER_THAN; case GREATER_THAN_OR_EQUAL -> - throw new UnsupportedOperationException("TODO"); + TypedBinaryOperator.INT_GREATER_THAN_OR_EQUAL; case LESS_THAN -> - throw new UnsupportedOperationException("TODO"); + TypedBinaryOperator.INT_LESS_THAN; case LESS_THAN_OR_EQUAL -> - throw new UnsupportedOperationException("TODO"); + TypedBinaryOperator.INT_LESS_THAN_OR_EQUAL; case NOT_EQUAL -> TypedBinaryOperator.INT_NOT_EQUAL; 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 902ba59d..6f8ffdb1 100644 --- a/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java +++ b/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java @@ -205,6 +205,34 @@ public class TypedNodeMatchers { return isTypedBinaryOperationNode(TypedBinaryOperator.INT_EQUALS, left, right); } + public static Matcher isTypedIntGreaterThanNode( + Matcher left, + Matcher right + ) { + return isTypedBinaryOperationNode(TypedBinaryOperator.INT_GREATER_THAN, left, right); + } + + public static Matcher isTypedIntGreaterThanOrEqualNode( + Matcher left, + Matcher right + ) { + return isTypedBinaryOperationNode(TypedBinaryOperator.INT_GREATER_THAN_OR_EQUAL, left, right); + } + + public static Matcher isTypedIntLessThanNode( + Matcher left, + Matcher right + ) { + return isTypedBinaryOperationNode(TypedBinaryOperator.INT_LESS_THAN, left, right); + } + + public static Matcher isTypedIntLessThanOrEqualNode( + Matcher left, + Matcher right + ) { + return isTypedBinaryOperationNode(TypedBinaryOperator.INT_LESS_THAN_OR_EQUAL, left, right); + } + public static Matcher isTypedIntLiteralNode(int value) { return isTypedIntLiteralNode(BigInteger.valueOf(value)); } 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 58b061cb..0ecf4719 100644 --- a/src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java +++ b/src/test/java/org/shedlang/compiler/ast/untyped/Untyped.java @@ -116,6 +116,30 @@ public class Untyped { return new UntypedFunctionReturnNode(expression, Sources.NULL); } + public static UntypedExpressionNode greaterThan( + UntypedExpressionNode left, + UntypedExpressionNode right + ) { + return new UntypedBinaryOperationNode( + UntypedBinaryOperator.GREATER_THAN, + left, + right, + Sources.NULL + ); + } + + public static UntypedExpressionNode greaterThanOrEqual( + UntypedExpressionNode left, + UntypedExpressionNode right + ) { + return new UntypedBinaryOperationNode( + UntypedBinaryOperator.GREATER_THAN_OR_EQUAL, + left, + right, + Sources.NULL + ); + } + public static UntypedIfNode if_( List conditionalBranches, UntypedBlockNode elseBody @@ -135,6 +159,30 @@ public class Untyped { return new UntypedIntLiteralNode(value, Sources.NULL); } + public static UntypedExpressionNode lessThan( + UntypedExpressionNode left, + UntypedExpressionNode right + ) { + return new UntypedBinaryOperationNode( + UntypedBinaryOperator.LESS_THAN, + left, + right, + Sources.NULL + ); + } + + public static UntypedExpressionNode lessThanOrEqual( + UntypedExpressionNode left, + UntypedExpressionNode right + ) { + return new UntypedBinaryOperationNode( + UntypedBinaryOperator.LESS_THAN_OR_EQUAL, + left, + right, + Sources.NULL + ); + } + public static UntypedExpressionNode memberAccess( UntypedExpressionNode receiver, String memberName diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerBinaryOperationTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerBinaryOperationTests.java index b5546188..cdf5bca1 100644 --- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerBinaryOperationTests.java +++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerBinaryOperationTests.java @@ -39,6 +39,58 @@ public class TypeCheckerBinaryOperationTests { assertThat(typed.value().type(), equalTo(Types.BOOL)); } + @Test + public void whenBothOperandsAreIntsAndOperatorIsLessThenIsTypedAsIntLessThan() { + var untyped = Untyped.greaterThan(Untyped.intLiteral(42), Untyped.intLiteral(47)); + + var typed = typeCheckExpression(untyped, TypeCheckerContext.EMPTY); + + assertThat(typed.value(), isTypedIntGreaterThanNode( + isTypedIntLiteralNode(42), + isTypedIntLiteralNode(47) + )); + assertThat(typed.value().type(), equalTo(Types.BOOL)); + } + + @Test + public void whenBothOperandsAreIntsAndOperatorIsGreaterThenOrEqualIsTypedAsIntGreaterThanOrEqual() { + var untyped = Untyped.greaterThanOrEqual(Untyped.intLiteral(42), Untyped.intLiteral(47)); + + var typed = typeCheckExpression(untyped, TypeCheckerContext.EMPTY); + + assertThat(typed.value(), isTypedIntGreaterThanOrEqualNode( + isTypedIntLiteralNode(42), + isTypedIntLiteralNode(47) + )); + assertThat(typed.value().type(), equalTo(Types.BOOL)); + } + + @Test + public void whenBothOperandsAreIntsAndOperatorIsGreaterThenIsTypedAsIntGreaterThan() { + var untyped = Untyped.lessThan(Untyped.intLiteral(42), Untyped.intLiteral(47)); + + var typed = typeCheckExpression(untyped, TypeCheckerContext.EMPTY); + + assertThat(typed.value(), isTypedIntLessThanNode( + isTypedIntLiteralNode(42), + isTypedIntLiteralNode(47) + )); + assertThat(typed.value().type(), equalTo(Types.BOOL)); + } + + @Test + public void whenBothOperandsAreIntsAndOperatorIsLessThenOrEqualIsTypedAsIntLessThanOrEqual() { + var untyped = Untyped.lessThanOrEqual(Untyped.intLiteral(42), Untyped.intLiteral(47)); + + var typed = typeCheckExpression(untyped, TypeCheckerContext.EMPTY); + + assertThat(typed.value(), isTypedIntLessThanOrEqualNode( + isTypedIntLiteralNode(42), + isTypedIntLiteralNode(47) + )); + assertThat(typed.value().type(), equalTo(Types.BOOL)); + } + @Test public void whenBothOperandsAreIntsAndOperatorIsNotEqualThenIsTypedAsIntNotEqual() { var untyped = Untyped.notEqual(Untyped.intLiteral(42), Untyped.intLiteral(47)); @@ -52,7 +104,6 @@ public class TypeCheckerBinaryOperationTests { assertThat(typed.value().type(), equalTo(Types.BOOL)); } - @Test public void whenBothOperandsAreIntsAndOperatorIsSubThenIsTypedAsIntSub() { var untyped = Untyped.sub(Untyped.intLiteral(42), Untyped.intLiteral(47)); -- cgit v1.2.3