Updating Angular version

third_party/pkg/angular/perf/parser_perf.dart

 library parser_perf;
 
 import '_perf.dart';
 import 'package:angular/core/module.dart';
-import 'package:angular/core/parser/parser_library.dart';
+import 'package:angular/core/parser/parser.dart';
 import 'package:angular/filter/module.dart';
 import 'package:di/di.dart';
 import 'package:di/dynamic_injector.dart';
 import 'package:intl/intl.dart';
 
 import '../gen/generated_functions.dart' as generated_functions;
 import '../gen/generated_getter_setter.dart' as generated_getter_setter;
 
 main() {
   var module = new Module()
     ..type(Parser, implementedBy: DynamicParser)
+    ..type(ParserBackend, implementedBy: DynamicParserBackend)
     ..type(SubstringFilter)
     ..type(IncrementFilter)
     ..install(new NgFilterModule());
   var injector = new DynamicInjector(
       modules: [module],
       allowImplicitInjection:true);
   var scope = injector.get(Scope);
   var reflectiveParser = injector.get(Parser);
   var filterMap = injector.get(FilterMap);
 
   var generatedParser = new DynamicInjector(
       modules: [new Module()
         ..type(Parser, implementedBy: StaticParser)
         ..value(StaticParserFunctions, generated_functions.functions(filterMap))],
       allowImplicitInjection:true).get(Parser);
 
   var hybridParser = new DynamicInjector(
       modules: [new Module()
         ..type(Parser, implementedBy: DynamicParser)
-        ..type(GetterSetter, implementedBy: generated_getter_setter.StaticGetterSetter)],
+        ..type(ParserBackend, implementedBy: DynamicParserBackend)
+        ..type(ClosureMap, implementedBy: generated_getter_setter.StaticClosureMap)],
       allowImplicitInjection:true).get(Parser);
 
   scope['a'] = new ATest();
   scope['e1'] = new EqualsThrows();
   scope['o'] = new OTest();
 
   compare(expr, idealFn) {
     var nf = new NumberFormat.decimalPattern();
-    var reflectionExpr = reflectiveParser(expr);
-    var generatedExpr = generatedParser(expr);
-    var hybridExpr = hybridParser(expr);
+    Expression reflectionExpr = reflectiveParser(expr);
+    Expression generatedExpr = generatedParser(expr);
+    Expression hybridExpr = hybridParser(expr);
     var measure = (b) => statMeasure(b).mean_ops_sec;
     var gTime = measure(() => generatedExpr.eval(scope));
     var rTime = measure(() => reflectionExpr.eval(scope));
     var hTime = measure(() => hybridExpr.eval(scope));
     var iTime = measure(() => idealFn(scope));
     print('$expr => g: ${nf.format(gTime)} ops/sec   ' +
           'r: ${nf.format(rTime)} ops/sec   ' +
           'h: ${nf.format(hTime)} ops/sec   ' +
           'i: ${nf.format(iTime)} ops/sec = ' +
           'i/g: ${nf.format(iTime / gTime)} x  ' +
@@ skipping 47 matching lines @@
   call(a, b) => a + b;
 }
 
 @NgFilter(name:'substring')
 class SubstringFilter {
   call(String str, startIndex, [endIndex]) {
     return str.substring(startIndex, endIndex);
   }
 }