Don't perform incremental resolution if curly brackets are not balanced.

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 'ast.dart';
@@ skipping 1243 matching lines @@
   }
 
   /**
    * Attempts to update [oldUnit] to the state corresponding to [newCode].
    * Returns `true` if success, or `false` otherwise.
    * The [oldUnit] might be damaged.
    */
   bool resolve(String newCode) {
     logger.enter('diff/resolve $_unitSource');
     try {
+      // prepare old unit
       CompilationUnit oldUnit = _units[_unitSource];
+      if (!_areCurlyBracketsBalanced(oldUnit.beginToken)) {
+        logger.log('Unbalanced number of curly brackets in the old unit.');
+        return false;
+      }
       _unitElement = oldUnit.element;
+      // prepare ne unit

[Brian Wilkerson, 2015/01/20 19:08:27]

'ne' --> 'new'

       CompilationUnit newUnit = _parseUnit(newCode);
+      if (!_areCurlyBracketsBalanced(newUnit.beginToken)) {
+        logger.log('Unbalanced number of curly brackets in the new unit.');
+        return false;
+      }
+      // find difference
       _TokenPair firstPair =
           _findFirstDifferentToken(oldUnit.beginToken, newUnit.beginToken);
       _TokenPair lastPair =
           _findLastDifferentToken(oldUnit.endToken, newUnit.endToken);
       if (firstPair != null && lastPair != null) {
         int firstOffsetOld = firstPair.oldToken.offset;
         int firstOffsetNew = firstPair.newToken.offset;
         int lastOffsetOld = lastPair.oldToken.end;
         int lastOffsetNew = lastPair.newToken.end;
         int beginOffsetOld = math.min(firstOffsetOld, lastOffsetOld);
@@ skipping 201 matching lines @@
       }
       token = token.next;
     }
   }
 
   void _updateEntry() {
     _entry.setValue(DartEntry.SCAN_ERRORS, _newScanErrors);
     _entry.setValue(DartEntry.PARSE_ERRORS, _newParseErrors);
   }
 
+  /**
+   * Checks if [token] has a balanced number of open and closed curly brackets.
+   */
+  static bool _areCurlyBracketsBalanced(Token token) {

[Brian Wilkerson, 2015/01/20 19:08:27]

Not for this CL, but... The scanner already computes these flags (as part of
bracket matching). As a future optimization we might want to store this
information in the CompilationUnit so that we don't have to traverse the token
stream two more times.

+    int numOpen = _getTokenCount(token, TokenType.OPEN_CURLY_BRACKET);
+    int numOpen2 =
+        _getTokenCount(token, TokenType.STRING_INTERPOLATION_EXPRESSION);
+    int numClosed = _getTokenCount(token, TokenType.CLOSE_CURLY_BRACKET);
+    return numOpen + numOpen2 == numClosed;
+  }
+
   static _TokenDifferenceKind _compareToken(Token oldToken, Token newToken,
       int delta) {
     if (oldToken == null && newToken == null) {
       return null;
     }
     if (oldToken == null || newToken == null) {
       return _TokenDifferenceKind.CONTENT;
     }
     if (oldToken.type != newToken.type) {
       return _TokenDifferenceKind.CONTENT;
@@ skipping 75 matching lines @@
   }
 
   static Token _getBeginTokenNotComment(AstNode node) {
     Token oldBeginToken = node.beginToken;
     if (oldBeginToken is CommentToken) {
       oldBeginToken = (oldBeginToken as CommentToken).parent;
     }
     return oldBeginToken;
   }
 
-
   static List<AstNode> _getParents(AstNode node) {
     List<AstNode> parents = <AstNode>[];
     while (node != null) {
       parents.insert(0, node);
       node = node.parent;
     }
     return parents;
   }
 
+
+  /**
+   * Returns number of tokens with the given [type].
+   */
+  static int _getTokenCount(Token token, TokenType type) {
+    int count = 0;
+    while (token.type != TokenType.EOF) {
+      if (token.type == type) {
+        count++;
+      }
+      token = token.next;
+    }
+    return count;
+  }
+
   /**
    * Set the given [comment] as a "precedingComments" for [parent].
    */
   static void _setPrecedingComments(Token parent, CommentToken comment) {
     if (parent is BeginTokenWithComment) {
       parent.precedingComments = comment;
     } else if (parent is KeywordTokenWithComment) {
       parent.precedingComments = comment;
     } else if (parent is StringTokenWithComment) {
       parent.precedingComments = comment;
@@ skipping 278 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }