Add CoreClasses

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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
@@ skipping 145 matching lines @@
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
 
   CodegenRegistry get registry => work.registry;
 
   native.NativeEnqueuer get nativeEnqueuer {
     return compiler.enqueuer.codegen.nativeEnqueuer;
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
 
+  CoreClasses get coreClasses => compiler.coreClasses;
+
   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);
           if (hasNonBitOpUser(user, phiSet)) return true;
@@ skipping 1364 matching lines @@
     // TODO(herhut): The namer should return the appropriate backendname here.
     if (target != null && !node.isInterceptedCall) {
       if (target == backend.jsArrayAdd) {
         methodName = 'push';
       } else if (target == backend.jsArrayRemoveLast) {
         methodName = 'pop';
       } else if (target == backend.jsStringSplit) {
         methodName = 'split';
         // Split returns a List, so we make sure the backend knows the
         // list class is instantiated.
-        registry.registerInstantiatedClass(compiler.listClass);
+        registry.registerInstantiatedClass(coreClasses.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.getFixedBackendName(target);
       }
     }
 
     js.Name methodLiteral;
@@ skipping 708 matching lines @@
       registry.registerStaticUse(convertToString);
       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(compiler.listClass);
+    registry.registerInstantiatedClass(coreClasses.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 212 matching lines @@
           .withSourceInformation(sourceInformation));
     }
     registry.registerInstantiatedType(type);
   }
 
   void handleNumberOrStringSupertypeCheck(HInstruction input,
                                           HInstruction interceptor,
                                           DartType type,
                                           SourceInformation sourceInformation,
                                           {bool negative: false}) {
-    assert(!identical(type.element, compiler.listClass) &&
+    assert(!identical(type.element, coreClasses.listClass) &&
            !Elements.isListSupertype(type.element, compiler) &&
            !Elements.isStringOnlySupertype(type.element, compiler));
     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, compiler.listClass)
+    assert(!identical(type.element, coreClasses.listClass)
            && !Elements.isListSupertype(type.element, compiler)
            && !Elements.isNumberOrStringSupertype(type.element, compiler));
     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, compiler.stringClass)
+    assert(!identical(type.element, coreClasses.stringClass)
            && !Elements.isStringOnlySupertype(type.element, compiler)
            && !Elements.isNumberOrStringSupertype(type.element, compiler));
     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 ? '||' : '&&',
@@ skipping 19 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 = compiler.objectClass;
+      ClassElement objectClass = coreClasses.objectClass;
       Element element = type.element;
-      if (element == compiler.nullClass) {
+      if (element == coreClasses.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 == compiler.stringClass) {
+      } else if (element == coreClasses.stringClass) {
         checkString(input, relation, sourceInformation);
-      } else if (element == compiler.doubleClass) {
+      } else if (element == coreClasses.doubleClass) {
         checkDouble(input, relation, sourceInformation);
-      } else if (element == compiler.numClass) {
+      } else if (element == coreClasses.numClass) {
         checkNum(input, relation, sourceInformation);
-      } else if (element == compiler.boolClass) {
+      } else if (element == coreClasses.boolClass) {
         checkBool(input, relation, sourceInformation);
-      } else if (element == compiler.intClass) {
+      } else if (element == coreClasses.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)) {
         handleNumberOrStringSupertypeCheck(
             input, interceptor, type,
             sourceInformation,
             negative: negative);
       } else if (Elements.isStringOnlySupertype(element, compiler)) {
         handleStringSupertypeCheck(
             input, interceptor, type,
             sourceInformation,
             negative: negative);
-      } else if (identical(element, compiler.listClass) ||
+      } else if (identical(element, coreClasses.listClass) ||
                  Elements.isListSupertype(element, compiler)) {
         handleListOrSupertypeCheck(
             input, interceptor, type,
             sourceInformation,
             negative: negative);
       } else if (type.isFunctionType) {
         checkType(input, interceptor, type,
                   sourceInformation,
                   negative: negative);
       } else if ((input.canBePrimitive(compiler)
@@ skipping 92 matching lines @@
           .withSourceInformation(node.sourceInformation));
       return;
     }
 
     assert(node.isCheckedModeCheck || node.isCastTypeCheck);
     DartType type = node.typeExpression;
     assert(type.kind != TypeKind.TYPEDEF);
     if (type.isFunctionType) {
       // TODO(5022): We currently generate $isFunction checks for
       // function types.
-      registry.registerIsCheck(compiler.functionClass.rawType);
+      registry.registerIsCheck(compiler.coreTypes.functionType);
     }
     registry.registerIsCheck(type);
 
     CheckedModeHelper helper;
     if (node.isBooleanConversionCheck) {
       helper =
           const CheckedModeHelper('boolConversionCheck');
     } else {
       helper =
           backend.getCheckedModeHelper(type, typeCast: node.isCastTypeCheck);
@@ skipping 114 matching lines @@
     }
     registry.registerStaticUse(helper);
     return backend.emitter.staticFunctionAccess(helper);
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }