Improve error-recovery from unmatched braces.

dart/sdk/lib/_internal/compiler/implementation/scanner/array_based_scanner.dart

 // Copyright (c) 2011, 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.
 
 part of scanner;
 
 abstract class ArrayBasedScanner extends AbstractScanner {
   ArrayBasedScanner(SourceFile file, bool includeComments)
       : super(file, includeComments);
 
@@ skipping 54 matching lines @@
     // Type parameters and arguments cannot contain 'this' or 'super'.
     if (identical(syntax, 'this') || identical(syntax, 'super')) {
       discardOpenLt();
     }
     tail.next = new KeywordToken(keyword, tokenStart);
     tail = tail.next;
   }
 
   void appendEofToken() {
     beginToken();
-    tail.next = new SymbolToken(EOF_INFO, tokenStart);
-    tail = tail.next;
-    // EOF points to itself so there's always infinite look-ahead.
-    tail.next = tail;
     discardOpenLt();
     while (!groupingStack.isEmpty) {
       unmatchedBeginGroup(groupingStack.head);
       groupingStack = groupingStack.tail;
     }
+    tail.next = new SymbolToken(EOF_INFO, tokenStart);
+    tail = tail.next;
+    // EOF points to itself so there's always infinite look-ahead.
+    tail.next = tail;
   }
 
   /**
    * Notifies scanning a whitespace character. Note that [appendWhiteSpace] is
    * not always invoked for [$SPACE] characters.
    *
    * This method is used by the scanners to track line breaks and create the
    * [lineStarts] map.
    */
   void appendWhiteSpace(int next) {
@@ skipping 28 matching lines @@
     groupingStack = groupingStack.prepend(token);
   }
 
   /**
    * Appends a token that begins an end group, represented by [value].
    * It handles the group end tokens '}', ')' and ']'. The tokens '>' and
    * '>>' are handled separately bo [appendGt] and [appendGtGt].
    */
   int appendEndGroup(PrecedenceInfo info, int openKind) {
     assert(!identical(openKind, LT_TOKEN)); // openKind is < for > and >>
+    discardBeginGroupUntil(openKind);
     appendPrecedenceToken(info);
-    // Don't report unmatched errors for <; it is also the less-than operator.
-    discardOpenLt();
+    Token close = tail;
     if (groupingStack.isEmpty) {
       return advance();
     }
     BeginGroupToken begin = groupingStack.head;
     if (!identical(begin.kind, openKind)) {
-      if (!identical(openKind, OPEN_CURLY_BRACKET_TOKEN) ||
-          !identical(begin.kind, STRING_INTERPOLATION_TOKEN)) {
-        // Not ending string interpolation.
-        unmatchedBeginGroup(begin);
-        return advance();
-      }
+      assert(begin.kind == STRING_INTERPOLATION_TOKEN &&
+             openKind == OPEN_CURLY_BRACKET_TOKEN);
       // We're ending an interpolated expression.
-      begin.endGroup = tail;
+      begin.endGroup = close;
       groupingStack = groupingStack.tail;
       // Using "start-of-text" to signal that we're back in string
       // scanning mode.
       return $STX;
     }
-    begin.endGroup = tail;
+    begin.endGroup = close;
     groupingStack = groupingStack.tail;
     return advance();
   }
 
   /**
+   * Discards begin group tokens until a match with [openKind] is found.
+   * This recovers nicely from from a situation like "{[}".
+   */
+  void discardBeginGroupUntil(int openKind) {
+    while (!groupingStack.isEmpty) {
+      // Don't report unmatched errors for <; it is also the less-than operator.
+      discardOpenLt();
+      if (groupingStack.isEmpty) return;
+      BeginGroupToken begin = groupingStack.head;
+      if (openKind == begin.kind) return;
+      if (openKind == OPEN_CURLY_BRACKET_TOKEN &&
+          begin.kind == STRING_INTERPOLATION_TOKEN) return;
+      unmatchedBeginGroup(begin);
+      groupingStack = groupingStack.tail;
+    }
+  }
+
+  /**
    * Appends a token for '>'.
    * This method does not issue unmatched errors, because > is also the
    * greater-than operator. It does not necessarily have to close a group.
    */
   void appendGt(PrecedenceInfo info) {
     appendPrecedenceToken(info);
     if (groupingStack.isEmpty) return;
     if (identical(groupingStack.head.kind, LT_TOKEN)) {
       groupingStack.head.endGroup = tail;
       groupingStack = groupingStack.tail;
@@ skipping 41 matching lines @@
    * something which cannot possibly be part of a type parameter/argument
    * list, like the '=' in the above example.
    */
   void discardOpenLt() {
     while (!groupingStack.isEmpty
         && identical(groupingStack.head.kind, LT_TOKEN)) {
       groupingStack = groupingStack.tail;
     }
   }
 }