Parser Improvements for Expressions (#57)

* Update version number for pypi

* fix: Improve parser handling of parenthesized expressions and unary operations

- Fix parsing of basic parenthesized expressions like '2 * (3 + 4)'
- Add proper handling of unary minus operations
- Update grammar rules to maintain correct operator precedence
- Add comprehensive tests for expression evaluation

Key changes:
- Add LPAREN expression RPAREN to expression rule
- Simplify primary_expr rule and fix handling of parentheses
- Add dedicated uminus handling in evaluate_operation
- Add TestExpressionEvaluation class with test cases for:
  - Nested unary operations
  - Complex nested expressions
  - Parenthesized expressions
  - Operator precedence

Author: lwgray

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "think-lang"
-version = "0.1.9.rc2"
+version = "0.1.9.rc3"
 description = "Think - A language for learning computational thinking"
 readme = "README.md"
 authors = [

tests/test_integration.py

@@ -185,4 +185,113 @@ def test_data_processing(self, interpreter, parser, capture_output):
         interpreter.execute(ast)
 
         assert 4 == interpreter.state['result'][0]
-        assert 5 == interpreter.state['result'][1]
+        assert 5 == interpreter.state['result'][1]
+
+class TestExpressionEvaluation:
+    def test_nested_unary_operations(self, interpreter, parser, capture_output):
+        """Test handling of nested unary minus operations."""
+        code = '''
+        objective "Test nested unary operations"
+        task "UnaryOps":
+            step "Calculate":
+                double_neg = - -42
+                triple_neg = - - -17
+                mixed = - -3.14
+                print(double_neg)
+                print(triple_neg)
+                print(mixed)
+        run "UnaryOps"'''
+        
+        ast = parser.parse(code)
+        interpreter.execute(ast)
+        
+        assert interpreter.state['double_neg'] == 42
+        assert interpreter.state['triple_neg'] == -17
+        assert pytest.approx(interpreter.state['mixed']) == 3.14
+
+    def test_complex_nested_expressions(self, interpreter, parser, capture_output):
+        """Test evaluation of complex nested expressions."""
+        code = '''
+        objective "Test complex expressions"
+        task "ComplexExpr":
+            step "Calculate":
+                a = 5
+                b = 3
+                c = 8
+                d = 2
+                nested1 = (a + b) * (c - d)
+                nested2 = ((a * b) + c) / (d + 1)
+                print(nested1)
+                print(nested2)
+        run "ComplexExpr"'''
+        
+        ast = parser.parse(code)
+        interpreter.execute(ast)
+        
+        # (5 + 3) * (8 - 2) = 8 * 6 = 48
+        assert interpreter.state['nested1'] == 48
+        # ((5 * 3) + 8) / (2 + 1) = (15 + 8) / 3 = 23/3
+        assert pytest.approx(interpreter.state['nested2']) == 7.666666666666667
+
+    def test_parenthesized_expressions(self, interpreter, parser, capture_output):
+        """Test evaluation of expressions with explicit parentheses."""
+        code = '''
+        objective "Test parenthesized expressions"
+        task "ParenExpr":
+            step "Calculate":
+                simple = 2 * (3 + 4)
+                complex = (1 + 2) * (3 - 4) / (5 + 6)
+                nested = (((1 + 2) * 3) - 4)
+                print(simple)
+                print(complex)
+                print(nested)
+        run "ParenExpr"'''
+        
+        ast = parser.parse(code)
+        interpreter.execute(ast)
+        
+        # 2 * (3 + 4) = 2 * 7 = 14
+        assert interpreter.state['simple'] == 14
+        # (1 + 2) * (3 - 4) / (5 + 6) = 3 * (-1) / 11 ≈ -0.2727
+        assert pytest.approx(interpreter.state['complex']) == -0.2727272727272727
+        # (((1 + 2) * 3) - 4) = ((3 * 3) - 4) = (9 - 4) = 5
+        assert interpreter.state['nested'] == 5
+
+    def test_operator_precedence(self, interpreter, parser, capture_output):
+        """Test proper handling of operator precedence."""
+        code = '''
+        objective "Test operator precedence"
+        task "Precedence":
+            step "Calculate":
+                mul_add = 2 + 3 * 4
+                div_add = 10 + 15 / 3
+                mixed = 2 * 3 + 4 * 5 / 2 - 1
+                print(mul_add)
+                print(div_add)
+                print(mixed)
+        run "Precedence"'''
+        
+        ast = parser.parse(code)
+        interpreter.execute(ast)
+        
+        # 2 + 3 * 4 = 2 + 12 = 14 (not 20)
+        assert interpreter.state['mul_add'] == 14
+        # 10 + 15 / 3 = 10 + 5 = 15 (not 8.33...)
+        assert interpreter.state['div_add'] == 15
+        # 2 * 3 + 4 * 5 / 2 - 1 = 6 + 20/2 - 1 = 6 + 10 - 1 = 15
+        assert interpreter.state['mixed'] == 15
+
+    def test_basic_parentheses(self, interpreter, parser, capture_output):
+        """Test basic parenthesized expression."""
+        code = '''
+        objective "Test basic parentheses"
+        task "ParenExpr":
+            step "Calculate":
+                result = 2 * (3 + 4)
+                print(result)
+        run "ParenExpr"'''
+        
+        ast = parser.parse(code)
+        interpreter.execute(ast)
+        
+        assert interpreter.state['result'] == 14

think/interpreter.py

@@ -409,10 +409,15 @@ def evaluate_expression(self, expr):
 
     def evaluate_operation(self, operation):
         """Evaluate a mathematical or logical operation"""
-        left = self.evaluate_expression(operation['left'])
-        right = self.evaluate_expression(operation['right'])
         op = operation['operator']
+
+        if op == 'uminus':
+            operand = self.evaluate_expression(operation['operand'])
+            return -operand
 
+        left = self.evaluate_expression(operation['left'])
+        right = self.evaluate_expression(operation['right'])
+
          # Handle string literals - extract actual string values
         if isinstance(left, dict) and left.get('type') == 'string_literal':
             left = left['value']

think/parser.py

@@ -417,23 +417,24 @@ def p_expression(self, p):
         """
         expression : arithmetic_expr
                     | comparison_expr
+                    | LPAREN expression RPAREN
         """
-        p[0] = p[1]
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = p[2]
 
     def p_primary_expr(self, p):
         """
         primary_expr : IDENTIFIER
                      | NUMBER
-                    | numeric_literal
                     | STRING
                     | BOOL
                     | FLOAT
-                    | MINUS FLOAT
                     | list
                     | function_call
                     | LPAREN expression RPAREN
                     | dict_literal
-                    | index_expression
         """
         if len(p) == 2:
             if isinstance(p[1], str) and hasattr(p[1], 'type'):
@@ -442,6 +443,8 @@ def p_primary_expr(self, p):
                 p[0] = {'type': 'string_literal', 'value': p[1]}
             else:
                 p[0] = p[1]
+        elif len(p) == 3:
+            p[0] = -p[2]
         else:
             p[0] = p[2] 
 
@@ -479,8 +482,11 @@ def p_arithmetic_expr(self, p):
         """
         if len(p) == 2:
             p[0] = p[1]
-        else:
-            p[0] = {'type': 'operation', 'left': p[1], 'operator': p[2], 'right': p[3]}
+        elif len(p) == 4:
+            if p[1] == '(':
+                p[0] = p[2]
+            else:
+                p[0] = {'type': 'operation', 'left': p[1], 'operator': p[2], 'right': p[3]}
 
     def p_comparison_expr(self, p):
         """