Add compileAll internal compiler flag.

dart/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 236 matching lines @@
    * We should get rid of this and ensure that all dependencies are
    * associated with a particular element.
    */
   final TreeElements globalDependencies = new TreeElementMapping(null);
 
   final bool enableMinification;
   final bool enableTypeAssertions;
   final bool enableUserAssertions;
   final bool trustTypeAnnotations;
   final bool enableConcreteTypeInference;
-  final bool disableTypeInference;
+  final bool disableTypeInferenceFlag;
 
   /**
    * The maximum size of a concrete type before it widens to dynamic during
    * concrete type inference.
    */
   final int maxConcreteTypeSize;
-  final bool analyzeAll;
+  final bool analyzeAllFlag;
   final bool analyzeOnly;
   /**
    * If true, skip analysis of method bodies and field initializers. Implies
    * [analyzeOnly].
    */
   final bool analyzeSignaturesOnly;
   final bool enableNativeLiveTypeAnalysis;
   final bool rejectDeprecatedFeatures;
   final bool checkDeprecationInSdk;
 
@@ skipping 175 matching lines @@
 
   bool compilationFailed = false;
 
   bool hasCrashed = false;
 
   Compiler({this.tracer: const Tracer(),
             this.enableTypeAssertions: false,
             this.enableUserAssertions: false,
             this.trustTypeAnnotations: false,
             this.enableConcreteTypeInference: false,
-            this.disableTypeInference: false,
+            this.disableTypeInferenceFlag: false,
             this.maxConcreteTypeSize: 5,
             this.enableMinification: false,
             this.enableNativeLiveTypeAnalysis: false,
             bool emitJavaScript: true,
             bool generateSourceMap: true,
             bool disallowUnsafeEval: false,
-            this.analyzeAll: false,
+            this.analyzeAllFlag: false,
             bool analyzeOnly: false,
             bool analyzeSignaturesOnly: false,
             this.rejectDeprecatedFeatures: false,
             this.checkDeprecationInSdk: false,
             this.preserveComments: false,
             this.verbose: false,
             this.sourceMapUri: null,
             this.buildId: UNDETERMINED_BUILD_ID,
             this.globalJsName: r'$',
             outputProvider,
@@ skipping 40 matching lines @@
         this, backend.constantSystem, isMetadata: true);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
   bool get hasBuildId => buildId != UNDETERMINED_BUILD_ID;
 
   bool get mirrorsEnabled => mirrorSystemClass != null;
 
+  bool get analyzeAll => analyzeAllFlag || compileAll;
+
+  bool get compileAll => mirrorsEnabled;
+
+  bool get disableTypeInference => disableTypeInferenceFlag || mirrorsEnabled;
+
   int getNextFreeClassId() => nextFreeClassId++;
 
   void ensure(bool condition) {
     if (!condition) cancel('failed assertion in leg');
   }
 
   void unimplemented(String methodName,
                      {Node node, Token token, HInstruction instruction,
                       Element element}) {
     internalError("$methodName not implemented",
@@ skipping 291 matching lines @@
       // something to the resolution queue.  So we cannot wait with
       // this until after the resolution queue is processed.
       // TODO(ahe): Clean this up, for example, by not enqueueing
       // classes only used for metadata.
       deferredLoadTask.findDeferredLibraries(mainApp);
     }
 
     log('Resolving...');
     phase = PHASE_RESOLVING;
     if (analyzeAll) {
-      libraries.forEach((_, lib) => fullyEnqueueLibrary(lib));
+      libraries.forEach(
+          (_, lib) => fullyEnqueueLibrary(lib, enqueuer.resolution));
     }
     // Elements required by enqueueHelpers are global dependencies
     // that are not pulled in by a particular element.
     backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
     resolveReflectiveDataIfNeeded();
     processQueue(enqueuer.resolution, main);
     enqueuer.resolution.logSummary(log);
 
     if (compilationFailed) return;
     if (analyzeOnly) return;
@@ skipping 17 matching lines @@
     // TODO(johnniwinther): Move these to [CodegenEnqueuer].
     if (hasIsolateSupport()) {
       enqueuer.codegen.addToWorkList(
           isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE));
       enqueuer.codegen.registerGetOfStaticFunction(mainApp.find(MAIN));
     }
     if (enabledNoSuchMethod) {
       enqueuer.codegen.registerInvocation(NO_SUCH_METHOD, noSuchMethodSelector);
       enqueuer.codegen.addToWorkList(createInvocationMirrorElement);
     }
+    if (compileAll) {
+      libraries.forEach((_, lib) => fullyEnqueueLibrary(lib, enqueuer.codegen));
+    }
     processQueue(enqueuer.codegen, main);
     enqueuer.codegen.logSummary(log);
 
     if (compilationFailed) return;
 
     backend.assembleProgram();
 
     checkQueues();
   }
 
   void resolveReflectiveDataIfNeeded() {
     // Only need reflective data when dart:mirrors is loaded.
     if (!mirrorsEnabled) return;
 
     for (LibraryElement library in libraries.values) {
       for (Link link = library.metadata; !link.isEmpty; link = link.tail) {
         link.head.ensureResolved(this);
       }
     }
   }
 
-  void fullyEnqueueLibrary(LibraryElement library) {
-    library.implementation.forEachLocalMember(fullyEnqueueTopLevelElement);
+  void fullyEnqueueLibrary(LibraryElement library, Enqueuer world) {
+    // The JS backend gets confused when it tries to compile code for
+    // interceptor classes.

[ngeoffray, 2013/06/10 19:21:00]

But it is compiling methods for interceptor classes, what is it that is failing?

[ahe, 2013/06/11 14:24:45]

I've sent you some additional details in a mail.

I think the problem is that we cannot compile JSNull's constructor, but we can
inline it.  When we see "const JSNull()", the constant handler inlines the
constructor.

+    if (!world.isResolutionQueue && library.isInternalLibrary) return;
+    void enqueueAll(Element element) {
+      fullyEnqueueTopLevelElement(element, world);
+    }
+    library.implementation.forEachLocalMember(enqueueAll);
   }
 
-  void fullyEnqueueTopLevelElement(Element element) {
+  void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
     if (element.isClass()) {
       ClassElement cls = element;
       cls.ensureResolved(this);
-      cls.forEachLocalMember(enqueuer.resolution.addToWorkList);
-      enqueuer.resolution.registerInstantiatedClass(
-          element, globalDependencies);
+      cls.forEachLocalMember(world.addToWorkList);
+      world.registerInstantiatedClass(element, globalDependencies);
     } else {
-      enqueuer.resolution.addToWorkList(element);
+      world.addToWorkList(element);
     }
   }
 
   void processQueue(Enqueuer world, Element main) {
     world.nativeEnqueuer.processNativeClasses(libraries.values);
     if (main != null) {
       world.addToWorkList(main);
     }
     progress.reset();
     world.forEach((WorkItem work) {
@@ skipping 449 matching lines @@
 
   void close() {}
 
   toString() => name;
 
   /// Convenience method for getting an [api.CompilerOutputProvider].
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }