fixed null coelsing for functions and empty return

Pavlo · Pavlo · commit c7e4bf5aa72d · 2021-03-07T11:59:08.000Z
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jspython-interpreter",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "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
@@ -134,10 +134,7 @@ export class Evaluator {
             return func(fps[0], fps[1], fps[2], fps[3], fps[4], fps[5], fps[6], fps[7], fps[8], fps[9], fps[10], fps[11], fps[12], fps[13], fps[14]);
         }
 
-
-        if (fps.length > 15) {
-            throw Error('Function has too many parameters. Current limitation is 10');
-        }
+        throw Error('Function has too many parameters. Current limitation is 15');
 
     }
 
@@ -377,15 +374,15 @@ export class Evaluator {
                     const funcCallNode = nestedProp as FunctionCallNode;
                     const func = startObject[funcCallNode.name] as (...args: unknown[]) => unknown;
 
-                    if (typeof func !== 'function') {
-                        throw Error(`'${funcCallNode.name}' is not a function or not defined.`)
-                    }
-
-                    if (func === undefined
+                    if ((func === undefined || func === null)
                         && (dotObject.nestedProps[i - 1] as unknown as IsNullCoelsing).nullCoelsing) {
+                        startObject = null;
                         continue;
                     }
 
+                    if (typeof func !== 'function') {
+                        throw Error(`'${funcCallNode.name}' is not a function or not defined.`)
+                    }
                     const pms = funcCallNode.paramNodes?.map(n => this.evalNode(n, blockContext)) || []
                     startObject = this.invokeFunction(func.bind(startObject), pms, {
                         moduleName: blockContext.moduleName,
diff --git a/src/evaluator/evaluatorAsync.ts b/src/evaluator/evaluatorAsync.ts
@@ -199,9 +199,8 @@ export class EvaluatorAsync {
             return await func(fps[0], fps[1], fps[2], fps[3], fps[4], fps[5], fps[6], fps[7], fps[8], fps[9], fps[10], fps[11], fps[12], fps[13], fps[14]);
         }
 
-        if (fps.length > 15) {
-            throw Error('Function has too many parameters. Current limitation is 10');
-        }
+        throw Error('Function has too many parameters. Current limitation is 15');
+
     }
 
     private async evalNodeAsync(node: AstNode, blockContext: BlockContext): Promise<unknown> {
@@ -442,8 +441,9 @@ export class EvaluatorAsync {
                     const funcCallNode = nestedProp as FunctionCallNode;
                     const func = startObject[funcCallNode.name] as (...args: unknown[]) => unknown;
 
-                    if (func === undefined
+                    if ((func === undefined || func === null)
                         && (dotObject.nestedProps[i - 1] as unknown as IsNullCoelsing).nullCoelsing) {
+                        startObject = null;
                         continue;
                     }
 
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.1.2`, "(c) 2021 FalconSoft Ltd. All rights reserved."].join('\n')
+        return [`JSPython v2.1.3`, "(c) 2021 FalconSoft Ltd. All rights reserved."].join('\n')
     },
     dateTime: (str: number | string | any = null) => parseDatetimeOrNull(str) || new Date(),
     range: range,
diff --git a/src/interpreter.spec.ts b/src/interpreter.spec.ts
@@ -626,6 +626,34 @@ describe('Interpreter', () => {
   }
   );
 
+  it('null coelsing functions', async () => {
+    const script = `
+    o = {}
+
+    if o?.nonExistentFunctions(23, 43) == null:
+      return 10
+
+    return 5
+    `
+    expect(await e.evaluate(script)).toBe(10);
+    expect(e.eval(script)).toBe(10);
+  }
+  );
+
+  it('return empty', async () => {
+    const script = `
+    if 1 == 1:
+      return
+
+    return 5
+    `
+    expect(await e.evaluate(script)).toBe(null);
+    expect(e.eval(script)).toBe(null);
+  }
+  );
+
+
+
   it('Import', async () => {
     const interpreter = Interpreter.create();
 
diff --git a/src/interpreter.ts b/src/interpreter.ts
@@ -22,6 +22,7 @@ export class Interpreter {
     private moduleLoader?: ModuleLoader;
 
     constructor() { }
+
     static create(): Interpreter {
         return new Interpreter();
     }
@@ -34,11 +35,11 @@ export class Interpreter {
         return this._lastExecutionContext;
     }
 
-    cleanUp() {
+    cleanUp(): void {
         this._lastExecutionContext = null;
     }
 
-    jsPythonInfo() {
+    jsPythonInfo(): string {
         return INITIAL_SCOPE.jsPython();
     }
 
@@ -135,36 +136,23 @@ export class Interpreter {
         return await this.evalAsync(ast, globalScope, entryFunctionName, moduleName);
     }
 
-
-    private assignLegacyImportContext(ast: AstBlock, context: object): Record<string, unknown> {
-        const importNodes = ast.body.filter(n => n.type === 'import') as ImportNode[];
-
-        const jsImport = importNodes
-            .filter(im => !im.module.name.startsWith('/'))
-            .map(im => this.nodeToPackage(im));
-
-        if (jsImport.length && this.packageLoader) {
-            const libraries = this.packageResolver(jsImport);
-            context = { ...context, ...libraries };
-        }
-
-        return context as Record<string, unknown>;
-    }
-
-    registerPackagesLoader(loader: PackageLoader) {
+    registerPackagesLoader(loader: PackageLoader): Interpreter {
         if (typeof loader === 'function') {
             this.packageLoader = loader;
         } else {
             throw Error('PackagesLoader');
         }
+        return this;
     }
 
-    registerModuleLoader(loader: ModuleLoader) {
+    registerModuleLoader(loader: ModuleLoader): Interpreter {
         if (typeof loader === 'function') {
             this.moduleLoader = loader;
         } else {
             throw Error('ModuleLoader should be a function');
         }
+
+        return this;
     }
 
     addFunction(funcName: string, fn: (...args: any[]) => void | any | Promise<any>): Interpreter {
@@ -181,6 +169,30 @@ export class Interpreter {
         return scripts.indexOf(`def ${funcName}`) > -1;
     }
 
+    private assignLegacyImportContext(ast: AstBlock, context: object): Record<string, unknown> {
+
+        const nodeToPackage = (im: ImportNode): PackageToImport => {
+            return {
+                name: im.module.name,
+                as: im.module.alias,
+                properties: im.parts?.map(p => ({ name: p.name, as: p.alias }))
+            } as PackageToImport
+        }
+
+        const importNodes = ast.body.filter(n => n.type === 'import') as ImportNode[];
+
+        const jsImport = importNodes
+            .filter(im => !im.module.name.startsWith('/'))
+            .map(im => nodeToPackage(im));
+
+        if (jsImport.length && this.packageLoader) {
+            const libraries = this.packageResolver(jsImport);
+            context = { ...context, ...libraries };
+        }
+
+        return context as Record<string, unknown>;
+    }
+
     private async moduleParser(modulePath: string): Promise<AstBlock> {
         if (!this.moduleLoader) {
             throw new Error('Module Loader is not registered')
@@ -190,15 +202,6 @@ export class Interpreter {
         return this.parse(content, modulePath);
     }
 
-
-    private nodeToPackage(im: ImportNode): PackageToImport {
-        return {
-            name: im.module.name,
-            as: im.module.alias,
-            properties: im.parts?.map(p => ({ name: p.name, as: p.alias }))
-        } as PackageToImport
-    }
-
     private packageResolver(packages: PackageToImport[]): object {
         if (!this.packageLoader) {
             throw Error('Package loader not provided.');
diff --git a/src/interpreter.v1.spec.ts b/src/interpreter.v1.spec.ts
@@ -1264,7 +1264,7 @@ describe('Interpreter', () => {
     const o = {
       value: 5,
       func: (f: (x: unknown) => unknown): number => {
-        var obj = { value: 5 };
+        const obj = { value: 5 };
         f(obj);
         return obj.value + 10;
       }
diff --git a/src/parser/parser.spec.ts b/src/parser/parser.spec.ts
@@ -5,7 +5,7 @@ import { Parser } from "./parser";
 describe('Parser => ', () => {
 
   it('1+2', async () => {
-    let ast = new Parser().parse(new Tokenizer().tokenize("1+2"))
+    const ast = new Parser().parse(new Tokenizer().tokenize("1+2"));
     expect(ast.body.length).toBe(1);
     expect(ast.body[0].type).toBe("binOp");
     const binOp = ast.body[0] as BinOpNode
@@ -15,7 +15,7 @@ describe('Parser => ', () => {
   });
 
   it('1+2-3', async () => {
-    let ast = new Parser().parse(new Tokenizer().tokenize("1 + 2 - 3"))
+    const ast = new Parser().parse(new Tokenizer().tokenize("1 + 2 - 3"))
     expect(ast.body.length).toBe(1);
     expect(ast.body[0].type).toBe("binOp");
     const binOp = ast.body[0] as BinOpNode
@@ -26,7 +26,7 @@ describe('Parser => ', () => {
 
   it('import datapipe-js-utils as utils', async () => {
     const script = `import datapipe-js-utils as utils`
-    let ast = new Parser().parse(new Tokenizer().tokenize(script))
+    const ast = new Parser().parse(new Tokenizer().tokenize(script));
     expect(ast.body.length).toBe(1);
     expect(ast.body[0].type).toBe("import");
     const importNode = (ast.body[0] as ImportNode);
@@ -36,7 +36,7 @@ describe('Parser => ', () => {
 
   it('import datapipe-js-utils', async () => {
     const script = `import datapipe-js-utils`
-    let ast = new Parser().parse(new Tokenizer().tokenize(script))
+    const ast = new Parser().parse(new Tokenizer().tokenize(script));
     expect(ast.body.length).toBe(1);
     expect(ast.body[0].type).toBe("import");
     const importNode = (ast.body[0] as ImportNode);
@@ -46,7 +46,7 @@ describe('Parser => ', () => {
 
   it('from datapipe-js-array import sort, first as f, fullJoin', async () => {
     const script = `from datapipe-js-array import sort, first as f, fullJoin`
-    let ast = new Parser().parse(new Tokenizer().tokenize(script))
+    const ast = new Parser().parse(new Tokenizer().tokenize(script));
     expect(ast.body.length).toBe(1);
     expect(ast.body[0].type).toBe("import");
     const importNode = (ast.body[0] as ImportNode);
diff --git a/src/parser/parser.ts b/src/parser/parser.ts
@@ -37,7 +37,7 @@ export class Parser {
      * @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 {
+    parse(tokens: Token[], name = 'main.jspy', type = 'module'): AstBlock {
         this._moduleName = name;
         const ast = { name, type, funcs: [], body: [] } as AstBlock;
 
@@ -214,7 +214,6 @@ export class Parser {
                         excepts.push(except);
                     }
 
-
                     i++;
                 }
 
@@ -229,7 +228,10 @@ export class Parser {
             } else if (getTokenValue(firstToken) === 'break') {
                 ast.body.push(new BreakNode());
             } else if (getTokenValue(firstToken) === 'return') {
-                ast.body.push(new ReturnNode(this.createExpressionNode(instruction.tokens.slice(1)), getTokenLoc(firstToken)));
+                ast.body.push(new ReturnNode(
+                    instruction.tokens.length > 1 ? this.createExpressionNode(instruction.tokens.slice(1)) : undefined,
+                    getTokenLoc(firstToken))
+                );
             } else if (getTokenValue(firstToken) === 'raise') {
 
                 if (instruction.tokens.length === 1) {
@@ -291,7 +293,7 @@ export class Parser {
                 const body = {} as AstBlock; // empty for now
                 ast.body.push(new ImportNode(module, body, undefined, getTokenLoc(firstToken)))
             } else if (getTokenValue(firstToken) === 'from') {
-                let importIndex = findTokenValueIndex(instruction.tokens, v => v === 'import');
+                const importIndex = findTokenValueIndex(instruction.tokens, v => v === 'import');
                 if (importIndex < 0) {
                     throw Error(`'import' must follow 'from'`);
                 }
@@ -336,7 +338,7 @@ export class Parser {
     }
 
     private groupComparisonOperations(indexes: number[], tokens: Token[]): AstNode {
-        let start = 0;
+        const start = 0;
 
         let leftNode: AstNode | null = null;
         for (let i = 0; i < indexes.length; i++) {
@@ -352,7 +354,7 @@ export class Parser {
         return leftNode as AstNode;
     }
 
-    private groupLogicalOperations(logicOp: number[], tokens: Token[]) {
+    private groupLogicalOperations(logicOp: number[], tokens: Token[]): LogicalOpNode {
         let start = 0;
         const logicItems: LogicalNodeItem[] = [];
         for (let i = 0; i < logicOp.length; i++) {
@@ -477,15 +479,15 @@ export class Parser {
         const ops = findOperators(tokens);
         if (ops.length) {
 
-            var prevNode: AstNode | null;
+            let prevNode: AstNode | null = null;
             for (let i = 0; i < ops.length; i++) {
                 const opIndex = ops[i];
                 const op = getTokenValue(tokens[opIndex]) as Operators;
 
                 let nextOpIndex = i + 1 < ops.length ? ops[i + 1] : null;
                 let nextOp = nextOpIndex !== null ? getTokenValue(tokens[nextOpIndex]) : null;
                 if (nextOpIndex !== null && (nextOp === '*' || nextOp === '/')) {
-                    var rightNode: AstNode | null = null;
+                    let rightNode: AstNode | null = null;
                     // iterate through all continuous '*', '/' operations
                     do {
                         const nextOpIndex2 = i + 2 < ops.length ? ops[i + 2] : null;
@@ -513,7 +515,7 @@ export class Parser {
                 } else {
                     const leftSlice = prevNode ? [] : this.sliceWithBrackets(tokens, 0, opIndex);
                     const rightSlice = this.sliceWithBrackets(tokens, opIndex + 1, nextOpIndex || tokens.length);
-                    const left = prevNode || this.createExpressionNode(leftSlice, prevNode);
+                    const left: AstNode = prevNode || this.createExpressionNode(leftSlice, prevNode);
                     const right = this.createExpressionNode(rightSlice);
                     prevNode = new BinOpNode(left, op as ExpressionOperators, right, getTokenLoc(tokens[0]));
                 }
diff --git a/src/tokenizer/tokenizer.ts b/src/tokenizer/tokenizer.ts
@@ -29,10 +29,10 @@ const SeparatorsMap: Record<string, string[]> = {
 const Keywords: string[] = ["async", "def", "for", "while", "if", "return", "in"];
 
 export class Tokenizer {
-    private _startLine: number = 1
-    private _startColumn: number = 1
-    private _currentLine: number = 1
-    private _currentColumn: number = 1
+    private _startLine = 1;
+    private _startColumn = 1;
+    private _currentLine = 1;
+    private _currentColumn = 1;
     private _tokenText = '';
     private _cursor = 0;
     private _script = "";
@@ -128,7 +128,8 @@ export class Tokenizer {
                     const cLine = this._currentLine;
                     const cColumn = this._currentColumn;
                     this.incrementCursor(2);
-                    while (true) {
+                    const passCond = true;
+                    while (passCond) {
                         this.tokenText += script[this.incrementCursor()];
                         if (this._cursor + 3 >= script.length
                             || (script[this._cursor + 1] === q && script[this._cursor + 2] === q && script[this._cursor + 3] === q)) {
@@ -167,7 +168,7 @@ export class Tokenizer {
         return tokens;
     }
 
-    private incrementCursor(count: number = 1): number {
+    private incrementCursor(count = 1): number {
         for (let i = 0; i < count; i++) {
             this._cursor = this._cursor + 1;
             if (this._script[this._cursor] === '\n') {
@@ -248,7 +249,7 @@ export class Tokenizer {
     private isPartOfNumber(symbol: string, currentTokens: Token[]): boolean {
         if (symbol === '-' && !this.tokenText.length) {
             // '-' needs to be handled e.g. -3; 2 + -2 etc
-            const prevToken = (currentTokens.length !== 0)? currentTokens[currentTokens.length - 1] : null;
+            const prevToken = (currentTokens.length !== 0) ? currentTokens[currentTokens.length - 1] : null;
             return prevToken === null || (getTokenType(prevToken) === TokenTypes.Operator && getTokenValue(prevToken) !== ')');
         } else if (symbol === '.' && this.parseNumberOrNull(this.tokenText) !== null) {
             return true;

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "jspython-interpreter",`
`3`		`- "version": "2.1.2",`
	`3`	`+ "version": "2.1.3",`
`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",`
Original file line number	Diff line number	Diff line change
`@@ -199,9 +199,8 @@ export class EvaluatorAsync {`
`199`	`199`	`return await func(fps[0], fps[1], fps[2], fps[3], fps[4], fps[5], fps[6], fps[7], fps[8], fps[9], fps[10], fps[11], fps[12], fps[13], fps[14]);`
`200`	`200`	`}`
`201`	`201`
`202`		`- if (fps.length > 15) {`
`203`		`- throw Error('Function has too many parameters. Current limitation is 10');`
`204`		`- }`
	`202`	`+ throw Error('Function has too many parameters. Current limitation is 15');`
	`203`	`+`
`205`	`204`	`}`
`206`	`205`
`207`	`206`	`private async evalNodeAsync(node: AstNode, blockContext: BlockContext): Promise<unknown> {`
`@@ -442,8 +441,9 @@ export class EvaluatorAsync {`
`442`	`441`	`const funcCallNode = nestedProp as FunctionCallNode;`
`443`	`442`	`const func = startObject[funcCallNode.name] as (...args: unknown[]) => unknown;`
`444`	`443`
`445`		`- if (func === undefined`
	`444`	`+ if ((func === undefined \|\| func === null)`
`446`	`445`	`&& (dotObject.nestedProps[i - 1] as unknown as IsNullCoelsing).nullCoelsing) {`
	`446`	`+ startObject = null;`
`447`	`447`	`continue;`
`448`	`448`	`}`
`449`	`449`
Original file line number	Diff line number	Diff line change
`@@ -1264,7 +1264,7 @@ describe('Interpreter', () => {`
`1264`	`1264`	`const o = {`
`1265`	`1265`	`value: 5,`
`1266`	`1266`	`func: (f: (x: unknown) => unknown): number => {`
`1267`		`- var obj = { value: 5 };`
	`1267`	`+ const obj = { value: 5 };`
`1268`	`1268`	`f(obj);`
`1269`	`1269`	`return obj.value + 10;`
`1270`	`1270`	`}`