Incremental resolution: rename function/constructor/method parameters.

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 129 matching lines @@
   }
 
   @override
   visitConstructorDeclaration(ConstructorDeclaration node) {
     _hasConstructor = true;
     SimpleIdentifier constructorName = node.name;
     ConstructorElement element = constructorName == null ?
         _enclosingClass.unnamedConstructor :
         _enclosingClass.getNamedConstructor(constructorName.name);
     _processElement(element);
+    node.element = element;
     _assertCompatibleParameters(node.parameters, element.parameters);
   }
 
   @override
   visitEnumConstantDeclaration(EnumConstantDeclaration node) {
     String name = node.name.name;
     FieldElement element = _findElement(_enclosingClass.fields, name);
     _processElement(element);
   }
 
@@ skipping 39 matching lines @@
   }
 
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
     String name = node.name.name;
     Token property = node.propertyKeyword;
     ExecutableElement element;
     if (property == null) {
       element = _findElement(_enclosingUnit.functions, name);
       _processElement(element);
+      node.name.staticElement = element;
+      node.functionExpression.element = element;
     } else {
       PropertyAccessorElement accessor =
           _findElement(_enclosingUnit.accessors, name);
       _assertNotNull(accessor);
       _assertFalse(element.isSynthetic);
       _assertEquals(node.isGetter, accessor.isGetter);
       _assertEquals(node.isSetter, accessor.isSetter);
       element = accessor;
     }
     _processElement(element);
@@ skipping 63 matching lines @@
       PropertyAccessorElement accessor =
           _findElement(_enclosingClass.accessors, name);
       _assertNotNull(accessor);
       _assertFalse(element.isSynthetic);
       _assertEquals(node.isGetter, accessor.isGetter);
       _assertEquals(node.isSetter, accessor.isSetter);
       element = accessor;
     }
     // process element
     _processElement(element);
+    node.name.staticElement = element;
     // TODO(scheglov) test returnType
     _assertSameType(node.returnType, element.returnType);
     _assertCompatibleParameters(node.parameters, element.parameters);
   }
 
   @override
   visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       CompilationUnitElement element =
@@ skipping 83 matching lines @@
       }
     }
     _assertTrue(showNames.isEmpty);
     _assertTrue(hideNames.isEmpty);
   }
 
   void _assertCompatibleParameter(FormalParameter node,
       ParameterElement element) {
     if (node is SimpleFormalParameter) {
       _assertSameType(node.type, element.type);
+      node.identifier.staticElement = element;
+      element.nameOffset = node.identifier.offset;
+      (element as ElementImpl).name = node.identifier.name;
     } else {
       // TODO(scheglov) support other parameter types
       _assertTrue(false);
     }
     // TODO(scheglov) check names of named parameters
   }
 
   void _assertCompatibleParameters(FormalParameterList nodes,
       List<ParameterElement> elements) {
     List<FormalParameter> parameters = nodes.parameters;
@@ skipping 249 matching lines @@
    *
    * [node] - the root of the AST structure to be resolved.
    */
   void resolve(AstNode node) {
     AstNode rootNode = _findResolutionRoot(node);
     // update elements
     _definingUnit.accept(
         new _ElementNameOffsetUpdater(
             _updateOffset,
             _updateNewLength - _updateOldLength));
-    _updateElements(rootNode);
     if (_elementModelChanged(rootNode)) {
       throw new AnalysisException("Cannot resolve node: element model changed");
     }
+    _updateElements(rootNode);
     // resolve root in scope
     ResolutionContext context =
         ResolutionContextBuilder.contextFor(rootNode, _errorListener);
     Scope scope = context.scope;
     _resolveTypes(rootNode, scope);
     _resolveVariables(rootNode, scope);
     _resolveReferences(rootNode, context);
   }
 
   /**
@@ skipping 17 matching lines @@
   /**
    * Return `true` if the portion of the element model defined by the given node
    * has changed.
    *
    * [node] - the node defining the portion of the element model being tested.
    *
    * Throws [AnalysisException] if the correctness of the element model cannot
    * be determined.
    */
   bool _elementModelChanged(AstNode node) {
+    // If we are replacing the whole declaration (e.g. rename a parameter), we
+    // can try to find the corresponding Element in the enclosing one, see if it
+    // is compatible, and if 'yes', then restore and update it.
+    if (node is Declaration) {
+      node = node.parent;
+    }
     Element element = _getElement(node);
     if (element == null) {
       throw new AnalysisException(
           "Cannot resolve node: a ${node.runtimeType} does not define an element");
     }
     DeclarationMatcher matcher = new DeclarationMatcher();
     return !matcher.matches(node, element);
   }
 
   /**
@@ skipping 358 matching lines @@
   visitFunctionExpression(FunctionExpression node) {
     _elements[node] = node.element;
     super.visitFunctionExpression(node);
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     _elements[node] = node.staticElement;
   }
 }