Always build elements, then match and restore if matches.

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 'ast.dart';
@@ skipping 142 matching lines @@
   @override
   visitCompilationUnit(CompilationUnit node) {
     _processElement(_enclosingUnit);
     super.visitCompilationUnit(node);
   }
 
   @override
   visitConstructorDeclaration(ConstructorDeclaration node) {
     _hasConstructor = true;
     SimpleIdentifier constructorName = node.name;
-    ConstructorElement element = constructorName == null ?
+    ConstructorElementImpl element = constructorName == null ?
         _enclosingClass.unnamedConstructor :
         _enclosingClass.getNamedConstructor(constructorName.name);
     _processElement(element);
+    _assertCompatibleParameters(node.parameters, element.parameters);
+    // matches, update the existing element
+    ExecutableElement newElement = node.element;
     node.element = element;
-    _assertCompatibleParameters(node.parameters, element.parameters);
+    _setLocalElements(element, newElement);
+    _setParameterElements(node.parameters, element.parameters);
   }
 
   @override
   visitEnumConstantDeclaration(EnumConstantDeclaration node) {
     String name = node.name.name;
     FieldElement element = _findElement(_enclosingClass.fields, name);
     _processElement(element);
   }
 
   @override
@@ skipping 39 matching lines @@
 
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
     // prepare element name
     String name = node.name.name;
     if (node.isSetter) {
       name += '=';
     }
     // prepare element
     Token property = node.propertyKeyword;
-    ExecutableElement element;
+    ExecutableElementImpl element;
     if (property == null) {
       element = _findElement(_enclosingUnit.functions, name);
     } else {
       element = _findElement(_enclosingUnit.accessors, name);
     }
     // process element
     _processElement(element);
-    node.name.staticElement = element;
-    node.functionExpression.element = element;
     _assertFalse(element.isSynthetic);
     _assertSameType(node.returnType, element.returnType);
     _assertCompatibleParameters(
         node.functionExpression.parameters,
         element.parameters);
+    // matches, update the existing element
+    ExecutableElement newElement = node.element;
+    node.name.staticElement = element;
+    node.functionExpression.element = element;
+    _setLocalElements(element, newElement);
+    _setParameterElements(
+        node.functionExpression.parameters,
+        element.parameters);
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     String name = node.name.name;
     FunctionTypeAliasElement element =
         _findElement(_enclosingUnit.functionTypeAliases, name);
     _processElement(element);
     _assertSameTypeParameters(node.typeParameters, element.typeParameters);
     _assertSameType(node.returnType, element.returnType);
@@ skipping 34 matching lines @@
     String name = node.name.name;
     if (name == TokenType.MINUS.lexeme &&
         node.parameters.parameters.length == 0) {
       name = "unary-";
     }
     if (node.isSetter) {
       name += '=';
     }
     // prepare element
     Token property = node.propertyKeyword;
-    ExecutableElement element;
+    ExecutableElementImpl element;
     if (property == null) {
       element = _findElement(_enclosingClass.methods, name);
     } else {
       element = _findElement(_enclosingClass.accessors, name);
     }
     // process element
     _processElement(element);
     _assertEquals(node.isStatic, element.isStatic);
-    node.name.staticElement = element;
     _assertSameType(node.returnType, element.returnType);
     _assertCompatibleParameters(node.parameters, element.parameters);
+    // matches, update the existing element
+    ExecutableElement newElement = node.element;
+    node.name.staticElement = element;
+    _setLocalElements(element, newElement);
+    _setParameterElements(node.parameters, element.parameters);
   }
 
   @override
   visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       CompilationUnitElement element =
           _findUriReferencedElement(_enclosingLibrary.parts, uri);
       _processElement(element);
     }
@@ skipping 24 matching lines @@
     _assertNotNull(element);
     _processElement(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);
+    // matches, restore the existing element
+    node.name.staticElement = element;
   }
 
   @override
   visitWithClause(WithClause node) {
     List<TypeName> nodes = node.mixinTypes;
     List<InterfaceType> types = _enclosingClass.mixins;
     _assertSameTypes(nodes, types);
   }
 
   void _assertCombinators(List<Combinator> nodeCombinators,
@@ skipping 42 matching lines @@
       }
     } 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);
-      node.identifier.staticElement = element;
-      (element as ElementImpl).nameOffset = node.identifier.offset;
-      (element as ElementImpl).name = node.identifier.name;
     }
   }
 
   void _assertCompatibleParameters(FormalParameterList nodes,
       List<ParameterElement> elements) {
     if (nodes == null) {
       return _assertEquals(elements.length, 0);
     }
     List<FormalParameter> parameters = nodes.parameters;
     int length = parameters.length;
@@ skipping 179 matching lines @@
   /**
    * Return the value of [literal], or `null` if the string is not a constant
    * string without any string interpolation.
    */
   static String _getStringValue(StringLiteral literal) {
     if (literal is StringInterpolation) {
       return null;
     }
     return literal.stringValue;
   }
+
+  static void _setLocalElements(ExecutableElementImpl to,
+      ExecutableElement from) {
+    to.functions = from.functions;
+    to.labels = from.labels;
+    to.localVariables = from.localVariables;
+  }
+
+  static void _setParameterElements(FormalParameterList nodes,
+      List<ParameterElement> elements) {
+    if (nodes != null) {
+      for (int i = 0; i < elements.length; i++) {
+        ParameterElement element = elements[i];
+        FormalParameter node = nodes.parameters[i];
+        ParameterElement newElement = node.element;
+        node.identifier.staticElement = element;
+        (element as ElementImpl).name = newElement.name;
+        (element as ElementImpl).nameOffset = newElement.nameOffset;
+      }
+    }
+  }
 }
 
 
 /**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The object used to access the types from the core library.
@@ skipping 23 matching lines @@
   /**
    * The number of characters in the original contents that were replaced.
    */
   final int _updateOldLength;
 
   /**
    * The number of characters in the replacement text.
    */
   final int _updateNewLength;
 
+  RecordingErrorListener errorListener = new RecordingErrorListener();
   ResolutionContext _resolutionContext;
 
   List<AnalysisError> _resolveErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _verifyErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created incremental resolver to resolve a node in the
    * given source in the given library.
    */
   IncrementalResolver(this._typeProvider, this._definingUnit,
       this._updateOffset, this._updateOldLength, this._updateNewLength) {
     _definingLibrary = _definingUnit.library;
     _source = _definingUnit.source;
   }
 
   /**
    * Resolve [node], reporting any errors or warnings to the given listener.
    *
    * [node] - the root of the AST structure to be resolved.
    *
    * Returns `true` if resolution was successful.
    */
   bool resolve(AstNode node) {
     logger.enter('resolve: $_definingUnit');
     try {
       logger.log(() => 'node: $node');
       AstNode rootNode = _findResolutionRoot(node);
       logger.log(() => 'rootNode: $rootNode');
+      _prepareResolutionContext(rootNode);
       // update elements
       _updateElementNameOffsets(
           _definingUnit,
           _updateOffset,
           _updateNewLength - _updateOldLength);
+      _buildElements(rootNode);
       if (_elementModelChanged(rootNode)) {
         return false;
       }
-      _updateElements(rootNode);
       // resolve
       _resolveReferences(rootNode);
       // verify
       _verify(rootNode);
       _generateHints(rootNode);
       // OK
       return true;
     } finally {
       logger.exit();
     }
   }
 
+  void _buildElements(AstNode node) {
+    LoggingTimer timer = logger.startTimer();
+    try {
+      ElementHolder holder = new ElementHolder();
+      ElementBuilder builder = new ElementBuilder(holder);
+      node.accept(builder);
+    } finally {
+      timer.stop('build elements');
+    }
+  }
+
   /**
    * 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) =>
@@ skipping 76 matching lines @@
    */
   Element _getElement(AstNode node) {
     if (node is Declaration) {
       return node.element;
     } else if (node is CompilationUnit) {
       return node.element;
     }
     return null;
   }
 
+  void _prepareResolutionContext(AstNode node) {
+    if (_resolutionContext == null) {
+      _resolutionContext =
+          ResolutionContextBuilder.contextFor(node, errorListener);
+    }
+  }
+
   _resolveReferences(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
-      RecordingErrorListener errorListener = new RecordingErrorListener();
-      // prepare context
-      _resolutionContext =
-          ResolutionContextBuilder.contextFor(node, errorListener);
+      _prepareResolutionContext(node);
       Scope scope = _resolutionContext.scope;
       // resolve types
       {
         TypeResolverVisitor visitor = new TypeResolverVisitor.con3(
             _definingLibrary,
             _source,
             _typeProvider,
             scope,
             errorListener);
         node.accept(visitor);
       }
       // resolve variables
       {
         VariableResolverVisitor visitor = new VariableResolverVisitor.con2(
             _definingLibrary,
             _source,
             _typeProvider,
             scope,
             errorListener);
         node.accept(visitor);
       }
       // resolve references
       {
         ResolverVisitor visitor = new ResolverVisitor.con3(
             _definingLibrary,
             _source,
             _typeProvider,
-            _resolutionContext.scope,
+            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);
       }
       // remember errors
       _resolveErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('resolve references');
     }
   }
 
-  void _updateElements(AstNode node) {
-    LoggingTimer timer = logger.startTimer();
-    try {
-      // build elements in node
-      ElementHolder holder;
-      _ElementsRestorer elementsRestorer = new _ElementsRestorer(node);
-      try {
-        holder = new ElementHolder();
-        ElementBuilder builder = new ElementBuilder(holder);
-        node.accept(builder);
-      } finally {
-        elementsRestorer.restore();
-      }
-      // apply compatible changes to elements
-      if (node is FunctionDeclaration) {
-        ExecutableElementImpl oldElement = node.element;
-        // prepare the new element
-        ExecutableElement newElement;
-        {
-          List<FunctionElement> holderFunctions = holder.functions;
-          List<PropertyAccessorElement> holderAccessors = holder.accessors;
-          if (holderFunctions.isNotEmpty) {
-            newElement = holderFunctions[0];
-          } else if (holderAccessors.isNotEmpty) {
-            newElement = holderAccessors[0];
-          }
-        }
-        // update the old Element
-        oldElement.functions = newElement.functions;
-        oldElement.labels = newElement.labels;
-        oldElement.localVariables = newElement.localVariables;
-      }
-      if (node is MethodDeclaration) {
-        ExecutableElementImpl oldElement = node.element;
-        // prepare the new element
-        ExecutableElement newElement;
-        {
-          List<MethodElement> holderMethods = holder.methods;
-          List<PropertyAccessorElement> holderAccessors = holder.accessors;
-          if (holderMethods.isNotEmpty) {
-            newElement = holderMethods[0];
-          } else if (holderAccessors.isNotEmpty) {
-            newElement = holderAccessors[0];
-          }
-        }
-        // update the old Element
-        oldElement.functions = newElement.functions;
-        oldElement.labels = newElement.labels;
-        oldElement.localVariables = newElement.localVariables;
-      }
-    } finally {
-      timer.stop('update elements');
-    }
-  }
-
   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,
           new InheritanceManager(_definingLibrary));
@@ skipping 421 matching lines @@
       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;
 
   /**
+   * The class containing the enclosing [CompilationUnitElement].
+   */
+  CompilationUnitElement _enclosingUnit;
+
+  /**
    * The class containing the enclosing [ClassDeclaration], or `null` if we are
    * not in the scope of a class.
    */
   ClassDeclaration _enclosingClassDeclaration;
 
   /**
    * The class containing the enclosing [ClassElement], or `null` if we are not
    * in the scope of a class.
    */
   ClassElement _enclosingClass;
@@ skipping 81 matching lines @@
             "Cannot build a scope for an unresolved method");
       }
       FunctionScope functionScope = new FunctionScope(scope, element);
       functionScope.defineParameters();
       scope = functionScope;
     }
     return scope;
   }
 
   Scope _scopeForCompilationUnit(CompilationUnit node) {
-    CompilationUnitElement unitElement = node.element;
-    if (unitElement == null) {
+    _enclosingUnit = node.element;
+    if (_enclosingUnit == null) {
       throw new AnalysisException(
           "Cannot create scope: compilation unit is not resolved");
     }
-    LibraryElement libraryElement = unitElement.library;
+    LibraryElement libraryElement = _enclosingUnit.library;
     if (libraryElement == null) {
       throw new AnalysisException(
           "Cannot create scope: compilation unit is not part of a library");
     }
     return new LibraryScope(libraryElement, _errorListener);
   }
 
   /**
    * 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) {
     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
@@ skipping 71 matching lines @@
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
       matcher._unmatchedElements.add(element);
     }
   }
 }
 
 
 /**
- * [ElementBuilder] not just builds elements, it also applies them to nodes.
- * But we want to keep externally visible (and referenced) elements instances.
- * So, we need to remember them and restore.
- */
-class _ElementsRestorer extends RecursiveAstVisitor {
-  final Map<AstNode, Element> _elements = <AstNode, Element>{};
-
-  _ElementsRestorer(AstNode root) {
-    root.accept(this);
-  }
-
-  void restore() {
-    _elements.forEach((AstNode node, Element element) {
-      if (node is ConstructorDeclaration) {
-        node.element = element;
-      } else if (node is FunctionExpression) {
-        node.element = element;
-      } else if (node is SimpleIdentifier) {
-        node.staticElement = element;
-      }
-    });
-  }
-
-  @override
-  visitBlockFunctionBody(BlockFunctionBody node) {
-  }
-
-  @override
-  visitConstructorDeclaration(ConstructorDeclaration node) {
-    _elements[node] = node.element;
-    super.visitConstructorDeclaration(node);
-  }
-
-  @override
-  visitExpressionFunctionBody(ExpressionFunctionBody node) {
-  }
-
-  @override
-  visitFunctionExpression(FunctionExpression node) {
-    _elements[node] = node.element;
-    super.visitFunctionExpression(node);
-  }
-
-  @override
-  visitSimpleIdentifier(SimpleIdentifier node) {
-    _elements[node] = node.staticElement;
-  }
-}
-
-
-/**
  * 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);
 }