Replace try/finally with PerformanceTag.makeCurrentWhile().

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 18 matching lines @@
 /**
  * Callback signature used by ImplicitConstructorBuilder to register
  * computations to be performed, and their dependencies.  A call to this
  * callback indicates that [computation] may be used to compute implicit
  * constructors for [classElement], but that the computation may not be invoked
  * until after implicit constructors have been built for [superclassElement].
  */
 typedef void ImplicitConstructorBuilderCallback(ClassElement classElement,
     ClassElement superclassElement, void computation());
 
+typedef ResolverVisitor ResolverVisitorFactory(Library library, Source source,
+    TypeProvider typeProvider);
+
+typedef StaticTypeAnalyzer StaticTypeAnalyzerFactory(ResolverVisitor visitor);
+
+typedef TypeResolverVisitor TypeResolverVisitorFactory(Library library,
+    Source source, TypeProvider typeProvider);
+
 typedef void VoidFunction();
 
 /**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  */
 class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
 //  static String _HASHCODE_GETTER_NAME = "hashCode";
 
   static String _NULL_TYPE_NAME = "Null";
@@ skipping 745 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) {
-    PerformanceTag prevTag = PerformanceStatistics.resolve.makeCurrent();
-    try {
+    return PerformanceStatistics.resolve.makeCurrentWhile(() {
       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 {
-      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 3498 matching lines @@
   }
 
   /**
    * Return `true` if the given [node] exits.
    */
   static bool exits(AstNode node) {
     return new ExitDetector()._nodeExits(node);
   }
 }
 
+
 /**
  * Instances of the class `FunctionScope` implement the scope defined by a function.
  */
 class FunctionScope extends EnclosedScope {
   final ExecutableElement _functionElement;
 
   bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
@@ skipping 101 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() {
-    PerformanceTag prevTag = PerformanceStatistics.hints.makeCurrent();
-    try {
+    PerformanceStatistics.hints.makeCurrentWhile(() {
       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 {
-      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
     if (_enableDart2JSHints) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices
     unit.accept(
         new BestPracticesVerifier(errorReporter, _context.typeProvider));
     unit.accept(new OverrideVerifier(_manager, errorReporter));
     // Find to-do comments
     new ToDoFinder(errorReporter).findIn(unit);
     // pub analysis
     // TODO(danrubel/jwren) Commented out until bugs in the pub verifier are
     // fixed
     //    unit.accept(new PubVerifier(context, errorReporter));
   }
 }
 
-
 /**
  * Instances of the class {@code HtmlTagInfo} record information about the tags used in an HTML
  * file.
  */
 class HtmlTagInfo {
   /**
    * An array containing all of the tags used in the HTML file.
    */
   List<String> allTags;
 
@@ skipping 3690 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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           EnumMemberBuilder builder = new EnumMemberBuilder(_typeProvider);
           library.getAST(source).accept(builder);
         }
       }
-    } finally {
-      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() {
-    PerformanceTag prevTag=
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       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 {
-      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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       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 {
-      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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           TypeResolverVisitorFactory typeResolverVisitorFactory =
               analysisContext.typeResolverVisitorFactory;
-          TypeResolverVisitor visitor = (typeResolverVisitorFactory == null)
-              ? new TypeResolverVisitor.con1(library, source, _typeProvider)
-              : typeResolverVisitorFactory(library, source, _typeProvider);
+          TypeResolverVisitor visitor = (typeResolverVisitorFactory == null) ?
+              new TypeResolverVisitor.con1(library, source, _typeProvider) :
+              typeResolverVisitorFactory(library, source, _typeProvider);
           library.getAST(source).accept(visitor);
         }
       }
-    } finally {
-      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
    * work backward we are guaranteed to only get libraries in the cycle.
@@ skipping 184 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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       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);
             }
           } on AnalysisException catch (exception, stackTrace) {
@@ skipping 16 matching lines @@
                 new ConstantVerifier(errorReporter, library.libraryElement, _typeProvider);
             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 {
-      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) {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
         ast.accept(
             new VariableResolverVisitor.con1(library, source, _typeProvider));
         ResolverVisitorFactory visitorFactory =
             analysisContext.resolverVisitorFactory;
-        ResolverVisitor visitor = visitorFactory != null
-            ? visitorFactory(library, source, _typeProvider)
-            : new ResolverVisitor.con1(library, source, _typeProvider);
+        ResolverVisitor visitor = visitorFactory != null ?
+            visitorFactory(library, source, _typeProvider) :
+            new ResolverVisitor.con1(library, source, _typeProvider);
         ast.accept(visitor);
       }
-    } finally {
-      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 337 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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (ResolvableLibrary library in _librariesInCycle) {
         for (Source source in library.compilationUnitSources) {
           EnumMemberBuilder builder = new EnumMemberBuilder(_typeProvider);
           library.getAST(source).accept(builder);
         }
       }
-    } finally {
-      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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       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 {
-      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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       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 {
-      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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       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 {
-      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() {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       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 {
-      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) {
-    PerformanceTag prevTag =
-        PerformanceStatistics.resolve.makeCurrent();
-    try {
+    PerformanceStatistics.resolve.makeCurrentWhile(() {
       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 {
-      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) {
     throw new AnalysisException("Could not resolve dart:async");
   }
 
   /**
    * Report that the core library could not be resolved in the given analysis context and throw an
    * exception.
    *
    * @param analysisContext the analysis context in which the failure occurred
    * @param coreLibrarySource the source representing the core library
    * @throws AnalysisException always
    */
   static void missingCoreLibrary(AnalysisContext analysisContext,
       Source coreLibrarySource) {
     throw new AnalysisException("Could not resolve dart:core");
   }
 }
 
+
 /**
  * Instances of the class `TypeAliasInfo` hold information about a [TypeAlias].
  */
 class LibraryResolver2_TypeAliasInfo {
   final ResolvableLibrary _library;
 
   final Source _source;
 
   final FunctionTypeAlias _typeAlias;
 
@@ skipping 102 matching lines @@
     for (PrefixElement prefix in definingLibrary.prefixes) {
       define(prefix);
     }
     _defineLocalNames(definingLibrary.definingCompilationUnit);
     for (CompilationUnitElement compilationUnit in definingLibrary.parts) {
       _defineLocalNames(compilationUnit);
     }
   }
 }
 
-
 /**
  * This class is used to replace uses of `HashMap<String, ExecutableElement>` which are not as
  * performant as this class.
  */
 class MemberMap {
   /**
    * The current size of this map.
    */
   int _size = 0;
 
@@ skipping 1035 matching lines @@
   const ResolverErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => type.severity;
 
   @override
   ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
 }
 
-typedef ResolverVisitor ResolverVisitorFactory(
-    Library library, Source source, TypeProvider typeProvider);
-
-typedef TypeResolverVisitor TypeResolverVisitorFactory(
-    Library library, Source source, TypeProvider typeProvider);
-
-typedef StaticTypeAnalyzer StaticTypeAnalyzerFactory(ResolverVisitor visitor);
-
 /**
  * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
  * compilation unit.
  */
 class ResolverVisitor extends ScopedVisitor {
   /**
    * The manager for the inheritance mappings.
    */
   InheritanceManager _inheritanceManager;
 
@@ skipping 63 matching lines @@
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ResolverVisitor.con1(Library library, Source source,
       TypeProvider typeProvider, {StaticTypeAnalyzer typeAnalyzer,
       StaticTypeAnalyzerFactory typeAnalyzerFactory})
       : super.con1(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
     this._elementResolver = new ElementResolver(this);
-    this._typeAnalyzer = typeAnalyzer != null
-        ? typeAnalyzer
-        : (typeAnalyzerFactory != null
-            ? typeAnalyzerFactory(this)
-            : new StaticTypeAnalyzer(this));
+    this._typeAnalyzer = typeAnalyzer != null ?
+        typeAnalyzer :
+        (typeAnalyzerFactory != null ?
+            typeAnalyzerFactory(this) :
+            new StaticTypeAnalyzer(this));
   }
 
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
@@ skipping 3487 matching lines @@
       _recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     _hasReferenceToSuper = false;
     super.visitClassDeclaration(node);
     ClassElementImpl classElement = _getClassElement(node.name);
-    if (classElement != null)  {
+    if (classElement != null) {
       classElement.hasReferenceToSuper = _hasReferenceToSuper;
     }
     return null;
   }
 
   @override
   void visitClassDeclarationInScope(ClassDeclaration node) {
     super.visitClassDeclarationInScope(node);
     ExtendsClause extendsClause = node.extendsClause;
     WithClause withClause = node.withClause;
@@ skipping 1727 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>();
 }