Build elements for local variable and label in functions/methods.

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 'ast.dart';
 import 'element.dart';
@@ skipping 638 matching lines @@
       this._definingLibrary, this._definingUnit, this._source, this._updateOffset,
       this._updateOldLength, this._updateNewLength);
 
   /**
    * Resolve [node], reporting any errors or warnings to the given listener.
    *
    * [node] - the root of the AST structure to be resolved.
    */
   void resolve(AstNode node) {
     AstNode rootNode = _findResolutionRoot(node);
-    Scope scope = ScopeBuilder.scopeFor(rootNode, _errorListener);
-    if (_elementModelChanged(rootNode.parent)) {
+    if (_elementModelChanged(rootNode)) {
       throw new AnalysisException("Cannot resolve node: element model changed");
     }
+    // update elements
     _definingUnit.accept(
         new _ElementNameOffsetUpdater(
             _updateOffset,
             _updateNewLength - _updateOldLength));
-    _resolveTypes(node, scope);
-    _resolveVariables(node, scope);
-    _resolveReferences(node, scope);
+    _updateElements(rootNode);
+    // resolve root in scope
+    Scope scope = ScopeBuilder.scopeFor(rootNode, _errorListener);
+    _resolveTypes(rootNode, scope);
+    _resolveVariables(rootNode, scope);
+    _resolveReferences(rootNode, scope);
   }
 
   /**
    * 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.scopeForAstNode].
    *
    * [node] - the node being tested.
@@ skipping 28 matching lines @@
 
   /**
    * 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) {
-    AstNode result = node;
-    AstNode parent = result.parent;
-    while (parent != null && !_canBeResolved(parent)) {
-      result = parent;
-      parent = result.parent;
+    while (node != null) {
+      if (_canBeResolved(node)) {
+        return node;
+      }
+      node = node.parent;
     }
-    if (parent == null) {
-      throw new AnalysisException("Cannot resolve node: no resolvable node");
-    }
-    return result;
+    throw new AnalysisException("Cannot resolve node: no resolvable node");
   }
 
   /**
    * Return the element defined by [node], or `null` if the node does not
    * define an element.
    */
   Element _getElement(AstNode node) {
     if (node is Declaration) {
       return node.element;
     } else if (node is CompilationUnit) {
@@ skipping 24 matching lines @@
 
   void _resolveVariables(AstNode node, Scope scope) {
     VariableResolverVisitor visitor = new VariableResolverVisitor.con2(
         _definingLibrary,
         _source,
         _typeProvider,
         scope,
         _errorListener);
     node.accept(visitor);
   }
+
+  void _updateElements(AstNode node) {
+    // 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) {
+      FunctionElementImpl oldElement = node.element;
+      FunctionElementImpl newElement = holder.functions[0];
+      oldElement.labels = newElement.labels;
+      oldElement.localVariables = newElement.localVariables;
+    }
+    if (node is MethodDeclaration) {
+      MethodElementImpl oldElement = node.element;
+      MethodElementImpl newElement = holder.methods[0];
+      oldElement.labels = newElement.labels;
+      oldElement.localVariables = newElement.localVariables;
+    }
+  }
 }
 
 
 /**
  * Instances of the class [ScopeBuilder] build the scope for a given node in an
  * AST structure. At the moment, this class only handles top-level and
  * class-level declarations.
  */
 class ScopeBuilder {
   /**
@@ skipping 184 matching lines @@
     // Don't visit children (such as property accessors).
   }
 
   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;
+  }
+}