reflactor(parser): rename DynamicParser into Parser

Since there is only one implementation of the Parser interface, which is used for both dynamic and static deployments, calling it DynamicParser is misleading.

- Remove the Parser interface
- Rename rename DynamicParser into Parser
- Rename DynamicParserBackend into RuntimeParserBackend

Author: vsavkin

bin/parser_generator_for_spec.dart

@@ -11,7 +11,7 @@ main(arguments) {
   Module module = new Module()
     ..bind(Lexer)
     ..bind(ParserGetterSetter)
-    ..bind(Parser, toImplementation: DynamicParser)
+    ..bind(Parser)
     ..install(new CacheModule());
   module.bind(ParserBackend, toImplementation: DartGetterSetterGen);
   Injector injector = new DynamicInjector(modules: [module],

lib/application_factory_static.dart

@@ -36,7 +36,6 @@ import 'package:angular/application.dart';
 import 'package:angular/core/registry.dart';
 import 'package:angular/core/parser/parser.dart';
 import 'package:angular/core/parser/parser_static.dart';
-import 'package:angular/core/parser/dynamic_parser.dart';
 import 'package:angular/core/registry_static.dart';
 import 'package:angular/change_detection/change_detection.dart';
 import 'package:angular/change_detection/dirty_checking_change_detector_static.dart';

lib/core/module.dart

@@ -13,10 +13,7 @@ export "package:angular/change_detection/watch_group.dart" show
     ReactionFn;
 
 export "package:angular/core/parser/parser.dart" show
-    Parser;
-
-export "package:angular/core/parser/dynamic_parser.dart" show
-    ClosureMap;
+    Parser, ClosureMap;
 
 export "package:angular/change_detection/change_detection.dart" show
     AvgStopwatch,

lib/core/module_internal.dart

@@ -46,10 +46,9 @@ class CoreModule extends Module {
     bind(ScopeStatsConfig);
     bind(Object, toValue: {}); // RootScope context
 
-    bind(Parser, inject: [DynamicParser]);
-    bind(ParserBackend, inject: [DynamicParserBackend]);
-    bind(DynamicParser);
-    bind(DynamicParserBackend);
+    bind(Parser);
+    bind(RuntimeParserBackend);
+    bind(ParserBackend, inject: [RuntimeParserBackend]);
     bind(Lexer);
     bind(ASTParser);
   }

lib/core/parser/dynamic_parser.dart

@@ -1,18 +1,21 @@
-library angular.core.parser.dynamic_parser_impl;
+library angular.core.parser.parse_expression;
 
 import 'package:angular/core/parser/parser.dart' show ParserBackend;
 import 'package:angular/core/parser/lexer.dart';
 import 'package:angular/core/parser/syntax.dart';
 import 'package:angular/core/parser/characters.dart';
 import 'package:angular/utils.dart' show isReservedWord;
 
-class DynamicParserImpl {
+Expression parseExpression(Lexer lexer, ParserBackend backend, String input) =>
+    new _ParseExpression(lexer, backend, input).parseChain();
+
+class _ParseExpression {
   final ParserBackend backend;
   final String input;
   final List<Token> tokens;
   int index = 0;
 
-  DynamicParserImpl(Lexer lexer, this.backend, String input)
+  _ParseExpression(Lexer lexer, this.backend, String input)
       : this.input = input, tokens = lexer.call(input);
 
   Token get next => peek(0);

lib/core/parser/dynamic_parser_impl.dart renamed to lib/core/parser/parse_expression.dart

@@ -1,11 +1,17 @@
 library angular.core.parser;
 
-import 'package:angular/core/parser/syntax.dart'
-   show CallArguments;
+import 'package:angular/core/parser/syntax.dart' show defaultFormatterMap, Expression, Visitor;
+import 'package:angular/core/parser/eval.dart';
+import 'package:angular/core/parser/utils.dart' show EvalError;
+import 'package:angular/cache/module.dart';
+import 'package:angular/core/annotation_src.dart' hide Formatter;
+import 'package:angular/core/module_internal.dart' show FormatterMap;
+import 'package:angular/core/parser/lexer.dart';
+import 'package:angular/core/parser/parse_expression.dart';
+import 'package:angular/utils.dart';
+
 export 'package:angular/core/parser/syntax.dart'
-   show Visitor, Expression, BoundExpression, CallArguments;
-export 'package:angular/core/parser/dynamic_parser.dart'
-   show DynamicParser, DynamicParserBackend, ClosureMap;
+    show Visitor, Expression, BoundExpression, CallArguments;
 
 typedef LocalsWrapper(context, locals);
 typedef Getter(self);
@@ -14,9 +20,11 @@ typedef BoundGetter([locals]);
 typedef BoundSetter(value, [locals]);
 typedef MethodClosure(obj, List posArgs, Map namedArgs);
 
-/// Placeholder for DI. The parser you are looking for is [DynamicParser].
-abstract class Parser<T> {
-  T call(String input);
+abstract class ClosureMap {
+  Getter lookupGetter(String name);
+  Setter lookupSetter(String name);
+  Symbol lookupSymbol(String name);
+  MethodClosure lookupFunction(String name, CallArguments arguments);
 }
 
 abstract class ParserBackend<T> {
@@ -67,3 +75,123 @@ abstract class ParserBackend<T> {
   T newLiteralNumber(num value) => newLiteralPrimitive(value);
   T newLiteralString(String value) => null;
 }
+
+@Injectable()
+class Parser {
+  final Lexer _lexer;
+  final ParserBackend _backend;
+  final Map<String, Expression> _cache = {};
+  Parser(this._lexer, this._backend, CacheRegister cacheRegister) {
+    cacheRegister.registerCache("Parser", _cache);
+  }
+
+  Expression call(String input) {
+    if (input == null) input = '';
+    return _cache.putIfAbsent(input, () => _parse(input));
+  }
+
+  Expression _parse(String input) {
+    Expression expression = parseExpression(_lexer, _backend, input);
+    return new _UnwrapExceptionDecorator(expression);
+  }
+}
+
+class _UnwrapExceptionDecorator extends Expression {
+  final Expression _expression;
+  _UnwrapExceptionDecorator (this._expression);
+
+  bool get isAssignable => _expression.isAssignable;
+  bool get isChain => _expression.isChain;
+
+  accept(Visitor visitor) => _expression.accept(visitor);
+  toString() => _expression.toString();
+
+  eval(scope, [FormatterMap formatters = defaultFormatterMap]) {
+    try {
+      return _expression.eval(scope, formatters);
+    } on EvalError catch (e, s) {
+      throw e.unwrap("$this", s);
+    }
+  }
+
+  assign(scope, value) {
+    try {
+      return _expression.assign(scope, value);
+    } on EvalError catch (e, s) {
+      throw e.unwrap("$this", s);
+    }
+  }
+}
+
+@Injectable()
+class RuntimeParserBackend extends ParserBackend {
+  final ClosureMap _closures;
+  RuntimeParserBackend(this._closures);
+
+  bool isAssignable(Expression expression) => expression.isAssignable;
+
+  Expression newFormatter(expression, name, arguments) {
+    List allArguments = new List(arguments.length + 1);
+    allArguments[0] = expression;
+    allArguments.setAll(1, arguments);
+    return new Formatter(expression, name, arguments, allArguments);
+  }
+
+  Expression newChain(expressions) => new Chain(expressions);
+  Expression newAssign(target, value) => new Assign(target, value);
+  Expression newConditional(condition, yes, no) =>
+      new Conditional(condition, yes, no);
+
+  Expression newAccessKeyed(object, key) => new AccessKeyed(object, key);
+  Expression newCallFunction(function, arguments) =>
+      new CallFunction(function, _closures, arguments);
+
+  Expression newPrefixNot(expression) => new PrefixNot(expression);
+
+  Expression newBinary(operation, left, right) =>
+      new Binary(operation, left, right);
+
+  Expression newLiteralPrimitive(value) => new LiteralPrimitive(value);
+  Expression newLiteralArray(elements) => new LiteralArray(elements);
+  Expression newLiteralObject(keys, values) => new LiteralObject(keys, values);
+  Expression newLiteralString(value) => new LiteralString(value);
+
+  Expression newAccessScope(name) {
+    Getter getter;
+    Setter setter;
+    if (name == 'this') {
+      getter = (o) => o;
+    } else {
+      _assertNotReserved(name);
+      getter = _closures.lookupGetter(name);
+      setter = _closures.lookupSetter(name);
+    }
+    return new AccessScopeFast(name, getter, setter);
+  }
+
+  Expression newAccessMember(object, name) {
+    _assertNotReserved(name);
+    Getter getter = _closures.lookupGetter(name);
+    Setter setter = _closures.lookupSetter(name);
+    return new AccessMemberFast(object, name, getter, setter);
+  }
+
+  Expression newCallScope(name, arguments) {
+    _assertNotReserved(name);
+    MethodClosure function = _closures.lookupFunction(name, arguments);
+    return new CallScope(name, function, arguments);
+  }
+
+  Expression newCallMember(object, name, arguments) {
+    _assertNotReserved(name);
+    MethodClosure function = _closures.lookupFunction(name, arguments);
+    return new CallMember(object, function, name, arguments);
+  }
+
+  _assertNotReserved(name) {
+    if (isReservedWord(name)) {
+      throw "Identifier '$name' is a reserved word.";
+    }
+  }
+}
+

lib/core/parser/parser.dart

@@ -56,10 +56,9 @@ main(args) {
   Module module = new Module()
       ..bind(ParserGetterSetter)
       ..bind(Lexer)
-      ..bind(DynamicParser)
       ..bind(DartGetterSetterGen)
       ..bind(CacheRegister)
-      ..bind(Parser, inject: [DynamicParser])
+      ..bind(Parser)
       ..bind(ParserBackend, inject: [DartGetterSetterGen]);
   Injector injector = new DynamicInjector(modules: [module]);
 

lib/tools/expression_extractor.dart

@@ -46,7 +46,7 @@ class ExpressionGenerator extends Transformer with ResolverTransformer {
         .forEach(htmlExtractor.parseHtml)
         .then((_) {
       var module = new Module()
-        ..bind(Parser, inject: const [DynamicParser])
+        ..bind(Parser)
         ..bind(ParserBackend, inject: const [DartGetterSetterGen]);
       var injector =
           new DynamicInjector(modules: [module], allowImplicitInjection: true);