fixed logical operations for for 'if' and while

Author: ppaska

index.html

@@ -29,34 +29,15 @@
   <div class="container">
     <h4>JSPython development console</h4>
     <div id="editor">
-    async def f1(p1, p2, p3, p4, p5):
-      errorFunc(p1 or 1)
-      errorFunc(p2 or 3)
-      errorFunc(p3 or 6)
-      errorFunc(p4 or 7)
-      
-      """
-      l = null
-      r = {price: 5}
-
-      if l?.price != null and r?.price != null:
-      return 100
+      x = 5
+      y = 10
 
-      return 1
-      """
-    f1()
+      if x == 5 or y == 10:
+        return 100
 
+      return 1
     </div>
-    <!--
-          def f(n):
-            n * n
-          x = [2, 3, 4]
-          x.map(f)
-             
-# arr = [1,2,3]
-# arr.map(mapFunc)
-
-    -->
+
     <button onclick="tokenize()">Tokenize</button>
     <button onclick="parse()">Parse</button>
     <button onclick="runInterpreter()">Run</button>

src/interpreter.spec.ts

@@ -483,7 +483,119 @@ describe('Interpreter', () => {
     };
     expect(await e.evaluate(script, obj)).toContain(jsErrorMessage);
     expect(e.eval(script, obj)).toContain(jsErrorMessage);
-  })
+  });
+
+  it('if with AND', async () => {
+    const script = `
+      x=5
+      y=10
+      r = 0
+      
+      if x == 5 and y == 10:
+          r = x + y
+          
+      return r
+    `;
+
+    expect(await e.evaluate(script)).toBe(15);
+    expect(e.eval(script)).toBe(15);
+  }
+  );
+
+  it('if with AND nullable objects', async () => {
+    const script = `
+      l = null
+      r = {price: 5}
+      
+      if l?.price != null and r?.price != null:
+        return 100
+      
+      return 1
+    `;
+    expect(await e.evaluate(script)).toBe(1);
+    expect(e.eval(script)).toBe(1);
+  }
+  );
+
+
+  it('if with AND in brackets', async () => {
+    const script = `
+      x=5
+      y=10
+      r = 0
+      
+      if (x == 5) and (y == 10):
+          r = x + y
+          
+      return r
+      `
+    expect(await e.evaluate(script)).toBe(15);
+    expect(e.eval(script)).toBe(15);
+  }
+  );
+
+  // incorrect
+  it('passing value type to the arrow function', async () => {
+
+    const script = `
+      x = [2,3,4,5,6,7,8,9]
+
+      sum = 0
+      x.forEach(i => sum = sum + i)
+      
+      sum
+      `
+  }
+  );
+
+  it('passing value type to the for loop', async () => {
+
+    const script = `
+    x = [2,3,4,5,6,7,8,9]
+    sum = 0
+
+    for i in x:
+        sum = sum + i
+
+    sum
+      `
+    expect(await e.evaluate(script)).toBe(44);
+    expect(e.eval(script)).toBe(44);
+  }
+  );
+
+  it('passing value type to the while loop', async () => {
+
+    const script = `
+    x = [2,3,4,5,6,7,8,9]
+    sum = 0
+    i=0
+    while i < x.length:
+      val = x[i]
+      sum = sum + val
+      i = i + 1
+
+    sum
+      `
+    expect(await e.evaluate(script)).toBe(44);
+    expect(e.eval(script)).toBe(44);
+  }
+  );
+
+  it('passing value type to the arrow function', async () => {
+
+    const script = `
+    x = [2,3,4,5,6,7,8,9]
+
+    sum = {value:0}
+    x.forEach(i => sum.value = sum.value + i)
+    
+    sum.value
+    `
+    expect(await e.evaluate(script)).toBe(44);
+    expect(e.eval(script)).toBe(44);
+  }
+  );
 
 
 });

src/parser/parser.ts

@@ -136,7 +136,12 @@ export class Parser {
                 }
 
                 const ifBody = getBody(instruction.tokens, endDefOfDef + 1);
-                const conditionNode = this.createExpressionNode(instruction.tokens.slice(1, endDefOfDef))
+                const conditionTokens = instruction.tokens.slice(1, endDefOfDef);
+
+                const conditionNode = (findIndexes(conditionTokens, OperationTypes.Logical, logicOpIndexes)) ?
+                    this.groupLogicalOperations(logicOpIndexes, conditionTokens)
+                    :
+                    this.createExpressionNode(conditionTokens);
 
                 let elseBody: AstNode[] | undefined = undefined;
                 if (instructions.length > i + 1
@@ -261,10 +266,16 @@ export class Parser {
                     throw (`Can't find : for [while]`)
                 }
 
-                const condition = this.createExpressionNode(instruction.tokens.slice(1, endDefOfDef))
+
+                const conditionTokens = instruction.tokens.slice(1, endDefOfDef);
+                const conditionNode = (findIndexes(conditionTokens, OperationTypes.Logical, logicOpIndexes)) ?
+                    this.groupLogicalOperations(logicOpIndexes, conditionTokens)
+                    :
+                    this.createExpressionNode(conditionTokens);
+
                 const body = getBody(instruction.tokens, endDefOfDef + 1);
 
-                ast.body.push(new WhileNode(condition, body, getTokenLoc(firstToken)))
+                ast.body.push(new WhileNode(conditionNode, body, getTokenLoc(firstToken)));
 
             } else if (getTokenValue(firstToken) === 'import') {
                 let asIndex = findTokenValueIndex(instruction.tokens, v => v === 'as');
@@ -556,7 +567,7 @@ export class Parser {
                     let name: AstNode | null = null;
                     const namePart = keyValue[0];
 
-                    if (namePart.length === 1) {                        
+                    if (namePart.length === 1) {
                         name = new ConstNode(namePart[0]);
                     } else if (getTokenValue(namePart[0]) === '['
                         && getTokenValue(namePart[namePart.length - 1]) === ']') {