Revert "Update all Angular libs (run update_all.sh)."

third_party/pkg/angular/lib/core/parser/eval_access.dart

Index: third_party/pkg/angular/lib/core/parser/eval_access.dart
diff --git a/third_party/pkg/angular/lib/core/parser/eval_access.dart b/third_party/pkg/angular/lib/core/parser/eval_access.dart
index 0fdfa61c018d4cc4e2954691af7eb31709c8f8a9..d8f47fea71f4799061f732478915bc35ca010ceb 100644
--- a/third_party/pkg/angular/lib/core/parser/eval_access.dart
+++ b/third_party/pkg/angular/lib/core/parser/eval_access.dart
@@ -1,38 +1,200 @@
 library angular.core.parser.eval_access;
 
+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_internal.dart';
+import 'package:angular/core/module.dart';
+
+class AccessScope extends syntax.AccessScope with AccessReflective {
+  final Symbol symbol;
+  AccessScope(String name) : super(name), symbol = newSymbol(name);
+  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;
-  final bool isThis;
-  AccessScopeFast(String name, this.getter, this.setter)
-      : super(name),
-        isThis = name == 'this';
-  eval(scope, [FormatterMap formatters]) => isThis ? scope : _eval(scope);
+  AccessScopeFast(String name, this.getter, this.setter) : super(name);
+  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 = newSymbol(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 });
+}
+
 class AccessMemberFast extends syntax.AccessMember with AccessFast {
   final Getter getter;
   final Setter setter;
   AccessMemberFast(object, String name, this.getter, this.setter)
       : super(object, name);
-  eval(scope, [FormatterMap formatters]) => _eval(object.eval(scope, formatters));
+  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, [FormatterMap formatters]) =>
-      getKeyed(object.eval(scope, formatters), key.eval(scope, formatters));
+  eval(scope, [FilterMap filters]) =>
+      getKeyed(object.eval(scope, filters), key.eval(scope, filters));
   assign(scope, value) => setKeyed(object.eval(scope), key.eval(scope), value);
 }
 
+
+/**
+ * The [AccessReflective] mixin is used to share code between access expressions
+ * where we need to use reflection to get or set a field. We optimize for the
+ * case where we access the same holder repeatedly through caching.
+ */
+abstract class AccessReflective {
+  static const int CACHED_FIELD = 0;
+  static const int CACHED_MAP = 1;
+  static const int CACHED_VALUE = 2;
+
+  int _cachedKind = 0;
+  var _cachedHolder = UNINITIALIZED;
+  var _cachedValue;
+
+  String get name;
+  Symbol get symbol;
+
+  _eval(holder) {
+    if (!identical(holder, _cachedHolder)) return _evalUncached(holder);
+    int cachedKind = _cachedKind;
+    if (cachedKind == CACHED_MAP) return holder[name];
+    var value = _cachedValue;
+    return (cachedKind == CACHED_FIELD && value != null)
+        ? value.getField(symbol).reflectee
+        : value;
+  }
+
+  _evalUncached(holder) {
+    _cachedHolder = holder;
+    if (holder == null) {
+      _cachedKind = CACHED_VALUE;
+      return _cachedValue = null;
+    } else if (holder is Map) {
+      _cachedKind = CACHED_MAP;
+      _cachedValue = null;
+      return holder[name];
+    } else if (symbol == null) {
+      _cachedHolder = UNINITIALIZED;
+      return null;
+    }
+    InstanceMirror mirror = reflect(holder);
+    try {
+      var result = mirror.getField(symbol).reflectee;
+      _cachedKind = CACHED_FIELD;
+      _cachedValue = mirror;
+      return result;
+    } on NoSuchMethodError catch (e) {
+      if (isNoSuchMethodDueToGetField(e)) {
+        var result = createInvokeClosure(mirror, symbol);
+        if (result == null) rethrow;
+        _cachedKind = CACHED_VALUE;
+        return _cachedValue = result;
+      } else {
+        rethrow;
+      }
+    } on UnsupportedError catch (e) {
+      var result = createInvokeClosure(mirror, symbol);
+      if (result == null) rethrow;
+      _cachedKind = CACHED_VALUE;
+      return _cachedValue = result;
+    }
+  }
+
+  bool isNoSuchMethodDueToGetField(NoSuchMethodError e) {
+    var msg = e.toString();
+    return msg.indexOf("has no instance getter '$name'.") != -1 || // Dart VM
+           msg.indexOf('Cannot call "$name\$') != -1; // Dart2JS
+  }
+
+  _assign(scope, holder, value) {
+    if (holder is Map) {
+      holder[name] = value;
+    } else if (holder == null) {
+      _assignToNonExisting(scope, value);
+    } else if (symbol != null) {
+      reflect(holder).setField(symbol, value);
+    }
+    return value;
+  }
+
+  // By default we don't do any assignments to non-existing holders. This
+  // is overwritten for access to members.
+  _assignToNonExisting(scope, value) => null;
+
+  static Function createInvokeClosure(InstanceMirror mirror, Symbol symbol) {
+    if (!hasMethod(mirror, symbol)) return null;
+    return relaxFnArgs(([a0, a1, a2, a3, a4, a5]) {
+      var arguments = stripTrailingNulls([a0, a1, a2, a3, a4, a5]);
+      return mirror.invoke(symbol, arguments).reflectee;
+    });
+  }
+
+  static stripTrailingNulls(List list) {
+    while (list.isNotEmpty && (list.last == null)) {
+      list.removeLast();
+    }
+    return list;
+  }
+
+  static bool hasMethod(InstanceMirror mirror, Symbol symbol) {
+    return hasMethodHelper(mirror.type, symbol);
+  }
+
+  static final objectClassMirror = reflectClass(Object);
+  static final Set<Symbol> objectClassInstanceMethods =
+      new Set<Symbol>.from([#toString, #noSuchMethod]);
+
+  static final Function hasMethodHelper = (() {
+    try {
+      // Use ClassMirror.instanceMembers if available. It contains local
+      // as well as inherited members.
+      objectClassMirror.instanceMembers;
+      // For SDK 1.2 we have to use a somewhat complicated helper for this
+      // to work around bugs in the dart2js implementation.
+      return hasInstanceMethod;
+    } on NoSuchMethodError catch (e) {
+      // For SDK 1.0 we fall back to just using the local members.
+      return (type, symbol) => type.members[symbol] is MethodMirror;
+    } on UnimplementedError catch (e) {
+      // For SDK 1.1 we fall back to just using the local declarations.
+      return (type, symbol) => type.declarations[symbol] is MethodMirror;
+    }
+    return null;
+  })();
+
+  static bool hasInstanceMethod(type, symbol) {
+    // Always allow instance methods found in the Object class. This makes
+    // it easier to work around a few bugs in the dart2js implementation.
+    if (objectClassInstanceMethods.contains(symbol)) return true;
+    // Work around http://dartbug.com/16309 which causes access to the
+    // instance members of certain builtin types to throw exceptions
+    // while traversing the superclass chain.
+    var mirror;
+    try {
+      mirror = type.instanceMembers[symbol];
+    } on UnsupportedError catch (e) {
+      mirror = type.declarations[symbol];
+    }
+    // Work around http://dartbug.com/15760 which causes noSuchMethod
+    // forwarding stubs to be treated as members of all classes. We have
+    // already checked for the real instance methods in Object, so if the
+    // owner of this method is Object we simply filter it out.
+    if (mirror is !MethodMirror) return false;
+    return mirror.owner != objectClassMirror;
+  }
+}
+
 /**
  * The [AccessFast] mixin is used to share code between access expressions
  * where we have a pair of pre-compiled getter and setter functions that we