Fix for incremental resolution of top-level and class-member accessors.

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 'dart:math' as math;
 
 import 'package:analyzer/src/generated/error_verifier.dart';
@@ skipping 800 matching lines @@
     _ElementsRestorer elementsRestorer = new _ElementsRestorer(node);
     try {
       holder = new ElementHolder();
       ElementBuilder builder = new ElementBuilder(holder);
       node.accept(builder);
     } finally {
       elementsRestorer.restore();
     }
     // apply compatible changes to elements
     if (node is FunctionDeclaration) {
-      FunctionElementImpl oldElement = node.element;
-      FunctionElementImpl newElement = holder.functions[0];
+      ExecutableElementImpl oldElement = node.element;
+      // prepare the new element
+      ExecutableElement newElement;
+      {
+        List<FunctionElement> holderFunctions = holder.functions;
+        List<PropertyAccessorElement> holderAccessors = holder.accessors;
+        if (holderFunctions.isNotEmpty) {
+          newElement = holderFunctions[0];
+        } else if (holderAccessors.isNotEmpty) {
+          newElement = holderAccessors[0];
+        }
+      }
+      // update the old Element
       oldElement.labels = newElement.labels;
       oldElement.localVariables = newElement.localVariables;
     }
     if (node is MethodDeclaration) {
-      MethodElementImpl oldElement = node.element;
-      MethodElementImpl newElement = holder.methods[0];
+      ExecutableElementImpl oldElement = node.element;
+      // prepare the new element
+      ExecutableElement newElement;
+      {
+        List<MethodElement> holderMethods = holder.methods;
+        List<PropertyAccessorElement> holderAccessors = holder.accessors;
+        if (holderMethods.isNotEmpty) {
+          newElement = holderMethods[0];
+        } else if (holderAccessors.isNotEmpty) {
+          newElement = holderAccessors[0];
+        }
+      }
+      // update the old Element
       oldElement.labels = newElement.labels;
       oldElement.localVariables = newElement.localVariables;
     }
   }
 
   void _verify(AstNode node) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
     ErrorVerifier errorVerifier = new ErrorVerifier(
         errorReporter,
@@ skipping 116 matching lines @@
             oldUnitElement,
             oldUnitElement.source,
             _updateOffset,
             oldNode.length,
             newNode.length);
         incrementalResolver.resolve(newNode);
         _newResolveErrors = incrementalResolver._resolveErrors;
         _newVerifyErrors = incrementalResolver._verifyErrors;
         _newHints = incrementalResolver._hints;
         _updateEntry();
+        print('Successfully incrementally resolved.');

[Brian Wilkerson, 2014/11/26 19:41:27]

Comment this out?

         return true;
       }
     } catch (e, st) {
       // TODO(scheglov) find a way to log these exceptions
       print(e);
       print(st);
     }
     return false;
   }
 
@@ skipping 429 matching lines @@
     _elements[node] = node.staticElement;
   }
 }
 
 
 class _TokenPair {
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.oldToken, this.newToken);
 }