Correctly compile unresolved for-in loops.

dart/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 get currentElement;
   Set<Node> get superUses;
 
   /// A set of additional dependencies.  See [registerDependency] below.
   Set<Element> get otherDependencies;
 
   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);
 
   /// Register additional dependencies required by [currentElement].
   /// For example, elements that are used by a backend.
   void registerDependency(Element element);
 }
 
 class TreeElementMapping implements TreeElements {
   final Element currentElement;
@@ skipping 61 matching lines @@
   }
 
   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 arbitrarily choose which ones.
-
-  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);
   }
 
   void registerDependency(Element element) {
     otherDependencies.add(element.implementation);
   }
 
   String toString() => 'TreeElementMapping($currentElement)';
 }
@@ skipping 1408 matching lines @@
                   {'type': node}, typeName.source, enclosingElement),
               new TypedefType.userProvidedBadType(typdef, arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
           } else {
            type = new TypedefType(typdef, arguments.toLink());
           }
         }
       } else if (element.isTypeVariable()) {
-        if (enclosingElement.isInStaticMember()) {
+        Element outer = enclosingElement.getOutermostEnclosingMemberOrTopLevel();
+        bool isInFactoryConstructor = outer != null && outer.isFactoryConstructor();
+        if (!outer.isClass()
+            && !outer.isTypedef()
+            && !isInFactoryConstructor
+            && Elements.isInStaticContext(enclosingElement)) {
           compiler.backend.registerThrowRuntimeError(
               // TODO(ahe): Get the TreeElements for the current element.
               compiler.globalDependencies);
           compiler.reportWarning(node,
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.message(
                   {'typeVariableName': node}));
           type = new MalformedType(
               new ErroneousElementX(
                   MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
                   {'typeVariableName': node},
@@ skipping 1135 matching lines @@
     mapping[node] = target;
   }
 
   registerImplicitInvocation(SourceString name, int arity) {
     Selector selector = new Selector.call(name, null, arity);
     world.registerDynamicInvocation(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);
-
-    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);
+    world.registerDynamicGetter(compiler.iteratorSelector.name,
+                                compiler.iteratorSelector);
+    world.registerDynamicGetter(compiler.currentSelector.name,
+                                compiler.currentSelector);
+    world.registerDynamicInvocation(compiler.moveNextSelector.name,
+                                    compiler.moveNextSelector);
 
     visit(node.expression);
     Scope blockScope = new BlockScope(scope);
     Node declaration = node.declaredIdentifier;
     visitIn(declaration, blockScope);
+
+    Send send = declaration.asSend();
+    VariableDefinitions variableDefinitions =
+        declaration.asVariableDefinitions();
+    Element loopVariable;
+    Selector loopVariableSelector;
+    if (send != null) {
+      loopVariable = mapping[send];
+      Identifier identifier = send.selector.asIdentifier();
+      if (identifier == null) {
+        compiler.reportErrorCode(send.selector, MessageKind.INVALID_FOR_IN);
+      } else {
+        loopVariableSelector = new Selector.setter(identifier.source, library);
+      }
+      if (send.receiver != null) {
+        compiler.reportErrorCode(send.receiver, MessageKind.INVALID_FOR_IN);
+      }
+    } else if (variableDefinitions != null) {
+      Link<Node> nodes = variableDefinitions.definitions.nodes;
+      if (!nodes.tail.isEmpty) {
+        compiler.reportErrorCode(nodes.tail.head, MessageKind.INVALID_FOR_IN);
+      }
+      Node first = nodes.head;
+      Identifier identifier = first.asIdentifier();
+      if (identifier == null) {
+        compiler.reportErrorCode(first, MessageKind.INVALID_FOR_IN);
+      } else {
+        loopVariableSelector = new Selector.setter(identifier.source, library);
+        loopVariable = mapping[identifier];
+      }
+    } else {
+      compiler.reportErrorCode(declaration, MessageKind.INVALID_FOR_IN);
+    }
+    if (loopVariableSelector != null) {
+      mapping.setSelector(declaration, loopVariableSelector);
+    } else {
+      // The selector may only be null if we reported an error.
+      assert(invariant(declaration, compiler.compilationFailed));
+    }
+    if (loopVariable != null) {
+      // loopVariable may be null if it could not be resolved.
+      mapping[declaration] = loopVariable;
+    }
     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 ||
-        !declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty))
-    {
-      // The variable declaration is either not an identifier, not a
-      // declaration, or it's declaring more than one variable.
-      error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN);
-    }
   }
 
   visitLabel(Label node) {
     // Labels are handled by their containing statements/cases.
   }
 
   visitLabeledStatement(LabeledStatement node) {
     Statement body = node.statement;
     TargetElement targetElement = getOrCreateTargetElement(body);
     Map<String, LabelElement> labelElements = <String, LabelElement>{};
@@ skipping 1119 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }