Issue 25514. Harden parents validation 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 1450 matching lines @@
         }
         // Find nodes covering the "old" and "new" token ranges.
         AstNode oldNode =
             _findNodeCovering(_oldUnit, beginOffsetOld, endOffsetOld - 1);
         AstNode newNode =
             _findNodeCovering(newUnit, beginOffsetNew, endOffsetNew - 1);
         logger.log(() => 'oldNode: $oldNode');
         logger.log(() => 'newNode: $newNode');
         // Try to find the smallest common node, a FunctionBody currently.
         {
           List<AstNode> oldParents = _getParents(oldNode);

[skybrian, 2016/01/20 06:29:50]

It would be clearer to rename the function to _getAncestors.

           List<AstNode> newParents = _getParents(newNode);
           int length = math.min(oldParents.length, newParents.length);
           bool found = false;
           for (int i = 0; i < length; i++) {
             AstNode oldParent = oldParents[i];
             AstNode newParent = newParents[i];
-            if (oldParent is ConstructorInitializer ||
-                newParent is ConstructorInitializer) {
-              logger.log('Failure: changes in constant constructor initializers'
-                  ' may cause external changes in constant objects.');
-              return false;
-            }
-            if (oldParent is FunctionDeclaration &&
+            if (oldParent is CompilationUnit && newParent is CompilationUnit) {
+              int oldLength = oldParent.declarations.length;
+              int newLength = newParent.declarations.length;
+              if (oldLength != newLength) {
+                logger.log(
+                    'Failure: unit declarations mismatch $oldLength vs. $newLength');
+                return false;
+              }
+            } else if (oldParent is ClassDeclaration &&
+                newParent is ClassDeclaration) {
+              int oldLength = oldParent.members.length;
+              int newLength = newParent.members.length;
+              if (oldLength != newLength) {
+                logger.log(
+                    'Failure: class declarations mismatch $oldLength vs. $newLength');
+                return false;
+              }
+            } else if (oldParent is FunctionDeclaration &&
                     newParent is FunctionDeclaration ||
+                oldParent is ConstructorDeclaration &&
+                    newParent is ConstructorDeclaration ||
                 oldParent is MethodDeclaration &&
-                    newParent is MethodDeclaration ||
-                oldParent is ConstructorDeclaration &&
-                    newParent is ConstructorDeclaration) {
+                    newParent is MethodDeclaration) {
               Element oldElement = (oldParent as Declaration).element;
               if (new DeclarationMatcher().matches(newParent, oldElement) ==
                   DeclarationMatchKind.MATCH) {
                 oldNode = oldParent;
                 newNode = newParent;
                 found = true;
+              } else {
+                return false;
               }
-            }
-            if (oldParent is FunctionBody || newParent is FunctionBody) {
+            } else if (oldParent is ConstructorInitializer ||
+                newParent is ConstructorInitializer) {
+              logger.log('Failure: changes in constant constructor initializers'
+                  ' may cause external changes in constant objects.');
+              return false;
+            } else if (oldParent is FunctionBody && newParent is FunctionBody) {
               if (oldParent is BlockFunctionBody &&
                   newParent is BlockFunctionBody) {
                 oldNode = oldParent;
                 newNode = newParent;
                 found = true;
                 break;
               }
               logger.log('Failure: not a block function body.');
               return false;
+            } else if (oldParent is FieldDeclaration &&
+                    newParent is FieldDeclaration ||
+                oldParent is FunctionExpression &&
+                    newParent is FunctionExpression ||
+                oldParent is VariableDeclaration &&
+                    newParent is VariableDeclaration) {
+              // skip
+            } else {
+              logger.log('Failure: old and new parent mismatch'
+                  ' ${oldParent.runtimeType} vs. ${newParent.runtimeType}');
+              return false;
             }
           }
           if (!found) {
             logger.log('Failure: no enclosing function body or executable.');
             return false;
           }
           // fail if a comment change outside the bodies
           if (firstPair.kind == _TokenDifferenceKind.COMMENT) {
             if (beginOffsetOld <= oldNode.offset ||
                 beginOffsetNew <= newNode.offset) {
@@ skipping 593 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }