From 2ee062f9f6024dedc9ae5928b0aa967c7c5a56c4 Mon Sep 17 00:00:00 2001
From: Nirhar <hmanishkausik@gmail.com>
Date: Fri, 7 Jun 2024 13:06:47 +0530
Subject: [PATCH] Evaluate Comparison Expressions with Constant Operands during
 Compilation

This patch supports evaluation of comparison expressions with
constants as operands during compile time.

Fixes #755
---
 src/sema/eval.rs | 144 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 144 insertions(+)

diff --git a/src/sema/eval.rs b/src/sema/eval.rs
index f5568076b..2c5e55e53 100644
--- a/src/sema/eval.rs
+++ b/src/sema/eval.rs
@@ -729,6 +729,150 @@ pub(crate) fn eval_constants_in_expression(
                 (None, true)
             }
         }
+        Expression::More {
+            loc,
+            left,
+            right,
+        } => {
+            let left = eval_constants_in_expression(left, diagnostics).0;
+            let right = eval_constants_in_expression(right, diagnostics).0;
+
+            if let (
+                Some(Expression::NumberLiteral { value: left, .. }),
+                Some(Expression::NumberLiteral { value: right, .. }),
+            ) = (&left, &right)
+            {
+                (
+                    Some(Expression::BoolLiteral { 
+                        loc: *loc,
+                        value: (left.cmp(right) == core::cmp::Ordering::Greater) 
+                    }),
+                    true,
+                )
+            } else {
+                (None, true)
+            }
+        }
+        Expression::Less {
+            loc,
+            left,
+            right,
+        } => {
+            let left = eval_constants_in_expression(left, diagnostics).0;
+            let right = eval_constants_in_expression(right, diagnostics).0;
+
+            if let (
+                Some(Expression::NumberLiteral { value: left, .. }),
+                Some(Expression::NumberLiteral { value: right, .. }),
+            ) = (&left, &right)
+            {
+                (
+                    Some(Expression::BoolLiteral { 
+                        loc: *loc,
+                        value: (left.cmp(right) == core::cmp::Ordering::Less) 
+                    }),
+                    true,
+                )
+            } else {
+                (None, true)
+            }
+        }
+        Expression::Equal {
+            loc,
+            left,
+            right,
+        } => {
+            let left = eval_constants_in_expression(left, diagnostics).0;
+            let right = eval_constants_in_expression(right, diagnostics).0;
+
+            if let (
+                Some(Expression::NumberLiteral { value: left, .. }),
+                Some(Expression::NumberLiteral { value: right, .. }),
+            ) = (&left, &right)
+            {
+                (
+                    Some(Expression::BoolLiteral { 
+                        loc: *loc,
+                        value: (left.cmp(right) == core::cmp::Ordering::Equal) 
+                    }),
+                    true,
+                )
+            } else {
+                (None, true)
+            }
+        }
+        Expression::NotEqual {
+            loc,
+            left,
+            right,
+        } => {
+            let left = eval_constants_in_expression(left, diagnostics).0;
+            let right = eval_constants_in_expression(right, diagnostics).0;
+
+            if let (
+                Some(Expression::NumberLiteral { value: left, .. }),
+                Some(Expression::NumberLiteral { value: right, .. }),
+            ) = (&left, &right)
+            {
+                (
+                    Some(Expression::BoolLiteral { 
+                        loc: *loc,
+                        value: (left.cmp(right) != core::cmp::Ordering::Equal) 
+                    }),
+                    true,
+                )
+            } else {
+                (None, true)
+            }
+        }
+        Expression::MoreEqual {
+            loc,
+            left,
+            right,
+        } => {
+            let left = eval_constants_in_expression(left, diagnostics).0;
+            let right = eval_constants_in_expression(right, diagnostics).0;
+
+            if let (
+                Some(Expression::NumberLiteral { value: left, .. }),
+                Some(Expression::NumberLiteral { value: right, .. }),
+            ) = (&left, &right)
+            {
+                (
+                    Some(Expression::BoolLiteral { 
+                        loc: *loc,
+                        value: (left.cmp(right) == core::cmp::Ordering::Greater && left.cmp(right) == core::cmp::Ordering::Equal) 
+                    }),
+                    true,
+                )
+            } else {
+                (None, true)
+            }
+        }
+        Expression::LessEqual {
+            loc,
+            left,
+            right,
+        } => {
+            let left = eval_constants_in_expression(left, diagnostics).0;
+            let right = eval_constants_in_expression(right, diagnostics).0;
+
+            if let (
+                Some(Expression::NumberLiteral { value: left, .. }),
+                Some(Expression::NumberLiteral { value: right, .. }),
+            ) = (&left, &right)
+            {
+                (
+                    Some(Expression::BoolLiteral { 
+                        loc: *loc,
+                        value: (left.cmp(right) == core::cmp::Ordering::Less && left.cmp(right) == core::cmp::Ordering::Equal) 
+                    }),
+                    true,
+                )
+            } else {
+                (None, true)
+            }
+        }
         Expression::ZeroExt { loc, to, expr } => {
             let expr = eval_constants_in_expression(expr, diagnostics).0;
             if let Some(Expression::NumberLiteral { value, .. }) = expr {