Add --x-perf-report flag to the dartanalyzer command

pkg/analyzer_cli/lib/src/analyzer_impl.dart

 // Copyright (c) 2015, 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 analyzer_cli.src.analyzer_impl;
 
 import 'dart:collection';
 import 'dart:io';
 
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 104 matching lines @@
   /// then no error or performance information is printed. If [printMode] is `1`,
   /// then both will be printed. If [printMode] is `2`, then only performance
   /// information will be printed, and it will be marked as being for a cold VM.
   ErrorSeverity analyzeSync({int printMode: 1}) {
     setupForAnalysis();
     return _analyzeSync(printMode);
   }
 
   /// Fills [errorInfos] using [sources].
   void prepareErrors() {
-    for (Source source in sources) {
-      context.computeErrors(source);
+    return _prepareErrorsTag.makeCurrentWhile(() {
+      for (Source source in sources) {
+        context.computeErrors(source);
+        errorInfos.add(context.getErrors(source));
+      }
+    });
+  }
 
-      errorInfos.add(context.getErrors(source));
-    }
-  }
+  static final PerformanceTag _prepareErrorsTag =
+      new PerformanceTag("AnalyzerImpl.prepareErrors");
 
   /// Fills [sources].
   void prepareSources(LibraryElement library) {
     var units = new Set<CompilationUnitElement>();
     var libraries = new Set<LibraryElement>();
     addLibrarySources(library, libraries, units);
   }
 
   /// Setup local fields such as the analysis context for analysis.
   void setupForAnalysis() {
     sources.clear();
     errorInfos.clear();
     Uri libraryUri = librarySource.uri;
     if (libraryUri.scheme == 'package' && libraryUri.pathSegments.length > 0) {
       _selfPackageName = libraryUri.pathSegments[0];
     }
   }
 
   /// The sync version of analysis.
   ErrorSeverity _analyzeSync(int printMode) {
     // Don't try to analyze parts.
     if (context.computeKindOf(librarySource) == SourceKind.PART) {
       stderr.writeln("Only libraries can be analyzed.");
       stderr.writeln(
           "${librarySource.fullName} is a part and can not be analyzed.");
       return ErrorSeverity.ERROR;
     }
-    // Resolve library.
-    var libraryElement = context.computeLibraryElement(librarySource);
-    // Prepare source and errors.
+    var libraryElement = _resolveLibrary();
     prepareSources(libraryElement);
     prepareErrors();
 
     // Print errors and performance numbers.
     if (printMode == 1) {
-      _printErrorsAndPerf();
+      _printErrors();
     } else if (printMode == 2) {
       _printColdPerf();
     }
 
     // Compute max severity and set exitCode.
     ErrorSeverity status = maxErrorSeverity;
     if (status == ErrorSeverity.WARNING && options.warningsAreFatal) {
       status = ErrorSeverity.ERROR;
     }
     return status;
@@ skipping 21 matching lines @@
       if (tag != PerformanceTag.UNKNOWN) {
         int tagTime = tag.elapsedMs;
         outSink.writeln('${tag.label}-cold:$tagTime');
         otherTime -= tagTime;
       }
     }
     outSink.writeln('other-cold:$otherTime');
     outSink.writeln("total-cold:$totalTime");
   }
 
-  _printErrorsAndPerf() {
+  _printErrors() {
     // The following is a hack. We currently print out to stderr to ensure that
     // when in batch mode we print to stderr, this is because the prints from
     // batch are made to stderr. The reason that options.shouldBatch isn't used
     // is because when the argument flags are constructed in BatchRunner and
     // passed in from batch mode which removes the batch flag to prevent the
     // "cannot have the batch flag and source file" error message.
     StringSink sink = options.machineFormat ? errorSink : outSink;
 
     // Print errors.
     ErrorFormatter formatter = new ErrorFormatter(sink, options, _processError);
@@ skipping 23 matching lines @@
 
       // Skip TODOs.
       if (severity == ErrorType.TODO) {
         return null;
       }
     }
 
     return new ProcessedSeverity(severity, isOverridden);
   }
 
+  LibraryElement _resolveLibrary() {
+    return _resolveLibraryTag.makeCurrentWhile(() {
+      return context.computeLibraryElement(librarySource);
+    });
+  }
+
+  static final PerformanceTag _resolveLibraryTag =
+      new PerformanceTag("AnalyzerImpl._resolveLibrary");
+
   /// Compute the severity of the error; however:
   ///   * if [options.enableTypeChecks] is false, then de-escalate checked-mode
   ///   compile time errors to a severity of [ErrorSeverity.INFO].
   ///   * if [options.hintsAreFatal] is true, escalate hints to errors.
   static ErrorSeverity computeSeverity(
       AnalysisError error, CommandLineOptions options,
       [AnalysisContext context]) {
     if (context != null) {
       ErrorProcessor processor = ErrorProcessor.getProcessor(context, error);
       // If there is a processor for this error, defer to it.
@@ skipping 46 matching lines @@
   }
 
   @override
   void logInformation(String message, [CaughtException exception]) {
     outSink.writeln(message);
     if (exception != null) {
       outSink.writeln(exception);
     }
   }
 }