error reporting improvements

ppaska · ppaska · commit 2bb0a29f71f6 · 2020-12-25T12:26:53.000Z
diff --git a/index.html b/index.html
@@ -119,7 +119,7 @@ <h4>JSPython development console</h4>
           }
         };
         const result = await jsPython()
-          .evaluate(scripts, scope);
+          .evaluate(scripts, scope, undefined, 'index1.jspy');
 
         // const result = jsPython()
         //   .eval(scripts, scope);
diff --git a/src/common/utils.ts b/src/common/utils.ts
@@ -1,3 +1,5 @@
+import { Token } from "./token-types";
+
 export function parseDatetimeOrNull(value: string | Date): Date | null {
     if (!value) { return null; }
     if (value instanceof Date && !isNaN(value.valueOf())) { return value; }
@@ -92,6 +94,6 @@ export class JspyEvalError extends Error {
     constructor(public module: string, public line: number, public column: number, public message: string) {
         super();
         this.message = jspyErrorMessage("JspyEvalError", module, line, column, message);
-        Object.setPrototypeOf(this, JspyParserError.prototype);
+        Object.setPrototypeOf(this, JspyEvalError.prototype);
     }
 }
diff --git a/src/evaluator/evaluator.ts b/src/evaluator/evaluator.ts
@@ -9,7 +9,7 @@ import { BlockContext, Scope } from './scope';
 
 export class Evaluator {
 
-    static evalBlock(ast: AstBlock, blockContext: BlockContext): unknown {
+    evalBlock(ast: AstBlock, blockContext: BlockContext): unknown {
         let lastResult = null;
 
         for (let node of ast?.funcs || []) {
@@ -19,14 +19,14 @@ export class Evaluator {
             const newScope = blockContext.blockScope;
 
             newScope.set(funcDef.funcAst.name,
-                (...args: unknown[]): unknown => Evaluator.jspyFuncInvoker(funcDef, blockContext, ...args)
+                (...args: unknown[]): unknown => this.jspyFuncInvoker(funcDef, blockContext, ...args)
             );
         }
 
         for (const node of ast.body) {
             if (node.type === 'comment') { continue; }
             try {
-                lastResult = Evaluator.evalNode(node, blockContext);
+                lastResult = this.evalNode(node, blockContext);
 
                 if (blockContext.returnCalled) {
                     const res = blockContext.returnObject;
@@ -50,7 +50,7 @@ export class Evaluator {
                     throw err;
                 } else {
                     const loc = node.loc ? node.loc : [0, 0]
-                    throw new JspyEvalError('mainModule', loc[0], loc[1], err.message)
+                    throw new JspyEvalError(ast.name, loc[0], loc[1], err.message)
                 }
             }
 
@@ -59,13 +59,13 @@ export class Evaluator {
         return lastResult;
     }
 
-    static jspyFuncInvoker(funcDef: FuncDefNode, context: BlockContext, ...args: unknown[]): unknown {
+    jspyFuncInvoker(funcDef: FuncDefNode, context: BlockContext, ...args: unknown[]): unknown {
 
         const ast = Object.assign({}, funcDef.funcAst);
         ast.type = 'func';
 
         const blockContext = {
-            namelessFuncsCount: 0,
+            moduleName: context.moduleName,
             blockScope: context.blockScope.clone()
         } as BlockContext;
 
@@ -78,10 +78,10 @@ export class Evaluator {
             blockContext.blockScope.set(funcDef.params[i], args[i]);
         }
 
-        return Evaluator.evalBlock(ast, blockContext);
+        return this.evalBlock(ast, blockContext);
     }
 
-    private static invokeFunction(func: (...args: unknown[]) => unknown, fps: unknown[]): unknown {
+    private invokeFunction(func: (...args: unknown[]) => unknown, fps: unknown[]): unknown {
         if (fps.length === 0) { return func(); }
         if (fps.length === 1) { return func(fps[0]); }
         if (fps.length === 2) { return func(fps[0], fps[1]); }
@@ -118,7 +118,7 @@ export class Evaluator {
         }
     }
 
-    private static evalNode(node: AstNode, blockContext: BlockContext): unknown {
+    private evalNode(node: AstNode, blockContext: BlockContext): unknown {
         if (node.type === 'import') {
             // skip this for now. As modules are implemented externally
             return null;
@@ -130,10 +130,10 @@ export class Evaluator {
 
         if (node.type === 'if') {
             const ifNode = node as IfNode;
-            if (Evaluator.evalNode(ifNode.conditionNode, blockContext)) {
-                Evaluator.evalBlock({ type: 'if', body: ifNode.ifBody } as AstBlock, blockContext);
+            if (this.evalNode(ifNode.conditionNode, blockContext)) {
+                this.evalBlock({ type: 'if', body: ifNode.ifBody } as AstBlock, blockContext);
             } else if (ifNode.elseBody) {
-                Evaluator.evalBlock({ type: 'if', body: ifNode.elseBody } as AstBlock, blockContext);
+                this.evalBlock({ type: 'if', body: ifNode.elseBody } as AstBlock, blockContext);
             }
 
             return;
@@ -143,7 +143,7 @@ export class Evaluator {
             const returnNode = node as ReturnNode;
             blockContext.returnCalled = true;
             blockContext.returnObject = returnNode.returnValue ?
-                Evaluator.evalNode(returnNode.returnValue, blockContext)
+                this.evalNode(returnNode.returnValue, blockContext)
                 : null;
 
             return blockContext.returnObject;
@@ -162,11 +162,11 @@ export class Evaluator {
         if (node.type === 'for') {
             const forNode = node as ForNode;
 
-            const array = Evaluator.evalNode(forNode.sourceArray, blockContext) as unknown[] | string;
+            const array = this.evalNode(forNode.sourceArray, blockContext) as unknown[] | string;
 
             for (let item of array) {
                 blockContext.blockScope.set(forNode.itemVarName, item);
-                Evaluator.evalBlock({ type: 'for', body: forNode.body } as AstBlock, blockContext);
+                this.evalBlock({ type: 'for', body: forNode.body } as AstBlock, blockContext);
                 if (blockContext.continueCalled) { blockContext.continueCalled = false; }
                 if (blockContext.breakCalled) { break; }
             }
@@ -177,8 +177,8 @@ export class Evaluator {
         if (node.type === 'while') {
             const whileNode = node as WhileNode;
 
-            while (Evaluator.evalNode(whileNode.condition, blockContext)) {
-                Evaluator.evalBlock({ type: 'while', body: whileNode.body } as AstBlock, blockContext);
+            while (this.evalNode(whileNode.condition, blockContext)) {
+                this.evalBlock({ type: 'while', body: whileNode.body } as AstBlock, blockContext);
 
                 if (blockContext.continueCalled) { blockContext.continueCalled = false; }
                 if (blockContext.breakCalled) { break; }
@@ -198,50 +198,50 @@ export class Evaluator {
 
         if (node.type === "binOp") {
             const binOpNode = (node as BinOpNode);
-            var left = Evaluator.evalNode(binOpNode.left, blockContext);
-            var right = Evaluator.evalNode(binOpNode.right, blockContext);
+            var left = this.evalNode(binOpNode.left, blockContext);
+            var right = this.evalNode(binOpNode.right, blockContext);
             return OperationFuncs[binOpNode.op](left as Primitive, right as Primitive);
         }
 
         if (node.type === "arrowFuncDef") {
             const arrowFuncDef = node as ArrowFuncDefNode;
 
-            return (...args: unknown[]): unknown => Evaluator.jspyFuncInvoker(arrowFuncDef, blockContext, ...args);
+            return (...args: unknown[]): unknown => this.jspyFuncInvoker(arrowFuncDef, blockContext, ...args);
         }
 
         if (node.type === "funcCall") {
             const funcCallNode = node as FunctionCallNode;
             const func = blockContext.blockScope.get(funcCallNode.name) as (...args: unknown[]) => unknown;
-            const pms = funcCallNode.paramNodes?.map(n => Evaluator.evalNode(n, blockContext)) || []
+            const pms = funcCallNode.paramNodes?.map(n => this.evalNode(n, blockContext)) || []
 
-            return Evaluator.invokeFunction(func, pms);
+            return this.invokeFunction(func, pms);
         }
 
         if (node.type === "assign") {
             const assignNode = node as AssignNode;
 
             if (assignNode.target.type === 'getSingleVar') {
                 const node = assignNode.target as SetSingleVarNode;
-                blockContext.blockScope.set(node.name, Evaluator.evalNode(assignNode.source, blockContext));
+                blockContext.blockScope.set(node.name, this.evalNode(assignNode.source, blockContext));
             } else if (assignNode.target.type === 'dotObjectAccess') {
                 const targetNode = assignNode.target as DotObjectAccessNode;
 
                 // create a node for all but last property token
                 // potentially it can go to parser
                 const targetObjectNode = new DotObjectAccessNode(targetNode.nestedProps.slice(0, targetNode.nestedProps.length - 1), targetNode.loc);
-                const targetObject = Evaluator.evalNode(targetObjectNode, blockContext) as Record<string, unknown>;
+                const targetObject = this.evalNode(targetObjectNode, blockContext) as Record<string, unknown>;
 
                 // not sure nested properties should be GetSingleVarNode
                 // can be factored in the parser
                 const lastPropertyName = (targetNode.nestedProps[targetNode.nestedProps.length - 1] as GetSingleVarNode).name
 
-                targetObject[lastPropertyName] = Evaluator.evalNode(assignNode.source, blockContext);
+                targetObject[lastPropertyName] = this.evalNode(assignNode.source, blockContext);
             } else if (assignNode.target.type === 'bracketObjectAccess') {
                 const targetNode = assignNode.target as BracketObjectAccessNode;
-                const keyValue = Evaluator.evalNode(targetNode.bracketBody, blockContext) as string | number;
+                const keyValue = this.evalNode(targetNode.bracketBody, blockContext) as string | number;
                 const targetObject = blockContext.blockScope.get(targetNode.propertyName as string) as Record<string, unknown>;
 
-                targetObject[keyValue] = Evaluator.evalNode(assignNode.source, blockContext);
+                targetObject[keyValue] = this.evalNode(assignNode.source, blockContext);
             } else {
                 throw Error('Not implemented Assign operation');
                 // get chaining calls
@@ -252,15 +252,15 @@ export class Evaluator {
 
         if (node.type === 'bracketObjectAccess') {
             const sbNode = node as BracketObjectAccessNode;
-            const key = Evaluator.evalNode(sbNode.bracketBody, blockContext) as string;
+            const key = this.evalNode(sbNode.bracketBody, blockContext) as string;
             const obj = blockContext.blockScope.get(sbNode.propertyName as string) as Record<string, unknown>;
             return (obj[key] === undefined) ? null : obj[key];
         }
 
         if (node.type === "dotObjectAccess") {
             const dotObject = node as DotObjectAccessNode;
 
-            let startObject = Evaluator.evalNode(dotObject.nestedProps[0], blockContext) as any;
+            let startObject = this.evalNode(dotObject.nestedProps[0], blockContext) as any;
             for (let i = 1; i < dotObject.nestedProps.length; i++) {
                 const nestedProp = dotObject.nestedProps[i];
 
@@ -273,13 +273,13 @@ export class Evaluator {
                 } else if (nestedProp.type === 'bracketObjectAccess') {
                     const node = nestedProp as BracketObjectAccessNode;
                     startObject = startObject[node.propertyName] as unknown;
-                    startObject = startObject[Evaluator.evalNode(node.bracketBody, blockContext) as string] as unknown;
+                    startObject = startObject[this.evalNode(node.bracketBody, blockContext) as string] as unknown;
                 } 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 => Evaluator.evalNode(n, blockContext)) || []
+                    const pms = funcCallNode.paramNodes?.map(n => this.evalNode(n, blockContext)) || []
 
-                    startObject = Evaluator.invokeFunction(func.bind(startObject), pms);
+                    startObject = this.invokeFunction(func.bind(startObject), pms);
 
                 } else {
                     throw Error("Can't resolve dotObjectAccess node")
@@ -295,7 +295,7 @@ export class Evaluator {
             const obj = {} as Record<string, unknown>;
 
             for (const p of createObjectNode.props) {
-                obj[Evaluator.evalNode(p.name, blockContext) as string] = Evaluator.evalNode(p.value, blockContext);
+                obj[this.evalNode(p.name, blockContext) as string] = this.evalNode(p.value, blockContext);
             }
 
             return obj;
@@ -306,7 +306,7 @@ export class Evaluator {
             const res = [] as unknown[];
 
             for (const item of arrayNode.items) {
-                res.push(Evaluator.evalNode(item, blockContext));
+                res.push(this.evalNode(item, blockContext));
             }
 
             return res;
diff --git a/src/evaluator/evaluatorAsync.ts b/src/evaluator/evaluatorAsync.ts
@@ -27,7 +27,7 @@ export class EvaluatorAsync {
 
             const invoker = (funcDef.isAsync) ?
                 async (...args: unknown[]): Promise<unknown> => await this.jspyFuncInvokerAsync(funcDef, blockContext, ...args)
-                : (...args: unknown[]): unknown => Evaluator.jspyFuncInvoker(funcDef, blockContext, ...args);
+                : (...args: unknown[]): unknown => new Evaluator().jspyFuncInvoker(funcDef, blockContext, ...args);
 
             newScope.set(funcDef.funcAst.name, invoker);
         }
@@ -58,7 +58,7 @@ export class EvaluatorAsync {
                     throw err;
                 } else {
                     const loc = node.loc? node.loc : [0, 0]
-                    throw new JspyEvalError('mainModule', loc[0], loc[1], err.message)
+                    throw new JspyEvalError(blockContext.moduleName, loc[0], loc[1], err.message)
                 }
             }
         }
@@ -72,7 +72,7 @@ export class EvaluatorAsync {
         ast.type = 'func';
 
         const blockContext = {
-            namelessFuncsCount: 0,
+            moduleName: context.moduleName,
             blockScope: context.blockScope.clone()
         } as BlockContext;
 
@@ -213,7 +213,7 @@ export class EvaluatorAsync {
         if (node.type === "arrowFuncDef") {
             const arrowFuncDef = node as ArrowFuncDefNode;
 
-            return (...args: unknown[]): unknown => Evaluator.jspyFuncInvoker(arrowFuncDef, blockContext, ...args);
+            return (...args: unknown[]): unknown => new Evaluator().jspyFuncInvoker(arrowFuncDef, blockContext, ...args);
         }
 
         if (node.type === "funcCall") {
diff --git a/src/evaluator/scope.ts b/src/evaluator/scope.ts
@@ -1,11 +1,10 @@
 
 export interface BlockContext {
+    moduleName: string;
     returnCalled: boolean;
     breakCalled: boolean;
     continueCalled: boolean;
     returnObject: any;
-    currentLevel: string;
-    namelessFuncsCount: number;
     blockScope: Scope
 }
 
diff --git a/src/interpreter.ts b/src/interpreter.ts
@@ -32,25 +32,26 @@ export class Interpreter {
         return tokenizer.tokenize(script);
     }
 
-    parse(script: string): AstBlock {
+    parse(script: string, moduleName: string='main.jspy'): AstBlock {
         const tokenizer = new Tokenizer();
         const parser = new Parser();
-        const jspyAst = parser.parse(tokenizer.tokenize(script));
+        const jspyAst = parser.parse(tokenizer.tokenize(script), moduleName);
         return jspyAst;
     }
 
     eval(codeOrAst: string | AstBlock, scope: Record<string, unknown> = {}
-        , entryFunctionName: string = ''): unknown {
-        const ast = (typeof codeOrAst === 'string') ? this.parse(codeOrAst as string) : codeOrAst as AstBlock;
+        , entryFunctionName: string = '', moduleName: string = 'main.jspy'): unknown {
+        const ast = (typeof codeOrAst === 'string') ? this.parse(codeOrAst as string, moduleName) : codeOrAst as AstBlock;
         
         const blockContext = {
+            moduleName: moduleName,
             blockScope: new Scope(scope)
         } as BlockContext;
 
         blockContext.blockScope.set('printExecutionContext', () => console.log(blockContext.blockScope));
         blockContext.blockScope.set('getExecutionContext', () => blockContext.blockScope);
         
-        const result = Evaluator.evalBlock(ast, blockContext);
+        const result = new Evaluator().evalBlock(ast, blockContext);
         if (!entryFunctionName || !entryFunctionName.length) {
             return result;
         } else {
@@ -63,10 +64,11 @@ export class Interpreter {
     }
 
     async evalAsync(codeOrAst: string | AstBlock, scope: Record<string, unknown> = {}
-        , entryFunctionName: string = ''): Promise<unknown> {
-        const ast = (typeof codeOrAst === 'string') ? this.parse(codeOrAst as string) : codeOrAst as AstBlock;
+        , entryFunctionName: string = '', moduleName: string = 'main.jspy'): Promise<unknown> {
+        const ast = (typeof codeOrAst === 'string') ? this.parse(codeOrAst as string, moduleName) : codeOrAst as AstBlock;
         const evaluator = new EvaluatorAsync();
         const blockContext = {
+            moduleName: moduleName,
             blockScope: new Scope(scope)
         } as BlockContext;
         blockContext.blockScope.set('printExecutionContext', () => console.log(blockContext.blockScope));
@@ -89,9 +91,10 @@ export class Interpreter {
     /**
      * Compatibility method! Will be deprecated soon
      */
-    async evaluate(script: string, context: object = {}, entryFunctionName: string = ''): Promise<any> {
+    async evaluate(script: string, context: object = {}, entryFunctionName: string = ''
+        , moduleName: string = 'main.jspy'): Promise<any> {
         if (!script || !script.length) { return null; }
-        const ast = this.parse(script);
+        const ast = this.parse(script, moduleName);
 
         context = (context && typeof context === 'object') ? context : {};
         context = await this.assignLegacyImportContext(ast, context);
@@ -102,8 +105,7 @@ export class Interpreter {
         } as Record<string, unknown>;
 
         try {
-
-            return this.evalAsync(ast, this.globalScope, entryFunctionName);
+            return this.evalAsync(ast, this.globalScope, entryFunctionName, moduleName);
         } catch (error) {
             throw error;
         }
diff --git a/src/parser/parser.ts b/src/parser/parser.ts

Original file line number	Diff line number	Diff line change
`@@ -119,7 +119,7 @@ <h4>JSPython development console</h4>`
`119`	`119`	`}`
`120`	`120`	`};`
`121`	`121`	`const result = await jsPython()`
`122`		`- .evaluate(scripts, scope);`
	`122`	`+ .evaluate(scripts, scope, undefined, 'index1.jspy');`
`123`	`123`
`124`	`124`	`// const result = jsPython()`
`125`	`125`	`// .eval(scripts, scope);`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+import { Token } from "./token-types";`
	`2`	`+`
`1`	`3`	`export function parseDatetimeOrNull(value: string \| Date): Date \| null {`
`2`	`4`	`if (!value) { return null; }`
`3`	`5`	`if (value instanceof Date && !isNaN(value.valueOf())) { return value; }`
`@@ -92,6 +94,6 @@ export class JspyEvalError extends Error {`
`92`	`94`	`constructor(public module: string, public line: number, public column: number, public message: string) {`
`93`	`95`	`super();`
`94`	`96`	`this.message = jspyErrorMessage("JspyEvalError", module, line, column, message);`
`95`		`- Object.setPrototypeOf(this, JspyParserError.prototype);`
	`97`	`+ Object.setPrototypeOf(this, JspyEvalError.prototype);`
`96`	`98`	`}`
`97`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ export class EvaluatorAsync {`
`27`	`27`
`28`	`28`	`const invoker = (funcDef.isAsync) ?`
`29`	`29`	`async (...args: unknown[]): Promise<unknown> => await this.jspyFuncInvokerAsync(funcDef, blockContext, ...args)`
`30`		`- : (...args: unknown[]): unknown => Evaluator.jspyFuncInvoker(funcDef, blockContext, ...args);`
	`30`	`+ : (...args: unknown[]): unknown => new Evaluator().jspyFuncInvoker(funcDef, blockContext, ...args);`
`31`	`31`
`32`	`32`	`newScope.set(funcDef.funcAst.name, invoker);`
`33`	`33`	`}`
`@@ -58,7 +58,7 @@ export class EvaluatorAsync {`
`58`	`58`	`throw err;`
`59`	`59`	`} else {`
`60`	`60`	`const loc = node.loc? node.loc : [0, 0]`
`61`		`- throw new JspyEvalError('mainModule', loc[0], loc[1], err.message)`
	`61`	`+ throw new JspyEvalError(blockContext.moduleName, loc[0], loc[1], err.message)`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`	`}`
`@@ -72,7 +72,7 @@ export class EvaluatorAsync {`
`72`	`72`	`ast.type = 'func';`
`73`	`73`
`74`	`74`	`const blockContext = {`
`75`		`- namelessFuncsCount: 0,`
	`75`	`+ moduleName: context.moduleName,`
`76`	`76`	`blockScope: context.blockScope.clone()`
`77`	`77`	`} as BlockContext;`
`78`	`78`
`@@ -213,7 +213,7 @@ export class EvaluatorAsync {`
`213`	`213`	`if (node.type === "arrowFuncDef") {`
`214`	`214`	`const arrowFuncDef = node as ArrowFuncDefNode;`
`215`	`215`
`216`		`- return (...args: unknown[]): unknown => Evaluator.jspyFuncInvoker(arrowFuncDef, blockContext, ...args);`
	`216`	`+ return (...args: unknown[]): unknown => new Evaluator().jspyFuncInvoker(arrowFuncDef, blockContext, ...args);`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`if (node.type === "funcCall") {`