Reformat

pkg/analyzer/lib/src/generated/incremental_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.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/services/lint.dart';
 
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'incremental_logger.dart' show logger, LoggingTimer;
 import 'java_engine.dart';
 import 'parser.dart';
 import 'resolver.dart';
 import 'scanner.dart';
 import 'source.dart';
 import 'utilities_dart.dart';
 
-
 /**
  * If `true`, an attempt to resolve API-changing modifications is made.
  */
 bool _resolveApiChanges = false;
 
-
 /**
  * This method is used to enable/disable API-changing modifications resolution.
  */
 void set test_resolveApiChanges(bool value) {
   _resolveApiChanges = value;
 }
 
-
 /**
  * Instances of the class [DeclarationMatcher] determine whether the element
  * model defined by a given AST structure matches an existing element model.
  */
 class DeclarationMatcher extends RecursiveAstVisitor {
   /**
    * The libary containing the AST nodes being visited.
    */
   LibraryElement _enclosingLibrary;
 
@@ skipping 126 matching lines @@
   @override
   visitCompilationUnit(CompilationUnit node) {
     _processElement(_enclosingUnit);
     super.visitCompilationUnit(node);
   }
 
   @override
   visitConstructorDeclaration(ConstructorDeclaration node) {
     _hasConstructor = true;
     SimpleIdentifier constructorName = node.name;
-    ConstructorElementImpl element = constructorName == null ?
-        _enclosingClass.unnamedConstructor :
-        _enclosingClass.getNamedConstructor(constructorName.name);
+    ConstructorElementImpl element = constructorName == null
+        ? _enclosingClass.unnamedConstructor
+        : _enclosingClass.getNamedConstructor(constructorName.name);
     _processElement(element);
     _assertCompatibleParameters(node.parameters, element.parameters);
     // TODO(scheglov) debug null Location
     if (element != null) {
       if (element.context == null || element.source == null) {
         logger.log(
             'Bad constructor element $element for $node in ${node.parent}');
       }
     }
     // matches, update the existing element
@@ skipping 64 matching lines @@
       element = _findElement(_enclosingUnit.functions, name);
     } else {
       element = _findElement(_enclosingUnit.accessors, name);
     }
     // process element
     _processElement(element);
     _assertSameAnnotations(node, element);
     _assertFalse(element.isSynthetic);
     _assertSameType(node.returnType, element.returnType);
     _assertCompatibleParameters(
-        node.functionExpression.parameters,
-        element.parameters);
+        node.functionExpression.parameters, element.parameters);
     _assertBodyModifiers(node.functionExpression.body, element);
     // matches, update the existing element
     ExecutableElement newElement = node.element;
     node.name.staticElement = element;
     node.functionExpression.element = element;
     _setLocalElements(element, newElement);
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
@@ skipping 116 matching lines @@
     // verify
     PropertyInducingElement newElement = node.name.staticElement;
     _processElement(element);
     _assertSameAnnotations(node, element);
     _assertEquals(node.isConst, element.isConst);
     _assertEquals(node.isFinal, element.isFinal);
     if (_enclosingFieldNode != null) {
       _assertEquals(_enclosingFieldNode.isStatic, element.isStatic);
     }
     _assertSameType(
-        (node.parent as VariableDeclarationList).type,
-        element.type);
+        (node.parent as VariableDeclarationList).type, element.type);
     // matches, restore the existing element
     node.name.staticElement = element;
     if (element is VariableElementImpl) {
       (element as VariableElementImpl).initializer = newElement.initializer;
     }
   }
 
   @override
   visitWithClause(WithClause node) {
     List<TypeName> nodes = node.mixinTypes;
@@ skipping 33 matching lines @@
         for (SimpleIdentifier nameNode in combinator.hiddenNames) {
           String name = nameNode.name;
           _assertTrue(hideNames.remove(name));
         }
       }
     }
     _assertTrue(showNames.isEmpty);
     _assertTrue(hideNames.isEmpty);
   }
 
-  void _assertCompatibleParameter(FormalParameter node,
-      ParameterElement element) {
+  void _assertCompatibleParameter(
+      FormalParameter node, ParameterElement element) {
     _assertEquals(node.kind, element.parameterKind);
     if (node.kind == ParameterKind.NAMED) {
       _assertEquals(node.identifier.name, element.name);
     }
     // check parameter type specific properties
     if (node is DefaultFormalParameter) {
       Expression nodeDefault = node.defaultValue;
       if (nodeDefault == null) {
         _assertNull(element.defaultValueCode);
       } else {
         _assertEquals(nodeDefault.toSource(), element.defaultValueCode);
       }
     } else if (node is FieldFormalParameter) {
       _assertTrue(element.isInitializingFormal);
     } else if (node is FunctionTypedFormalParameter) {
       _assertTrue(element.type is FunctionType);
       FunctionType elementType = element.type;
       _assertCompatibleParameters(node.parameters, element.parameters);
       _assertSameType(node.returnType, elementType.returnType);
     } else if (node is SimpleFormalParameter) {
       _assertSameType(node.type, element.type);
     }
   }
 
-  void _assertCompatibleParameters(FormalParameterList nodes,
-      List<ParameterElement> elements) {
+  void _assertCompatibleParameters(
+      FormalParameterList nodes, List<ParameterElement> elements) {
     if (nodes == null) {
       return _assertEquals(elements.length, 0);
     }
     List<FormalParameter> parameters = nodes.parameters;
     int length = parameters.length;
     _assertEquals(length, elements.length);
     for (int i = 0; i < length; i++) {
       _assertCompatibleParameter(parameters[i], elements[i]);
     }
   }
@@ skipping 86 matching lines @@
       _assertEquals(nodeName, 'void');
     } else if (type.isDynamic) {
       _assertEquals(nodeName, 'dynamic');
     } else {
       // TODO(scheglov) support other types
       logger.log('node: $node type: $type  type.type: ${type.runtimeType}');
       _assertTrue(false);
     }
   }
 
-  void _assertSameTypeParameter(TypeParameter node,
-      TypeParameterElement element) {
+  void _assertSameTypeParameter(
+      TypeParameter node, TypeParameterElement element) {
     _assertSameType(node.bound, element.bound);
   }
 
-  void _assertSameTypeParameters(TypeParameterList nodesList,
-      List<TypeParameterElement> elements) {
+  void _assertSameTypeParameters(
+      TypeParameterList nodesList, List<TypeParameterElement> elements) {
     if (nodesList == null) {
       return _assertEquals(elements.length, 0);
     }
     List<TypeParameter> nodes = nodesList.typeParameters;
     int length = nodes.length;
     _assertEquals(length, elements.length);
     for (int i = 0; i < length; i++) {
       _assertSameTypeParameter(nodes[i], elements[i]);
     }
   }
@@ skipping 85 matching lines @@
         return element;
       }
     }
     return null;
   }
 
   /**
    * Return the [UriReferencedElement] from [elements] with the given [uri], or
    * `null` if there is no such element.
    */
-  static UriReferencedElement
-      _findUriReferencedElement(List<UriReferencedElement> elements, String uri) {
+  static UriReferencedElement _findUriReferencedElement(
+      List<UriReferencedElement> elements, String uri) {
     for (UriReferencedElement element in elements) {
       if (element.uri == uri) {
         return element;
       }
     }
     return null;
   }
 
   /**
    * Return the value of [literal], or `null` if the string is not a constant
@@ skipping 12 matching lines @@
   static void _removeIdenticalElement(List elements, Object element) {
     int length = elements.length;
     for (int i = 0; i < length; i++) {
       if (identical(elements[i], element)) {
         elements.removeAt(i);
         return;
       }
     }
   }
 
-  static void _setLocalElements(ExecutableElementImpl to,
-      ExecutableElement from) {
+  static void _setLocalElements(
+      ExecutableElementImpl to, ExecutableElement from) {
     to.functions = from.functions;
     to.labels = from.labels;
     to.localVariables = from.localVariables;
     to.parameters = from.parameters;
   }
 }
 
-
 /**
  * Describes how declarations match an existing elements model.
  */
 class DeclarationMatchKind {
   /**
    * Complete match, no API changes.
    */
   static const MATCH = const DeclarationMatchKind('MATCH');
 
   /**
    * Has API changes that we might be able to resolve incrementally.
    */
   static const MISMATCH_OK = const DeclarationMatchKind('MISMATCH_OK');
 
   /**
    * Has API changes that we cannot resolve incrementally.
    */
   static const MISMATCH = const DeclarationMatchKind('MISMATCH');
 
   final String name;
 
   const DeclarationMatchKind(this.name);
 
   @override
   String toString() => name;
 }
 
-
 /**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The element of the compilation unit being resolved.
    */
   final CompilationUnitElement _definingUnit;
 
@@ skipping 144 matching lines @@
 
   /**
    * Return `true` if the given node can be resolved independently of any other
    * nodes.
    *
    * *Note*: This method needs to be kept in sync with
    * [ScopeBuilder.ContextBuilder].
    *
    * [node] - the node being tested.
    */
-  bool _canBeResolved(AstNode node) =>
-      node is ClassDeclaration ||
-          node is ClassTypeAlias ||
-          node is CompilationUnit ||
-          node is ConstructorDeclaration ||
-          node is FunctionDeclaration ||
-          node is FunctionTypeAlias ||
-          node is MethodDeclaration ||
-          node is TopLevelVariableDeclaration;
+  bool _canBeResolved(AstNode node) => node is ClassDeclaration ||
+      node is ClassTypeAlias ||
+      node is CompilationUnit ||
+      node is ConstructorDeclaration ||
+      node is FunctionDeclaration ||
+      node is FunctionTypeAlias ||
+      node is MethodDeclaration ||
+      node is TopLevelVariableDeclaration;
 
   /**
    * Starting at [node], find the smallest AST node that can be resolved
    * independently of any other nodes. Return the node that was found.
    *
    * [node] - the node at which the search is to begin
    *
    * Throws [AnalysisException] if there is no such node.
    */
   AstNode _findResolutionRoot(AstNode node) {
@@ skipping 41 matching lines @@
   }
 
   _resolveReferences(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       _prepareResolutionContext(node);
       Scope scope = _resolutionContext.scope;
       // resolve types
       {
         TypeResolverVisitor visitor = new TypeResolverVisitor.con3(
-            _definingLibrary,
-            _source,
-            _typeProvider,
-            scope,
-            errorListener);
+            _definingLibrary, _source, _typeProvider, scope, errorListener);
         node.accept(visitor);
       }
       // resolve variables
       {
         VariableResolverVisitor visitor = new VariableResolverVisitor.con2(
-            _definingLibrary,
-            _source,
-            _typeProvider,
-            scope,
-            errorListener);
+            _definingLibrary, _source, _typeProvider, scope, errorListener);
         node.accept(visitor);
       }
       // resolve references
       {
         ResolverVisitor visitor = new ResolverVisitor.con3(
-            _definingLibrary,
-            _source,
-            _typeProvider,
-            scope,
-            errorListener);
+            _definingLibrary, _source, _typeProvider, scope, errorListener);
         if (_resolutionContext.enclosingClassDeclaration != null) {
           visitor.visitClassDeclarationIncrementally(
               _resolutionContext.enclosingClassDeclaration);
         }
         if (node is Comment) {
           visitor.resolveOnlyCommentInFunctionBody = true;
           node = node.parent;
         }
         visitor.initForIncrementalResolution();
         node.accept(visitor);
@@ skipping 19 matching lines @@
       int errorOffset = error.offset;
       if (errorOffset > _updateOffset) {
         error.offset += _updateDelta;
       }
     }
   }
 
   void _updateElementNameOffsets() {
     LoggingTimer timer = logger.startTimer();
     try {
-      _definingUnit.accept(
-          new _ElementNameOffsetUpdater(_updateOffset, _updateDelta));
+      _definingUnit
+          .accept(new _ElementNameOffsetUpdater(_updateOffset, _updateDelta));
     } finally {
       timer.stop('update element offsets');
     }
   }
 
   void _updateEntry() {
     {
       List<AnalysisError> oldErrors =
           entry.getValueInLibrary(DartEntry.RESOLUTION_ERRORS, _librarySource);
       List<AnalysisError> errors = _updateErrors(oldErrors, _resolveErrors);
       entry.setValueInLibrary(
-          DartEntry.RESOLUTION_ERRORS,
-          _librarySource,
-          errors);
+          DartEntry.RESOLUTION_ERRORS, _librarySource, errors);
     }
     {
-      List<AnalysisError> oldErrors =
-          entry.getValueInLibrary(DartEntry.VERIFICATION_ERRORS, _librarySource);
+      List<AnalysisError> oldErrors = entry.getValueInLibrary(
+          DartEntry.VERIFICATION_ERRORS, _librarySource);
       List<AnalysisError> errors = _updateErrors(oldErrors, _verifyErrors);
       entry.setValueInLibrary(
-          DartEntry.VERIFICATION_ERRORS,
-          _librarySource,
-          errors);
+          DartEntry.VERIFICATION_ERRORS, _librarySource, errors);
     }
     entry.setValueInLibrary(DartEntry.LINTS, _librarySource, _lints);
   }
 
-  List<AnalysisError> _updateErrors(List<AnalysisError> oldErrors,
-      List<AnalysisError> newErrors) {
+  List<AnalysisError> _updateErrors(
+      List<AnalysisError> oldErrors, List<AnalysisError> newErrors) {
     List<AnalysisError> errors = new List<AnalysisError>();
     // add updated old errors
     for (AnalysisError error in oldErrors) {
       int errorOffset = error.offset;
       if (errorOffset < _updateOffset) {
         errors.add(error);
       } else if (errorOffset > _updateEndOld) {
         error.offset += _updateDelta;
         errors.add(error);
       }
     }
     // add new errors
     for (AnalysisError error in newErrors) {
       int errorOffset = error.offset;
       if (errorOffset > _updateOffset && errorOffset < _updateEndNew) {
         errors.add(error);
       }
     }
     // done
     return errors;
   }
 
   void _verify(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
-      ErrorVerifier errorVerifier = new ErrorVerifier(
-          errorReporter,
-          _definingLibrary,
-          _typeProvider,
+      ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter,
+          _definingLibrary, _typeProvider,
           new InheritanceManager(_definingLibrary));
       if (_resolutionContext.enclosingClassDeclaration != null) {
         errorVerifier.visitClassDeclarationIncrementally(
             _resolutionContext.enclosingClassDeclaration);
       }
       node.accept(errorVerifier);
       _verifyErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('verify');
     }
   }
 }
 
-
 class PoorMansIncrementalResolver {
   final TypeProvider _typeProvider;
   final Source _unitSource;
   final DartEntry _entry;
   final CompilationUnit _oldUnit;
   CompilationUnitElement _unitElement;
 
   int _updateOffset;
   int _updateDelta;
   int _updateEndOld;
@@ skipping 53 matching lines @@
             bool success = _resolveComment(_oldUnit, newUnit, firstPair);
             logger.log('Documentation comment resolved: $success');
             return success;
           }
           // A pure whitespace change.
           if (firstPair.kind == _TokenDifferenceKind.OFFSET) {
             logger.log('Whitespace change.');
             _shiftTokens(firstPair.oldToken);
             {
               IncrementalResolver incrementalResolver = new IncrementalResolver(
-                  _unitElement,
-                  _updateOffset,
-                  _updateEndOld,
-                  _updateEndNew);
+                  _unitElement, _updateOffset, _updateEndOld, _updateEndNew);
               incrementalResolver._updateElementNameOffsets();
               incrementalResolver._shiftEntryErrors();
             }
             _updateEntry();
             logger.log('Success.');
             return true;
           }
           // fall-through, end-of-line comment
         }
         // Find nodes covering the "old" and "new" token ranges.
         AstNode oldNode =
             _findNodeCovering(_oldUnit, beginOffsetOld, endOffsetOld);
         AstNode newNode =
             _findNodeCovering(newUnit, beginOffsetNew, endOffsetNew);
         logger.log(() => 'oldNode: $oldNode');
         logger.log(() => 'newNode: $newNode');
         // Try to find the smallest common node, a FunctionBody currently.
         {
           List<AstNode> oldParents = _getParents(oldNode);
           List<AstNode> newParents = _getParents(newNode);
           int length = math.min(oldParents.length, newParents.length);
           bool found = false;
           for (int i = 0; i < length; i++) {
             AstNode oldParent = oldParents[i];
             AstNode newParent = newParents[i];
             if (oldParent is FunctionDeclaration &&
-                newParent is FunctionDeclaration ||
-                oldParent is MethodDeclaration && newParent is MethodDeclaration ||
-                oldParent is ConstructorDeclaration && newParent is ConstructorDeclaration) {
+                    newParent is FunctionDeclaration ||
+                oldParent is MethodDeclaration &&
+                    newParent is MethodDeclaration ||
+                oldParent is ConstructorDeclaration &&
+                    newParent is ConstructorDeclaration) {
               oldNode = oldParent;
               newNode = newParent;
               found = true;
             }
             if (oldParent is FunctionBody && newParent is FunctionBody) {
               oldNode = oldParent;
               newNode = newParent;
               found = true;
               break;
             }
@@ skipping 19 matching lines @@
           if (oldBeginToken.previous.type == TokenType.EOF) {
             _oldUnit.beginToken = newBeginToken;
           } else {
             oldBeginToken.previous.setNext(newBeginToken);
           }
           newNode.endToken.setNext(oldNode.endToken.next);
           _shiftTokens(oldNode.endToken.next);
         }
         // perform incremental resolution
         IncrementalResolver incrementalResolver = new IncrementalResolver(
-            _unitElement,
-            _updateOffset,
-            _updateEndOld,
-            _updateEndNew);
+            _unitElement, _updateOffset, _updateEndOld, _updateEndNew);
         bool success = incrementalResolver.resolve(newNode);
         // check if success
         if (!success) {
           logger.log('Failure: element model changed.');
           return false;
         }
         // update DartEntry
         _updateEntry();
         logger.log('Success.');
         return true;
@@ skipping 19 matching lines @@
       return unit;
     } finally {
       timer.stop('parse');
     }
   }
 
   /**
    * Attempts to resolve a documentation comment change.
    * Returns `true` if success.
    */
-  bool _resolveComment(CompilationUnit oldUnit, CompilationUnit newUnit,
-      _TokenPair firstPair) {
+  bool _resolveComment(
+      CompilationUnit oldUnit, CompilationUnit newUnit, _TokenPair firstPair) {
     Token oldToken = firstPair.oldToken;
     Token newToken = firstPair.newToken;
     CommentToken oldComments = oldToken.precedingComments;
     CommentToken newComments = newToken.precedingComments;
     if (oldComments == null || newComments == null) {
       return false;
     }
     // find nodes
     int offset = oldComments.offset;
     logger.log('offset: $offset');
     Comment oldComment = _findNodeCovering(oldUnit, offset, offset);
     Comment newComment = _findNodeCovering(newUnit, offset, offset);
     logger.log('oldComment.beginToken: ${oldComment.beginToken}');
     logger.log('newComment.beginToken: ${newComment.beginToken}');
     _updateOffset = oldToken.offset - 1;
     // update token references
     _shiftTokens(firstPair.oldToken);
     _setPrecedingComments(oldToken, newComment.tokens.first);
     // replace node
     NodeReplacer.replace(oldComment, newComment);
     // update elements
     IncrementalResolver incrementalResolver = new IncrementalResolver(
-        _unitElement,
-        _updateOffset,
-        _updateEndOld,
-        _updateEndNew);
+        _unitElement, _updateOffset, _updateEndOld, _updateEndNew);
     incrementalResolver._updateElementNameOffsets();
     incrementalResolver._shiftEntryErrors();
     _updateEntry();
     // resolve references in the comment
     incrementalResolver._resolveReferences(newComment);
     // OK
     return true;
   }
 
   Token _scan(String code) {
@@ skipping 34 matching lines @@
    * Checks if [token] has a balanced number of open and closed curly brackets.
    */
   static bool _areCurlyBracketsBalanced(Token token) {
     int numOpen = _getTokenCount(token, TokenType.OPEN_CURLY_BRACKET);
     int numOpen2 =
         _getTokenCount(token, TokenType.STRING_INTERPOLATION_EXPRESSION);
     int numClosed = _getTokenCount(token, TokenType.CLOSE_CURLY_BRACKET);
     return numOpen + numOpen2 == numClosed;
   }
 
-  static _TokenDifferenceKind _compareToken(Token oldToken, Token newToken,
-      int delta, bool forComment) {
+  static _TokenDifferenceKind _compareToken(
+      Token oldToken, Token newToken, int delta, bool forComment) {
     while (true) {
       if (oldToken == null && newToken == null) {
         return null;
       }
       if (oldToken == null || newToken == null) {
         return _TokenDifferenceKind.CONTENT;
       }
       if (oldToken.type != newToken.type) {
         return _TokenDifferenceKind.CONTENT;
       }
@@ skipping 92 matching lines @@
 
   static List<AstNode> _getParents(AstNode node) {
     List<AstNode> parents = <AstNode>[];
     while (node != null) {
       parents.insert(0, node);
       node = node.parent;
     }
     return parents;
   }
 
-
   /**
    * Returns number of tokens with the given [type].
    */
   static int _getTokenCount(Token token, TokenType type) {
     int count = 0;
     while (token.type != TokenType.EOF) {
       if (token.type == type) {
         count++;
       }
       token = token.next;
@@ skipping 13 matching lines @@
       parent.precedingComments = comment;
     } else if (parent is TokenWithComment) {
       parent.precedingComments = comment;
     } else {
       Type parentType = parent != null ? parent.runtimeType : null;
       throw new AnalysisException('Uknown parent token type: $parentType');
     }
   }
 }
 
-
 /**
  * The context to resolve an [AstNode] in.
  */
 class ResolutionContext {
   CompilationUnitElement enclosingUnit;
   ClassDeclaration enclosingClassDeclaration;
   ClassElement enclosingClass;
   Scope scope;
 }
 
-
 /**
  * Instances of the class [ResolutionContextBuilder] build the context for a
  * given node in an AST structure. At the moment, this class only handles
  * top-level and class-level declarations.
  */
 class ResolutionContextBuilder {
   /**
    * The listener to which analysis errors will be reported.
    */
   final AnalysisErrorListener _errorListener;
@@ skipping 55 matching lines @@
     }
     Scope scope = _scopeForAstNode(parent);
     if (node is ClassDeclaration) {
       _enclosingClassDeclaration = node;
       _enclosingClass = node.element;
       if (_enclosingClass == null) {
         throw new AnalysisException(
             "Cannot build a scope for an unresolved class");
       }
       scope = new ClassScope(
-          new TypeParameterScope(scope, _enclosingClass),
-          _enclosingClass);
+          new TypeParameterScope(scope, _enclosingClass), _enclosingClass);
     } else if (node is ClassTypeAlias) {
       ClassElement element = node.element;
       if (element == null) {
         throw new AnalysisException(
             "Cannot build a scope for an unresolved class type alias");
       }
       scope = new ClassScope(new TypeParameterScope(scope, element), element);
     } else if (node is ConstructorDeclaration) {
       ConstructorElement element = node.element;
       if (element == null) {
@@ skipping 43 matching lines @@
 
   /**
    * Return the context in which the given AST structure should be resolved.
    *
    * [node] - the root of the AST structure to be resolved.
    * [errorListener] - the listener to which analysis errors will be reported.
    *
    * Throws [AnalysisException] if the AST structure has not been resolved or
    * is not part of a [CompilationUnit]
    */
-  static ResolutionContext contextFor(AstNode node,
-      AnalysisErrorListener errorListener) {
+  static ResolutionContext contextFor(
+      AstNode node, AnalysisErrorListener errorListener) {
     if (node == null) {
       throw new AnalysisException("Cannot create context: node is null");
     }
     // build scope
     ResolutionContextBuilder builder =
         new ResolutionContextBuilder(errorListener);
     Scope scope = builder._scopeFor(node);
     // prepare context
     ResolutionContext context = new ResolutionContext();
     context.scope = scope;
     context.enclosingUnit = builder._enclosingUnit;
     context.enclosingClassDeclaration = builder._enclosingClassDeclaration;
     context.enclosingClass = builder._enclosingClass;
     return context;
   }
 }
 
-
 /**
  * Instances of the class [_DeclarationMismatchException] represent an exception
  * that is thrown when the element model defined by a given AST structure does
  * not match an existing element model.
  */
-class _DeclarationMismatchException {
-}
-
+class _DeclarationMismatchException {}
 
 class _ElementNameOffsetUpdater extends GeneralizingElementVisitor {
   final int updateOffset;
   final int updateDelta;
 
   _ElementNameOffsetUpdater(this.updateOffset, this.updateDelta);
 
   @override
   visitElement(Element element) {
     int nameOffset = element.nameOffset;
     if (nameOffset > updateOffset) {
       (element as ElementImpl).nameOffset = nameOffset + updateDelta;
     }
     super.visitElement(element);
   }
 }
 
-
 class _ElementsGatherer extends GeneralizingElementVisitor {
   final DeclarationMatcher matcher;
 
   _ElementsGatherer(this.matcher);
 
   void addElements(List<Element> elements) {
     for (Element element in elements) {
       if (!element.isSynthetic) {
         _addElement(element);
       }
     }
   }
 
   @override
   visitElement(Element element) {
     _addElement(element);
     super.visitElement(element);
   }
 
   @override
   visitExecutableElement(ExecutableElement element) {
     _addElement(element);
   }
 
   @override
-  visitParameterElement(ParameterElement element) {
-  }
+  visitParameterElement(ParameterElement element) {}
 
   @override
   visitPropertyAccessorElement(PropertyAccessorElement element) {
     if (!element.isSynthetic) {
       _addElement(element);
     }
     // Don't visit children (such as synthetic setter parameters).
   }
 
   @override
   visitPropertyInducingElement(PropertyInducingElement element) {
     if (!element.isSynthetic) {
       _addElement(element);
     }
     // Don't visit children (such as property accessors).
   }
 
   @override
-  visitTypeParameterElement(TypeParameterElement element) {
-  }
+  visitTypeParameterElement(TypeParameterElement element) {}
 
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
       matcher._removedElements.add(element);
     }
   }
 }
 
-
 /**
  * Describes how two [Token]s are different.
  */
 class _TokenDifferenceKind {
   static const COMMENT = const _TokenDifferenceKind('COMMENT');
   static const COMMENT_DOC = const _TokenDifferenceKind('COMMENT_DOC');
   static const CONTENT = const _TokenDifferenceKind('CONTENT');
   static const OFFSET = const _TokenDifferenceKind('OFFSET');
 
   final String name;
 
   const _TokenDifferenceKind(this.name);
 
   @override
   String toString() => name;
 }
 
-
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }