Turn getters and setters that we know are not intercepted into regular getter and setter calls.

sdk/lib/_internal/compiler/implementation/universe/universe.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library universe;
 
 import '../closure.dart';
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 32 matching lines @@
                invokedNames = new Map<SourceString, Set<Selector>>(),
                invokedGetters = new Map<SourceString, Set<Selector>>(),
                invokedSetters = new Map<SourceString, Set<Selector>>(),
                isChecks = new Set<DartType>();
 
   bool hasMatchingSelector(Set<Selector> selectors,
                            Element member,
                            Compiler compiler) {
     if (selectors == null) return false;
     for (Selector selector in selectors) {
-      if (selector.applies(member, compiler)) return true;
+      if (selector.appliesUnnamed(member, compiler)) return true;
     }
     return false;
   }
 
   bool hasInvocation(Element member, Compiler compiler) {
     return hasMatchingSelector(invokedNames[member.name], member, compiler);
   }
 
   bool hasInvokedGetter(Element member, Compiler compiler) {
     return hasMatchingSelector(invokedGetters[member.name], member, compiler);
@@ skipping 184 matching lines @@
     const int SETTER = 2;
     int kind = METHOD;
     if (isGetter()) {
       kind = GETTER;
     } else if (isSetter()) {
       kind = SETTER;
     }
     return kind;
   }
 
-  bool applies(Element element, Compiler compiler)
-      => appliesUntyped(element, compiler);
+  bool appliesUnnamed(Element element, Compiler compiler) {
+    assert(sameNameHack(element, compiler));
+    return appliesUntyped(element, compiler);
+  }
 
   bool appliesUntyped(Element element, Compiler compiler) {
+    assert(sameNameHack(element, compiler));
     if (Elements.isUnresolved(element)) return false;
     if (name.isPrivate() && library != element.getLibrary()) return false;
     if (element.isForeign(compiler)) return true;
     if (element.isSetter()) return isSetter();
     if (element.isGetter()) return isGetter() || isCall();
     if (element.isField()) return isGetter() || isSetter() || isCall();
     if (isGetter()) return true;
     if (isSetter()) return false;
 
     FunctionElement function = element;
@@ skipping 22 matching lines @@
         if (!nameSet.contains(name)) return false;
         // TODO(5213): By removing from the set we are checking
         // that we are not passing the name twice. We should have this
         // check in the resolver also.
         nameSet.remove(name);
       }
       return true;
     }
   }
 
+  bool sameNameHack(Element element, Compiler compiler) {
+    // TODO(ngeoffray): Remove workaround checks.
+    return element == compiler.assertMethod
+        || element.isConstructor()
+        || name == element.name;
+  }
+
+  bool applies(Element element, Compiler compiler) {
+    if (!sameNameHack(element, compiler)) return false;
+    return appliesUnnamed(element, compiler);
+  }
+
   /**
+   * Fills [list] with the arguments in a defined order.
+   *
+   * [compileArgument] is a function that returns a compiled version
+   * of an argument located in [arguments].
+   *
+   * [compileConstant] is a function that returns a compiled constant
+   * of an optional argument that is not in [arguments.
+   *
    * Returns [:true:] if the selector and the [element] match; [:false:]
    * otherwise.
    *
    * Invariant: [element] must be the implementation element.
    */
   bool addArgumentsToList(Link<Node> arguments,
                           List list,
                           FunctionElement element,
                           compileArgument(Node argument),
                           compileConstant(Element element),
@@ skipping 125 matching lines @@
       } else {
         ClassElement otherCls = field.getEnclosingClass();
         // We have not found a match, but another class higher in the
         // hierarchy may define the getter or the setter.
         return hasElementIn(otherCls.superclass, element);
       }
     }
     return false;
   }
 
-  bool applies(Element element, Compiler compiler) {
+  bool appliesUnnamed(Element element, Compiler compiler) {
+    assert(sameNameHack(element, compiler));
     // [TypedSelector] are only used when compiling.
     assert(compiler.phase == Compiler.PHASE_COMPILING);
     if (!element.isMember()) return false;
 
     // A closure can be called through any typed selector:
     // class A {
     //   get foo => () => 42;
     //   bar() => foo(); // The call to 'foo' is a typed selector.
     // }
     ClassElement other = element.getEnclosingClass();
@@ skipping 19 matching lines @@
     ClassElement cls = self;
     if (cls.isSubclassOf(other)) {
       // Resolve an invocation of [element.name] on [self]. If it
       // is found, this selector is a candidate.
       return hasElementIn(self, element) && appliesUntyped(element, compiler);
     }
 
     return false;
   }
 }