Added if condition support

Author: ppaska

index.html

@@ -29,14 +29,12 @@
   <div class="container">
     <h4>JSPython development console</h4>
     <div id="editor">
-arr = [1,2,3]
-arr.map(n =>
-  n = n * 2
-  {
-    t1: n * 2,
-    t2: n * 3
-  }
-)
+x = 1
+
+if x == 3:
+  x = 5
+else:
+  x = 10
 
     </div>
     <button onclick="tokenize()">Tokenize</button>

src/common/ast-types.ts

@@ -57,6 +57,12 @@ export class ArrowFuncDefNode extends AstNode {
     }
 }
 
+export class IfNode extends AstNode {
+    constructor(public conditionNode: AstNode, public ifBody: AstNode[], public elseBody: AstNode[] | undefined = undefined) {
+        super('if');
+    }
+}
+
 export class GetSingleVarNode extends AstNode {
     name: string;
     nullCoelsing: boolean | undefined = undefined;

src/evaluator/evaluator.ts

@@ -1,7 +1,7 @@
 import {
     ArrowFuncDefNode,
     AssignNode, AstBlock, AstNode, BinOpNode, BracketObjectAccessNode, ConstNode, CreateArrayNode,
-    CreateObjectNode, DotObjectAccessNode, FunctionCallNode, FunctionDefNode, GetSingleVarNode, OperationFuncs, Primitive, SetSingleVarNode
+    CreateObjectNode, DotObjectAccessNode, FunctionCallNode, FunctionDefNode, GetSingleVarNode, IfNode, OperationFuncs, Primitive, SetSingleVarNode
 } from '../common';
 import { Scope } from './scope';
 
@@ -85,6 +85,18 @@ export class Evaluator {
     }
 
     private evalNode(node: AstNode, scope: Scope): unknown {
+        if (node.type === 'if') {
+            const ifNode = node as IfNode;
+            const newScope = scope;
+            if (this.evalNode(ifNode.conditionNode, scope)) {
+                this.evalBlock({ body: ifNode.ifBody } as AstBlock, newScope);
+            } else if (ifNode.elseBody) {
+                this.evalBlock({ body: ifNode.elseBody } as AstBlock, newScope);
+            }
+
+            return;
+        }
+
         if (node.type === "const") {
             return (node as ConstNode).value;
         }
@@ -100,7 +112,7 @@ export class Evaluator {
             return OperationFuncs[binOpNode.op](left as Primitive, right as Primitive);
         }
 
-        if(node.type === "arrowFuncDef") {
+        if (node.type === "arrowFuncDef") {
             const arrowFuncDef = node as ArrowFuncDefNode;
 
             const newScope = scope;
@@ -120,7 +132,7 @@ export class Evaluator {
                     }
                     newScope.set(arrowFuncDef.params[i], args[i]);
                 }
-                return this.evalBlock(ast, newScope);              
+                return this.evalBlock(ast, newScope);
             }
 
             return arrowFuncHandler;

src/interpreter.spec.ts

@@ -207,4 +207,19 @@ describe('Interpreter', () => {
     expect(e.evaluate(script)).toBe("96,216");
   });
 
+
+  it('if condition', () => {
+    const script = (p) => `
+    x = 1
+    if x == ${p}:
+      x = 5
+    else:
+      x = 10
+    x
+          `; 
+    expect(e.evaluate(script(1))).toBe(5);
+    expect(e.evaluate(script(2))).toBe(10);
+  });
+  
+
 });

src/parser/parser.ts

@@ -1,8 +1,8 @@
 import {
-    BinOpNode, ConstNode, AstBlock, Token, ParserOptions, AstNode, Operators, AssignNode, TokenTypes, 
-    GetSingleVarNode, FunctionCallNode, getTokenType, getTokenValue, isTokenTypeLiteral, getStartLine, 
-    getStartColumn, getEndColumn, getEndLine, findOperators, splitTokens, DotObjectAccessNode, BracketObjectAccessNode, 
-    findTokenValueIndex, FunctionDefNode, CreateObjectNode, ObjectPropertyInfo, CreateArrayNode, ArrowFuncDefNode, ExpressionOperators
+    BinOpNode, ConstNode, AstBlock, Token, ParserOptions, AstNode, Operators, AssignNode, TokenTypes,
+    GetSingleVarNode, FunctionCallNode, getTokenType, getTokenValue, isTokenTypeLiteral, getStartLine,
+    getStartColumn, getEndColumn, getEndLine, findOperators, splitTokens, DotObjectAccessNode, BracketObjectAccessNode,
+    findTokenValueIndex, FunctionDefNode, CreateObjectNode, ObjectPropertyInfo, CreateArrayNode, ArrowFuncDefNode, ExpressionOperators, IfNode
 } from '../common';
 
 export class InstructionLine {
@@ -52,12 +52,19 @@ export class Parser {
 
     private instructionsToNodes(instructions: InstructionLine[], ast: AstBlock): void {
 
-        for (let instruction of instructions) {
+        const getBody = (tokens: Token[], startTokenIndex: number): AstNode[] => {
+            const instructionLines = this.getBlock(tokens, getStartLine(tokens[startTokenIndex]));
+            const bodyAst = { body: [] as AstNode[], funcs: [] as AstNode[] } as AstBlock;
+            this.instructionsToNodes(instructionLines, bodyAst);
+            return bodyAst.body;
+        }
+
+        for (let i = 0; i < instructions.length; i++) {
+            const instruction = instructions[i]
 
             if (!instruction.tokens.length) {
                 continue;
             }
-
             const assignTokens = splitTokens(instruction.tokens, '=');
 
             if (getTokenValue(instruction.tokens[0]) === 'def') {
@@ -84,6 +91,26 @@ export class Parser {
 
                 ast.funcs.push(new FunctionDefNode(funcName, params, funcAst.body))
 
+            } else if (getTokenValue(instruction.tokens[0]) === 'if') {
+
+                const endDefOfDef = findTokenValueIndex(instruction.tokens, v => v === ':');
+
+                if (endDefOfDef === -1) {
+                    throw (`Can't find : for if`)
+                }
+
+                const ifBody = getBody(instruction.tokens, endDefOfDef + 1);
+                const conditionNode = this.createExpressionNode(instruction.tokens.slice(1, endDefOfDef))
+
+                let elseBody: AstNode[] | undefined = undefined;
+                if (getTokenValue(instructions[i + 1].tokens[0]) === 'else'
+                    && getTokenValue(instructions[i + 1].tokens[1]) === ':') {
+                    elseBody = getBody(instructions[i + 1].tokens, 2);
+                    i++;
+                }
+
+                ast.body.push(new IfNode(conditionNode, ifBody, elseBody))
+
             } else if (assignTokens.length > 1) {
                 const target = this.createExpressionNode(assignTokens[0]);
                 const source = this.createExpressionNode(assignTokens[1]);
@@ -112,7 +139,7 @@ export class Parser {
                     currentLine = sLine;
                 }
 
-                if (column === sColumn && !")}]".includes(value as string) ) {
+                if (column === sColumn && !")}]".includes(value as string)) {
                     currentLine = sLine;
                     lines.push(line);
                     line = new InstructionLine();
@@ -164,7 +191,7 @@ export class Parser {
 
         // arrow function
         const arrowFuncParts = splitTokens(tokens, '=>');
-        if(arrowFuncParts.length > 1) {           
+        if (arrowFuncParts.length > 1) {
             const params = splitTokens(arrowFuncParts[0], ',').map(t => getTokenValue(t[0]) as string);
 
             const instructionLines = this.getBlock(arrowFuncParts[1], 0);
@@ -275,7 +302,7 @@ export class Parser {
                 }
 
                 // unquoted string becomes a variable, so, we don't need it, that is why we are creating const node explicitlely
-                const name = (keyValue[0].length === 1 && !`'"`.includes((getTokenValue(keyValue[0][0]) as string)[0])) 
+                const name = (keyValue[0].length === 1 && !`'"`.includes((getTokenValue(keyValue[0][0]) as string)[0]))
                     ? new ConstNode(keyValue[0][0])
                     : this.createExpressionNode(keyValue[0]);
                 const pInfo = {