Issue 25238. Update LoclaElement(s) visible ranges during incremental resolution.

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 analyzer.src.generated.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 1099 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 ||
+  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;
 
   /**
    * Compute a value for all of the constants in the given [node].
@@ skipping 131 matching lines @@
       } finally {
         timer.stop('invalidate cache with delta');
       }
     }
   }
 
   void _updateElementNameOffsets() {
     LoggingTimer timer = logger.startTimer();
     try {
       _definingUnit
-          .accept(new _ElementNameOffsetUpdater(_updateOffset, _updateDelta));
+          .accept(new _ElementOffsetUpdater(_updateOffset, _updateDelta));
       _definingUnit.afterIncrementalResolution();
     } finally {
       timer.stop('update element offsets');
     }
   }
 
   void _updateEntry() {
     _updateErrors_NEW(RESOLVE_TYPE_NAMES_ERRORS, []);
     _updateErrors_NEW(RESOLVE_UNIT_ERRORS, _resolveErrors);
     _updateErrors_NEW(VARIABLE_REFERENCE_ERRORS, []);
@@ skipping 697 matching lines @@
   }
 }
 
 /**
  * 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 _ElementNameOffsetUpdater extends GeneralizingElementVisitor {
+class _ElementOffsetUpdater extends GeneralizingElementVisitor {
   final int updateOffset;
   final int updateDelta;
 
-  _ElementNameOffsetUpdater(this.updateOffset, this.updateDelta);
+  _ElementOffsetUpdater(this.updateOffset, this.updateDelta);
 
   @override
   visitElement(Element element) {
+    // name offset
     int nameOffset = element.nameOffset;
     if (nameOffset > updateOffset) {
       (element as ElementImpl).nameOffset = nameOffset + updateDelta;
     }
+    // visible range
+    if (element is LocalElement) {
+      SourceRange visibleRange = element.visibleRange;
+      if (visibleRange != null && visibleRange.offset > updateOffset) {
+        int newOffset = visibleRange.offset + updateDelta;
+        int length = visibleRange.length;
+        if (element is FunctionElementImpl) {

[Brian Wilkerson, 2015/12/12 15:31:56]

I want to make a couple of changes to the element model first, but then we
should add an internal interface that defines the "setVisibleRange" method so
that we don't have to have all these 'is' tests.

+          element.setVisibleRange(newOffset, length);
+        } else if (element is LocalVariableElementImpl) {
+          element.setVisibleRange(newOffset, length);
+        } else if (element is ParameterElementImpl) {
+          element.setVisibleRange(newOffset, length);
+        }
+      }
+    }
     super.visitElement(element);
   }
 }
 
 class _ElementsGatherer extends GeneralizingElementVisitor {
   final DeclarationMatcher matcher;
 
   _ElementsGatherer(this.matcher);
 
   void addElements(List<Element> elements) {
@@ skipping 61 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }