Fix parsing postfix expressions with type parameters
Fix https://github.com/dart-lang/sdk/issues/34315
Change-Id: Id6b1749070473ed5a04a3f024276f9985f82da6e
Reviewed-on: https://dart-review.googlesource.com/72560
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Dan Rubel <danrubel@google.com>
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index 7d669f4..4385697 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -6415,6 +6415,56 @@
expect(invocation.argumentList, isNotNull);
}
+ void test_parseExpression_sendWithTypeParam_afterIndex() {
+ final unit = parseCompilationUnit('main() { factories[C]<num, int>(); }');
+ expect(unit.declarations, hasLength(1));
+ FunctionDeclaration mainMethod = unit.declarations[0];
+ BlockFunctionBody body = mainMethod.functionExpression.body;
+ NodeList<Statement> statements = body.block.statements;
+ expect(statements, hasLength(1));
+ ExpressionStatement statement = statements[0];
+ FunctionExpressionInvocation expression = statement.expression;
+
+ IndexExpression function = expression.function;
+ SimpleIdentifier target = function.target;
+ expect(target.name, 'factories');
+ SimpleIdentifier index = function.index;
+ expect(index.name, 'C');
+
+ NodeList<TypeAnnotation> typeArguments = expression.typeArguments.arguments;
+ expect(typeArguments, hasLength(2));
+ expect((typeArguments[0] as NamedType).name.name, 'num');
+ expect((typeArguments[1] as NamedType).name.name, 'int');
+
+ expect(expression.argumentList.arguments, hasLength(0));
+ }
+
+ void test_parseExpression_sendWithTypeParam_afterSend() {
+ final unit = parseCompilationUnit('main() { factories(C)<num, int>(); }');
+ expect(unit.declarations, hasLength(1));
+ FunctionDeclaration mainMethod = unit.declarations[0];
+ BlockFunctionBody body = mainMethod.functionExpression.body;
+ NodeList<Statement> statements = body.block.statements;
+ expect(statements, hasLength(1));
+ ExpressionStatement statement = statements[0];
+ FunctionExpressionInvocation expression = statement.expression;
+
+ MethodInvocation invocation = expression.function;
+ expect(invocation.methodName.name, 'factories');
+ NodeList<Expression> invocationArguments =
+ invocation.argumentList.arguments;
+ expect(invocationArguments, hasLength(1));
+ SimpleIdentifier index = invocationArguments[0];
+ expect(index.name, 'C');
+
+ NodeList<TypeAnnotation> typeArguments = expression.typeArguments.arguments;
+ expect(typeArguments, hasLength(2));
+ expect((typeArguments[0] as NamedType).name.name, 'num');
+ expect((typeArguments[1] as NamedType).name.name, 'int');
+
+ expect(expression.argumentList.arguments, hasLength(0));
+ }
+
void test_parseExpression_superMethodInvocation() {
Expression expression = parseExpression('super.m()');
var invocation = expression as MethodInvocation;
diff --git a/pkg/front_end/lib/src/fasta/parser/parser.dart b/pkg/front_end/lib/src/fasta/parser/parser.dart
index 6296b32..ad479ed 100644
--- a/pkg/front_end/lib/src/fasta/parser/parser.dart
+++ b/pkg/front_end/lib/src/fasta/parser/parser.dart
@@ -3658,20 +3658,15 @@
assert(precedence >= 1);
assert(precedence <= SELECTOR_PRECEDENCE);
token = parseUnaryExpression(token, allowCascades);
- Token next = token.next;
- TokenType type = next.type;
- int tokenLevel = type.precedence;
- Token typeArguments;
TypeParamOrArgInfo typeArg = computeMethodTypeArguments(token);
if (typeArg != noTypeParamOrArg) {
// For example a(b)<T>(c), where token is before '<'.
- typeArguments = next;
token = typeArg.parseArguments(token, this);
- next = token.next;
- assert(optional('(', next));
- type = next.type;
- tokenLevel = type.precedence;
+ assert(optional('(', token.next));
}
+ Token next = token.next;
+ TokenType type = next.type;
+ int tokenLevel = type.precedence;
for (int level = tokenLevel; level >= precedence; --level) {
int lastBinaryExpressionLevel = -1;
while (identical(tokenLevel, level)) {
@@ -3708,8 +3703,7 @@
listener.endBinaryExpression(operator);
} else if ((identical(type, TokenType.OPEN_PAREN)) ||
(identical(type, TokenType.OPEN_SQUARE_BRACKET))) {
- token = parseArgumentOrIndexStar(token, typeArguments);
- next = token.next;
+ token = parseArgumentOrIndexStar(token, typeArg);
} else if (identical(type, TokenType.INDEX)) {
BeginToken replacement = link(
new BeginToken(TokenType.OPEN_SQUARE_BRACKET, next.charOffset,
@@ -3717,7 +3711,7 @@
new Token(TokenType.CLOSE_SQUARE_BRACKET, next.charOffset + 1));
rewriter.replaceTokenFollowing(token, replacement);
replacement.endToken = replacement.next;
- token = parseArgumentOrIndexStar(token, null);
+ token = parseArgumentOrIndexStar(token, noTypeParamOrArg);
} else {
// Recovery
reportRecoverableErrorWithToken(
@@ -3761,7 +3755,7 @@
assert(optional('..', cascadeOperator));
listener.beginCascade(cascadeOperator);
if (optional('[', token.next)) {
- token = parseArgumentOrIndexStar(token, null);
+ token = parseArgumentOrIndexStar(token, noTypeParamOrArg);
} else {
token = parseSend(token, IdentifierContext.expressionContinuation);
listener.endBinaryExpression(cascadeOperator);
@@ -3776,16 +3770,14 @@
next = token.next;
listener.endBinaryExpression(period);
}
- Token typeArguments;
TypeParamOrArgInfo typeArg = computeMethodTypeArguments(token);
if (typeArg != noTypeParamOrArg) {
// For example a(b)..<T>(c), where token is '<'.
- typeArguments = next;
token = typeArg.parseArguments(token, this);
next = token.next;
assert(optional('(', next));
}
- token = parseArgumentOrIndexStar(token, typeArguments);
+ token = parseArgumentOrIndexStar(token, typeArg);
next = token.next;
} while (!identical(mark, token));
@@ -3856,15 +3848,12 @@
return parsePrimary(token, IdentifierContext.expression);
}
- Token parseArgumentOrIndexStar(Token token, Token typeArguments) {
- // TODO(danrubel): Accept the token before typeArguments
- // TODO(brianwilkerson): Consider replacing `typeArguments` with a boolean
- // flag, given that the only thing it's used for is to compare it with null.
+ Token parseArgumentOrIndexStar(Token token, TypeParamOrArgInfo typeArg) {
Token next = token.next;
Token beginToken = next;
while (true) {
if (optional('[', next)) {
- assert(typeArguments == null);
+ assert(typeArg == noTypeParamOrArg);
Token openSquareBracket = next;
bool old = mayParseFunctionExpressions;
mayParseFunctionExpressions = true;
@@ -3879,15 +3868,26 @@
}
listener.handleIndexedExpression(openSquareBracket, next);
token = next;
+ typeArg = computeMethodTypeArguments(token);
+ if (typeArg != noTypeParamOrArg) {
+ // For example a[b]<T>(c), where token is before '<'.
+ token = typeArg.parseArguments(token, this);
+ assert(optional('(', token.next));
+ }
next = token.next;
} else if (optional('(', next)) {
- if (typeArguments == null) {
+ if (typeArg == noTypeParamOrArg) {
listener.handleNoTypeArguments(next);
}
token = parseArguments(token);
+ typeArg = computeMethodTypeArguments(token);
+ if (typeArg != noTypeParamOrArg) {
+ // For example a(b)<T>(c), where token is before '<'.
+ token = typeArg.parseArguments(token, this);
+ assert(optional('(', token.next));
+ }
next = token.next;
listener.handleSend(beginToken, next);
- typeArguments = null;
} else {
break;
}
