Stop creating selectors in the SSA builder that were already created by the resolver.

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
+  Selector getGetterSelectorInComplexSendSet(SendSet node);
+  Selector getOperatorSelectorInComplexSendSet(SendSet node);
+  Selector getIteratorSelector(ForIn node);
+  Selector getMoveNextSelector(ForIn node);
+  Selector getCurrentSelector(ForIn node);
   DartType getType(Node node);
   bool isParameterChecked(Element element);
   Set<Node> get superUses;
 }
 
 class TreeElementMapping implements TreeElements {
   final Element currentElement;
-  final Map<Node, Selector> selectors = new LinkedHashMap<Node, Selector>();
+  final Map<Spannable, Selector> selectors =
+      new LinkedHashMap<Spannable, Selector>();
   final Map<Node, DartType> types = new LinkedHashMap<Node, DartType>();
   final Set<Element> checkedParameters = new Set<Element>();
   final Set<Node> superUses = new Set<Node>();
 
   TreeElementMapping(this.currentElement);
 
   operator []=(Node node, Element element) {
     assert(invariant(node, () {
       if (node is FunctionExpression) {
         return !node.modifiers.isExternal();
@@ skipping 26 matching lines @@
   void setType(Node node, DartType type) {
     types[node] = type;
   }
 
   DartType getType(Node node) => types[node];
 
   void setSelector(Node node, Selector selector) {
     selectors[node] = selector;
   }
 
-  Selector getSelector(Node node) => selectors[node];
+  Selector getSelector(Node node) {
+    return selectors[node];
+  }
+
+  void setGetterSelectorInComplexSendSet(SendSet node, Selector selector) {
+    selectors[node.selector] = selector;
+  }
+
+  Selector getGetterSelectorInComplexSendSet(SendSet node) {
+    return selectors[node.selector];
+  }
+
+  void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector) {
+    selectors[node.assignmentOperator] = selector;
+  }
+
+  Selector getOperatorSelectorInComplexSendSet(SendSet node) {
+    return selectors[node.assignmentOperator];
+  }
+
+  // The following methods set selectors on the "for in" node. Since
+  // we're using three selectors, we need to use children of the node,
+  // and we arbritraly choose which ones.

[kasperl, 2013/02/27 10:11:28]

arbitrarily 

[ngeoffray, 2013/02/27 12:23:59]

Done.

+
+  Selector setIteratorSelector(ForIn node, Selector selector) {
+    selectors[node] = selector;
+  }
+
+  Selector getIteratorSelector(ForIn node) {
+    return selectors[node];
+  }
+
+  Selector setMoveNextSelector(ForIn node, Selector selector) {
+    selectors[node.forToken] = selector;
+  }
+
+  Selector getMoveNextSelector(ForIn node) {
+    return selectors[node.forToken];
+  }
+
+  Selector setCurrentSelector(ForIn node, Selector selector) {
+    selectors[node.inToken] = selector;
+  }
+
+  Selector getCurrentSelector(ForIn node) {
+    return selectors[node.inToken];
+  }
 
   bool isParameterChecked(Element element) {
     return checkedParameters.contains(element);
   }
 }
 
 class ResolverTask extends CompilerTask {
   ResolverTask(Compiler compiler) : super(compiler);
 
   String get name => 'Resolver';
@@ skipping 1873 matching lines @@
         // for a real error message.
         error(node.receiver, MessageKind.GENERIC,
               {'text': "Object has no superclass"});
       }
       // TODO(johnniwinther): Ensure correct behavior if currentClass is a
       // patch.
       target = currentClass.lookupSuperMember(name);
       // [target] may be null which means invoking noSuchMethod on
       // super.
       if (target == null) {
+        target = warnAndCreateErroneousElement(
+            node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
+            {'className': currentClass, 'memberName': name});
+        // We still need to register the invocation, because we might
+        // call [:super.noSuchMethod:] that does a
+        // [:InvocationMirror.invokeOn:].
+        world.registerDynamicInvocation(selector.name, selector);
         compiler.backend.registerSuperNoSuchMethod();
       }
     } else if (Elements.isUnresolved(resolvedReceiver)) {
       return null;
     } else if (resolvedReceiver.isClass()) {
       ClassElement receiverClass = resolvedReceiver;
       receiverClass.ensureResolved(compiler);
       if (node.isOperator) {
         // When the resolved receiver is a class, we can have two cases:
         //  1) a static send: C.foo, or
@@ skipping 259 matching lines @@
                                             MessageKind.CANNOT_RESOLVE_GETTER);
           compiler.backend.registerThrowNoSuchMethod();
         }
       } else if (target.impliesType()) {
         compiler.backend.registerThrowNoSuchMethod();
       } else if (target.modifiers.isFinal() || target.modifiers.isConst()) {
         setter =
             warnAndCreateErroneousElement(node.selector, target.name,
                                           MessageKind.CANNOT_RESOLVE_SETTER);
         compiler.backend.registerThrowNoSuchMethod();
+      } else if (isComplex && target.name == const SourceString('[]=')) {
+        getter =
+            setter.getEnclosingClass().lookupMember(const SourceString('[]'));

[kasperl, 2013/02/27 10:11:28]

Seems more logical to use the enclosing class of the field (even though that
should be the same, right?).

[ngeoffray, 2013/02/27 12:23:59]

Yes, it's the same. Replaced to use target.

+        if (getter == null) {
+          getter =
+              warnAndCreateErroneousElement(node, setter.name,

[kasperl, 2013/02/27 10:11:28]

Move the warnAnd...( part to the previous line (like done in line 2010) because
it looks nicer? Maybe do that in more places?

[ngeoffray, 2013/02/27 12:23:59]

Done.

+                                            MessageKind.CANNOT_RESOLVE_INDEX);
+          compiler.backend.registerThrowNoSuchMethod();
+        }
       }
     }
 
     visit(node.argumentsNode);
 
     // TODO(ngeoffray): Check if the target can be assigned.
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
 
     Selector selector = mapping.getSelector(node);
     if (isComplex) {
+      Selector getterSelector;
       if (selector.isSetter()) {
-        // TODO(kasperl): We're registering the getter selector for
-        // compound assignments on the AST selector node. In the code
-        // generator, we then fetch it from there when generating the
-        // getter for a SendSet node.
-        Selector getterSelector = new Selector.getterFrom(selector);
-        registerSend(getterSelector, getter);
-        mapping.setSelector(node.selector, getterSelector);
-        useElement(node.selector, getter);
+        getterSelector = new Selector.getterFrom(selector);
       } else {
-        // TODO(kasperl): If [getter] is resolved, it will actually
-        // refer to the []= operator which isn't the one we want to
-        // register here. We should consider using some notion of
-        // abstract indexable element that we can resolve to so we can
-        // distinguish the two.
         assert(selector.isIndexSet());
-        registerSend(new Selector.index(), null);
+        getterSelector = new Selector.index();
       }
+      registerSend(getterSelector, getter);
+      mapping.setGetterSelectorInComplexSendSet(node, getterSelector);
+      useElement(node.selector, getter);
 
       // Make sure we include the + and - operators if we are using
       // the ++ and -- ones.  Also, if op= form is used, include op itself.
       void registerBinaryOperator(SourceString name) {
         Selector binop = new Selector.binaryOperator(name);
         world.registerDynamicInvocation(binop.name, binop);
+        mapping.setOperatorSelectorInComplexSendSet(node, binop);
       }
-      if (identical(source, '++')) registerBinaryOperator(const SourceString('+'));
-      if (identical(source, '--')) registerBinaryOperator(const SourceString('-'));
-      if (source.endsWith('=')) {
+      if (identical(source, '++')) {
+        registerBinaryOperator(const SourceString('+'));
+      } else if (identical(source, '--')) {
+        registerBinaryOperator(const SourceString('-'));
+      } else if (source.endsWith('=')) {
         registerBinaryOperator(Elements.mapToUserOperator(operatorName));
       }
     }
 
     registerSend(selector, setter);
     return useElement(node, setter);
   }
 
   void registerSend(Selector selector, Element target) {
     if (target == null || target.isInstanceMember()) {
@@ skipping 338 matching lines @@
       mapping[node.target] = label;
     }
     mapping[node] = target;
   }
 
   registerImplicitInvocation(SourceString name, int arity) {
     Selector selector = new Selector.call(name, null, arity);
     world.registerDynamicInvocation(name, selector);
   }
 
-  registerImplicitFieldGet(SourceString name) {
-    Selector selector = new Selector.getter(name, null);
-    world.registerDynamicGetter(name, selector);
-  }
+  visitForIn(ForIn node) {
+    LibraryElement library = enclosingElement.getLibrary();
+    Selector iteratorSelector =
+        new Selector.getter(const SourceString('iterator'), library);
+    world.registerDynamicGetter(iteratorSelector.name, iteratorSelector);
+    mapping.setIteratorSelector(node, iteratorSelector);
 
-  visitForIn(ForIn node) {
-    for (final name in const [
-        const SourceString('iterator'),
-        const SourceString('current')]) {
-      registerImplicitFieldGet(name);
-    }
-    registerImplicitInvocation(const SourceString('moveNext'), 0);
+    Selector currentSelector =
+        new Selector.getter(const SourceString('current'), library);
+    world.registerDynamicGetter(currentSelector.name, currentSelector);
+    mapping.setCurrentSelector(node, currentSelector);
+
+    Selector moveNextSelector =
+        new Selector.call(const SourceString('moveNext'), library, 0);
+    world.registerDynamicInvocation(moveNextSelector.name, moveNextSelector);
+    mapping.setMoveNextSelector(node, moveNextSelector);
+
     visit(node.expression);
     Scope blockScope = new BlockScope(scope);
     Node declaration = node.declaredIdentifier;
     visitIn(declaration, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
 
     // TODO(lrn): Also allow a single identifier.
     if ((declaration is !Send || declaration.asSend().selector is !Identifier
         || declaration.asSend().receiver != null)
         && (declaration is !VariableDefinitions ||
@@ skipping 1083 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }