Make unit testing of the compiler work with the new isolate helper library.

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 385 matching lines @@
 
     createInvocationMirrorElement =
         findHelper(CREATE_INVOCATION_MIRROR);
     enqueuer.resolution.addToWorkList(createInvocationMirrorElement);
     enqueuer.codegen.addToWorkList(createInvocationMirrorElement);
   }
 
   void enableIsolateSupport(LibraryElement element) {
     // TODO(ahe): Move this method to Enqueuer.
     isolateLibrary = element.patch;
-    isolateHelperLibrary = scanBuiltinLibrary('_isolate_helper');
-    importForeignLibrary(isolateHelperLibrary);
-    importHelperLibrary(isolateHelperLibrary);
-
-    libraryLoader.importLibrary(isolateLibrary, isolateHelperLibrary, null);
     enqueuer.resolution.addToWorkList(
         isolateHelperLibrary.find(START_ROOT_ISOLATE));
     enqueuer.resolution.addToWorkList(
         isolateHelperLibrary.find(const SourceString('_currentIsolate')));
     enqueuer.resolution.addToWorkList(
         isolateHelperLibrary.find(const SourceString('_callInIsolate')));
     enqueuer.codegen.addToWorkList(
         isolateHelperLibrary.find(START_ROOT_ISOLATE));
-
-    // 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('_Window'));
-    cls.setNative('"*DOMWindow"');
-
-    cls = isolateHelperLibrary.find(const SourceString('_WorkerStub'));
-    cls.setNative('"*Worker"');
-
-    enqueuer.resolution.nativeEnqueuer.processNativeClassesInLibrary(
-        isolateHelperLibrary);
-    enqueuer.codegen.nativeEnqueuer.processNativeClassesInLibrary(
-        isolateHelperLibrary);
   }
 
   bool hasIsolateSupport() => isolateLibrary != null;
 
   /**
    * This method is called before [library] import and export scopes have been
    * set up.
    */
   void onLibraryScanned(LibraryElement library, Uri uri) {
     if (dynamicClass != null) {
@@ skipping 35 matching lines @@
     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 @@
    */
   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.uri.toString();
     bool nativeTest = library.entryCompilationUnit.script.name.contains(
         'dart/tests/compiler/dart2js_native');
     if (nativeTest
         || libraryName == 'dart:mirrors'
         || libraryName == 'dart:math'
         || libraryName == 'dart:html'
@@ skipping 15 matching lines @@
       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.uri.toString();
+    if (libraryName == 'dart:isolate'
+        || libraryName == 'dart:html') {
+      importIsolateHelperLibrary(library);
+    }
+  }
+
   void runCompiler(Uri uri) {
     log('compiling $uri ($BUILD_ID)');
     scanBuiltinLibraries();
     mainApp = libraryLoader.loadLibrary(uri, null, uri);
     libraries.forEach((_, library) {
       maybeEnableJSHelper(library);
+      maybeEnableIsolateHelper(library);
     });
     final Element main = mainApp.find(MAIN);
     if (main == null) {
       reportFatalError('Could not find $MAIN', mainApp);
     } else {
       if (!main.isFunction()) reportFatalError('main is not a function', main);
       FunctionElement mainMethod = main;
       FunctionSignature parameters = mainMethod.computeSignature(this);
       parameters.forEachParameter((Element parameter) {
         reportFatalError('main cannot have parameters', parameter);
@@ skipping 395 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;
 }