Fix cache corruption in incremental resolver

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 100 matching lines @@
    * Determines how elements model corresponding to the given [node] differs
    * from the [element].
    */
   DeclarationMatchKind matches(AstNode node, Element element) {
     logger.enter('match $element @ ${element.nameOffset}');
     try {
       _captureEnclosingElements(element);
       _gatherElements(element);
       node.accept(this);
     } on _DeclarationMismatchException {
+      logger.log("mismatched");
       return DeclarationMatchKind.MISMATCH;
     } finally {
       logger.exit();
     }
     // no API changes
     if (_removedElements.isEmpty && _addedElements.isEmpty) {
+      logger.log("no API changes");
       return DeclarationMatchKind.MATCH;
     }
     // simple API change
     logger.log('_removedElements: $_removedElements');
     logger.log('_addedElements: $_addedElements');
     _removedElements.forEach(_removeElement);
     if (_removedElements.length <= 1 && _addedElements.length == 1) {
       return DeclarationMatchKind.MISMATCH_OK;
     }
     // something more complex
@@ skipping 1926 matching lines @@
 
   _ElementOffsetUpdater(this.updateOffset, this.updateDelta, this.cache);
 
   @override
   visitElement(Element element) {
     // name offset
     int nameOffset = element.nameOffset;
     if (nameOffset > updateOffset) {
       // TODO(scheglov) make sure that we don't put local variables
       // and functions into the cache at all.
-      if (element is LocalVariableElement ||
-          element is FunctionElement &&
-              element.enclosingElement is ExecutableElement) {
+      try {
+        (element as ElementImpl).nameOffset = nameOffset + updateDelta;
+      } on StateError {

[skybrian, 2016/02/17 01:23:41]

StateError is definitely not the right exception, because Errors should not
normally be caught [1].

Alternatives are to create a new exception (perhaps FrozenHashCodeException) or
avoid using an exception here.

We want to avoid clearing the cache entry if at all possible. I don't know how
to do that without actually calculating the new hashCode to see if it's
different. So perhaps I could add an uncachedHashCode property. This would
require subclasses to override uncachedHashCode instead of hashCode. I'm not
sure everyone will remember to do that. Also it's tricky since we would want to
use the uncached location as well.

So, I think introducing FrozenHashCodeException and sticking with this approach
is simplest.

[1]
https://www.dartlang.org/effective-dart/usage/#dont-explicitly-catch-error-or...

         cache.remove(element);
+        (element as ElementImpl).nameOffset = nameOffset + updateDelta;
       }
-      (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
     if (element is LocalElement) {
@@ skipping 110 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }