fixed #190

Author: TomWambsgans

crates/lean_compiler/src/a_simplify_lang.rs

@@ -2406,6 +2406,11 @@ fn simplify_lines(
                                             let result = ConstExpression::MathExpr(*operation, const_args);
                                             res.push(SimpleLine::equality(target_var, SimpleExpr::Constant(result)));
                                         } else {
+                                            if !operation.supports_runtime() {
+                                                return Err(format!(
+                                                    "Operation `{operation}` is compile-time only; all operands must be constants"
+                                                ));
+                                            }
                                             res.push(SimpleLine::Assignment {
                                                 var: target_var.into(),
                                                 operation: *operation,
@@ -2449,6 +2454,11 @@ fn simplify_lines(
                                         let result = ConstExpression::MathExpr(*operation, const_args);
                                         res.push(SimpleLine::equality(var, SimpleExpr::Constant(result)));
                                     } else {
+                                        if !operation.supports_runtime() {
+                                            return Err(format!(
+                                                "Operation `{operation}` is compile-time only; all operands must be constants"
+                                            ));
+                                        }
                                         assert_eq!(simplified_args.len(), 2);
                                         res.push(SimpleLine::Assignment {
                                             var,
@@ -3062,6 +3072,11 @@ fn simplify_expr(
             if let Some(const_args) = SimpleExpr::try_vec_as_constant(&simplified_args) {
                 return Ok(SimpleExpr::Constant(ConstExpression::MathExpr(*operation, const_args)));
             }
+            if !operation.supports_runtime() {
+                return Err(format!(
+                    "Operation `{operation}` is compile-time only; all operands must be constants"
+                ));
+            }
             let aux_var = state.counters.aux_var();
             assert_eq!(simplified_args.len(), 2);
             lines.push(SimpleLine::Assignment {

crates/lean_compiler/src/lang.rs

@@ -359,6 +359,9 @@ impl MathOperation {
     pub fn is_unary(&self) -> bool {
         self.num_args() == 1
     }
+    pub const fn supports_runtime(&self) -> bool {
+        matches!(self, Self::Add | Self::Sub | Self::Mul | Self::Div)
+    }
     pub fn num_args(&self) -> usize {
         match self {
             Self::Log2Ceil => 1,

crates/lean_compiler/tests/test_data/error_54.py

@@ -0,0 +1,9 @@
+# Error: `%` is compile-time only; operands must be constants.
+def main():
+    a = one()
+    out = a % 2
+    assert out == 1
+    return
+
+def one():
+    return 1

crates/lean_compiler/tests/test_data/error_56.py

@@ -0,0 +1,9 @@
+# Error: unary `log2_ceil` is compile-time only; operand must be a constant.
+def main():
+    a = one()
+    out = log2_ceil(a)
+    assert out == 0
+    return
+
+def one():
+    return 1

crates/lean_compiler/tests/test_data/error_61.py

@@ -0,0 +1,10 @@
+# Error: `%` is compile-time only; operands must be constants (array assignment path).
+def main():
+    a = one()
+    arr = Array(1)
+    arr[0] = a % 2
+    assert arr[0] == 1
+    return
+
+def one():
+    return 1