Add CoreTypes interface.

pkg/compiler/lib/src/compiler.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 dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 611 matching lines @@
   static final Uri DART_NATIVE_TYPED_DATA =
       new Uri(scheme: 'dart', path: '_native_typed_data');
   static final Uri DART_INTERNAL = new Uri(scheme: 'dart', path: '_internal');
   static final Uri DART_ASYNC = new Uri(scheme: 'dart', path: 'async');
 
   final Stopwatch totalCompileTime = new Stopwatch();
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Types types;
+  _CompilerCoreTypes _coreTypes;
 
   final CacheStrategy cacheStrategy;
 
   /**
    * Map from token to the first preceeding comment token.
    */
   final TokenMap commentMap = new TokenMap();
 
   /**
    * Records global dependencies, that is, dependencies that don't
@@ skipping 121 matching lines @@
 
   LibraryElement mainApp;
   FunctionElement mainFunction;
 
   /// Initialized when dart:mirrors is loaded.
   LibraryElement mirrorsLibrary;
 
   /// Initialized when dart:typed_data is loaded.
   LibraryElement typedDataLibrary;
 
-  ClassElement objectClass;
-  ClassElement boolClass;
-  ClassElement numClass;
-  ClassElement intClass;
-  ClassElement doubleClass;
-  ClassElement stringClass;
-  ClassElement functionClass;
-  ClassElement nullClass;
-  ClassElement listClass;
-  ClassElement typeClass;
-  ClassElement mapClass;
-  ClassElement symbolClass;
-  ClassElement stackTraceClass;
+  ClassElement get objectClass => _coreTypes.objectClass;
+  ClassElement get boolClass => _coreTypes.boolClass;
+  ClassElement get numClass => _coreTypes.numClass;
+  ClassElement get intClass => _coreTypes.intClass;
+  ClassElement get doubleClass => _coreTypes.doubleClass;
+  ClassElement get stringClass => _coreTypes.stringClass;
+  ClassElement get functionClass => _coreTypes.functionClass;
+  ClassElement get nullClass => _coreTypes.nullClass;
+  ClassElement get listClass => _coreTypes.listClass;
+  ClassElement get typeClass => _coreTypes.typeClass;
+  ClassElement get mapClass => _coreTypes.mapClass;
+  ClassElement get symbolClass => _coreTypes.symbolClass;
+  ClassElement get stackTraceClass => _coreTypes.stackTraceClass;
+  ClassElement get futureClass => _coreTypes.futureClass;
+  ClassElement get iterableClass => _coreTypes.iterableClass;
+  ClassElement get streamClass => _coreTypes.streamClass;
+
+  CoreTypes get coreTypes => _coreTypes;
+
   ClassElement typedDataClass;
-  ClassElement futureClass;
-  ClassElement iterableClass;
-  ClassElement streamClass;
 
   /// The constant for the [proxy] variable defined in dart:core.
   ConstantValue proxyConstant;
 
   // TODO(johnniwinther): Move this to the JavaScriptBackend.
   /// The constant for the [patch] variable defined in dart:_js_helper.
   ConstantValue patchConstant;
 
   // TODO(johnniwinther): Move this to the JavaScriptBackend.
   ClassElement nativeAnnotationClass;
@@ skipping 201 matching lines @@
         cacheStrategy = new CacheStrategy(hasIncrementalSupport),
         this.outputProvider = (outputProvider == null)
             ? NullSink.outputProvider
             : outputProvider {
     if (hasIncrementalSupport) {
       // TODO(ahe): This is too much. Any method from platform and package
       // libraries can be inlined.
       disableInlining = true;
     }
     world = new World(this);
+    _coreTypes = new _CompilerCoreTypes(this);
     types = new Types(this);
     tracer = new Tracer(this, this.outputProvider);
 
     if (verbose) {
       progress = new Stopwatch()..start();
     }
 
     // TODO(johnniwinther): Separate the dependency tracking from the enqueueing
     // for global dependencies.
     globalDependencies =
@@ skipping 195 matching lines @@
     if (uri == DART_CORE) {
       initializeCoreClasses();
       identicalFunction = coreLibrary.find('identical');
     } else if (uri == DART_INTERNAL) {
       symbolImplementationClass = findRequiredElement(library, 'Symbol');
     } else if (uri == DART_MIRRORS) {
       mirrorSystemClass = findRequiredElement(library, 'MirrorSystem');
       mirrorsUsedClass = findRequiredElement(library, 'MirrorsUsed');
     } else if (uri == DART_ASYNC) {
       deferredLibraryClass = findRequiredElement(library, 'DeferredLibrary');
-      futureClass = findRequiredElement(library, 'Future');
-      streamClass = findRequiredElement(library, 'Stream');
+      _coreTypes.futureClass = findRequiredElement(library, 'Future');
+      _coreTypes.streamClass = findRequiredElement(library, 'Stream');
     } else if (uri == DART_NATIVE_TYPED_DATA) {
       typedDataClass = findRequiredElement(library, 'NativeTypedData');
     } else if (uri == js_backend.JavaScriptBackend.DART_JS_HELPER) {
       nativeAnnotationClass = findRequiredElement(library, 'Native');
     }
     return backend.onLibraryScanned(library, loader);
   }
 
   /// This method is called when all new libraries loaded through
   /// [LibraryLoader.loadLibrary] has been loaded and their imports/exports
@@ skipping 122 matching lines @@
 
   void initializeCoreClasses() {
     final List missingCoreClasses = [];
     ClassElement lookupCoreClass(String name) {
       ClassElement result = coreLibrary.find(name);
       if (result == null) {
         missingCoreClasses.add(name);
       }
       return result;
     }
-    objectClass = lookupCoreClass('Object');
-    boolClass = lookupCoreClass('bool');
-    numClass = lookupCoreClass('num');
-    intClass = lookupCoreClass('int');
-    doubleClass = lookupCoreClass('double');
-    stringClass = lookupCoreClass('String');
-    functionClass = lookupCoreClass('Function');
-    listClass = lookupCoreClass('List');
-    typeClass = lookupCoreClass('Type');
-    mapClass = lookupCoreClass('Map');
-    nullClass = lookupCoreClass('Null');
-    stackTraceClass = lookupCoreClass('StackTrace');
-    iterableClass = lookupCoreClass('Iterable');
-    symbolClass = lookupCoreClass('Symbol');
+    _coreTypes.objectClass = lookupCoreClass('Object');

[karlklose, 2014/12/16 09:04:38]

Would it be possible to construct the whole CoreTypes instance here (and make
the fields final)?

[Johnni Winther, 2014/12/16 10:21:01]

Adding a TODO.

+    _coreTypes.boolClass = lookupCoreClass('bool');
+    _coreTypes.numClass = lookupCoreClass('num');
+    _coreTypes.intClass = lookupCoreClass('int');
+    _coreTypes.doubleClass = lookupCoreClass('double');
+    _coreTypes.stringClass = lookupCoreClass('String');
+    _coreTypes.functionClass = lookupCoreClass('Function');
+    _coreTypes.listClass = lookupCoreClass('List');
+    _coreTypes.typeClass = lookupCoreClass('Type');
+    _coreTypes.mapClass = lookupCoreClass('Map');
+    _coreTypes.nullClass = lookupCoreClass('Null');
+    _coreTypes.stackTraceClass = lookupCoreClass('StackTrace');
+    _coreTypes.iterableClass = lookupCoreClass('Iterable');
+    _coreTypes.symbolClass = lookupCoreClass('Symbol');
     if (!missingCoreClasses.isEmpty) {
       internalError(coreLibrary,
           'dart:core library does not contain required classes: '
           '$missingCoreClasses');
     }
   }
 
   Element _unnamedListConstructor;
   Element get unnamedListConstructor {
     if (_unnamedListConstructor != null) return _unnamedListConstructor;
@@ skipping 946 matching lines @@
 }
 
 /// A code location that contains any uri.
 class AnyLocation implements CodeLocation {
   const AnyLocation();
 
   bool inSameLocation(Uri uri) => true;
 
   String relativize(Uri baseUri) => '$baseUri';
 }
+
+class _CompilerCoreTypes implements CoreTypes {
+  final Compiler compiler;
+
+  ClassElementX objectClass;
+  ClassElementX boolClass;
+  ClassElementX numClass;
+  ClassElementX intClass;
+  ClassElementX doubleClass;
+  ClassElementX stringClass;
+  ClassElementX functionClass;
+  ClassElementX nullClass;
+  ClassElementX listClass;
+  ClassElementX typeClass;
+  ClassElementX mapClass;
+  ClassElementX symbolClass;
+  ClassElementX stackTraceClass;
+  ClassElementX futureClass;
+  ClassElementX iterableClass;
+  ClassElementX streamClass;
+
+  _CompilerCoreTypes(this.compiler);
+
+  @override
+  InterfaceType get boolType => boolClass.computeType(compiler);
+
+  @override
+  InterfaceType get doubleType => doubleClass.computeType(compiler);
+
+  @override
+  InterfaceType get functionType =>  functionClass.computeType(compiler);
+
+  @override
+  InterfaceType get intType => intClass.computeType(compiler);
+
+  @override
+  InterfaceType listType([DartType elementType = const DynamicType()]) {
+    return listClass.computeType(compiler).createInstantiation([elementType]);
+  }
+
+  @override
+  InterfaceType mapType([DartType keyType = const DynamicType(),
+                         DartType valueType = const DynamicType()]) {
+    return mapClass.computeType(compiler)
+        .createInstantiation([keyType, valueType]);
+  }
+
+  @override
+  InterfaceType get nullType => nullClass.computeType(compiler);
+
+  @override
+  InterfaceType get numType => numClass.computeType(compiler);
+
+  @override
+  InterfaceType get stringType =>  stringClass.computeType(compiler);
+}