refactor(parser): pass FilterMap to expression eval instead of parser constructor

Author: pavelgj

bin/parser_generator_for_spec.dart

@@ -224,6 +224,7 @@ main(arguments) {
       "n",
       "1|nonexistent",
       "publicField",
-      "_privateField"
+      "_privateField",
+      "'World'|hello"
   ]);
 }

lib/core/parser/dynamic_parser.dart

@@ -5,6 +5,7 @@ import 'package:angular/core/module.dart' show FilterMap, NgInjectableService;
 import 'package:angular/core/parser/parser.dart';
 import 'package:angular/core/parser/lexer.dart';
 import 'package:angular/core/parser/dynamic_parser_impl.dart';
+import 'package:angular/core/parser/syntax.dart' show defaultFilterMap;
 
 import 'package:angular/core/parser/eval.dart';
 import 'package:angular/core/parser/utils.dart' show EvalError;
@@ -45,9 +46,9 @@ class DynamicExpression extends Expression {
   accept(Visitor visitor) => _expression.accept(visitor);
   toString() => _expression.toString();
 
-  eval(scope) {
+  eval(scope, [FilterMap filters = defaultFilterMap]) {
     try {
-      return _expression.eval(scope);
+      return _expression.eval(scope, filters);
     } on EvalError catch (e, s) {
       throw e.unwrap("$this", s);
     }
@@ -64,19 +65,17 @@ class DynamicExpression extends Expression {
 
 @NgInjectableService()
 class DynamicParserBackend extends ParserBackend {
-  final FilterMap _filters;
   final ClosureMap _closures;
-  DynamicParserBackend(this._filters, this._closures);
+  DynamicParserBackend(this._closures);
 
   bool isAssignable(Expression expression)
       => expression.isAssignable;
 
   Expression newFilter(expression, name, arguments) {
-    Function filter = _filters(name);
     List allArguments = new List(arguments.length + 1);
     allArguments[0] = expression;
     allArguments.setAll(1, arguments);
-    return new Filter(expression, name, arguments, filter, allArguments);
+    return new Filter(expression, name, arguments, allArguments);
   }
 
   Expression newChain(expressions)

lib/core/parser/eval.dart

@@ -2,53 +2,57 @@ library angular.core.parser.eval;
 
 import 'package:angular/core/parser/syntax.dart' as syntax;
 import 'package:angular/core/parser/utils.dart';
+import 'package:angular/core/module.dart';
+import 'package:angular/core/parser/syntax.dart';
 
 export 'package:angular/core/parser/eval_access.dart';
 export 'package:angular/core/parser/eval_calls.dart';
 
 class Chain extends syntax.Chain {
   Chain(List<syntax.Expression> expressions) : super(expressions);
-  eval(scope) {
+  eval(scope, [FilterMap filters]) {
     var result;
     for (int i = 0, length = expressions.length; i < length; i++) {
-      var last = expressions[i].eval(scope);
+      var last = expressions[i].eval(scope, filters);
       if (last != null) result = last;
     }
     return result;
   }
 }
 
 class Filter extends syntax.Filter {
-  final Function function;
   final List allArguments;
   Filter(syntax.Expression expression, String name, List<syntax.Expression> arguments,
-         Function this.function, List<syntax.Expression> this.allArguments)
+         List<syntax.Expression> this.allArguments)
       : super(expression, name, arguments);
-  eval(scope) => Function.apply(function, evalList(scope, allArguments));
+
+  eval(scope, [FilterMap filters]) =>
+      Function.apply(filters(name), evalList(scope, allArguments, filters));
 }
 
 class Assign extends syntax.Assign {
   Assign(syntax.Expression target, value) : super(target, value);
-  eval(scope) => target.assign(scope, value.eval(scope));
+  eval(scope, [FilterMap filters]) =>
+      target.assign(scope, value.eval(scope, filters));
 }
 
 class Conditional extends syntax.Conditional {
   Conditional(syntax.Expression condition,
               syntax.Expression yes, syntax.Expression no): super(condition, yes, no);
-  eval(scope) => toBool(condition.eval(scope))
+  eval(scope, [FilterMap filters]) => toBool(condition.eval(scope))
       ? yes.eval(scope)
       : no.eval(scope);
 }
 
 class PrefixNot extends syntax.Prefix {
   PrefixNot(syntax.Expression expression) : super('!', expression);
-  eval(scope) => !toBool(expression.eval(scope));
+  eval(scope, [FilterMap filters]) => !toBool(expression.eval(scope));
 }
 
 class Binary extends syntax.Binary {
   Binary(String operation, syntax.Expression left, syntax.Expression right):
       super(operation, left, right);
-  eval(scope) {
+  eval(scope, [FilterMap filters]) {
     var left = this.left.eval(scope);
     switch (operation) {
       case '&&': return toBool(left) && toBool(this.right.eval(scope));
@@ -77,20 +81,22 @@ class Binary extends syntax.Binary {
 
 class LiteralPrimitive extends syntax.LiteralPrimitive {
   LiteralPrimitive(dynamic value) : super(value);
-  eval(scope) => value;
+  eval(scope, [FilterMap filters]) => value;
 }
 
 class LiteralString extends syntax.LiteralString {
   LiteralString(String value) : super(value);
-  eval(scope) => value;
+  eval(scope, [FilterMap filters]) => value;
 }
 
 class LiteralArray extends syntax.LiteralArray {
   LiteralArray(List<syntax.Expression> elements) : super(elements);
-  eval(scope) => elements.map((e) => e.eval(scope)).toList();
+  eval(scope, [FilterMap filters]) =>
+      elements.map((e) => e.eval(scope, filters)).toList();
 }
 
 class LiteralObject extends syntax.LiteralObject {
   LiteralObject(List<String> keys, List<syntax.Expression>values) : super(keys, values);
-  eval(scope) => new Map.fromIterables(keys, values.map((e) => e.eval(scope)));
+  eval(scope, [FilterMap filters]) =>
+      new Map.fromIterables(keys, values.map((e) => e.eval(scope, filters)));
 }

lib/core/parser/eval_access.dart

@@ -4,26 +4,28 @@ import 'dart:mirrors';
 import 'package:angular/core/parser/parser.dart';
 import 'package:angular/core/parser/syntax.dart' as syntax;
 import 'package:angular/core/parser/utils.dart';
+import 'package:angular/core/module.dart';
 
 class AccessScope extends syntax.AccessScope with AccessReflective {
   final Symbol symbol;
   AccessScope(String name) : super(name), symbol = new Symbol(name);
-  eval(scope) => _eval(scope);
+  eval(scope, [FilterMap filters]) => _eval(scope);
   assign(scope, value) => _assign(scope, scope, value);
 }
 
 class AccessScopeFast extends syntax.AccessScope with AccessFast {
   final Getter getter;
   final Setter setter;
   AccessScopeFast(String name, this.getter, this.setter) : super(name);
-  eval(scope) => _eval(scope);
+  eval(scope, [FilterMap filters]) => _eval(scope);
   assign(scope, value) => _assign(scope, scope, value);
 }
 
 class AccessMember extends syntax.AccessMember with AccessReflective {
   final Symbol symbol;
-  AccessMember(object, String name) : super(object, name), symbol = new Symbol(name);
-  eval(scope) => _eval(object.eval(scope));
+  AccessMember(object, String name)
+      : super(object, name), symbol = new Symbol(name);
+  eval(scope, [FilterMap filters]) => _eval(object.eval(scope, filters));
   assign(scope, value) => _assign(scope, object.eval(scope), value);
   _assignToNonExisting(scope, value) => object.assign(scope, { name: value });
 }
@@ -33,14 +35,15 @@ class AccessMemberFast extends syntax.AccessMember with AccessFast {
   final Setter setter;
   AccessMemberFast(object, String name, this.getter, this.setter)
       : super(object, name);
-  eval(scope) => _eval(object.eval(scope));
+  eval(scope, [FilterMap filters]) => _eval(object.eval(scope, filters));
   assign(scope, value) => _assign(scope, object.eval(scope), value);
   _assignToNonExisting(scope, value) => object.assign(scope, { name: value });
 }
 
 class AccessKeyed extends syntax.AccessKeyed {
   AccessKeyed(object, key) : super(object, key);
-  eval(scope) => getKeyed(object.eval(scope), key.eval(scope));
+  eval(scope, [FilterMap filters]) =>
+      getKeyed(object.eval(scope, filters), key.eval(scope, filters));
   assign(scope, value) => setKeyed(object.eval(scope), key.eval(scope), value);
 }
 

lib/core/parser/eval_calls.dart

@@ -3,58 +3,59 @@ library angular.core.parser.eval_calls;
 import 'dart:mirrors';
 import 'package:angular/core/parser/syntax.dart' as syntax;
 import 'package:angular/core/parser/utils.dart';
+import 'package:angular/core/module.dart';
 
 class CallScope extends syntax.CallScope with CallReflective {
   final Symbol symbol;
   CallScope(name, arguments)
       : super(name, arguments)
       , symbol = new Symbol(name);
-  eval(scope) => _eval(scope, scope);
+  eval(scope, [FilterMap filters]) => _eval(scope, scope);
 }
 
 class CallMember extends syntax.CallMember with CallReflective {
   final Symbol symbol;
   CallMember(object, name, arguments)
       : super(object, name, arguments)
       , symbol = new Symbol(name);
-  eval(scope) => _eval(scope, object.eval(scope));
+  eval(scope, [FilterMap filters]) => _eval(scope, object.eval(scope, filters));
 }
 
 class CallScopeFast0 extends syntax.CallScope with CallFast {
   final Function function;
   CallScopeFast0(name, arguments, this.function) : super(name, arguments);
-  eval(scope) => _evaluate0(scope);
+  eval(scope, [FilterMap filters]) => _evaluate0(scope);
 }
 
 class CallScopeFast1 extends syntax.CallScope with CallFast {
   final Function function;
   CallScopeFast1(name, arguments, this.function) : super(name, arguments);
-  eval(scope) => _evaluate1(scope, arguments[0].eval(scope));
+  eval(scope, [FilterMap filters]) => _evaluate1(scope, arguments[0].eval(scope, filters));
 }
 
 class CallMemberFast0 extends syntax.CallMember with CallFast {
   final Function function;
   CallMemberFast0(object, name, arguments, this.function)
       : super(object, name, arguments);
-  eval(scope) => _evaluate0(object.eval(scope));
+  eval(scope, [FilterMap filters]) => _evaluate0(object.eval(scope, filters));
 }
 
 class CallMemberFast1 extends syntax.CallMember with CallFast {
   final Function function;
   CallMemberFast1(object, name, arguments, this.function)
       : super(object, name, arguments);
-  eval(scope) => _evaluate1(object.eval(scope),
-      arguments[0].eval(scope));
+  eval(scope, [FilterMap filters]) => _evaluate1(object.eval(scope, filters),
+      arguments[0].eval(scope, filters));
 }
 
 class CallFunction extends syntax.CallFunction {
   CallFunction(function, arguments) : super(function, arguments);
-  eval(scope) {
-    var function  = this.function.eval(scope);
+  eval(scope, [FilterMap filters]) {
+    var function  = this.function.eval(scope, filters);
     if (function is !Function) {
       throw new EvalError('${this.function} is not a function');
     } else {
-      return relaxFnApply(function, evalList(scope, arguments));
+      return relaxFnApply(function, evalList(scope, arguments, filters));
     }
   }
 }

lib/core/parser/static_parser.dart

@@ -1,8 +1,9 @@
 library angular.core.parser.static_parser;
 
-import 'package:angular/core/module.dart' show NgInjectableService;
+import 'package:angular/core/module.dart' show FilterMap, NgInjectableService;
 import 'package:angular/core/parser/parser.dart';
 import 'package:angular/core/parser/utils.dart' show EvalError;
+import 'package:angular/core/parser/syntax.dart';
 
 class StaticParserFunctions {
   final Map<String, Function> eval;
@@ -41,9 +42,9 @@ class StaticExpression extends Expression {
   accept(Visitor visitor) => throw "Cannot visit static expression $this";
   toString() => _input;
 
-  eval(scope) {
+  eval(scope, [FilterMap filters = defaultFilterMap]) {
     try {
-      return _eval(scope);
+      return _eval(scope, filters);
     } on EvalError catch (e, s) {
       throw e.unwrap("$this", s);
     }

lib/core/parser/syntax.dart

@@ -3,6 +3,7 @@ library angular.core.parser.syntax;
 import 'package:angular/core/parser/parser.dart' show LocalsWrapper;
 import 'package:angular/core/parser/unparser.dart' show Unparser;
 import 'package:angular/core/parser/utils.dart' show EvalError;
+import 'package:angular/core/module.dart';
 
 abstract class Visitor {
   visit(Expression expression)
@@ -56,7 +57,7 @@ abstract class Expression {
   bool get isAssignable => false;
   bool get isChain => false;
 
-  eval(scope)
+  eval(scope, [FilterMap filters = defaultFilterMap])
       => throw new EvalError("Cannot evaluate $this");
   assign(scope, value)
       => throw new EvalError("Cannot assign to $this");
@@ -200,3 +201,14 @@ class LiteralObject extends Literal {
   LiteralObject(this.keys, this.values);
   accept(Visitor visitor) => visitor.visitLiteralObject(this);
 }
+
+const defaultFilterMap = const _DefaultFilterMap();
+
+class _DefaultFilterMap implements FilterMap {
+  const _DefaultFilterMap();
+
+  call(name) => throw 'No NgFilter: $name found!';
+  Type operator[](annotation) => null;
+  forEach(fn) { }
+  annotationsFor(type) => null;
+}

lib/core/parser/utils.dart

@@ -1,6 +1,7 @@
 library angular.core.parser.utils;
 
 import 'package:angular/core/parser/syntax.dart' show Expression;
+import 'package:angular/core/module.dart';
 export 'package:angular/utils.dart' show relaxFnApply, relaxFnArgs, toBool;
 
 /// Marker for an uninitialized value.
@@ -18,14 +19,14 @@ class EvalError {
 }
 
 /// Evaluate the [list] in context of the [scope].
-List evalList(scope, List<Expression> list) {
+List evalList(scope, List<Expression> list, [FilterMap filters]) {
   int length = list.length;
   for(int cacheLength = _evalListCache.length; cacheLength <= length; cacheLength++) {
     _evalListCache.add(new List(cacheLength));
   }
   List result = _evalListCache[length];
   for (int i = 0; i < length; i++) {
-    result[i] = list[i].eval(scope);
+    result[i] = list[i].eval(scope, filters);
   }
   return result;
 }