Updating Angular version

third_party/pkg/angular/lib/tools/parser_getter_setter/generator.dart

-import 'package:angular/core/parser/parser_library.dart';
+import 'package:angular/core/parser/parser.dart';
 import 'package:angular/tools/reserved_dart_keywords.dart';
+import 'dart:math';
 
-class _AST implements ParserAST {
-  bool get assignable => true;
-}
+class DartGetterSetterGen extends ParserBackend {
+  final Set<String> properties = new Set<String>();
+  final Map<String, Set<int>> calls = new Map<String, Set<int>>();
 
-class DartGetterSetterGen implements ParserBackend {
-  Map<String, bool> identifiers = {};
+  bool isAssignable(expression) => true;
 
-  profiled(value, perf, text)  => new _AST();
-
-  binaryFn(left, String fn, right) => new _AST();
-  unaryFn(String fn, right)  => new _AST();
-  ternaryFn(Expression cond, Expression _true, Expression _false) => new _AST();
-  assignment(left, right, evalError)  => new _AST();
-  multipleStatements(List statements)  => new _AST();
-  arrayDeclaration(List elementFns)  => new _AST();
-  objectIndex(obj, indexFn, evalError)  => new _AST();
-  object(List keyValues)  => new _AST();
-  fromOperator(String op) => new _AST();
-  value(v) => new _AST();
-  zero() => new _AST();
-  functionCall(fn, fnName, List argsFn, evalError) => new _AST();
-  filter(String filterName,
-      Expression leftHandSide,
-      List<Expression> parameters,
-      Function evalError) => new _AST();
-
-  setter(String path) => throw new UnimplementedError();
-  getter(String path) => throw new UnimplementedError();
-
-
-  fieldAccess(object, String field) {
-    identifiers[field] = true;
-    return new _AST();
+  registerAccess(String name) {
+    if (isReserved(name)) return;
+    properties.add(name);
   }
 
-  getterSetter(String key)  {
-    key.split('.').forEach((i) => identifiers[i] = true);
-    return new _AST();
+  registerCall(String name, List arguments) {
+    if (isReserved(name)) return;
+    Set<int> arities = calls.putIfAbsent(name, () => new Set<int>());
+    arities.add(arguments.length);
   }
+
+  newAccessScope(String name)
+      => registerAccess(name);
+  newAccessMember(var object, String name)
+      => registerAccess(name);
+  newCallScope(String name, List arguments)
+      => registerCall(name, arguments);
+  newCallMember(var object, String name, List arguments)
+      => registerCall(name, arguments);
 }
 
 class ParserGetterSetter {
-
-  DynamicParser parser;
-  DartGetterSetterGen backend;
-
+  final Parser parser;
+  final ParserBackend backend;
   ParserGetterSetter(this.parser, this.backend);
 
   generateParser(List<String> exprs) {
     exprs.forEach((expr) {
       try {
         parser(expr);
-      } catch (e) { }
+      } catch (e) {
+        // Ignore exceptions.
+      }
     });
 
-    print(generateCode(backend.identifiers.keys.toList()));
+    DartGetterSetterGen backend = this.backend;
+    print(generateClosureMap(backend.properties, backend.calls));
   }
 
-  generateCode(Iterable<String> keys) {
-    keys = keys.where((key) => !isReserved(key));
+  generateClosureMap(Set<String> properties, Map<String, Set<int>> calls) {
     return '''
-class StaticGetterSetter extends GetterSetter {
-  Map<String, Function> _getters = ${generateGetterMap(keys)};
-  Map<String, Function> _setters = ${generateSetterMap(keys)};
+class StaticClosureMap extends ClosureMap {
+  Map<String, Getter> _getters = ${generateGetterMap(properties)};
+  Map<String, Setter> _setters = ${generateSetterMap(properties)};
+  List<Map<String, Function>> _functions = ${generateFunctionMap(calls)};
 
-  Function getter(String key) {
-    return _getters.containsKey(key) ? _getters[key] : super.getter(key);
-  }
-
-  Function setter(String key) {
-    return _setters.containsKey(key) ? _setters[key] : super.setter(key);
-  }
-
+  Getter lookupGetter(String name)
+      => _getters[name];
+  Setter lookupSetter(String name)
+      => _setters[name];
+  lookupFunction(String name, int arity) 
+      => (arity < _functions.length) ? _functions[arity][name] : null;
 }
 ''';
   }
 
   generateGetterMap(Iterable<String> keys) {
-    var lines = keys.map((key) => 'r"${key}": (s) => s.$key');
+    var lines = keys.map((key) => 'r"${key}": (o) => o.$key');
     return '{\n   ${lines.join(",\n    ")}\n  }';
   }
 
   generateSetterMap(Iterable<String> keys) {
-    var lines = keys.map((key) => 'r"${key}": (s, v) => s.$key = v');
+    var lines = keys.map((key) => 'r"${key}": (o, v) => o.$key = v');
     return '{\n   ${lines.join(",\n    ")}\n  }';
   }
+
+  generateFunctionMap(Map<String, Set<int>> calls) {
+    Map<int, Set<String>> arities = {};
+    calls.forEach((name, callArities) {
+      callArities.forEach((arity){
+        arities.putIfAbsent(arity, () => new Set<String>()).add(name);
+      });
+    });
+
+    var maxArity = arities.keys.reduce((x, y) => max(x, y));
+
+    var maps = new Iterable.generate(maxArity, (arity) {
+      var names = arities[arity];
+      if (names == null) {
+        return '{\n    }';
+      } else {
+        var args = new List.generate(arity, (e) => "a$e").join(',');
+        var p = args.isEmpty ? '' : ', $args';
+        var lines = names.map((name) => 'r"$name": (o$p) => o.$name($args)');
+        return '{\n    ${lines.join(",\n    ")}\n  }';
+      }
+    });
+
+    return '[${maps.join(",")}]';
+  }
 }