Fixed an issue with conflicting prototype methods. #37

Author: ppaska

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jspython-interpreter",
-  "version": "2.1.13",
+  "version": "2.1.14",
   "description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",
   "keywords": [
     "python",

src/common/operators.ts

@@ -19,38 +19,38 @@ export type Operators =
   | LogicalOperators
   | MembershipOperators;
 
-export const OperatorsMap: Record<Operators, OperationTypes> = {
-  '+': OperationTypes.Arithmetic,
-  '-': OperationTypes.Arithmetic,
-  '*': OperationTypes.Arithmetic,
-  '/': OperationTypes.Arithmetic,
-  '%': OperationTypes.Arithmetic,
-  '**': OperationTypes.Arithmetic,
-  '//': OperationTypes.Arithmetic,
-
-  '>': OperationTypes.Comparison,
-  '>=': OperationTypes.Comparison,
-  '==': OperationTypes.Comparison,
-  '!=': OperationTypes.Comparison,
-  '<>': OperationTypes.Comparison,
-  '<': OperationTypes.Comparison,
-  '<=': OperationTypes.Comparison,
-
-  and: OperationTypes.Logical,
-  or: OperationTypes.Logical,
-  // "not": OperationTypes.Logical,
-  // "not in": OperationTypes.Logical,
-
-  in: OperationTypes.Membership,
-
-  '=': OperationTypes.Assignment,
-  '+=': OperationTypes.Assignment,
-  '-=': OperationTypes.Assignment,
-  '*=': OperationTypes.Assignment,
-  '/=': OperationTypes.Assignment,
-  '++': OperationTypes.Assignment,
-  '--': OperationTypes.Assignment
-};
+export const OperatorsMap: Map<Operators, OperationTypes> = new Map<Operators, OperationTypes>([
+  ['+', OperationTypes.Arithmetic],
+  ['-', OperationTypes.Arithmetic],
+  ['*', OperationTypes.Arithmetic],
+  ['/', OperationTypes.Arithmetic],
+  ['%', OperationTypes.Arithmetic],
+  ['**', OperationTypes.Arithmetic],
+  ['//', OperationTypes.Arithmetic],
+
+  ['>', OperationTypes.Comparison],
+  ['>=', OperationTypes.Comparison],
+  ['==', OperationTypes.Comparison],
+  ['!=', OperationTypes.Comparison],
+  ['<>', OperationTypes.Comparison],
+  ['<', OperationTypes.Comparison],
+  ['<=', OperationTypes.Comparison],
+
+  ['and', OperationTypes.Logical],
+  ['or', OperationTypes.Logical],
+  // "not", OperationTypes.Logical],
+  // "not in", OperationTypes.Logical],
+
+  ['in', OperationTypes.Membership],
+
+  ['=', OperationTypes.Assignment],
+  ['+=', OperationTypes.Assignment],
+  ['-=', OperationTypes.Assignment],
+  ['*=', OperationTypes.Assignment],
+  ['/=', OperationTypes.Assignment],
+  ['++', OperationTypes.Assignment],
+  ['--', OperationTypes.Assignment]
+]);
 
 export type Primitive = string | number | boolean | null;
 
@@ -61,30 +61,48 @@ export type ExpressionOperators =
   | MembershipOperators;
 type ExpressionOperation = (l: Primitive, r: Primitive) => Primitive;
 
-export const OperationFuncs: Record<ExpressionOperators, ExpressionOperation> = {
-  '+': (l, r) => arithmeticOperation(l, r, '+'),
-  '-': (l, r) => arithmeticOperation(l, r, '-'),
-  '/': (l, r) => arithmeticOperation(l, r, '/'),
-  '*': (l, r) => arithmeticOperation(l, r, '*'),
-  '%': (l, r) => arithmeticOperation(l, r, '%'),
-  '**': (l, r) => arithmeticOperation(l, r, '**'),
-  '//': (l, r) => arithmeticOperation(l, r, '//'),
-
-  '>': (l, r) => comparissonOperation(l, r, '>'),
-  '>=': (l, r) => comparissonOperation(l, r, '>='),
-  '<': (l, r) => comparissonOperation(l, r, '<'),
-  '<=': (l, r) => comparissonOperation(l, r, '<='),
-  '==': (l, r) => comparissonOperation(l, r, '=='),
-  '!=': (l, r) => comparissonOperation(l, r, '!='),
-  '<>': (l, r) => comparissonOperation(l, r, '<>'),
-
-  and: (l, r) => logicalOperation(l, r, 'and'),
-  or: (l, r) => logicalOperation(l, r, 'or'),
-  // "not": (l, r) => logicalOperation(l, r, "not"),
-  // "not in": (l, r) => logicalOperation(l, r, "not in"),
-
-  in: (l, r) => membershipOperation(l, r, 'in')
-};
+export const OperationFuncs: Map<ExpressionOperators, ExpressionOperation> = new Map<
+  ExpressionOperators,
+  ExpressionOperation
+>([
+  ['+' as ExpressionOperators, ((l, r) => arithmeticOperation(l, r, '+')) as ExpressionOperation],
+  ['-' as ExpressionOperators, ((l, r) => arithmeticOperation(l, r, '-')) as ExpressionOperation],
+  ['/' as ExpressionOperators, ((l, r) => arithmeticOperation(l, r, '/')) as ExpressionOperation],
+  ['*' as ExpressionOperators, ((l, r) => arithmeticOperation(l, r, '*')) as ExpressionOperation],
+  ['%' as ExpressionOperators, ((l, r) => arithmeticOperation(l, r, '%')) as ExpressionOperation],
+  ['**' as ExpressionOperators, ((l, r) => arithmeticOperation(l, r, '**')) as ExpressionOperation],
+  ['//' as ExpressionOperators, ((l, r) => arithmeticOperation(l, r, '//')) as ExpressionOperation],
+
+  ['>' as ExpressionOperators, ((l, r) => comparissonOperation(l, r, '>')) as ExpressionOperation],
+  [
+    '>=' as ExpressionOperators,
+    ((l, r) => comparissonOperation(l, r, '>=')) as ExpressionOperation
+  ],
+  ['<' as ExpressionOperators, ((l, r) => comparissonOperation(l, r, '<')) as ExpressionOperation],
+  [
+    '<=' as ExpressionOperators,
+    ((l, r) => comparissonOperation(l, r, '<=')) as ExpressionOperation
+  ],
+  [
+    '==' as ExpressionOperators,
+    ((l, r) => comparissonOperation(l, r, '==')) as ExpressionOperation
+  ],
+  [
+    '!=' as ExpressionOperators,
+    ((l, r) => comparissonOperation(l, r, '!=')) as ExpressionOperation
+  ],
+  [
+    '<>' as ExpressionOperators,
+    ((l, r) => comparissonOperation(l, r, '<>')) as ExpressionOperation
+  ],
+
+  ['and' as ExpressionOperators, ((l, r) => logicalOperation(l, r, 'and')) as ExpressionOperation],
+  ['or' as ExpressionOperators, ((l, r) => logicalOperation(l, r, 'or')) as ExpressionOperation],
+  // "not" as ExpressionOperators, ((l, r) => logicalOperation(l, r, "not")) as ExpressionOperation],
+  // "not in" as ExpressionOperators, ((l, r) => logicalOperation(l, r, "not in")) as ExpressionOperation],
+
+  ['in' as ExpressionOperators, ((l, r) => membershipOperation(l, r, 'in')) as ExpressionOperation]
+]);
 
 function membershipOperation(l: Primitive, r: Primitive, op: MembershipOperators): Primitive {
   if (typeof l === 'string') {

src/common/token-types.ts

@@ -182,8 +182,11 @@ export function findOperators(
   operationType: OperationTypes | null = null
 ): number[] {
   return !operationType
-    ? findTokenValueIndexes(tokens, value => OperatorsMap[value as Operators] !== undefined)
-    : findTokenValueIndexes(tokens, value => OperatorsMap[value as Operators] === operationType);
+    ? findTokenValueIndexes(tokens, value => OperatorsMap.has(value as Operators))
+    : findTokenValueIndexes(
+        tokens,
+        value => OperatorsMap.get(value as Operators) === operationType
+      );
 }
 
 function skipInnerBrackets(

src/evaluator/evaluator.ts

@@ -160,7 +160,7 @@ export class Evaluator {
           }
         }
       }
-      
+
       if (doElse && ifNode.elseBody) {
         this.evalBlock(
           { name: blockContext.moduleName, type: 'if', body: ifNode.elseBody } as AstBlock,
@@ -332,7 +332,9 @@ export class Evaluator {
       const binOpNode = node as BinOpNode;
       const left = this.evalNode(binOpNode.left, blockContext);
       const right = this.evalNode(binOpNode.right, blockContext);
-      return OperationFuncs[binOpNode.op](left as Primitive, right as Primitive);
+      const func = OperationFuncs.get(binOpNode.op);
+      if (typeof func === 'function') return func(left as Primitive, right as Primitive);
+      else throw new Error('Unknown binary oprastion');
     }
 
     if (node.type === 'logicalOp') {

src/evaluator/evaluatorAsync.ts

@@ -436,7 +436,10 @@ export class EvaluatorAsync {
       const binOpNode = node as BinOpNode;
       const left = await this.evalNodeAsync(binOpNode.left, blockContext);
       const right = await this.evalNodeAsync(binOpNode.right, blockContext);
-      return OperationFuncs[binOpNode.op](left as Primitive, right as Primitive);
+
+      const func = OperationFuncs.get(binOpNode.op);
+      if (typeof func === 'function') return func(left as Primitive, right as Primitive);
+      else throw new Error('Unknown binary oprastion');
     }
 
     if (node.type === 'logicalOp') {

src/parser/parser.spec.ts

@@ -157,6 +157,28 @@ describe('Parser => ', () => {
     expect(!!(innerNodes[3] as ChainingObjectAccessNode).nullCoelsing).toBe(true);
     expect(!!(innerNodes[4] as ChainingObjectAccessNode).nullCoelsing).toBe(true);
     expect(!!(innerNodes[5] as ChainingObjectAccessNode).nullCoelsing).toBe(false);
-  });  
+  });
+
+  it('chaining calls 1 with ? ', async () => {
+    const script = `"1,2,3".split(',')?[0]`;
+    const ast = new Parser().parse(new Tokenizer().tokenize(script));
+    expect(ast.body.length).toBe(1);
+    const innerNodes = (ast.body[0] as ChainingCallsNode).innerNodes;
+
+    expect(ast.body[0].type).toBe("chainingCalls");
+    expect(innerNodes.length).toBe(3);
+    expect(innerNodes[2].type).toBe("chainingObjectAccess");
+
+    expect(!!(innerNodes[0] as ChainingObjectAccessNode).nullCoelsing).toBe(false);
+    expect((innerNodes[1] as ChainingObjectAccessNode).nullCoelsing).toBe(true);
+    expect(!!(innerNodes[2] as ChainingObjectAccessNode).nullCoelsing).toBe(false);    
+  });
+
+  it('prototype methods call ', async () => {
+    expect(new Parser().parse(new Tokenizer().tokenize(`t.toString`)).body.length).toBe(1);
+    expect(new Parser().parse(new Tokenizer().tokenize(`t.toString()`)).body.length).toBe(1);
+    expect(new Parser().parse(new Tokenizer().tokenize(`t.valueOf`)).body.length).toBe(1);
+    expect(new Parser().parse(new Tokenizer().tokenize(`t.valueOf()`)).body.length).toBe(1);
+  });
 
 });