Add CoreClasses

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.dart

 // Copyright (c) 2014, 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.js_emitter.full_emitter;
 
 import 'dart:convert';
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 import 'package:js_runtime/shared/embedded_names.dart' show
     JsBuiltin,
     JsGetName;
 
 import '../headers.dart';
 import '../js_emitter.dart' hide Emitter;
 import '../js_emitter.dart' as js_emitter show Emitter;
 import '../model.dart';
 import '../program_builder/program_builder.dart';
 
 import '../../common.dart';
 import '../../common/names.dart' show
     Names;
 import '../../compiler.dart' show
     Compiler;
 import '../../constants/values.dart';
+import '../../core_types.dart' show
+    CoreClasses;
 import '../../dart_types.dart' show
     DartType;
 import '../../deferred_load.dart' show OutputUnit;
 import '../../elements/elements.dart' show
     ClassElement,
     ConstructorBodyElement,
     Element,
     Elements,
     ElementKind,
     FieldElement,
@@ skipping 87 matching lines @@
 
   /// True if [ContainerBuilder.addMemberMethodFromInfo] used "structured info",
   /// that is, some function was needed for reflection, had stubs, or had a
   /// super alias.
   bool needsStructuredMemberInfo = false;
 
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter get nativeEmitter => task.nativeEmitter;
   TypeTestRegistry get typeTestRegistry => task.typeTestRegistry;
+  CoreClasses get coreClasses => compiler.coreClasses;
 
   // The full code that is written to each hunk part-file.
   Map<OutputUnit, CodeOutput> outputBuffers = new Map<OutputUnit, CodeOutput>();
 
   String classesCollector;
   final Map<jsAst.Name, String> mangledFieldNames =
       new HashMap<jsAst.Name, String>();
   final Map<jsAst.Name, String> mangledGlobalFieldNames =
       new HashMap<jsAst.Name, String>();
   final Set<jsAst.Name> recordedMangledNames = new Set<jsAst.Name>();
@@ skipping 219 matching lines @@
   @override
   jsAst.PropertyAccess typeAccess(Element element) {
     return globalPropertyAccess(element);
   }
 
   @override
   jsAst.Template templateForBuiltin(JsBuiltin builtin) {
     switch (builtin) {
       case JsBuiltin.dartObjectConstructor:
         return jsAst.js.expressionTemplateYielding(
-            typeAccess(compiler.objectClass));
+            typeAccess(coreClasses.objectClass));
 
       case JsBuiltin.isCheckPropertyToJsConstructorName:
         int isPrefixLength = namer.operatorIsPrefix.length;
         return jsAst.js.expressionTemplateFor('#.substring($isPrefixLength)');
 
       case JsBuiltin.isFunctionType:
         return backend.rtiEncoder.templateForIsFunctionType;
 
       case JsBuiltin.rawRtiToJsConstructorName:
         return jsAst.js.expressionTemplateFor("#.$typeNameProperty");
@@ skipping 54 matching lines @@
                                                   leafTagsAccess);
   }
 
   jsAst.ObjectInitializer generateInterceptedNamesSet() {
     return interceptorEmitter.generateInterceptedNamesSet();
   }
 
   /// In minified mode we want to keep the name for the most common core types.
   bool _isNativeTypeNeedingReflectionName(Element element) {
     if (!element.isClass) return false;
-    return (element == compiler.intClass ||
-            element == compiler.doubleClass ||
-            element == compiler.numClass ||
-            element == compiler.stringClass ||
-            element == compiler.boolClass ||
-            element == compiler.nullClass ||
-            element == compiler.listClass);
+    return (element == coreClasses.intClass ||
+            element == coreClasses.doubleClass ||
+            element == coreClasses.numClass ||
+            element == coreClasses.stringClass ||
+            element == coreClasses.boolClass ||
+            element == coreClasses.nullClass ||
+            element == coreClasses.listClass);
   }
 
   /// Returns the "reflection name" of an [Element] or [Selector].
   /// The reflection name of a getter 'foo' is 'foo'.
   /// The reflection name of a setter 'foo' is 'foo='.
   /// The reflection name of a method 'foo' is 'foo:N:M:O', where N is the
   /// number of required arguments, M is the number of optional arguments, and
   /// O is the named arguments.
   /// The reflection name of a constructor is similar to a regular method but
   /// starts with 'new '.
@@ skipping 715 matching lines @@
           task.metadataCollector.reifyType(type, ignoreTypeVariables: true);
       ClassBuilder builder = new ClassBuilder.forStatics(typedef, namer);
       builder.addPropertyByName(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME,
                                 typeIndex);
       builder.addPropertyByName(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
                                 js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
-      assert(compiler.objectClass != null);
-      builder.superName = namer.className(compiler.objectClass);
+      assert(coreClasses.objectClass != null);
+      builder.superName = namer.className(coreClasses.objectClass);
       jsAst.Node declaration = builder.toObjectInitializer();
       jsAst.Name mangledName = namer.globalPropertyName(typedef);
       String reflectionName = getReflectionName(typedef, mangledName);
       getElementDescriptor(library, mainFragment)
           ..addProperty(mangledName, declaration)
           ..addPropertyByName("+$reflectionName", js.string(''));
       // Also emit a trivial constructor for CSP mode.
       jsAst.Name constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<jsAst.Name> fieldNames = [];
@@ skipping 920 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }