dart2js: Fix an issue with erroneous for-in.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
@@ skipping 1226 matching lines @@
       ast.NodeList arguments,
       CallStructure callStructure,
       _);
 
   @override
   ir.Primitive handleStaticFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         elements.getSelector(node),
         arguments.nodes.mapToList(visit));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
@@ skipping 378 matching lines @@
           });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(target, nested(helper))
         : helper();
   }
 
   ir.Primitive buildLocalNoSuchSetter(LocalElement local, ir.Primitive value) {
     Selector selector = new Selector.setter(
         new Name(local.name, local.library, isSetter: true));
-    return buildStaticNoSuchMethod(selector, [value]);
+    return irBuilder.buildStaticNoSuchMethod(selector, [value]);
   }
 
   @override
   ir.Primitive handleLocalCompounds(
       ast.SendSet node,
       LocalElement local,
       CompoundRhs rhs,
       arg,
       {bool isSetterValid}) {
     return translateCompounds(
@@ skipping 35 matching lines @@
         setValue: (ir.Primitive result) {
           if (isSetterValid) {
             irBuilder.buildLocalVariableSet(local, result);
           } else {
             return buildLocalNoSuchSetter(local, result);
           }
         });
   }
 
   ir.Primitive buildStaticNoSuchGetter(Element element) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.getter(new Name(element.name, element.library)),
         const <ir.Primitive>[]);
   }
 
   ir.Primitive buildStaticNoSuchSetter(Element element, ir.Primitive value) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(new Name(element.name, element.library)),
         <ir.Primitive>[value]);
   }
 
   @override
   ir.Primitive handleStaticCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
@@ skipping 308 matching lines @@
         sourceInformation: sourceInformationBuilder.buildGet(node));
   }
 
   ir.Primitive visitThrow(ast.Throw node) {
     assert(irBuilder.isOpen);
     // This function is not called for throw expressions occurring as
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
-  ir.Primitive buildStaticNoSuchMethod(
-      Selector selector,
-      List<ir.Primitive> arguments);
-
   ir.Primitive buildInstanceNoSuchMethod(
       Selector selector,
       TypeMask mask,
       List<ir.Primitive> arguments);
 
   ir.Primitive buildRuntimeError(String message);
 
   ir.Primitive buildAbstractClassInstantiationError(ClassElement element);
 
   @override
   ir.Primitive visitUnresolvedCompound(
       ast.Send node,
       Element element,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     // TODO(asgerf): What is unresolved? The getter and/or the setter?
     //               If it was the setter, we must evaluate the right-hand side.
-    return buildStaticNoSuchMethod(elements.getSelector(node), []);
+    return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
   ir.Primitive visitUnresolvedClassConstructorInvoke(
       ast.NewExpression node,
       Element element,
       DartType type,
       ast.NodeList arguments,
       Selector selector, _) {
     // If the class is missing it's a runtime error.
     return buildRuntimeError("Unresolved class: '${element.name}'");
   }
 
   @override
   ir.Primitive visitUnresolvedConstructorInvoke(
       ast.NewExpression node,
       Element constructor,
       DartType type,
       ast.NodeList argumentsNode,
       Selector selector, _) {
     // If the class is there but the constructor is missing, it's an NSM error.
     List<ir.Primitive> arguments = <ir.Primitive>[];
     CallStructure callStructure = translateDynamicArguments(
         argumentsNode, selector.callStructure, arguments);
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector(selector.kind, selector.memberName, callStructure),
         arguments);
   }
 
   @override
   ir.Primitive visitConstructorIncompatibleInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList argumentsNode,
       CallStructure callStructure, _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.call(constructor.memberName, callStructure), arguments);
   }
 
   @override
   ir.Primitive visitUnresolvedGet(
       ast.Send node,
       Element element, _) {
-    return buildStaticNoSuchMethod(elements.getSelector(node), []);
+    return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
   ir.Primitive visitUnresolvedInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector, _) {
-    return buildStaticNoSuchMethod(elements.getSelector(node),
+    return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node),
         arguments.nodes.mapToList(visit));
   }
 
   @override
   ir.Primitive visitUnresolvedRedirectingFactoryConstructorInvoke(
        ast.NewExpression node,
        ConstructorElement constructor,
        InterfaceType type,
        ast.NodeList argumentsNode,
        CallStructure callStructure, _) {
     String nameString = Elements.reconstructConstructorName(constructor);
     Name name = new Name(nameString, constructor.library);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.call(name, callStructure),
         arguments);
   }
 
   @override
   ir.Primitive visitUnresolvedSet(
       ast.Send node,
       Element element,
       ast.Node rhs, _) {
-    return buildStaticNoSuchMethod(elements.getSelector(node), [visit(rhs)]);
+    return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node),
+        [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitUnresolvedSuperIndex(
       ast.Send node,
       Element function,
       ast.Node index, _) {
     // Assume the index getter is missing.
     return buildInstanceNoSuchMethod(
         new Selector.index(), elements.getTypeMask(node), [visit(index)]);
@@ skipping 30 matching lines @@
     return irBuilder.buildNullConstant();
   }
 
   @override
   ir.Primitive visitClassTypeLiteralSet(
       ast.SendSet node,
       TypeConstantExpression constant,
       ast.Node rhs, _) {
     InterfaceType type = constant.type;
     ClassElement element = type.element;
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(element.memberName),
         [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitTypedefTypeLiteralSet(
       ast.SendSet node,
       TypeConstantExpression constant,
       ast.Node rhs, _) {
     TypedefType type = constant.type;
     TypedefElement element = type.element;
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(element.memberName),
         [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralSet(
       ast.SendSet node,
       TypeVariableElement element,
       ast.Node rhs, _) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(element.memberName), [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralSet(
       ast.SendSet node,
       ConstantExpression constant,
       ast.Node rhs, _) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(Names.dynamic_), [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitAbstractClassConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement element,
       InterfaceType type,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     for (ast.Node argument in arguments) visit(argument);
     return buildAbstractClassInstantiationError(element.enclosingClass);
   }
 
   @override
   ir.Primitive handleFinalStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     // TODO(asgerf): Include class name somehow for static class members?
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(field.memberName),
         [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitFinalSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     return buildInstanceNoSuchMethod(
         new Selector.setter(field.memberName),
         elements.getTypeMask(node),
         [visit(rhs)]);
   }
 
   @override
   ir.Primitive handleImmutableLocalSet(
       ast.SendSet node,
       LocalElement local,
       ast.Node rhs, _) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(new Name(local.name, local.library)),
         [visit(rhs)]);
   }
 
   @override
   ir.Primitive handleStaticFunctionSet(
       ast.Send node,
       MethodElement function,
       ast.Node rhs,
       _) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(function.memberName),
         [visit(rhs)]);
   }
 
   @override
   ir.Primitive handleStaticGetterSet(
       ast.SendSet node,
       GetterElement getter,
       ast.Node rhs,
       _) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(getter.memberName),
         [visit(rhs)]);
   }
 
   @override
   ir.Primitive handleStaticSetterGet(
       ast.Send node,
       SetterElement setter,
       _) {
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.getter(setter.memberName),
         []);
   }
 
   @override
   ir.Primitive handleStaticSetterInvoke(
       ast.Send node,
       SetterElement setter,
       ast.NodeList argumentsNode,
       CallStructure callStructure, _) {
     // Translate as a method call.
     List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
-    return buildStaticNoSuchMethod(
+    return irBuilder.buildStaticNoSuchMethod(
         new Selector.call(setter.memberName, callStructure),
         arguments);
   }
 
   @override
   ir.Primitive visitSuperGetterSet(
       ast.SendSet node,
       GetterElement getter,
       ast.Node rhs,
       _) {
@@ skipping 251 matching lines @@
   /// arguments for the class [cls] are never used in the program.
   bool requiresRuntimeTypesFor(ClassElement cls) {
     return cls.typeVariables.isNotEmpty && _backend.classNeedsRti(cls);
   }
 
   FunctionElement get stringifyFunction {
     return _backend.helpers.stringInterpolationHelper;
   }
 
   FunctionElement get throwTypeErrorHelper => _backend.helpers.throwTypeError;
+  Element get throwNoSuchMethod => _backend.helpers.throwNoSuchMethod;
 
   ClassElement get nullClass => _compiler.coreClasses.nullClass;
 
   DartType unaliasType(DartType type) => type.unaliased;
 
   TypeMask getTypeMaskForForeign(NativeBehavior behavior) {
     if (behavior == null) {
       return _backend.dynamicType;
     }
     return TypeMaskFactory.fromNativeBehavior(behavior, _compiler);
@@ skipping 769 matching lines @@
     return irBuilder.buildConstructorInvocation(
         target,
         callStructure,
         constructor.computeEffectiveTargetType(type),
         arguments,
         sourceInformationBuilder.buildNew(node),
         allocationSiteType: allocationSiteType);
   }
 
   @override
-  ir.Primitive buildStaticNoSuchMethod(Selector selector,
-                                       List<ir.Primitive> arguments) {
-    Element thrower = backend.helpers.throwNoSuchMethod;
-    ir.Primitive receiver = irBuilder.buildStringConstant('');
-    ir.Primitive name = irBuilder.buildStringConstant(selector.name);
-    ir.Primitive argumentList = irBuilder.buildListLiteral(null, arguments);
-    ir.Primitive expectedArgumentNames = irBuilder.buildNullConstant();
-    return irBuilder.buildStaticFunctionInvocation(
-        thrower,
-        new CallStructure.unnamed(4),
-        [receiver, name, argumentList, expectedArgumentNames]);
-  }
-
-  @override
   ir.Primitive buildInstanceNoSuchMethod(Selector selector,
                                          TypeMask mask,
                                          List<ir.Primitive> arguments) {
     return irBuilder.buildDynamicInvocation(
         irBuilder.buildThis(),
         Selectors.noSuchMethod_,
         mask,
         [irBuilder.buildInvocationMirror(selector, arguments)]);
   }
 
@@ skipping 273 matching lines @@
       callStructure = translateStaticArguments(argumentsNode, function,
           callStructure, arguments);
       return irBuilder.buildStaticFunctionInvocation(function,
           callStructure,
           arguments,
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }