Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/ssa/codegen.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.
 
 import 'dart:math' as math;
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
-import '../core_types.dart' show CoreClasses;
+import '../core_types.dart' show CommonElements;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../js_emitter/js_emitter.dart' show NativeEmitter;
 import '../native/native.dart' as native;
 import '../types/types.dart';
@@ skipping 163 matching lines @@
   CodegenRegistry get registry => work.registry;
 
   BackendHelpers get helpers => backend.helpers;
 
   native.NativeEnqueuer get nativeEnqueuer {
     return compiler.enqueuer.codegen.nativeEnqueuer;
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
 
-  CoreClasses get coreClasses => compiler.coreClasses;
+  CommonElements get commonElements => closedWorld.commonElements;
 
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
   }
 
   bool hasNonBitOpUser(HInstruction instruction, Set<HPhi> phiSet) {
     for (HInstruction user in instruction.usedBy) {
       if (user is HPhi) {
         if (!phiSet.contains(user)) {
           phiSet.add(user);
@@ skipping 93 matching lines @@
    */
   push(js.Expression expression) {
     expressionStack.add(expression);
   }
 
   js.Expression pop() {
     return expressionStack.removeLast();
   }
 
   void preGenerateMethod(HGraph graph) {
-    new SsaInstructionSelection(compiler).visitGraph(graph);
+    new SsaInstructionSelection(compiler, closedWorld).visitGraph(graph);
     new SsaTypeKnownRemover().visitGraph(graph);
     new SsaTrustedCheckRemover(compiler).visitGraph(graph);
     new SsaInstructionMerger(generateAtUseSite, compiler).visitGraph(graph);
     new SsaConditionMerger(generateAtUseSite, controlFlowOperators)
         .visitGraph(graph);
     SsaLiveIntervalBuilder intervalBuilder = new SsaLiveIntervalBuilder(
         compiler, generateAtUseSite, controlFlowOperators);
     intervalBuilder.visitGraph(graph);
     SsaVariableAllocator allocator = new SsaVariableAllocator(
         compiler,
@@ skipping 1321 matching lines @@
     // TODO(herhut): The namer should return the appropriate backendname here.
     if (target != null && !node.isInterceptedCall) {
       if (target == helpers.jsArrayAdd) {
         methodName = 'push';
       } else if (target == helpers.jsArrayRemoveLast) {
         methodName = 'pop';
       } else if (target == helpers.jsStringSplit) {
         methodName = 'split';
         // Split returns a List, so we make sure the backend knows the
         // list class is instantiated.
-        registry.registerInstantiatedClass(coreClasses.listClass);
+        registry.registerInstantiatedClass(commonElements.listClass);
       } else if (backend.isNative(target) &&
           target.isFunction &&
           !node.isInterceptedCall) {
         // A direct (i.e. non-interceptor) native call is the result of
         // optimization.  The optimization ensures any type checks or
         // conversions have been satisified.
         methodName = backend.nativeData.getFixedBackendName(target);
       }
     }
 
@@ skipping 735 matching lines @@
           new StaticUse.staticInvoke(convertToString, CallStructure.ONE_ARG));
       js.Expression jsHelper =
           backend.emitter.staticFunctionAccess(convertToString);
       use(input);
       push(new js.Call(jsHelper, <js.Expression>[pop()],
           sourceInformation: node.sourceInformation));
     }
   }
 
   void visitLiteralList(HLiteralList node) {
-    registry.registerInstantiatedClass(coreClasses.listClass);
+    registry.registerInstantiatedClass(commonElements.listClass);
     generateArrayLiteral(node);
   }
 
   void generateArrayLiteral(HLiteralList node) {
     List<js.Expression> elements = node.inputs.map((HInstruction input) {
       use(input);
       return pop();
     }).toList();
     push(new js.ArrayInitializer(elements)
         .withSourceInformation(node.sourceInformation));
@@ skipping 208 matching lines @@
     }
     registry.registerInstantiation(type);
   }
 
   void handleNumberOrStringSupertypeCheck(
       HInstruction input,
       HInstruction interceptor,
       DartType type,
       SourceInformation sourceInformation,
       {bool negative: false}) {
-    assert(!identical(type.element, coreClasses.listClass) &&
-        !Elements.isListSupertype(type.element, compiler) &&
-        !Elements.isStringOnlySupertype(type.element, compiler));
+    assert(!identical(type.element, commonElements.listClass) &&
+        !Elements.isListSupertype(type.element, commonElements) &&
+        !Elements.isStringOnlySupertype(type.element, commonElements));
     String relation = negative ? '!==' : '===';
     checkNum(input, relation, sourceInformation);
     js.Expression numberTest = pop();
     checkString(input, relation, sourceInformation);
     js.Expression stringTest = pop();
     checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
     checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '&&' : '||';
     String combiner2 = negative ? '||' : '&&';
     push(new js.Binary(
             combiner,
             new js.Binary(combiner, numberTest, stringTest)
                 .withSourceInformation(sourceInformation),
             new js.Binary(combiner2, objectTest, pop())
                 .withSourceInformation(sourceInformation))
         .withSourceInformation(sourceInformation));
   }
 
   void handleStringSupertypeCheck(HInstruction input, HInstruction interceptor,
       DartType type, SourceInformation sourceInformation,
       {bool negative: false}) {
-    assert(!identical(type.element, coreClasses.listClass) &&
-        !Elements.isListSupertype(type.element, compiler) &&
-        !Elements.isNumberOrStringSupertype(type.element, compiler));
+    assert(!identical(type.element, commonElements.listClass) &&
+        !Elements.isListSupertype(type.element, commonElements) &&
+        !Elements.isNumberOrStringSupertype(type.element, commonElements));
     String relation = negative ? '!==' : '===';
     checkString(input, relation, sourceInformation);
     js.Expression stringTest = pop();
     checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
     checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '||' : '&&';
     push(new js.Binary(negative ? '&&' : '||', stringTest,
         new js.Binary(combiner, objectTest, pop())));
   }
 
   void handleListOrSupertypeCheck(HInstruction input, HInstruction interceptor,
       DartType type, SourceInformation sourceInformation,
       {bool negative: false}) {
-    assert(!identical(type.element, coreClasses.stringClass) &&
-        !Elements.isStringOnlySupertype(type.element, compiler) &&
-        !Elements.isNumberOrStringSupertype(type.element, compiler));
+    assert(!identical(type.element, commonElements.stringClass) &&
+        !Elements.isStringOnlySupertype(type.element, commonElements) &&
+        !Elements.isNumberOrStringSupertype(type.element, commonElements));
     String relation = negative ? '!==' : '===';
     checkObject(input, relation, sourceInformation);
     js.Expression objectTest = pop();
     checkArray(input, relation);
     js.Expression arrayTest = pop();
     checkType(input, interceptor, type, sourceInformation, negative: negative);
     String combiner = negative ? '&&' : '||';
     push(new js.Binary(negative ? '||' : '&&', objectTest,
             new js.Binary(combiner, arrayTest, pop()))
         .withSourceInformation(sourceInformation));
@@ skipping 16 matching lines @@
     // be changed to match.
     assert(relation == '===' || relation == '!==');
     bool negative = relation == '!==';
 
     if (node.isVariableCheck || node.isCompoundCheck) {
       use(node.checkCall);
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       assert(node.isRawCheck);
       HInstruction interceptor = node.interceptor;
-      ClassElement objectClass = coreClasses.objectClass;
+      ClassElement objectClass = commonElements.objectClass;
       Element element = type.element;
-      if (element == coreClasses.nullClass) {
+      if (element == commonElements.nullClass) {
         if (negative) {
           checkNonNull(input);
         } else {
           checkNull(input);
         }
       } else if (identical(element, objectClass) || type.treatAsDynamic) {
         // The constant folder also does this optimization, but we make
         // it safe by assuming it may have not run.
         push(newLiteralBool(!negative, sourceInformation));
-      } else if (element == coreClasses.stringClass) {
+      } else if (element == commonElements.stringClass) {
         checkString(input, relation, sourceInformation);
-      } else if (element == coreClasses.doubleClass) {
+      } else if (element == commonElements.doubleClass) {
         checkDouble(input, relation, sourceInformation);
-      } else if (element == coreClasses.numClass) {
+      } else if (element == commonElements.numClass) {
         checkNum(input, relation, sourceInformation);
-      } else if (element == coreClasses.boolClass) {
+      } else if (element == commonElements.boolClass) {
         checkBool(input, relation, sourceInformation);
-      } else if (element == coreClasses.intClass) {
+      } else if (element == commonElements.intClass) {
         // The is check in the code tells us that it might not be an
         // int. So we do a typeof first to avoid possible
         // deoptimizations on the JS engine due to the Math.floor check.
         checkNum(input, relation, sourceInformation);
         js.Expression numTest = pop();
         checkBigInt(input, relation, sourceInformation);
         push(new js.Binary(negative ? '||' : '&&', numTest, pop())
             .withSourceInformation(sourceInformation));
       } else if (node.useInstanceOf) {
         assert(interceptor == null);
         checkTypeViaInstanceof(input, type, sourceInformation,
             negative: negative);
-      } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
+      } else if (Elements.isNumberOrStringSupertype(element, commonElements)) {
         handleNumberOrStringSupertypeCheck(
             input, interceptor, type, sourceInformation,
             negative: negative);
-      } else if (Elements.isStringOnlySupertype(element, compiler)) {
+      } else if (Elements.isStringOnlySupertype(element, commonElements)) {
         handleStringSupertypeCheck(input, interceptor, type, sourceInformation,
             negative: negative);
-      } else if (identical(element, coreClasses.listClass) ||
-          Elements.isListSupertype(element, compiler)) {
+      } else if (identical(element, commonElements.listClass) ||
+          Elements.isListSupertype(element, commonElements)) {
         handleListOrSupertypeCheck(input, interceptor, type, sourceInformation,
             negative: negative);
       } else if (type.isFunctionType) {
         checkType(input, interceptor, type, sourceInformation,
             negative: negative);
       } else if ((input.canBePrimitive(closedWorld) &&
               !input.canBePrimitiveArray(closedWorld)) ||
           input.canBeNull()) {
         checkObject(input, relation, node.sourceInformation);
         js.Expression objectTest = pop();
@@ skipping 223 matching lines @@
         js.Expression result = backend.rtiEncoder.getTypeRepresentation(
             node.dartType, (TypeVariableType variable) => arguments[index++]);
         assert(index == node.inputs.length);
         push(result);
         return;
 
       case TypeInfoExpressionKind.INSTANCE:
         // We expect only flat types for the INSTANCE representation.
         assert(
             node.dartType == (node.dartType.element as ClassElement).thisType);
-        registry.registerInstantiatedClass(coreClasses.listClass);
+        registry.registerInstantiatedClass(commonElements.listClass);
         push(new js.ArrayInitializer(arguments)
             .withSourceInformation(node.sourceInformation));
     }
   }
 
   bool typeVariableAccessNeedsSubstitution(
       TypeVariableElement element, TypeMask receiverMask) {
     ClassElement cls = element.enclosingClass;
 
     // See if the receiver type narrows the set of classes to ones that can be
@@ skipping 80 matching lines @@
     registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(argumentCount)));
     return backend.emitter.staticFunctionAccess(helper);
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }