Rework analysis server performance measurement code.

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import "dart:math" as math;
@@ skipping 2313 matching lines @@
             "Internal error while performing the task: $task",
             new CaughtException(exception, stackTrace));
       }
     }
     int performEnd = JavaSystem.currentTimeMillis();
     List<ChangeNotice> notices = _getChangeNotices(false);
     int noticeCount = notices.length;
     for (int i = 0; i < noticeCount; i++) {
       ChangeNotice notice = notices[i];
       Source source = notice.source;
+
       // TODO(brianwilkerson) Figure out whether the compilation unit is always
       // resolved, or whether we need to decide whether to invoke the "parsed"
       // or "resolved" method. This might be better done when recording task
       // results in order to reduce the chance of errors.
       //      if (notice.getCompilationUnit() != null) {
       //        notifyResolvedDart(source, notice.getCompilationUnit());
       //      } else if (notice.getHtmlUnit() != null) {
       //        notifyResolvedHtml(source, notice.getHtmlUnit());
       //      }
       _notifyErrors(source, notice.errors, notice.lineInfo);
@@ skipping 6431 matching lines @@
   @override
   String get taskDescription =>
       "generate errors and warnings for ${source.fullName}";
 
   @override
   accept(AnalysisTaskVisitor visitor) =>
       visitor.visitGenerateDartErrorsTask(this);
 
   @override
   void internalPerform() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.errors.start();
+    PerformanceTag prevTag = PerformanceStatistics.errors.makeCurrent();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       TypeProvider typeProvider = context.typeProvider;
       //
       // Validate the directives
       //
       validateDirectives(context, source, _unit, errorListener);
       //
       // Use the ConstantVerifier to verify the use of constants.
@@ skipping 10 matching lines @@
       // Use the ErrorVerifier to compute the rest of the errors.
       //
       ErrorVerifier errorVerifier = new ErrorVerifier(
           errorReporter,
           libraryElement,
           typeProvider,
           new InheritanceManager(libraryElement));
       _unit.accept(errorVerifier);
       _errors = errorListener.getErrorsForSource(source);
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Check each directive in the given compilation unit to see if the referenced source exists and
    * report an error if it does not.
    *
    * @param context the context in which the library exists
    * @param librarySource the source representing the library containing the directives
    * @param unit the compilation unit containing the directives to be validated
@@ skipping 1211 matching lines @@
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseDartTask(this);
 
   @override
   void internalPerform() {
     //
     // Then parse the token stream.
     //
-    TimeCounter_TimeCounterHandle timeCounterParse =
-        PerformanceStatistics.parse.start();
+    PerformanceTag prevTag = PerformanceStatistics.parse.makeCurrent();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       Parser parser = new Parser(source, errorListener);
       AnalysisOptions options = context.analysisOptions;
       parser.parseFunctionBodies = options.analyzeFunctionBodies;
       _unit = parser.parseCompilationUnit(_tokenStream);
       _unit.lineInfo = lineInfo;
       AnalysisContext analysisContext = context;
       for (Directive directive in _unit.directives) {
         if (directive is PartOfDirective) {
@@ skipping 15 matching lines @@
               } else {
                 throw new AnalysisException(
                     "$runtimeType failed to handle a ${directive.runtimeType}");
               }
             }
           }
         }
       }
       _errors = errorListener.getErrorsForSource(source);
     } finally {
-      timeCounterParse.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Efficiently convert the given set of sources to an array.
    *
    * @param sources the set to be converted
    * @return an array containing all of the sources in the given set
    */
   List<Source> _toArray(HashSet<Source> sources) {
@@ skipping 366 matching lines @@
   void _onCancel() {
     _context._cancelFuture(this);
   }
 }
 
 /**
  * Container with global [AnalysisContext] performance statistics.
  */
 class PerformanceStatistics {
   /**
-   * The [TimeCounter] for time spent in reading files.
+   * The [PerformanceTag] for time spent in reading files.
    */
-  static TimeCounter io = new TimeCounter();
+  static PerformanceTag io = new PerformanceTag('io');
 
   /**
-   * The [TimeCounter] for time spent in scanning.
+   * The [PerformanceTag] for time spent in scanning.
    */
-  static TimeCounter scan = new TimeCounter();
+  static PerformanceTag scan = new PerformanceTag('scan');
 
   /**
-   * The [TimeCounter] for time spent in parsing.
+   * The [PerformanceTag] for time spent in parsing.
    */
-  static TimeCounter parse = new TimeCounter();
+  static PerformanceTag parse = new PerformanceTag('parse');
 
   /**
-   * The [TimeCounter] for time spent in resolving.
+   * The [PerformanceTag] for time spent in resolving.
    */
-  static TimeCounter resolve = new TimeCounter();
+  static PerformanceTag resolve = new PerformanceTag('resolve');
 
   /**
-   * The [TimeCounter] for time spent in error verifier.
+   * The [PerformanceTag] for time spent in error verifier.
    */
-  static TimeCounter errors = new TimeCounter();
+  static PerformanceTag errors = new PerformanceTag('errors');
 
   /**
-   * The [TimeCounter] for time spent in hints generator.
+   * The [PerformanceTag] for time spent in hints generator.
    */
-  static TimeCounter hints = new TimeCounter();
+  static PerformanceTag hints = new PerformanceTag('hints');
 
   /**
-   * The [TimeCounter] for time spent in linting.
+   * The [PerformanceTag] for time spent in linting.
    */
-  static TimeCounter lint = new TimeCounter();
-
-  /**
-   * Reset all of the time counters to zero.
-   */
-  static void reset() {
-    io = new TimeCounter();
-    scan = new TimeCounter();
-    parse = new TimeCounter();
-    resolve = new TimeCounter();
-    errors = new TimeCounter();
-    hints = new TimeCounter();
-    lint = new TimeCounter();
-  }
+  static PerformanceTag lint = new PerformanceTag('lint');
 }
 
 /**
  * Instances of the class `RecordingErrorListener` implement an error listener that will
  * record the errors that are reported to it in a way that is appropriate for caching those errors
  * within an analysis context.
  */
 class RecordingErrorListener implements AnalysisErrorListener {
   /**
    * A HashMap of lists containing the errors that were collected, keyed by each [Source].
@@ skipping 750 matching lines @@
     ResolverVisitor resolverVisitor = new ResolverVisitor.con2(
         _libraryElement,
         source,
         typeProvider,
         inheritanceManager,
         errorListener);
     unit.accept(resolverVisitor);
     //
     // Perform additional error checking.
     //
-    TimeCounter_TimeCounterHandle counterHandleErrors =
-        PerformanceStatistics.errors.start();
+    PerformanceTag prevTag = PerformanceStatistics.errors.makeCurrent();
     try {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       ErrorVerifier errorVerifier = new ErrorVerifier(
           errorReporter,
           _libraryElement,
           typeProvider,
           inheritanceManager);
       unit.accept(errorVerifier);
       // TODO(paulberry): as a temporary workaround for issue 21572,
       // ConstantVerifier is being run right after ConstantValueComputer, so we
       // don't need to run it here.  Once issue 21572 is fixed, re-enable the
       // call to ConstantVerifier.
 //       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _libraryElement, typeProvider);
 //       unit.accept(constantVerifier);
     } finally {
-      counterHandleErrors.stop();
+      prevTag.makeCurrent();
     }
     //
     // Capture the results.
     //
     _resolvedUnit = unit;
   }
 
   /**
    * Search the compilation units that are part of the given library and return the element
    * representing the compilation unit with the given source. Return `null` if there is no
@@ skipping 209 matching lines @@
    * @return the token stream that was produced by scanning the source
    */
   Token get tokenStream => _tokenStream;
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitScanDartTask(this);
 
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
-    TimeCounter_TimeCounterHandle timeCounterScan =
-        PerformanceStatistics.scan.start();
+    PerformanceTag prevTag = PerformanceStatistics.scan.makeCurrent();
     try {
       Scanner scanner =
           new Scanner(source, new CharSequenceReader(_content), errorListener);
       scanner.preserveComments = context.analysisOptions.preserveComments;
       _tokenStream = scanner.tokenize();
       _lineInfo = new LineInfo(scanner.lineStarts);
       _errors = errorListener.getErrorsForSource(source);
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           "Exception",
           new CaughtException(exception, stackTrace));
     } finally {
-      timeCounterScan.stop();
+      prevTag.makeCurrent();
     }
   }
 }
 
 /**
  * Instances of the class `SdkAnalysisContext` implement an [AnalysisContext] that only
  * contains sources for a Dart SDK.
  */
 class SdkAnalysisContext extends AnalysisContextImpl {
   @override
@@ skipping 864 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }