From 037fd3fee47b0fd94e8f7a3cff25ab7578a6e5da Mon Sep 17 00:00:00 2001
From: Michael Williamson <mike@zwobble.org>
Date: Sun, 2 Feb 2025 18:48:30 +0000
Subject: Type check relational operations for integers

---
 .../compiler/ast/typed/TypedNodeMatchers.java      | 28 ++++++++++++
 .../org/shedlang/compiler/ast/untyped/Untyped.java | 48 ++++++++++++++++++++
 .../TypeCheckerBinaryOperationTests.java           | 53 +++++++++++++++++++++-
 3 files changed, 128 insertions(+), 1 deletion(-)

(limited to 'src/test/java')

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<TypedExpressionNode> isTypedIntGreaterThanNode(
+        Matcher<TypedExpressionNode> left,
+        Matcher<TypedExpressionNode> right
+    ) {
+        return isTypedBinaryOperationNode(TypedBinaryOperator.INT_GREATER_THAN, left, right);
+    }
+
+    public static Matcher<TypedExpressionNode> isTypedIntGreaterThanOrEqualNode(
+        Matcher<TypedExpressionNode> left,
+        Matcher<TypedExpressionNode> right
+    ) {
+        return isTypedBinaryOperationNode(TypedBinaryOperator.INT_GREATER_THAN_OR_EQUAL, left, right);
+    }
+
+    public static Matcher<TypedExpressionNode> isTypedIntLessThanNode(
+        Matcher<TypedExpressionNode> left,
+        Matcher<TypedExpressionNode> right
+    ) {
+        return isTypedBinaryOperationNode(TypedBinaryOperator.INT_LESS_THAN, left, right);
+    }
+
+    public static Matcher<TypedExpressionNode> isTypedIntLessThanOrEqualNode(
+        Matcher<TypedExpressionNode> left,
+        Matcher<TypedExpressionNode> right
+    ) {
+        return isTypedBinaryOperationNode(TypedBinaryOperator.INT_LESS_THAN_OR_EQUAL, left, right);
+    }
+
     public static Matcher<TypedExpressionNode> 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<UntypedConditionalBranchNode> 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