Fix for issues 3729 and 3523

compiler/java/com/google/dart/compiler/parser/DartParser.java

 // Copyright (c) 2012, 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.
 
 package com.google.dart.compiler.parser;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.io.CharStreams;
 import com.google.dart.compiler.DartCompilationError;
@@ skipping 76 matching lines @@
 import com.google.dart.compiler.ast.DartUnaryExpression;
 import com.google.dart.compiler.ast.DartUnit;
 import com.google.dart.compiler.ast.DartUnqualifiedInvocation;
 import com.google.dart.compiler.ast.DartVariable;
 import com.google.dart.compiler.ast.DartVariableStatement;
 import com.google.dart.compiler.ast.DartWhileStatement;
 import com.google.dart.compiler.ast.ImportCombinator;
 import com.google.dart.compiler.ast.LibraryNode;
 import com.google.dart.compiler.ast.LibraryUnit;
 import com.google.dart.compiler.ast.Modifiers;
+import com.google.dart.compiler.common.HasSourceInfo;
 import com.google.dart.compiler.metrics.CompilerMetrics;
 import com.google.dart.compiler.parser.DartScanner.Location;
 import com.google.dart.compiler.parser.DartScanner.Position;
 import com.google.dart.compiler.util.Lists;
 
 import java.io.IOException;
 import java.io.Reader;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Collections;
@@ skipping 1769 matching lines @@
       }
     }
   }
 
   /**
    * Parse an expression.
    *
    * <pre>
    * expression
    *     : assignableExpression assignmentOperator expression
-   *     | conditionalExpression
+   *     | conditionalExpression cascadeSection*
    *     ;
    *
    * assignableExpression
    *     : primary (arguments* assignableSelector)+
    *     | SUPER assignableSelector
    *     | identifier
    *     ;
    * </pre>
    *
    * @return an expression matching the {@code expression} production above
    */
   @VisibleForTesting
   public DartExpression parseExpression() {
     beginExpression();
     if (looksLikeTopLevelKeyword() || peek(0).equals(Token.RBRACE)) {
       // Allow recovery back to the top level.
       reportErrorWithoutAdvancing(ParserErrorCode.UNEXPECTED_TOKEN);
       return done(null);
     }
     DartExpression result = parseConditionalExpression();
     Token token = peek(0);
-    if (token.isAssignmentOperator()) {
+    if (token == Token.CASCADE) {
+      while (token == Token.CASCADE) {
+        result = parseCascadeSection(result);
+        token = peek(0);
+      }
+      done(result);
+    } else if (token.isAssignmentOperator()) {
       ensureAssignable(result);
       consume(token);
       int tokenOffset = ctx.getTokenLocation().getBegin().getPos();
       result = done(new DartBinaryExpression(token, tokenOffset, result, parseExpression()));
     } else {
       done(null);
     }
     return result;
   }
 
   /**
+   * Parse an expression without a cascade.
+   *
+   * <pre>
+   * expressionWithoutCascade
+   *     : assignableExpression assignmentOperator expressionWithoutCascade
+   *     | conditionalExpression
+   *     ;
+   * </pre>
+   *
+   * @return an expression matching the {@code expression} production above
+   */
+  private DartExpression parseExpressionWithoutCascade() {
+    beginExpression();
+    if (looksLikeTopLevelKeyword() || peek(0).equals(Token.RBRACE)) {
+      // Allow recovery back to the top level.
+      reportErrorWithoutAdvancing(ParserErrorCode.UNEXPECTED_TOKEN);
+      return done(null);
+    }
+    DartExpression result = parseConditionalExpression();
+    Token token = peek(0);
+   if (token.isAssignmentOperator()) {
+      ensureAssignable(result);
+      consume(token);
+      int tokenOffset = ctx.getTokenLocation().getBegin().getPos();
+      result = done(new DartBinaryExpression(token, tokenOffset, result, parseExpressionWithoutCascade()));
+    } else {
+      done(null);
+    }
+    return result;
+  }
+
+  /**
+   * Parse a cascade section.
+   * <pre>
+   * cascadeSection
+   *     : CASCADE (cascadeSelector arguments*) (assignableSelector arguments*)* (assignmentOperator
+   * expressionWithoutCascade)?
+   *     ;
+   *
+   * cascadeSelector
+   *     : LBRACK expression RBRACK
+   *     | identifier
+   *     ;
+   * </pre>
+   * 
+   * @param target the target of the method invocation
+   * @return the expression representing the cascaded method invocation
+   */
+  private DartExpression parseCascadeSection(DartExpression target) {
+    expect(Token.CASCADE);
+    DartExpression result = target;
+    DartIdentifier functionName = null;
+    if (peek(0) == Token.IDENTIFIER) {
+      functionName = parseIdentifier();
+    } else if (peek(0) == Token.LBRACK) {
+      consume(Token.LBRACK);
+      result = doneWithoutConsuming(new DartArrayAccess(result, parseExpression()));
+      expect(Token.RBRACK);
+    } else {
+      reportUnexpectedToken(position(), null, next());
+      return result;
+    }
+    if (peek(0) == Token.LPAREN) {
+      while (peek(0) == Token.LPAREN) {
+        if (functionName != null) {
+          result = doneWithoutConsuming(new DartMethodInvocation(result, true, functionName, parseArguments()));
+          functionName = null;
+        } else {
+          result = doneWithoutConsuming(new DartFunctionObjectInvocation(result, parseArguments()));
+        }
+      }
+    } else if (functionName != null) {
+      result = doneWithoutConsuming(new DartPropertyAccess(result, true, functionName));
+    }
+    boolean progress = true;
+    while (progress) {
+      progress = false;
+      DartExpression selector = tryParseAssignableSelector(result);
+      if (selector != null) {
+        result = selector;
+        progress = true;
+        while (peek(0) == Token.LPAREN) {
+          result = doneWithoutConsuming(new DartFunctionObjectInvocation(result, parseArguments()));
+        }
+      }
+    }
+    Token token = peek(0);
+    if (token.isAssignmentOperator()) {
+      ensureAssignable(result);
+      consume(token);
+      int tokenOffset = ctx.getTokenLocation().getBegin().getPos();
+      result = doneWithoutConsuming(new DartBinaryExpression(token, tokenOffset, result, parseExpressionWithoutCascade()));
+    }
+    return result;
+  }
+
+  /**
    * expressionList
    *     : expression (',' expression)*
    *     ;
    */
   @Terminals(tokens={Token.COMMA})
   private DartExpression parseExpressionList() {
     beginExpressionList();
     DartExpression result = parseExpression();
     // Must keep in sync with @Terminals above
     while (optional(Token.COMMA)) {
@@ skipping 1164 matching lines @@
         switch (peek(0)) {
           case SEMICOLON:
           case RBRACE:
             reportError(position(), ParserErrorCode.EXPECTED_IDENTIFIER);
             DartIdentifier error = doneWithoutConsuming(new DartIdentifier(""));
             return doneWithoutConsuming(new DartPropertyAccess(receiver, error));
         }
         DartIdentifier name = parseIdentifier();
         if (peek(0) == Token.LPAREN) {
           boolean save = setAllowFunctionExpression(true);
-          DartMethodInvocation expr = doneWithoutConsuming(new DartMethodInvocation(receiver, name,
-              parseArguments()));
+          DartMethodInvocation expr = doneWithoutConsuming(new DartMethodInvocation(receiver, false,
+              name, parseArguments()));
           setAllowFunctionExpression(save);
           return expr;
         } else {
           return doneWithoutConsuming(new DartPropertyAccess(receiver, name));
         }
 
       case LBRACK:
         consume(Token.LBRACK);
         DartExpression key = parseExpression();
         expect(Token.RBRACK);
@@ skipping 1365 matching lines @@
   }
 
   private void reportError(DartNode node, ErrorCode errorCode, Object... arguments) {
     reportError(new DartCompilationError(node, errorCode, arguments));
   }
 
   private boolean currentlyParsingToplevel() {
     return   !(isParsingInterface || isTopLevelAbstract || isParsingClass);
   }
 }