Incremental improvements in the matcher.

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 261 matching lines @@
   }
 
   @override
   visitMethodDeclaration(MethodDeclaration node) {
     // prepare element name
     String name = node.name.name;
     if (name == TokenType.MINUS.lexeme &&
         node.parameters.parameters.length == 0) {
       name = "unary-";
     }
+    if (node.isSetter) {
+      name += '=';
+    }
     // prepare element
     Token property = node.propertyKeyword;
     ExecutableElement element;
     if (property == null) {
       element = _findElement(_enclosingClass.methods, name);
     } else {
       element = _findElement(_enclosingClass.accessors, name);
     }
     // process element
     _processElement(element);
@@ skipping 142 matching lines @@
   }
 
   void _assertSameType(TypeName node, DartType type) {
     // no return type == dynamic
     if (node == null) {
       return _assertTrue(type == null || type.isDynamic);
     }
     if (type == null) {
       return _assertTrue(false);
     }
+    // prepare name
+    Identifier nameIdentifier = node.name;
+    if (nameIdentifier is PrefixedIdentifier) {
+      nameIdentifier = (nameIdentifier as PrefixedIdentifier).identifier;
+    }
+    String nodeName = nameIdentifier.name;
     // check specific type kinds
-    String nodeName = node.name.name;
     if (type is InterfaceType) {
       _assertEquals(nodeName, type.name);
       // check arguments
       TypeArgumentList nodeArgumentList = node.typeArguments;
       List<DartType> typeArguments = type.typeArguments;
       if (nodeArgumentList == null) {
-        // Node doesn't have type arguments, so all type argument of the
+        // Node doesn't have type arguments, so all type arguments of the
         // element must be "dynamic".
         for (DartType typeArgument in typeArguments) {
           _assertTrue(typeArgument.isDynamic);
         }
       } else {
         List<TypeName> nodeArguments = nodeArgumentList.arguments;
         _assertSameTypes(nodeArguments, typeArguments);
       }
     } else if (type is TypeParameterType) {
       _assertEquals(nodeName, type.name);
@@ skipping 228 matching lines @@
    *
    * [node] - the node defining the portion of the element model being tested.
    *
    * Throws [AnalysisException] if the correctness of the element model cannot
    * be determined.
    */
   bool _elementModelChanged(AstNode node) {
     // If we are replacing the whole declaration (e.g. rename a parameter), we
     // can try to find the corresponding Element in the enclosing one, see if it
     // is compatible, and if 'yes', then restore and update it.
+    // TODO(scheglov) This should be rewritten. It causes validating the whole
+    // class, when just one method is changed.
     if (node is Declaration) {
       node = node.parent;
     }
     Element element = _getElement(node);
     if (element == null) {
       throw new AnalysisException(
           "Cannot resolve node: a ${node.runtimeType} does not define an element");
     }
     DeclarationMatcher matcher = new DeclarationMatcher();
     return !matcher.matches(node, element);
@@ skipping 196 matching lines @@
               oldNode = oldParent;
               newNode = newParent;
               found = true;
               break;
             }
           }
           if (!found) {
             return false;
           }
         }
+//        print('oldNode: $oldNode');
+//        print('newNode: $newNode');
         // prepare update range
         _updateOffset = oldNode.offset;
         _updateEndOld = oldNode.end;
         _updateEndNew = newNode.end;
         _updateDelta = _updateEndNew - _updateEndOld;
         // replace node
         NodeReplacer.replace(oldNode, newNode);
         // update token references
         {
           Token oldBeginToken = oldNode.beginToken;
@@ skipping 462 matching lines @@
     _elements[node] = node.staticElement;
   }
 }
 
 
 class _TokenPair {
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.oldToken, this.newToken);
 }