Private libraries used.

sdk/lib/_internal/compiler/implementation/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 474 matching lines @@
       // this way.
       withCurrentElement(dynamicClass, () {
         library.addToScope(dynamicClass, this);
       });
     }
   }
 
   LibraryElement scanBuiltinLibrary(String filename);
 
   void initializeSpecialClasses() {
-    final List missingClasses = [];
-    ClassElement lookupSpecialClass(SourceString name) {
+    final List missingCoreClasses = [];
+    ClassElement lookupCoreClass(SourceString name) {
       ClassElement result = coreLibrary.find(name);
       if (result == null) {
-        missingClasses.add(name.slowToString());
+        missingCoreClasses.add(name.slowToString());
       }
       return result;
     }
-    objectClass = lookupSpecialClass(const SourceString('Object'));
-    boolClass = lookupSpecialClass(const SourceString('bool'));
-    numClass = lookupSpecialClass(const SourceString('num'));
-    intClass = lookupSpecialClass(const SourceString('int'));
-    doubleClass = lookupSpecialClass(const SourceString('double'));
-    stringClass = lookupSpecialClass(const SourceString('String'));
-    functionClass = lookupSpecialClass(const SourceString('Function'));
-    listClass = lookupSpecialClass(const SourceString('List'));
-    typeClass = lookupSpecialClass(const SourceString('Type'));
-    mapClass = lookupSpecialClass(const SourceString('Map'));
+    objectClass = lookupCoreClass(const SourceString('Object'));
+    boolClass = lookupCoreClass(const SourceString('bool'));
+    numClass = lookupCoreClass(const SourceString('num'));
+    intClass = lookupCoreClass(const SourceString('int'));
+    doubleClass = lookupCoreClass(const SourceString('double'));
+    stringClass = lookupCoreClass(const SourceString('String'));
+    functionClass = lookupCoreClass(const SourceString('Function'));
+    listClass = lookupCoreClass(const SourceString('List'));
+    typeClass = lookupCoreClass(const SourceString('Type'));
+    mapClass = lookupCoreClass(const SourceString('Map'));
+    if (!missingCoreClasses.isEmpty) {
+      internalErrorOnElement(coreLibrary,
+          'dart:core library does not contain required classes: '
+          '$missingCoreClasses');
+    }
+
+    final List missingHelperClasses = [];
+    ClassElement lookupHelperClass(SourceString name) {
+      ClassElement result = jsHelperLibrary.find(name);
+      if (result == null) {
+        missingHelperClasses.add(name.slowToString());
+      }
+      return result;
+    }
     jsInvocationMirrorClass =
-        lookupSpecialClass(const SourceString('JSInvocationMirror'));
-    closureClass = lookupSpecialClass(const SourceString('Closure'));
-    dynamicClass = lookupSpecialClass(const SourceString('Dynamic_'));
-    nullClass = lookupSpecialClass(const SourceString('Null'));
+        lookupHelperClass(const SourceString('JSInvocationMirror'));
+    closureClass = lookupHelperClass(const SourceString('Closure'));
+    dynamicClass = lookupHelperClass(const SourceString('Dynamic_'));
+    nullClass = lookupHelperClass(const SourceString('Null'));
+    if (!missingHelperClasses.isEmpty) {
+      internalErrorOnElement(jsHelperLibrary,
+          'dart:_js_helper library does not contain required classes: '
+          '$missingHelperClasses');
+    }
+
     types = new Types(this, dynamicClass);
-    if (!missingClasses.isEmpty) {
-      cancel('core library does not contain required classes: $missingClasses');
-    }
   }
 
   void scanBuiltinLibraries() {
     jsHelperLibrary = scanBuiltinLibrary('_js_helper');
     interceptorsLibrary = scanBuiltinLibrary('_interceptors');
     foreignLibrary = scanBuiltinLibrary('_foreign_helper');
     isolateHelperLibrary = scanBuiltinLibrary('_isolate_helper');
     // The helper library does not use the native language extension,
     // so we manually set the native classes this library defines.
     // TODO(ngeoffray): Enable annotations on these classes.
     ClassElement cls =
         isolateHelperLibrary.find(const SourceString('_WorkerStub'));
     cls.setNative('"*Worker"');
 
-    // The core library was loaded and patched before jsHelperLibrary was
-    // initialized, so it wasn't imported into those two libraries during
-    // patching.
-    importHelperLibrary(coreLibrary);
-    importHelperLibrary(interceptorsLibrary);
-
-    importForeignLibrary(jsHelperLibrary);
-    importForeignLibrary(interceptorsLibrary);
-
-    importForeignLibrary(isolateHelperLibrary);
-    importHelperLibrary(isolateHelperLibrary);
-
     assertMethod = jsHelperLibrary.find(const SourceString('assertHelper'));
     identicalFunction = coreLibrary.find(const SourceString('identical'));
 
     initializeSpecialClasses();
 
     functionClass.ensureResolved(this);
     functionApplyMethod =
         functionClass.lookupLocalMember(const SourceString('apply'));
     jsInvocationMirrorClass.ensureResolved(this);
     invokeOnMethod = jsInvocationMirrorClass.lookupLocalMember(
@@ skipping 12 matching lines @@
       libraryLoader.importLibrary(library, jsHelperLibrary, null);
     }
   }
 
   /**
    * Get an [Uri] pointing to a patch for the dart: library with
    * the given path. Returns null if there is no patch.
    */
   Uri resolvePatchUri(String dartLibraryPath);
 
-  /** Define the JS helper functions in the given library. */
-  void importForeignLibrary(LibraryElement library) {
-    if (foreignLibrary != null) {
-      libraryLoader.importLibrary(library, foreignLibrary, null);
-    }
-  }
-
-  void importIsolateHelperLibrary(LibraryElement library) {
-    if (isolateHelperLibrary != null) {
-      libraryLoader.importLibrary(library, isolateHelperLibrary, null);
-    }
-  }
-
-  // TODO(karlklose,floitsch): move this to the javascript backend.
-  /** Enable the 'JS' helper for a library if needed. */
-  void maybeEnableJSHelper(LibraryElement library) {
-    String libraryName = library.canonicalUri.toString();
-    bool nativeTest = library.entryCompilationUnit.script.name.contains(
-        'dart/tests/compiler/dart2js_native');
-    if (nativeTest
-        || libraryName == 'dart:async'
-        || libraryName == 'dart:chrome'
-        || libraryName == 'dart:mirrors'
-        || libraryName == 'dart:math'
-        || libraryName == 'dart:html'
-        || libraryName == 'dart:html_common'
-        || libraryName == 'dart:indexed_db'
-        || libraryName == 'dart:svg'
-        || libraryName == 'dart:web_audio') {
-      if (nativeTest
-          || libraryName == 'dart:chrome'
-          || libraryName == 'dart:html'
-          || libraryName == 'dart:html_common'
-          || libraryName == 'dart:indexed_db'
-          || libraryName == 'dart:svg') {
-        // dart:html and dart:svg need access to convertDartClosureToJS and
-        // annotation classes.
-        // dart:mirrors needs access to the Primitives class.
-        importHelperLibrary(library);
-      }
-      library.addToScope(
-          foreignLibrary.findLocal(const SourceString('JS')), this);
-      Element jsIndexingBehaviorInterface =
-          findHelper(const SourceString('JavaScriptIndexingBehavior'));
-      if (jsIndexingBehaviorInterface != null) {
-        library.addToScope(jsIndexingBehaviorInterface, this);
-      }
-    }
-  }
-
-  void maybeEnableIsolateHelper(LibraryElement library) {
-    String libraryName = library.canonicalUri.toString();
-    if (libraryName == 'dart:isolate'
-        || libraryName == 'dart:html'
-        // TODO(floitsch): create a separate async-helper library instead of
-        // importing the isolate-library just for TimerImpl.
-        || libraryName == 'dart:async') {
-      importIsolateHelperLibrary(library);
-    }
-  }
-
   void runCompiler(Uri uri) {
     assert(uri != null || analyzeOnly);
     scanBuiltinLibraries();
     if (librariesToAnalyzeWhenRun != null) {
       for (Uri libraryUri in librariesToAnalyzeWhenRun) {
         log('analyzing $libraryUri ($BUILD_ID)');
         libraryLoader.loadLibrary(libraryUri, null, libraryUri);
       }
     }
     if (uri != null) {
       if (analyzeOnly) {
         log('analyzing $uri ($BUILD_ID)');
       } else {
         log('compiling $uri ($BUILD_ID)');
       }
       mainApp = libraryLoader.loadLibrary(uri, null, uri);
     }
-    libraries.forEach((_, library) {
-      maybeEnableJSHelper(library);
-      maybeEnableIsolateHelper(library);
-    });
     Element main = null;
     if (mainApp != null) {
       main = mainApp.find(MAIN);
       if (main == null) {
         if (!analyzeOnly) {
           // Allow analyze only of libraries with no main.
           reportFatalError('Could not find $MAIN', mainApp);
         } else if (!analyzeAll) {
           reportFatalError(
               "Could not find $MAIN. "
@@ skipping 468 matching lines @@
   // TODO(johnniwinther): Use [spannable] and [message] to provide better
   // information on assertion errors.
   if (condition is Function){
     condition = condition();
   }
   if (spannable == null || !condition) {
     throw new SpannableAssertionFailure(spannable, message);
   }
   return true;
 }