feat(Parser): add support for method invocations

Author: vsavkin

modules/change_detection/src/parser/ast.js

@@ -1,5 +1,6 @@
 import {FIELD, toBool, autoConvertAdd, isBlank, FunctionWrapper, BaseException} from "facade/lang";
 import {List, Map, ListWrapper, MapWrapper} from "facade/collection";
+import {ClosureMap} from "./closure_map";
 
 export class AST {
  eval(context) {
@@ -221,8 +222,6 @@ export class Binary extends AST {
  case '-' : return left - right;
  case '*' : return left * right;
  case '/' : return left / right;
- // This exists only in Dart, TODO(rado) figure out whether to support it.
- // case '~/' : return left ~/ right;
  case '%' : return left % right;
  case '==' : return left == right;
  case '!=' : return left != right;
@@ -263,6 +262,38 @@ export class Assignment extends AST {
  }
 }
 
+export class MethodCall extends AST {
+ @FIELD('final receiver:AST')
+ @FIELD('final fn:Function')
+ @FIELD('final args:List')
+ constructor(receiver:AST, fn:Function, args:List) {
+ this.receiver = receiver;
+ this.fn = fn;
+ this.args = args;
+ }
+
+ eval(context) {
+ var obj = this.receiver.eval(context);
+ return this.fn(obj, evalList(context, this.args));
+ }
+}
+
+export class FunctionCall extends AST {
+ @FIELD('final receiver:AST')
+ @FIELD('final closureMap:ClosureMap')
+ @FIELD('final args:List')
+ constructor(target:AST, closureMap:ClosureMap, args:List) {
+ this.target = target;
+ this.closureMap = closureMap;
+ this.args = args;
+ }
+
+ eval(context) {
+ var obj = this.target.eval(context);
+ return FunctionWrapper.apply(obj, evalList(context, this.args));
+ }
+}
+
 //INTERFACE
 export class AstVisitor {
  visitImplicitReceiver(ast:ImplicitReceiver) {}

modules/change_detection/src/parser/closure_map.dart

@@ -12,4 +12,9 @@ class ClosureMap {
  var symbol = new Symbol(name);
  return (receiver, value) => reflect(receiver).setField(symbol, value).reflectee;
  }
+
+ Function fn(String name) {
+ var symbol = new Symbol(name);
+ return (receiver, posArgs) => reflect(receiver).invoke(symbol, posArgs).reflectee;
+ }
 }

modules/change_detection/src/parser/closure_map.es6

@@ -8,4 +8,8 @@ export class ClosureMap {
  setter(name:string) {
  return new Function('o', 'v', 'return o.' + name + ' = v;');
  }
+
+ fn(name:string) {
+ return new Function('o', 'pos', 'return o.' + name + '.apply(o, pos);');
+ }
 }

modules/change_detection/src/parser/parser.js

@@ -1,6 +1,7 @@
 import {FIELD, int, isBlank, BaseException, StringWrapper} from 'facade/lang';
 import {ListWrapper, List} from 'facade/collection';
-import {Lexer, EOF, Token, $PERIOD, $COLON, $SEMICOLON, $LBRACKET, $RBRACKET, $COMMA, $LBRACE, $RBRACE} from './lexer';
+import {Lexer, EOF, Token, $PERIOD, $COLON, $SEMICOLON, $LBRACKET, $RBRACKET,
+ $COMMA, $LBRACE, $RBRACE, $LPAREN, $RPAREN} from './lexer';
 import {ClosureMap} from './closure_map';
 import {
  AST,
@@ -16,7 +17,9 @@ import {
  Chain,
  KeyedAccess,
  LiteralArray,
- LiteralMap
+ LiteralMap,
+ MethodCall,
+ FunctionCall
  } from './ast';
 
 var _implicitReceiver = new ImplicitReceiver();
@@ -273,21 +276,26 @@ class _ParseAST {
  } else if (this.optionalOperator('!')) {
  return new PrefixNot(this.parsePrefix());
  } else {
- return this.parseAccessOrCallMember();
+ return this.parseCallChain();
  }
  }
 
- parseAccessOrCallMember():AST {
+ parseCallChain():AST {
  var result = this.parsePrimary();
  while (true) {
  if (this.optionalCharacter($PERIOD)) {
- result = this.parseFieldRead(result);
+ result = this.parseAccessorOrMethodCall(result);
 
  } else if (this.optionalCharacter($LBRACKET)) {
  var key = this.parseExpression();
  this.expectCharacter($RBRACKET);
  result = new KeyedAccess(result, key);
 
+ } else if (this.optionalCharacter($LPAREN)) {
+ var args = this.parseCallArguments();
+ this.expectCharacter($RPAREN);
+ result = new FunctionCall(result, this.closureMap, args);
+
  } else {
  return result;
  }
@@ -316,7 +324,7 @@ class _ParseAST {
  return this.parseLiteralMap();
 
  } else if (this.next.isIdentifier()) {
- return this.parseFieldRead(_implicitReceiver);
+ return this.parseAccessorOrMethodCall(_implicitReceiver);
 
  } else if (this.next.isNumber()) {
  var value = this.next.toNumber();
@@ -362,9 +370,29 @@ class _ParseAST {
  return new LiteralMap(keys, values);
  }
 
- parseFieldRead(receiver):AST {
+ parseAccessorOrMethodCall(receiver):AST {
  var id = this.expectIdentifierOrKeyword();
- return new FieldRead(receiver, id, this.closureMap.getter(id), this.closureMap.setter(id));
+
+ if (this.optionalCharacter($LPAREN)) {
+ var args = this.parseCallArguments();
+ this.expectCharacter($RPAREN);
+ var fn = this.closureMap.fn(id);
+ return new MethodCall(receiver, fn, args);
+
+ } else {
+ var getter = this.closureMap.getter(id);
+ var setter = this.closureMap.setter(id);
+ return new FieldRead(receiver, id, getter, setter);
+ }
+ }
+
+ parseCallArguments() {
+ if (this.next.isCharacter($RPAREN)) return [];
+ var positionals = [];
+ do {
+ ListWrapper.push(positionals, this.parseExpression());
+ } while (this.optionalCharacter($COMMA))
+ return positionals;
  }
 
  error(message:string, index:int = null) {

modules/change_detection/test/parser/parser_spec.js

@@ -7,13 +7,14 @@ import {Formatter, LiteralPrimitive} from 'change_detection/parser/ast';
 import {ClosureMap} from 'change_detection/parser/closure_map';
 
 class TestData {
- constructor(a, b) {
+ constructor(a, b, fnReturnValue) {
  this.a = a;
  this.b = b;
+ this.fnReturnValue = fnReturnValue;
  }
 
- constant() {
- return "constant";
+ fn() {
+ return this.fnReturnValue;
  }
 
  add(a, b) {
@@ -28,8 +29,8 @@ class ContextWithErrors {
 }
 
 export function main() {
- function td(a = 0, b = 0) {
- return new TestData(a, b);
+ function td(a = 0, b = 0, fnReturnValue = "constant") {
+ return new TestData(a, b, fnReturnValue);
  }
 
  function createParser() {
@@ -183,6 +184,17 @@ export function main() {
  expectEvalError("5=4").toThrowError(new RegExp("Expression 5 is not assignable"));
  });
 
+ it("should evaluate method calls", () => {
+ expectEval("fn()", td(0,0, "constant")).toEqual("constant");
+ expectEval("add(1,2)").toEqual(3);
+ expectEval("a.add(1,2)", td(td())).toEqual(3);
+ expectEval("fn().add(1,2)", td(0,0,td())).toEqual(3);
+ });
+
+ it("should evaluate function calls", () => {
+ expectEval("fn()(1,2)", td(0, 0, (a,b) => a + b)).toEqual(3);
+ });
+
  it('should evaluate array', () => {
  expectEval("[1][0]").toEqual(1);
  expectEval("[[1]][0][0]").toEqual(1);