Update 'nameOffset' for elements during incremental analysis.

pkg/analyzer/test/generated/incremental_resolver_test.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_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 445 matching lines @@
   }
 
   void test_functionBody_statement() {
     _resolveUnit(r'''
 main(int a, int b) {
   return a + b;
 }''');
     _resolve(_editString('+', '*'), _isStatement);
   }
 
+  void test_updateElementOffset() {
+    _resolveUnit(r'''
+class A {
+  int am(String ap) {
+    int av = 1;
+    return av;
+  }
+}
+main(int a, int b) {
+  return a + b;
+}
+class B {
+  int bm(String bp) {
+    int bv = 1;
+    return bv;
+  }
+}
+''');
+    _resolve(_editString('+', ' + '), _isStatement);
+  }
+
   _Edit _editString(String search, String replacement, [int length]) {
     int offset = code.indexOf(search);
     expect(offset, isNot(-1));
     if (length == null) {
       length = search.length;
     }
     return new _Edit(offset, length, replacement);
   }
 
   /**
@@ skipping 11 matching lines @@
         edit.replacement +
         code.substring(offset + edit.length);
     CompilationUnit newUnit = _parseUnit(newCode);
     // replace the node
     AstNode oldNode = _findNodeAt(unit, offset, predicate);
     AstNode newNode = _findNodeAt(newUnit, offset, predicate);
     bool success = NodeReplacer.replace(oldNode, newNode);
     expect(success, isTrue);
     // do incremental resolution
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    // TODO(scheglov) use 'replacement' to update elements offsets
-    IncrementalResolver resolver =
-        new IncrementalResolver(library, source, typeProvider, errorListener);
+    IncrementalResolver resolver = new IncrementalResolver(
+        errorListener,
+        typeProvider,
+        library,
+        unit.element,
+        source,
+        edit.offset,
+        edit.length,
+        edit.replacement.length);
     resolver.resolve(newNode);
     // resolve "newCode" from scratch
     CompilationUnit fullNewUnit;
     {
       source = addSource(newCode);
       LibraryElement library = resolve(source);
       fullNewUnit = resolveCompilationUnit(source, library);
     }
     _SameResolutionValidator.assertSameResolution(unit, fullNewUnit);
   }
@@ skipping 398 matching lines @@
     CatchClause other = this.other;
     _visitNode(node.exceptionType, other.exceptionType);
     _visitNode(node.exceptionParameter, other.exceptionParameter);
     _visitNode(node.stackTraceParameter, other.stackTraceParameter);
     _visitNode(node.body, other.body);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     ClassDeclaration other = this.other;
+    _visitDeclaration(node, other);
     _visitNode(node.name, other.name);
     _visitNode(node.typeParameters, other.typeParameters);
     _visitNode(node.extendsClause, other.extendsClause);
     _visitNode(node.implementsClause, other.implementsClause);
     _visitNode(node.withClause, other.withClause);
     _visitList(node.members, other.members);
   }
 
   @override
   visitClassTypeAlias(ClassTypeAlias node) {
     ClassTypeAlias other = this.other;
-    _verifyElement(node.element, other.element);
+    _visitDeclaration(node, other);
     _visitNode(node.name, other.name);
     _visitNode(node.typeParameters, other.typeParameters);
     _visitNode(node.superclass, other.superclass);
     _visitNode(node.withClause, other.withClause);
   }
 
   @override
   visitComment(Comment node) {
     Comment other = this.other;
     _visitList(node.references, other.references);
@@ skipping 18 matching lines @@
     ConditionalExpression other = this.other;
     _visitExpression(node, other);
     _visitNode(node.condition, other.condition);
     _visitNode(node.thenExpression, other.thenExpression);
     _visitNode(node.elseExpression, other.elseExpression);
   }
 
   @override
   visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorDeclaration other = this.other;
-    _verifyElement(node.element, other.element);
+    _visitDeclaration(node, other);
     _visitNode(node.returnType, other.returnType);
     _visitNode(node.name, other.name);
     _visitNode(node.parameters, other.parameters);
     _visitNode(node.redirectedConstructor, other.redirectedConstructor);
     _visitList(node.initializers, other.initializers);
   }
 
   @override
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     ConstructorFieldInitializer other = this.other;
@@ skipping 85 matching lines @@
 
   @override
   visitExtendsClause(ExtendsClause node) {
     ExtendsClause other = this.other;
     _visitNode(node.superclass, other.superclass);
   }
 
   @override
   visitFieldDeclaration(FieldDeclaration node) {
     FieldDeclaration other = this.other;
+    _visitDeclaration(node, other);
     _visitNode(node.fields, other.fields);
   }
 
   @override
   visitFieldFormalParameter(FieldFormalParameter node) {
     FieldFormalParameter other = this.other;
     _visitNormalFormalParameter(node, other);
     _visitNode(node.type, other.type);
     _visitNode(node.parameters, other.parameters);
   }
@@ skipping 188 matching lines @@
   @override
   visitMapLiteralEntry(MapLiteralEntry node) {
     MapLiteralEntry other = this.other;
     _visitNode(node.key, other.key);
     _visitNode(node.value, other.value);
   }
 
   @override
   visitMethodDeclaration(MethodDeclaration node) {
     MethodDeclaration other = this.other;
+    _visitDeclaration(node, other);
     _visitNode(node.name, other.name);
     _visitNode(node.parameters, other.parameters);
     _visitNode(node.body, other.body);
   }
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     MethodInvocation other = this.other;
     _visitNode(node.target, other.target);
     _visitNode(node.methodName, other.methodName);
@@ skipping 217 matching lines @@
 
   @override
   visitTypeParameterList(TypeParameterList node) {
     TypeParameterList other = this.other;
     _visitList(node.typeParameters, other.typeParameters);
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     VariableDeclaration other = this.other;
+    _visitDeclaration(node, other);
     _visitNode(node.name, other.name);
     _visitNode(node.initializer, other.initializer);
   }
 
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
     VariableDeclarationList other = this.other;
     _visitNode(node.type, other.type);
     _visitList(node.variables, other.variables);
   }
@@ skipping 23 matching lines @@
     _visitNode(node.expression, other.expression);
   }
 
   void _verifyElement(Element a, Element b) {
     if (a != b) {
       fail('Expected: $b\n  Actual: $a');
     }
     if (a == null && b == null) {
       return;
     }
-    // TODO(scheglov) uncomment when implement elements shifting
-//    expect(a.nameOffset, b.nameOffset);
+    expect(a.nameOffset, b.nameOffset);
   }
 
   void _verifyType(DartType a, DartType b) {
     expect(a, equals(b));
   }
 
   void _visitAnnotatedNode(AnnotatedNode node, AnnotatedNode other) {
     _visitNode(node.documentationComment, other.documentationComment);
     _visitList(node.metadata, other.metadata);
   }
@@ skipping 27 matching lines @@
     if (node == null) {
       expect(other, isNull);
     } else {
       this.other = other;
       node.accept(this);
     }
   }
 
   void _visitNormalFormalParameter(NormalFormalParameter node,
       NormalFormalParameter other) {
+    _verifyElement(node.element, other.element);
     _visitNode(node.documentationComment, other.documentationComment);
     _visitList(node.metadata, other.metadata);
     _visitNode(node.identifier, other.identifier);
   }
 
   static void assertSameResolution(CompilationUnit actual,
       CompilationUnit expected) {
     _SameResolutionValidator validator = new _SameResolutionValidator(expected);
     actual.accept(validator);
   }
 }