Rework analysis server performance measurement code.

pkg/analyzer/lib/src/generated/resolver.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.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 783 matching lines @@
  * unit.
  */
 class CompilationUnitBuilder {
   /**
    * Build the compilation unit element for the given [source] based on the
    * compilation [unit] associated with the source. Throw an AnalysisException
    * if the element could not be built.
    */
   CompilationUnitElementImpl buildCompilationUnit(Source source,
       CompilationUnit unit) {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag = PerformanceStatistics.resolve.makeCurrent();
     try {
       if (unit == null) {
         return null;
       }
       ElementHolder holder = new ElementHolder();
       ElementBuilder builder = new ElementBuilder(holder);
       unit.accept(builder);
       CompilationUnitElementImpl element =
           new CompilationUnitElementImpl(source.shortName);
       element.accessors = holder.accessors;
       element.enums = holder.enums;
       element.functions = holder.functions;
       element.source = source;
       element.typeAliases = holder.typeAliases;
       element.types = holder.types;
       element.topLevelVariables = holder.topLevelVariables;
       unit.element = element;
       holder.validate();
       return element;
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 }
 
 /**
  * Instances of the class `ConstantVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver. In particular, it looks for errors
  * and warnings related to constant expressions.
  */
 class ConstantVerifier extends RecursiveAstVisitor<Object> {
@@ skipping 3617 matching lines @@
 
   HintGenerator(this._compilationUnits, this._context, this._errorListener) {
     _library = _compilationUnits[0].element.library;
     _importsVerifier = new ImportsVerifier(_library);
     _enableDart2JSHints = _context.analysisOptions.dart2jsHint;
     _manager = new InheritanceManager(_compilationUnits[0].element.library);
     _usedElementsVisitor = new _GatherUsedElementsVisitor(_library);
   }
 
   void generateForLibrary() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.hints.start();
+    PerformanceTag prevTag = PerformanceStatistics.hints.makeCurrent();
     try {
       for (int i = 0; i < _compilationUnits.length; i++) {
         CompilationUnitElement element = _compilationUnits[i].element;
         if (element != null) {
           if (i == 0) {
             _importsVerifier.inDefiningCompilationUnit = true;
             _generateForCompilationUnit(_compilationUnits[i], element.source);
             _importsVerifier.inDefiningCompilationUnit = false;
           } else {
             _generateForCompilationUnit(_compilationUnits[i], element.source);
           }
         }
       }
       ErrorReporter definingCompilationUnitErrorReporter =
           new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
       _importsVerifier.generateDuplicateImportHints(
           definingCompilationUnitErrorReporter);
       _importsVerifier.generateUnusedImportHints(
           definingCompilationUnitErrorReporter);
       _library.accept(
           new _UnusedElementsVerifier(_errorListener, _usedElementsVisitor.usedElements));
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   void _generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     unit.accept(_importsVerifier);
     // dead code analysis
     unit.accept(new DeadCodeVerifier(errorReporter));
     unit.accept(_usedElementsVisitor);
     // dart2js analysis
@@ skipping 3735 matching lines @@
   }
 
   /**
    * Build the members in enum declarations. This cannot be done while building the rest of the
    * element model because it depends on being able to access core types, which cannot happen until
    * the rest of the element model has been built (when resolving the core library).
    *
    * @throws AnalysisException if any of the enum members could not be built
    */
   void _buildEnumMembers() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           EnumMemberBuilder builder = new EnumMemberBuilder(_typeProvider);
           library.getAST(source).accept(builder);
         }
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Finish steps that the [buildTypeHierarchies] could not perform, see
    * [ImplicitConstructorBuilder].
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildImplicitConstructors() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag=
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       ImplicitConstructorComputer computer =
           new ImplicitConstructorComputer(_typeProvider);
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           computer.add(
               library.getAST(source),
               source,
               library.libraryElement,
               library.libraryScope);
         }
       }
       computer.compute();
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Resolve the types referenced by function type aliases across all of the function type aliases
    * defined in the current cycle.
    *
    * @throws AnalysisException if any of the function type aliases could not be resolved
    */
   void _buildTypeAliases() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       List<LibraryResolver_TypeAliasInfo> typeAliases =
           new List<LibraryResolver_TypeAliasInfo>();
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           CompilationUnit ast = library.getAST(source);
           for (CompilationUnitMember member in ast.declarations) {
             if (member is FunctionTypeAlias) {
               typeAliases.add(
                   new LibraryResolver_TypeAliasInfo(library, source, member));
             }
           }
         }
       }
       // TODO(brianwilkerson) We need to sort the type aliases such that all
       // aliases referenced by an alias T are resolved before we resolve T.
       for (LibraryResolver_TypeAliasInfo info in typeAliases) {
         TypeResolverVisitor visitor =
             new TypeResolverVisitor.con1(info._library, info._source, _typeProvider);
         info._typeAlias.accept(visitor);
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildTypeHierarchies() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           TypeResolverVisitor visitor =
               new TypeResolverVisitor.con1(library, source, _typeProvider);
           library.getAST(source).accept(visitor);
         }
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
    * table that maps individual libraries to a list of the libraries that either import or export
    * those libraries.
    *
    * This map is used to compute all of the libraries involved in a cycle that include the root
    * library. Given that we only add libraries that are reachable from the root library, when we
@@ skipping 185 matching lines @@
     for (int i = 0; i < count; i++) {
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void _performConstantEvaluation() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       ConstantValueComputer computer =
           new ConstantValueComputer(_typeProvider, analysisContext.declaredVariables);
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           try {
             CompilationUnit unit = library.getAST(source);
             if (unit != null) {
               computer.add(unit);
             }
@@ skipping 18 matching lines @@
             unit.accept(constantVerifier);
           } on AnalysisException catch (exception, stackTrace) {
             AnalysisEngine.instance.logger.logError(
                 "Internal Error: Could not access AST for ${source.fullName} "
                     "during constant verification",
                 new CaughtException(exception, stackTrace));
           }
         }
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    *           libraries could not have their types analyzed
    */
   void _resolveReferencesAndTypes() {
     for (Library library in _librariesInCycles) {
       _resolveReferencesAndTypesInLibrary(library);
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the given library.
    *
    * @param library the library to be resolved
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
   void _resolveReferencesAndTypesInLibrary(Library library) {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
         ast.accept(
             new VariableResolverVisitor.con1(library, source, _typeProvider));
         ResolverVisitor visitor =
             new ResolverVisitor.con1(library, source, _typeProvider);
         ast.accept(visitor);
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
@@ skipping 338 matching lines @@
   }
 
   /**
    * Build the members in enum declarations. This cannot be done while building the rest of the
    * element model because it depends on being able to access core types, which cannot happen until
    * the rest of the element model has been built (when resolving the core library).
    *
    * @throws AnalysisException if any of the enum members could not be built
    */
   void _buildEnumMembers() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       for (ResolvableLibrary library in _librariesInCycle) {
         for (Source source in library.compilationUnitSources) {
           EnumMemberBuilder builder = new EnumMemberBuilder(_typeProvider);
           library.getAST(source).accept(builder);
         }
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Finish steps that the [buildTypeHierarchies] could not perform, see
    * [ImplicitConstructorBuilder].
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildImplicitConstructors() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       ImplicitConstructorComputer computer =
           new ImplicitConstructorComputer(_typeProvider);
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit in
             library.resolvableCompilationUnits) {
           Source source = unit.source;
           CompilationUnit ast = unit.compilationUnit;
           computer.add(
               ast,
               source,
               library.libraryElement,
               library.libraryScope);
         }
       }
       computer.compute();
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   HashMap<Source, ResolvableLibrary> _buildLibraryMap() {
     HashMap<Source, ResolvableLibrary> libraryMap =
         new HashMap<Source, ResolvableLibrary>();
     int libraryCount = _librariesInCycle.length;
     for (int i = 0; i < libraryCount; i++) {
       ResolvableLibrary library = _librariesInCycle[i];
       library.errorListener = _errorListener;
       libraryMap[library.librarySource] = library;
       List<ResolvableLibrary> dependencies = library.importsAndExports;
       int dependencyCount = dependencies.length;
       for (int j = 0; j < dependencyCount; j++) {
         ResolvableLibrary dependency = dependencies[j];
         //dependency.setErrorListener(errorListener);
         libraryMap[dependency.librarySource] = dependency;
       }
     }
     return libraryMap;
   }
 
   /**
    * Resolve the types referenced by function type aliases across all of the function type aliases
    * defined in the current cycle.
    *
    * @throws AnalysisException if any of the function type aliases could not be resolved
    */
   void _buildTypeAliases() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       List<LibraryResolver2_TypeAliasInfo> typeAliases =
           new List<LibraryResolver2_TypeAliasInfo>();
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit in
             library.resolvableCompilationUnits) {
           for (CompilationUnitMember member in
               unit.compilationUnit.declarations) {
             if (member is FunctionTypeAlias) {
               typeAliases.add(
                   new LibraryResolver2_TypeAliasInfo(library, unit.source, member));
             }
           }
         }
       }
       // TODO(brianwilkerson) We need to sort the type aliases such that all
       // aliases referenced by an alias T are resolved before we resolve T.
       for (LibraryResolver2_TypeAliasInfo info in typeAliases) {
         TypeResolverVisitor visitor =
             new TypeResolverVisitor.con4(info._library, info._source, _typeProvider);
         info._typeAlias.accept(visitor);
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildTypeHierarchies() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit in
             library.resolvableCompilationUnits) {
           Source source = unit.source;
           CompilationUnit ast = unit.compilationUnit;
           TypeResolverVisitor visitor =
               new TypeResolverVisitor.con4(library, source, _typeProvider);
           ast.accept(visitor);
         }
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Return an array containing the lexical identifiers associated with the nodes in the given list.
    *
    * @param names the AST nodes representing the identifiers
    * @return the lexical identifiers associated with the nodes in the list
    */
   List<String> _getIdentifiers(NodeList<SimpleIdentifier> names) {
     int count = names.length;
     List<String> identifiers = new List<String>(count);
     for (int i = 0; i < count; i++) {
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void _performConstantEvaluation() {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       ConstantValueComputer computer =
           new ConstantValueComputer(_typeProvider, analysisContext.declaredVariables);
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit in
             library.resolvableCompilationUnits) {
           CompilationUnit ast = unit.compilationUnit;
           if (ast != null) {
             computer.add(ast);
           }
         }
       }
       computer.computeValues();
       // As a temporary workaround for issue 21572, run ConstantVerifier now.
       // TODO(paulberry): remove this workaround once issue 21572 is fixed.
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit in
             library.resolvableCompilationUnits) {
           CompilationUnit ast = unit.compilationUnit;
           ErrorReporter errorReporter =
               new ErrorReporter(_errorListener, unit.source);
           ConstantVerifier constantVerifier =
               new ConstantVerifier(errorReporter, library.libraryElement, _typeProvider);
           ast.accept(constantVerifier);
         }
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    *           libraries could not have their types analyzed
    */
   void _resolveReferencesAndTypes() {
     for (ResolvableLibrary library in _librariesInCycle) {
       _resolveReferencesAndTypesInLibrary(library);
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the given library.
    *
    * @param library the library to be resolved
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
   void _resolveReferencesAndTypesInLibrary(ResolvableLibrary library) {
-    TimeCounter_TimeCounterHandle timeCounter =
-        PerformanceStatistics.resolve.start();
+    PerformanceTag prevTag =
+        PerformanceStatistics.resolve.makeCurrent();
     try {
       for (ResolvableCompilationUnit unit in library.resolvableCompilationUnits)
           {
         Source source = unit.source;
         CompilationUnit ast = unit.compilationUnit;
         ast.accept(
             new VariableResolverVisitor.con3(library, source, _typeProvider));
         ResolverVisitor visitor =
             new ResolverVisitor.con4(library, source, _typeProvider);
         ast.accept(visitor);
       }
     } finally {
-      timeCounter.stop();
+      prevTag.makeCurrent();
     }
   }
 
   /**
    * Report that the async library could not be resolved in the given
    * [analysisContext] and throw an exception.  [asyncLibrarySource] is the source
    * representing the async library.
    */
   static void missingAsyncLibrary(AnalysisContext analysisContext,
       Source asyncLibrarySource) {
@@ skipping 6494 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }