Remove only local variables/functions from the cache.

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/dart/ast/ast.dart';
@@ skipping 2031 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 {}
 
 /**
  * Adjusts the location of each Element that moved.
  *
- * Since operator== and hashCode of an Element are based
- * on the element location, we also need to remove each
- * moved element from the cache to avoid a memory leak.
+ * Since `==` and `hashCode` of a local variable or function Element are based
+ * on the element name offsets, we also need to remove these elements from the
+ * cache to avoid a memory leak. TODO(scheglov) fix and remove this
  */
 class _ElementOffsetUpdater extends GeneralizingElementVisitor {
   final int updateOffset;
   final int updateDelta;
   final AnalysisCache cache;
 
   _ElementOffsetUpdater(this.updateOffset, this.updateDelta, this.cache);
 
   @override
   visitElement(Element element) {
     // name offset
     int nameOffset = element.nameOffset;
     if (nameOffset > updateOffset) {
-      cache.remove(element);
+      // TODO(scheglov) make sure that we don't put local variables
+      // and functions into the cache at all.
+      if (element is LocalVariableElement ||

[skybrian, 2016/02/13 18:39:22]

This check is missing DefaultParameterElementImpl and ConstFieldElementImpl (at
least).

It looks like changing LocalVariableElement to LocalElement might cover it.

But it seems like this check should be reversed. If there are Elements that we
know are safe to move while still in the cache, we can check for those cases and
skip cache.remove(). If we haven't thought about a particular case then we
should default to removing them from the cache, which is always safe but might
be unnecessary.

+          element is FunctionElement &&
+              element.enclosingElement is ExecutableElement) {
+        cache.remove(element);
+      }
       (element as ElementImpl).nameOffset = nameOffset + updateDelta;
       if (element is ConstVariableElement) {
         ConstVariableElement constVariable = element as ConstVariableElement;
         Expression initializer = constVariable.constantInitializer;
         if (initializer != null) {
           _shiftTokens(initializer.beginToken);
         }
       }
     }
     // visible range
@@ skipping 111 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }