New analyzer snapshot (with CaughtException).

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import 'java_core.dart';
@@ skipping 2031 matching lines @@
     Token period = null;
     SimpleIdentifier name = null;
     if (_matches(TokenType.PERIOD)) {
       period = andAdvance;
       name = parseSimpleIdentifier();
     }
     return new ConstructorName(type, period, name);
   }
 
   /**
-   * Parse an expression that does not contain any cascades.
+   * Parse an expression that might contain a cascade.
    *
    * <pre>
    * expression ::=
    *     assignableExpression assignmentOperator expression
    *   | conditionalExpression cascadeSection*
    *   | throwExpression
    * </pre>
    *
    * @return the expression that was parsed
    */
@@ skipping 1459 matching lines @@
    * Parse an assignable selector.
    *
    * <pre>
    * assignableSelector ::=
    *     '[' expression ']'
    *   | '.' identifier
    * </pre>
    *
    * @param prefix the expression preceding the selector
    * @param optional `true` if the selector is optional
-   * @return the assignable selector that was parsed
+   * @return the assignable selector that was parsed, or the original prefix if there was no
+   *         assignable selector
    */
   Expression _parseAssignableSelector(Expression prefix, bool optional) {
     if (_matches(TokenType.OPEN_SQUARE_BRACKET)) {
       Token leftBracket = andAdvance;
       bool wasInInitializer = _inInitializer;
       _inInitializer = false;
       try {
         Expression index = parseExpression2();
         Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
         return new IndexExpression.forTarget(prefix, leftBracket, index, rightBracket);
@@ skipping 117 matching lines @@
         Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
         expression = new IndexExpression.forCascade(period, leftBracket, index, rightBracket);
         period = null;
       } finally {
         _inInitializer = wasInInitializer;
       }
     } else {
       _reportErrorForToken(ParserErrorCode.MISSING_IDENTIFIER, _currentToken, [_currentToken.lexeme]);
       functionName = _createSyntheticIdentifier();
     }
+    assert((expression == null && functionName != null) || (expression != null && functionName == null));
     if (_currentToken.type == TokenType.OPEN_PAREN) {
       while (_currentToken.type == TokenType.OPEN_PAREN) {
         if (functionName != null) {
           expression = new MethodInvocation(expression, period, functionName, parseArgumentList());
           period = null;
           functionName = null;
         } else if (expression == null) {
           // It should not be possible to get here.
           expression = new MethodInvocation(expression, period, _createSyntheticIdentifier(), parseArgumentList());
         } else {
           expression = new FunctionExpressionInvocation(expression, parseArgumentList());
         }
       }
     } else if (functionName != null) {
       expression = new PropertyAccess(expression, period, functionName);
       period = null;
     }
+    assert(expression != null);
     bool progress = true;
     while (progress) {
       progress = false;
       Expression selector = _parseAssignableSelector(expression, true);
       if (!identical(selector, expression)) {
         expression = selector;
         progress = true;
         while (_currentToken.type == TokenType.OPEN_PAREN) {
           if (expression is PropertyAccess) {
             PropertyAccess propertyAccess = expression as PropertyAccess;
@@ skipping 5380 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }