Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/inferrer/simple_types_inferrer.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 simple_types_inferrer;
 
 import '../closure.dart' show ClosureClassMap;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 1677 matching lines @@
     TypeMask mask = inTreeData.typeOfSend(node);
     // In erroneous code the number of arguments in the selector might not
     // match the function element.
     // TODO(polux): return nonNullEmpty and check it doesn't break anything
     if (target.isMalformed ||
         !callStructure.signatureApplies(target.functionSignature)) {
       return types.dynamicType;
     }
 
     T returnType = handleStaticSend(node, selector, mask, target, arguments);
-    if (Elements.isGrowableListConstructorCall(constructor, node, compiler)) {
+    if (Elements.isGrowableListConstructorCall(
+        constructor, node, closedWorld.commonElements)) {
       return inferrer.concreteTypes.putIfAbsent(
           node,
           () => types.allocateList(types.growableListType, node,
               outermostElement, types.nonNullEmpty(), 0));
     } else if (Elements.isFixedListConstructorCall(
-            constructor, node, compiler) ||
-        Elements.isFilledListConstructorCall(constructor, node, compiler)) {
+            constructor, node, closedWorld.commonElements) ||
+        Elements.isFilledListConstructorCall(
+            constructor, node, closedWorld.commonElements)) {
       int length = findLength(node);
-      T elementType =
-          Elements.isFixedListConstructorCall(constructor, node, compiler)
-              ? types.nullType
-              : arguments.positional[1];
+      T elementType = Elements.isFixedListConstructorCall(
+              constructor, node, closedWorld.commonElements)
+          ? types.nullType
+          : arguments.positional[1];
 
       return inferrer.concreteTypes.putIfAbsent(
           node,
           () => types.allocateList(types.fixedListType, node, outermostElement,
               elementType, length));
     } else if (Elements.isConstructorOfTypedArraySubclass(
-        constructor, compiler)) {
+        constructor, closedWorld)) {
       int length = findLength(node);
       T elementType = inferrer
           .returnTypeOfElement(target.enclosingClass.lookupMember('[]'));
       return inferrer.concreteTypes.putIfAbsent(
           node,
           () => types.allocateList(types.nonNullExact(target.enclosingClass),
               node, outermostElement, elementType, length));
     } else {
       return returnType;
     }
@@ skipping 521 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     T iteratorType = handleDynamicSend(node, iteratorSelector, iteratorMask,
         expressionType, new ArgumentsTypes<T>.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }