Error reporting and other minor integration issues

ppaska · ppaska · commit 9f5cb9c8f8f7 · 2020-12-25T22:27:47.000Z
diff --git a/index.html b/index.html
@@ -30,11 +30,14 @@
     <h4>JSPython development console</h4>
     <div id="editor">
 
-def f():
-  null
-
-f()?.prop or 1
-
+  async def f2():
+      """
+      long comment
+      """
+      778
+  
+  f2()
+  
     </div>
     <!--
           def f(n):
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jspython-interpreter",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",
   "keywords": [
     "python",
diff --git a/src/evaluator/evaluator.ts b/src/evaluator/evaluator.ts
@@ -2,7 +2,7 @@ import {
     ArrowFuncDefNode,
     AssignNode, AstBlock, AstNode, BinOpNode, BracketObjectAccessNode, ConstNode, CreateArrayNode,
     CreateObjectNode, DotObjectAccessNode, ForNode, FuncDefNode, FunctionCallNode, FunctionDefNode, GetSingleVarNode,
-    IfNode, OperationFuncs, Primitive, ReturnNode, SetSingleVarNode, WhileNode
+    IfNode, IsNullCoelsing, OperationFuncs, Primitive, ReturnNode, SetSingleVarNode, WhileNode
 } from '../common';
 import { JspyEvalError } from '../common/utils';
 import { BlockContext, Scope } from './scope';
@@ -50,7 +50,7 @@ export class Evaluator {
                     throw err;
                 } else {
                     const loc = node.loc ? node.loc : [0, 0]
-                    throw new JspyEvalError(ast.name, loc[0], loc[1], err.message)
+                    throw new JspyEvalError(ast.name, loc[0], loc[1], err.message || err)
                 }
             }
 
@@ -277,8 +277,13 @@ export class Evaluator {
                 } else if (nestedProp.type === 'funcCall') {
                     const funcCallNode = nestedProp as FunctionCallNode;
                     const func = startObject[funcCallNode.name] as (...args: unknown[]) => unknown;
-                    const pms = funcCallNode.paramNodes?.map(n => this.evalNode(n, blockContext)) || []
 
+                    if(func === undefined 
+                        && (dotObject.nestedProps[i - 1] as unknown as IsNullCoelsing).nullCoelsing){
+                            continue;
+                    }
+
+                    const pms = funcCallNode.paramNodes?.map(n => this.evalNode(n, blockContext)) || []
                     startObject = this.invokeFunction(func.bind(startObject), pms);
 
                 } else {
diff --git a/src/evaluator/evaluatorAsync.ts b/src/evaluator/evaluatorAsync.ts
@@ -3,7 +3,7 @@ import {
     AssignNode, AstBlock, AstNode, BinOpNode, BracketObjectAccessNode, ConstNode, CreateArrayNode,
     CreateObjectNode, DotObjectAccessNode, ForNode, FuncDefNode, FunctionCallNode, FunctionDefNode, GetSingleVarNode,
     getTokenLoc,
-    IfNode, OperationFuncs, Primitive, ReturnNode, SetSingleVarNode, WhileNode
+    IfNode, IsNullCoelsing, OperationFuncs, Primitive, ReturnNode, SetSingleVarNode, WhileNode
 } from '../common';
 import { JspyEvalError } from '../common/utils';
 import { Evaluator } from './evaluator';
@@ -58,7 +58,7 @@ export class EvaluatorAsync {
                     throw err;
                 } else {
                     const loc = node.loc? node.loc : [0, 0]
-                    throw new JspyEvalError(blockContext.moduleName, loc[0], loc[1], err.message)
+                    throw new JspyEvalError(blockContext.moduleName, loc[0], loc[1], err.message || err)
                 }
             }
         }
@@ -274,7 +274,7 @@ export class EvaluatorAsync {
             for (let i = 1; i < dotObject.nestedProps.length; i++) {
                 const nestedProp = dotObject.nestedProps[i];
 
-                if ((dotObject.nestedProps[i - 1] as any).nullCoelsing && !startObject) {
+                if ((dotObject.nestedProps[i - 1] as unknown as IsNullCoelsing).nullCoelsing && !startObject) {
                     startObject = {};
                 }
 
@@ -288,6 +288,11 @@ export class EvaluatorAsync {
                     const funcCallNode = nestedProp as FunctionCallNode;
                     const func = startObject[funcCallNode.name] as (...args: unknown[]) => unknown;
 
+                    if(func === undefined 
+                        && (dotObject.nestedProps[i - 1] as unknown as IsNullCoelsing).nullCoelsing){
+                            continue;
+                    }
+
                     const pms = []
                     for (let p of funcCallNode.paramNodes || []) {
                         pms.push(await this.evalNodeAsync(p, blockContext));
diff --git a/src/initialScope.ts b/src/initialScope.ts
@@ -2,7 +2,7 @@ import { parseDatetimeOrNull } from "./common/utils";
 
 export const INITIAL_SCOPE = {
     jsPython(): string {
-        return [`JSPython v2.0.2`, "(c) FalconSoft Ltd"].join('\n')
+        return [`JSPython v2.0.4`, "(c) FalconSoft Ltd"].join('\n')
     },
     dateTime: (str: number | string | any = null) => (str && str.length)
         ? parseDatetimeOrNull(str) || new Date() : new Date(),
diff --git a/src/interpreter.spec.ts b/src/interpreter.spec.ts
@@ -275,6 +275,26 @@ describe('Interpreter', () => {
     expect(e.eval(script)).toBe(5);
   });
 
+  it('long comments issue', () => {
+    const script = `
+    async def f2():
+      """
+      long comment
+      """
+      5
+
+    f2()
+    `
+    ;
+    expect(e.eval(script)).toBe(5);
+  });
+
+  it('chaining funcCall with null coelsing', () => {
+    expect(e.eval("p?.f()?.sdsd")).toBe(null);
+    //expect(e.eval("p?.f()?.sdsd or 5")).toBe(5);
+  });
+
+
 
 
 });
diff --git a/src/interpreter.ts b/src/interpreter.ts
@@ -21,7 +21,6 @@ export class Interpreter {
     private packageLoader?: PackageLoader;
     private fileLoader?: FileLoader;
 
-
     constructor() { }
     static create(): Interpreter {
         return new Interpreter();
@@ -32,6 +31,7 @@ export class Interpreter {
         return tokenizer.tokenize(script);
     }
 
+    
     parse(script: string, moduleName: string='main.jspy'): AstBlock {
         const tokenizer = new Tokenizer();
         const parser = new Parser();
diff --git a/src/parser/parser.ts b/src/parser/parser.ts
@@ -29,13 +29,15 @@ class InstructionLine {
 
 export class Parser {
     private _currentToken: Token | null = null;
+    private _moduleName = '';
 
     /**
      * Parses tokens and return Ast - Abstract Syntax Tree for jsPython code
      * @param tokens tokens
      * @param options parsing options. By default it will exclude comments and include LOC (Line of code)
      */
     parse(tokens: Token[], name = 'main.jspy', type: string = 'module'): AstBlock {
+        this._moduleName = name;
         const ast = { name, type, funcs: [], body: [] } as AstBlock;
 
         if (!tokens || !tokens.length) { return ast; }
@@ -50,7 +52,7 @@ export class Parser {
 
         } catch (err) {
             const token = this._currentToken ?? {} as Token
-            throw new JspyParserError(ast.name, getStartLine(token), getStartColumn(token), err.message)
+            throw new JspyParserError(ast.name, getStartLine(token), getStartColumn(token), err.message || err)
         }
         return ast;
     }
@@ -59,7 +61,7 @@ export class Parser {
 
         const getBody = (tokens: Token[], startTokenIndex: number): AstNode[] => {
             const instructionLines = this.tokensToInstructionLines(tokens, getStartLine(tokens[startTokenIndex]));
-            const bodyAst = { body: [] as AstNode[], funcs: [] as AstNode[] } as AstBlock;
+            const bodyAst = { name: ast.name, body: [] as AstNode[], funcs: [] as AstNode[] } as AstBlock;
             this.instructionsToNodes(instructionLines, bodyAst);
             return bodyAst.body;
         }
@@ -225,7 +227,7 @@ export class Parser {
             const sColumn = getStartColumn(token);
             const value = getTokenValue(token);
             this._currentToken = token;
-            
+
             if (sLine >= startLine) {
 
                 if (currentLine !== sLine) {
@@ -293,6 +295,7 @@ export class Parser {
 
             const instructionLines = this.tokensToInstructionLines(arrowFuncParts[1], 0);
             const funcAst = {
+                name: this._moduleName,
                 body: [] as AstNode[],
                 funcs: [] as AstNode[]
             } as AstBlock;
diff --git a/src/tokenizer/tokenizer.ts b/src/tokenizer/tokenizer.ts
@@ -125,6 +125,8 @@ export class Tokenizer {
 
                 // handle """ comment """"
                 if (script[this._cursor + 1] === q && script[this._cursor + 2] === q) {
+                    const cLine = this._currentLine;
+                    const cColumn = this._currentColumn;
                     this.incrementCursor(2);
                     while (true) {
                         this.tokenText += script[this.incrementCursor()];
@@ -133,6 +135,10 @@ export class Tokenizer {
                             break;
                         }
                     }
+                    // a special case when multiline string
+                    this._startLine = cLine;
+                    this._startColumn = cColumn;
+
                     this.incrementCursor(3);
                 } else {
                     while (script[this.incrementCursor()] !== q) {

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "jspython-interpreter",`
`3`		`- "version": "2.0.2",`
	`3`	`+ "version": "2.0.4",`
`4`	`4`	`"description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",`
`5`	`5`	`"keywords": [`
`6`	`6`	`"python",`