Use Zone to correctly measure async operations.

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.
 
 library dart2js.compiler_base;
 
 import 'dart:async' show
     EventSink,
     Future;
 
@@ skipping 14 matching lines @@
 import 'common/registry.dart' show
     EagerRegistry,
     Registry;
 import 'common/resolution.dart' show
     Parsing,
     Resolution,
     ResolutionWorkItem,
     ResolutionImpact;
 import 'common/tasks.dart' show
     CompilerTask,
-    GenericTask;
+    GenericTask,
+    Measurer;
 import 'common/work.dart' show
     WorkItem;
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show
     CoreClasses,
     CoreTypes;
 import 'dart_backend/dart_backend.dart' as dart_backend;
 import 'dart_types.dart' show
     DartType,
@@ skipping 92 matching lines @@
     StaticUse;
 import 'universe/world_impact.dart' show
     WorldImpact;
 import 'util/util.dart' show
     Link,
     Setlet;
 import 'world.dart' show
     World;
 
 abstract class Compiler {
+  // Constructor must be first to ensure [Measurer] is instantiated before
+  // other computations.
+  Compiler({this.enableTypeAssertions: false,
+            this.enableUserAssertions: false,
+            this.trustTypeAnnotations: false,
+            this.trustPrimitives: false,
+            bool disableTypeInferenceFlag: false,
+            this.maxConcreteTypeSize: 5,
+            this.enableMinification: false,
+            this.preserveUris: false,
+            this.enableNativeLiveTypeAnalysis: false,
+            bool emitJavaScript: true,
+            bool dart2dartMultiFile: false,
+            bool generateSourceMap: true,
+            bool analyzeAllFlag: false,
+            bool analyzeOnly: false,
+            this.analyzeMain: false,
+            bool analyzeSignaturesOnly: false,
+            this.preserveComments: false,
+            this.useCpsIr: false,
+            this.useFrequencyNamer: false,
+            this.verbose: false,
+            this.sourceMapUri: null,
+            this.outputUri: null,
+            this.buildId: UNDETERMINED_BUILD_ID,
+            this.deferredMapUri: null,
+            this.dumpInfo: false,
+            bool useStartupEmitter: false,
+            this.useContentSecurityPolicy: false,
+            bool hasIncrementalSupport: false,
+            this.enableExperimentalMirrors: false,
+            this.enableAssertMessage: false,
+            this.allowNativeExtensions: false,
+            this.generateCodeWithCompileTimeErrors: false,
+            this.testMode: false,
+            DiagnosticOptions diagnosticOptions,
+            api.CompilerOutput outputProvider,
+            List<String> strips: const [],
+            Backend makeBackend(Compiler compiler),
+            Measurer measurer})
+      : this.measurer = measurer == null ? new Measurer() : measurer,
+        this.disableTypeInferenceFlag =
+            disableTypeInferenceFlag || !emitJavaScript,
+        this.analyzeOnly =
+            analyzeOnly || analyzeSignaturesOnly || analyzeAllFlag,
+        this.analyzeSignaturesOnly = analyzeSignaturesOnly,
+        this.analyzeAllFlag = analyzeAllFlag,
+        this.hasIncrementalSupport = hasIncrementalSupport,
+        cacheStrategy = new CacheStrategy(hasIncrementalSupport),
+        this.userOutputProvider = outputProvider == null
+            ? const NullCompilerOutput() : 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);
+    // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
+    // make its field final.
+    _reporter = new _CompilerDiagnosticReporter(this, diagnosticOptions);
+    _parsing = new _CompilerParsing(this);
+    _resolution = new _CompilerResolution(this);
+    _coreTypes = new _CompilerCoreTypes(_resolution);
+    types = new Types(_resolution);
+    tracer = new Tracer(this, this.outputProvider);
 
-  final Stopwatch totalCompileTime = new Stopwatch();
+    if (verbose) {
+      progress = new Stopwatch()..start();
+    }
+
+    // TODO(johnniwinther): Separate the dependency tracking from the enqueuing
+    // for global dependencies.
+    globalDependencies = new GlobalDependencyRegistry(this);
+
+    if (makeBackend != null) {
+      backend = makeBackend(this);
+    } else if (emitJavaScript) {
+      js_backend.JavaScriptBackend jsBackend =
+          new js_backend.JavaScriptBackend(
+              this, generateSourceMap: generateSourceMap,
+              useStartupEmitter: useStartupEmitter);
+      backend = jsBackend;
+    } else {
+      backend = new dart_backend.DartBackend(this, strips,
+                                             multiFile: dart2dartMultiFile);
+      if (dumpInfo) {
+        throw new ArgumentError('--dump-info is not supported for dart2dart.');
+      }
+    }
+
+    tasks = [
+      libraryLoader = new LibraryLoaderTask(this),
+      serialization = new SerializationTask(this),
+      scanner = new ScannerTask(this),
+      dietParser = new DietParserTask(this),
+      parser = new ParserTask(this),
+      patchParser = new PatchParserTask(this),
+      resolver = new ResolverTask(this, backend.constantCompilerTask),
+      closureToClassMapper = new closureMapping.ClosureTask(this),
+      checker = new TypeCheckerTask(this),
+      typesTask = new ti.TypesTask(this),
+      constants = backend.constantCompilerTask,
+      deferredLoadTask = new DeferredLoadTask(this),
+      mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
+      enqueuer = backend.makeEnqueuer(),
+      dumpInfoTask = new DumpInfoTask(this),
+      reuseLibraryTask = new GenericTask('Reuse library', this),
+      selfTask = new GenericTask('self', this),
+    ];
+
+    tasks.addAll(backend.tasks);
+  }
+
+  /// Helper instance for measurements in [CompilerTask].
+  final Measurer measurer;
+
   int nextFreeClassId = 0;
   World world;
   Types types;
   _CompilerCoreTypes _coreTypes;
   _CompilerDiagnosticReporter _reporter;
   _CompilerResolution _resolution;
   _CompilerParsing _parsing;
 
   final CacheStrategy cacheStrategy;
 
@@ skipping 108 matching lines @@
 
   List<Uri> librariesToAnalyzeWhenRun;
 
   /// The set of platform libraries reported as unsupported.
   ///
   /// For instance when importing 'dart:io' without '--categories=Server'.
   Set<Uri> disallowedLibraryUris = new Setlet<Uri>();
 
   Tracer tracer;
 
-  CompilerTask measuredTask;
   LibraryElement coreLibrary;
   LibraryElement asyncLibrary;
 
   LibraryElement mainApp;
   FunctionElement mainFunction;
 
   /// Initialized when dart:mirrors is loaded.
   LibraryElement mirrorsLibrary;
 
   /// Initialized when dart:typed_data is loaded.
@@ skipping 72 matching lines @@
   LibraryLoaderTask libraryLoader;
   SerializationTask serialization;
   ResolverTask resolver;
   closureMapping.ClosureTask closureToClassMapper;
   TypeCheckerTask checker;
   ti.TypesTask typesTask;
   Backend backend;
 
   GenericTask reuseLibraryTask;
 
+  GenericTask selfTask;
+
   /// The constant environment for the frontend interpretation of compile-time
   /// constants.
   ConstantEnvironment constants;
 
   EnqueueTask enqueuer;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   DumpInfoTask dumpInfoTask;
   String buildId;
 
@@ skipping 26 matching lines @@
   static const int PHASE_RESOLVING = 1;
   static const int PHASE_DONE_RESOLVING = 2;
   static const int PHASE_COMPILING = 3;
   int phase;
 
   bool compilationFailed = false;
 
   /// Set by the backend if real reflection is detected in use of dart:mirrors.
   bool disableTypeInferenceForMirrors = false;
 
-  Compiler({this.enableTypeAssertions: false,
-            this.enableUserAssertions: false,
-            this.trustTypeAnnotations: false,
-            this.trustPrimitives: false,
-            bool disableTypeInferenceFlag: false,
-            this.maxConcreteTypeSize: 5,
-            this.enableMinification: false,
-            this.preserveUris: false,
-            this.enableNativeLiveTypeAnalysis: false,
-            bool emitJavaScript: true,
-            bool dart2dartMultiFile: false,
-            bool generateSourceMap: true,
-            bool analyzeAllFlag: false,
-            bool analyzeOnly: false,
-            this.analyzeMain: false,
-            bool analyzeSignaturesOnly: false,
-            this.preserveComments: false,
-            this.useCpsIr: false,
-            this.useFrequencyNamer: false,
-            this.verbose: false,
-            this.sourceMapUri: null,
-            this.outputUri: null,
-            this.buildId: UNDETERMINED_BUILD_ID,
-            this.deferredMapUri: null,
-            this.dumpInfo: false,
-            bool useStartupEmitter: false,
-            this.useContentSecurityPolicy: false,
-            bool hasIncrementalSupport: false,
-            this.enableExperimentalMirrors: false,
-            this.enableAssertMessage: false,
-            this.allowNativeExtensions: false,
-            this.generateCodeWithCompileTimeErrors: false,
-            this.testMode: false,
-            DiagnosticOptions diagnosticOptions,
-            api.CompilerOutput outputProvider,
-            List<String> strips: const [],
-            Backend makeBackend(Compiler compiler)})
-      : this.disableTypeInferenceFlag =
-          disableTypeInferenceFlag || !emitJavaScript,
-        this.analyzeOnly =
-            analyzeOnly || analyzeSignaturesOnly || analyzeAllFlag,
-        this.analyzeSignaturesOnly = analyzeSignaturesOnly,
-        this.analyzeAllFlag = analyzeAllFlag,
-        this.hasIncrementalSupport = hasIncrementalSupport,
-        cacheStrategy = new CacheStrategy(hasIncrementalSupport),
-        this.userOutputProvider = outputProvider == null
-            ? const NullCompilerOutput() : 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);
-    // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
-    // make its field final.
-    _reporter = new _CompilerDiagnosticReporter(this, diagnosticOptions);
-    _parsing = new _CompilerParsing(this);
-    _resolution = new _CompilerResolution(this);
-    _coreTypes = new _CompilerCoreTypes(_resolution);
-    types = new Types(_resolution);
-    tracer = new Tracer(this, this.outputProvider);
-
-    if (verbose) {
-      progress = new Stopwatch()..start();
-    }
-
-    // TODO(johnniwinther): Separate the dependency tracking from the enqueuing
-    // for global dependencies.
-    globalDependencies = new GlobalDependencyRegistry(this);
-
-    if (makeBackend != null) {
-      backend = makeBackend(this);
-    } else if (emitJavaScript) {
-      js_backend.JavaScriptBackend jsBackend =
-          new js_backend.JavaScriptBackend(
-              this, generateSourceMap: generateSourceMap,
-              useStartupEmitter: useStartupEmitter);
-      backend = jsBackend;
-    } else {
-      backend = new dart_backend.DartBackend(this, strips,
-                                             multiFile: dart2dartMultiFile);
-      if (dumpInfo) {
-        throw new ArgumentError('--dump-info is not supported for dart2dart.');
-      }
-    }
-
-    tasks = [
-      libraryLoader = new LibraryLoaderTask(this),
-      serialization = new SerializationTask(this),
-      scanner = new ScannerTask(this),
-      dietParser = new DietParserTask(this),
-      parser = new ParserTask(this),
-      patchParser = new PatchParserTask(this),
-      resolver = new ResolverTask(this, backend.constantCompilerTask),
-      closureToClassMapper = new closureMapping.ClosureTask(this),
-      checker = new TypeCheckerTask(this),
-      typesTask = new ti.TypesTask(this),
-      constants = backend.constantCompilerTask,
-      deferredLoadTask = new DeferredLoadTask(this),
-      mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
-      enqueuer = backend.makeEnqueuer(),
-      dumpInfoTask = new DumpInfoTask(this),
-      reuseLibraryTask = new GenericTask('Reuse library', this),
-    ];
-
-    tasks.addAll(backend.tasks);
-  }
-
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
   bool get hasBuildId => buildId != UNDETERMINED_BUILD_ID;
 
   bool get analyzeAll => analyzeAllFlag || compileAll;
 
   bool get compileAll => false;
 
   bool get disableTypeInference {
     return disableTypeInferenceFlag || compilationFailed;
   }
 
   int getNextFreeClassId() => nextFreeClassId++;
 
   void unimplemented(Spannable spannable, String methodName) {
     reporter.internalError(spannable, "$methodName not implemented.");
   }
 
   // Compiles the dart script at [uri].
   //
   // The resulting future will complete with true if the compilation
   // succeded.
-  Future<bool> run(Uri uri) {
-    totalCompileTime.start();
+  Future<bool> run(Uri uri) => selfTask.measureSubtask("Compiler.run", () {
+    measurer.startWallClock();
 
     return new Future.sync(() => runInternal(uri))
         .catchError((error) => _reporter.onError(uri, error))
         .whenComplete(() {
       tracer.close();
-      totalCompileTime.stop();
+      measurer.stopWallClock();
     }).then((_) {
       return !compilationFailed;
     });
-  }
+  });
 
   /// This method is called immediately after the [LibraryElement] [library] has
   /// been created.
   ///
   /// Use this callback method to store references to specific libraries.
   /// Note that [library] has not been scanned yet, nor has its imports/exports
   /// been resolved.
   void onLibraryCreated(LibraryElement library) {
     Uri uri = library.canonicalUri;
     if (uri == Uris.dart_core) {
@@ skipping 383 matching lines @@
         return null;
       }
       fullyEnqueueLibrary(library, enqueuer.resolution);
       emptyQueue(enqueuer.resolution);
       enqueuer.resolution.logSummary(reporter.log);
       return library;
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
-  void compileLoadedLibraries() {
+  void compileLoadedLibraries()
+      => selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
+
     computeMain();
 
     mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
 
     // In order to see if a library is deferred, we must compute the
     // compile-time constants that are metadata.  This means adding
     // something to the resolution queue.  So we cannot wait with
     // this until after the resolution queue is processed.
     deferredLoadTask.beforeResolution(this);
 
@@ skipping 76 matching lines @@
     enqueuer.codegen.logSummary(reporter.log);
 
     int programSize = backend.assembleProgram();
 
     if (dumpInfo) {
       dumpInfoTask.reportSize(programSize);
       dumpInfoTask.dumpInfo();
     }
 
     checkQueues();
-  }
+  });
 
   void fullyEnqueueLibrary(LibraryElement library, Enqueuer world) {
     void enqueueAll(Element element) {
       fullyEnqueueTopLevelElement(element, world);
     }
     library.implementation.forEachLocalMember(enqueueAll);
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
     if (element.isClass) {
@@ skipping 16 matching lines @@
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
    * Empty the [world] queue.
    */
-  void emptyQueue(Enqueuer world) {
+  void emptyQueue(Enqueuer world)
+      => selfTask.measureSubtask("Compiler.emptyQueue", () {
     world.forEach((WorkItem work) {
-    reporter.withCurrentElement(work.element, () {
-        world.applyImpact(work.element, work.run(this, world));
-      });
+      reporter.withCurrentElement(
+          work.element, () => selfTask.measureSubtask("world.applyImpact", () {
+        world.applyImpact(
+            work.element,
+            selfTask.measureSubtask("work.run", () => work.run(this, world)));
+      }));
     });
-  }
+  });
 
-  void processQueue(Enqueuer world, Element main) {
+  void processQueue(Enqueuer world, Element main)
+      => selfTask.measureSubtask("Compiler.processQueue", () {
     world.nativeEnqueuer.processNativeClasses(libraryLoader.libraries);
     if (main != null && !main.isMalformed) {
       FunctionElement mainMethod = main;
       mainMethod.computeType(resolution);
       if (mainMethod.functionSignature.parameterCount != 0) {
         // The first argument could be a list of strings.
         backend.listImplementation.ensureResolved(resolution);
         backend.registerInstantiatedType(
             backend.listImplementation.rawType, world, globalDependencies);
         backend.stringImplementation.ensureResolved(resolution);
         backend.registerInstantiatedType(
             backend.stringImplementation.rawType, world, globalDependencies);
 
         backend.registerMainHasArguments(world);
       }
       world.addToWorkList(main);
     }
     if (verbose) {
       progress.reset();
     }
     emptyQueue(world);
     world.queueIsClosed = true;
     backend.onQueueClosed();
     assert(compilationFailed || world.checkNoEnqueuedInvokedInstanceMethods());
-  }
+  });
 
   /**
    * Perform various checks of the queues. This includes checking that
    * the queues are empty (nothing was added after we stopped
    * processing the queues). Also compute the number of methods that
    * were resolved, but not compiled (aka excess resolution).
    */
   checkQueues() {
     for (Enqueuer world in [enqueuer.resolution, enqueuer.codegen]) {
       world.forEach((WorkItem work) {
@@ skipping 21 matching lines @@
       }
     }
     reporter.log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reporter.reportWarningMessage(e,
           MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
-  WorldImpact analyzeElement(Element element) {
+  WorldImpact analyzeElement(Element element)
+      => selfTask.measureSubtask("Compiler.analyzeElement", () {
     assert(invariant(element,
            element.impliesType ||
            element.isField ||
            element.isFunction ||
            element.isConstructor ||
            element.isGetter ||
            element.isSetter,
            message: 'Unexpected element kind: ${element.kind}'));
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     assert(invariant(element, element.isDeclaration));
     return resolution.computeWorldImpact(element);
-  }
+  });
 
-  WorldImpact analyze(ResolutionWorkItem work,
-                      ResolutionEnqueuer world) {
+  WorldImpact analyze(ResolutionWorkItem work, ResolutionEnqueuer world)
+      => selfTask.measureSubtask("Compiler.analyze", () {
     assert(invariant(work.element, identical(world, enqueuer.resolution)));
     assert(invariant(work.element, !work.isAnalyzed,
         message: 'Element ${work.element} has already been analyzed'));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_RESOLVING) {
         reporter.log(
             'Resolved ${enqueuer.resolution.processedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     AstElement element = work.element;
     if (world.hasBeenProcessed(element)) {
       return const WorldImpact();
     }
     WorldImpact worldImpact = analyzeElement(element);
     backend.onElementResolved(element, element.resolvedAst.elements);
     world.registerProcessedElement(element);
     return worldImpact;
-  }
+  });
 
   WorldImpact codegen(CodegenWorkItem work, CodegenEnqueuer world) {
     assert(invariant(work.element, identical(world, enqueuer.codegen)));
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       reporter.log(
           'Compiled ${enqueuer.codegen.generatedCode.length} methods.');
       progress.reset();
     }
@@ skipping 858 matching lines @@
     if (_otherDependencies == null) {
       _otherDependencies = new Setlet<Element>();
     }
     _otherDependencies.add(element.implementation);
   }
 
   Iterable<Element> get otherDependencies {
     return _otherDependencies != null ? _otherDependencies : const <Element>[];
   }
 }