Improve error recovery (issue 27646)

pkg/analyzer/lib/src/generated/parser.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.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 762 matching lines @@
     } else {
       bool isQuestionPeriod = type == TokenType.QUESTION_PERIOD;
       if (type == TokenType.PERIOD || isQuestionPeriod) {
         if (isQuestionPeriod && !allowConditional) {
           _reportErrorForCurrentToken(
               ParserErrorCode.INVALID_OPERATOR_FOR_SUPER,
               [_currentToken.lexeme]);
         }
         Token operator = getAndAdvance();
         return new PropertyAccess(prefix, operator, parseSimpleIdentifier());
+      } else if (type == TokenType.INDEX) {
+        _splitIndex();
+        Token leftBracket = getAndAdvance();
+        Expression index = parseSimpleIdentifier();
+        Token rightBracket = getAndAdvance();
+        return new IndexExpression.forTarget(
+            prefix, leftBracket, index, rightBracket);
       } else {
         if (!optional) {
           // Report the missing selector.
           _reportErrorForCurrentToken(
               ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR);
         }
         return prefix;
       }
     }
   }
@@ skipping 2710 matching lines @@
    * no type arguments. Return the list literal that was parsed.
    *
    * This method assumes that the current token matches either
    * `TokenType.OPEN_SQUARE_BRACKET` or `TokenType.INDEX`.
    *
    *     listLiteral ::=
    *         'const'? typeArguments? '[' (expressionList ','?)? ']'
    */
   ListLiteral parseListLiteral(Token modifier, TypeArgumentList typeArguments) {
     if (_matches(TokenType.INDEX)) {
-      // Split the token into two separate tokens.
-      BeginToken leftBracket = _createToken(
-          _currentToken, TokenType.OPEN_SQUARE_BRACKET,
-          isBegin: true);
-      Token rightBracket =
-          new Token(TokenType.CLOSE_SQUARE_BRACKET, _currentToken.offset + 1);
-      leftBracket.endToken = rightBracket;
-      rightBracket.setNext(_currentToken.next);
-      leftBracket.setNext(rightBracket);
-      _currentToken.previous.setNext(leftBracket);
-      _currentToken = _currentToken.next;
+      _splitIndex();
       return new ListLiteral(
-          modifier, typeArguments, leftBracket, null, rightBracket);
+          modifier, typeArguments, getAndAdvance(), null, getAndAdvance());
     }
     Token leftBracket = getAndAdvance();
     if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
       return new ListLiteral(
           modifier, typeArguments, leftBracket, null, getAndAdvance());
     }
     bool wasInInitializer = _inInitializer;
     _inInitializer = false;
     try {
       List<Expression> elements = <Expression>[parseExpression2()];
@@ skipping 576 matching lines @@
    *         assignableSelector
    *       | argumentList
    */
   Expression parsePostfixExpression() {
     Expression operand = parseAssignableExpression(true);
     TokenType type = _currentToken.type;
     if (type == TokenType.OPEN_SQUARE_BRACKET ||
         type == TokenType.PERIOD ||
         type == TokenType.QUESTION_PERIOD ||
         type == TokenType.OPEN_PAREN ||
-        (parseGenericMethods && type == TokenType.LT)) {
+        (parseGenericMethods && type == TokenType.LT) ||
+        type == TokenType.INDEX) {
       do {
         if (_isLikelyArgumentList()) {
           TypeArgumentList typeArguments = _parseOptionalTypeArguments();
           ArgumentList argumentList = parseArgumentList();
           Expression currentOperand = operand;
           if (currentOperand is PropertyAccess) {
             operand = new MethodInvocation(
                 currentOperand.target,
                 currentOperand.operator,
                 currentOperand.propertyName,
                 typeArguments,
                 argumentList);
           } else {
             operand = new FunctionExpressionInvocation(
                 operand, typeArguments, argumentList);
           }
         } else {
           operand = parseAssignableSelector(operand, true);
         }
         type = _currentToken.type;
       } while (type == TokenType.OPEN_SQUARE_BRACKET ||
           type == TokenType.PERIOD ||
           type == TokenType.QUESTION_PERIOD ||
-          type == TokenType.OPEN_PAREN);
+          type == TokenType.OPEN_PAREN ||
+          type == TokenType.INDEX);
       return operand;
     }
     if (!_currentToken.type.isIncrementOperator) {
       return operand;
     }
     _ensureAssignable(operand);
     Token operator = getAndAdvance();
     return new PostfixExpression(operand, operator);
   }
 
@@ skipping 3421 matching lines @@
           return fakeEquals;
         }
         depth -= 2;
       }
       next = next.next;
     }
     return next;
   }
 
   /**
+   * Assuming that the current token is an index token ('[]'), split it into two
+   * tokens ('[' and ']'), leaving the left bracket as the current token.
+   */
+  void _splitIndex() {
+    // Split the token into two separate tokens.
+    BeginToken leftBracket = _createToken(
+        _currentToken, TokenType.OPEN_SQUARE_BRACKET,
+        isBegin: true);
+    Token rightBracket =
+        new Token(TokenType.CLOSE_SQUARE_BRACKET, _currentToken.offset + 1);
+    leftBracket.endToken = rightBracket;
+    rightBracket.setNext(_currentToken.next);
+    leftBracket.setNext(rightBracket);
+    _currentToken.previous.setNext(leftBracket);
+    _currentToken = leftBracket;
+  }
+
+  /**
    * Return `true` if the given [token] has the given [type].
    */
   bool _tokenMatches(Token token, TokenType type) => token.type == type;
 
   /**
    * Return `true` if the given [token] is a valid identifier. Valid identifiers
    * include built-in identifiers (pseudo-keywords).
    */
   bool _tokenMatchesIdentifier(Token token) =>
       _tokenMatches(token, TokenType.IDENTIFIER) ||
@@ skipping 502 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }