Fix parsing of super expressions (issue 32393)

Change-Id: I887288254eb1be33c111b6dedd16c2acd3eb3dd1
Reviewed-on: https://dart-review.googlesource.com/45440
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: William Hesse <[email protected]>

Author: bwilkerson

pkg/analyzer/lib/src/generated/parser.dart

@@ -846,12 +846,52 @@ class Parser {
    *       | identifier
    */
   Expression parseAssignableExpression(bool primaryAllowed) {
-    if (_matchesKeyword(Keyword.SUPER)) {
-      return parseAssignableSelector(
-          astFactory.superExpression(getAndAdvance()), false,
-          allowConditional: false);
+    //
+    // A primary expression can start with an identifier. We resolve the
+    // ambiguity by determining whether the primary consists of anything other
+    // than an identifier and/or is followed by an assignableSelector.
+    //
+    Expression expression = parsePrimaryExpression();
+    bool isOptional =
+        primaryAllowed || _isValidAssignableExpression(expression);
+    while (true) {
+      while (_isLikelyArgumentList()) {
+        TypeArgumentList typeArguments = _parseOptionalTypeArguments();
+        ArgumentList argumentList = parseArgumentList();
+        Expression currentExpression = expression;
+        if (currentExpression is SimpleIdentifier) {
+          expression = astFactory.methodInvocation(
+              null, null, currentExpression, typeArguments, argumentList);
+        } else if (currentExpression is PrefixedIdentifier) {
+          expression = astFactory.methodInvocation(
+              currentExpression.prefix,
+              currentExpression.period,
+              currentExpression.identifier,
+              typeArguments,
+              argumentList);
+        } else if (currentExpression is PropertyAccess) {
+          expression = astFactory.methodInvocation(
+              currentExpression.target,
+              currentExpression.operator,
+              currentExpression.propertyName,
+              typeArguments,
+              argumentList);
+        } else {
+          expression = astFactory.functionExpressionInvocation(
+              expression, typeArguments, argumentList);
+        }
+        if (!primaryAllowed) {
+          isOptional = false;
+        }
+      }
+      Expression selectorExpression = parseAssignableSelector(
+          expression, isOptional || (expression is PrefixedIdentifier));
+      if (identical(selectorExpression, expression)) {
+        return expression;
+      }
+      expression = selectorExpression;
+      isOptional = true;
     }
-    return _parseAssignableExpressionNotStartingWithSuper(primaryAllowed);
   }
 
   /**
@@ -4457,7 +4497,7 @@ class Parser {
    *
    *     selector ::=
    *         assignableSelector
-   *       | argumentList
+   *       | argumentPart
    */
   Expression parsePostfixExpression() {
     Expression operand = parseAssignableExpression(true);
@@ -4583,8 +4623,6 @@ class Parser {
     } else if (keyword == Keyword.THIS) {
       return astFactory.thisExpression(getAndAdvance());
     } else if (keyword == Keyword.SUPER) {
-      // TODO(paulberry): verify with Gilad that "super" must be followed by
-      // unconditionalAssignableSelector in this case.
       return parseAssignableSelector(
           astFactory.superExpression(getAndAdvance()), false,
           allowConditional: false);
@@ -5416,7 +5454,7 @@ class Parser {
             operator, astFactory.superExpression(getAndAdvance()));
       }
       return astFactory.prefixExpression(
-          operator, _parseAssignableExpressionNotStartingWithSuper(false));
+          operator, parseAssignableExpression(false));
     } else if (type == TokenType.PLUS) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
       return createSyntheticIdentifier();
@@ -6381,6 +6419,21 @@ class Parser {
     return false;
   }
 
+  /**
+   * Return `true` if the given [expression] is a primary expression that is
+   * allowed to be an assignable expression without any assignable selector.
+   */
+  bool _isValidAssignableExpression(Expression expression) {
+    if (expression is SimpleIdentifier) {
+      return true;
+    } else if (expression is PropertyAccess) {
+      return expression.target is SuperExpression;
+    } else if (expression is IndexExpression) {
+      return expression.target is SuperExpression;
+    }
+    return false;
+  }
+
   /**
    * Increments the error reporting lock level. If level is more than `0`, then
    * [reportError] wont report any error.
@@ -6519,61 +6572,6 @@ class Parser {
         keyword, leftParen, expression, comma, message, rightParen);
   }
 
-  /**
-   * Parse an assignable expression given that the current token is not 'super'.
-   * The [primaryAllowed] is `true` if the expression is allowed to be a primary
-   * without any assignable selector. Return the assignable expression that was
-   * parsed.
-   */
-  Expression _parseAssignableExpressionNotStartingWithSuper(
-      bool primaryAllowed) {
-    //
-    // A primary expression can start with an identifier. We resolve the
-    // ambiguity by determining whether the primary consists of anything other
-    // than an identifier and/or is followed by an assignableSelector.
-    //
-    Expression expression = parsePrimaryExpression();
-    bool isOptional = primaryAllowed || expression is SimpleIdentifier;
-    while (true) {
-      while (_isLikelyArgumentList()) {
-        TypeArgumentList typeArguments = _parseOptionalTypeArguments();
-        ArgumentList argumentList = parseArgumentList();
-        Expression currentExpression = expression;
-        if (currentExpression is SimpleIdentifier) {
-          expression = astFactory.methodInvocation(
-              null, null, currentExpression, typeArguments, argumentList);
-        } else if (currentExpression is PrefixedIdentifier) {
-          expression = astFactory.methodInvocation(
-              currentExpression.prefix,
-              currentExpression.period,
-              currentExpression.identifier,
-              typeArguments,
-              argumentList);
-        } else if (currentExpression is PropertyAccess) {
-          expression = astFactory.methodInvocation(
-              currentExpression.target,
-              currentExpression.operator,
-              currentExpression.propertyName,
-              typeArguments,
-              argumentList);
-        } else {
-          expression = astFactory.functionExpressionInvocation(
-              expression, typeArguments, argumentList);
-        }
-        if (!primaryAllowed) {
-          isOptional = false;
-        }
-      }
-      Expression selectorExpression = parseAssignableSelector(
-          expression, isOptional || (expression is PrefixedIdentifier));
-      if (identical(selectorExpression, expression)) {
-        return expression;
-      }
-      expression = selectorExpression;
-      isOptional = true;
-    }
-  }
-
   /**
    * Parse a block when we need to check for an open curly brace and recover
    * when there isn't one. Return the block that was parsed.

pkg/analyzer/test/generated/parser_test.dart

@@ -3717,6 +3717,20 @@ class Wrong<T> {
 //        [expectedError(ParserErrorCode.GETTER_WITH_PARAMETERS, 9, 2)]);
   }
 
+  void test_illegalAssignmentToNonAssignable_assign_int() {
+    parseStatement("0 = 1;");
+    listener.assertErrors([
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 0, 1)
+    ]);
+  }
+
+  void test_illegalAssignmentToNonAssignable_assign_this() {
+    parseStatement("this = 1;");
+    listener.assertErrors([
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 0, 4)
+    ]);
+  }
+
   void test_illegalAssignmentToNonAssignable_postfix_minusMinus_literal() {
     parseExpression("0--", errors: [
       expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 1, 2)
@@ -3742,8 +3756,6 @@ class Wrong<T> {
   }
 
   void test_illegalAssignmentToNonAssignable_superAssigned() {
-    // TODO(brianwilkerson) When this test starts to pass, remove the test
-    // test_illegalAssignmentToNonAssignable_superAssigned.
     parseStatement("super = x;");
     listener.assertErrors(usingFastaParser
         ? [
@@ -6587,6 +6599,17 @@ abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
     expect(invocation.argumentList, isNotNull);
   }
 
+  void test_parseExpression_superMethodInvocation_typeArguments_chained() {
+    Expression expression = parseExpression('super.b.c<D>()');
+    MethodInvocation invocation = expression as MethodInvocation;
+    Expression target = invocation.target;
+    expect(target, new isInstanceOf<PropertyAccess>());
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.methodName.name, 'c');
+    expect(invocation.typeArguments, isNotNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
   void test_parseExpressionList_multiple() {
     List<Expression> result = parseExpressionList('1, 2, 3');
     expect(result, isNotNull);