Improve recovery in argument lists when missing a comma before a named argument (issue 29005)

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 667 matching lines @@
    *
    *     argumentList ::=
    *         namedArgument (',' namedArgument)*
    *       | expressionList (',' namedArgument)*
    */
   ArgumentList parseArgumentList() {
     Token leftParenthesis = getAndAdvance();
     if (_matches(TokenType.CLOSE_PAREN)) {
       return astFactory.argumentList(leftParenthesis, null, getAndAdvance());
     }
+
+    /**
+     * Return `true` if the parser appears to be at the beginning of an argument
+     * even though there was no comma. This is a special case of the more
+     * general recovery technique described below.
+     */
+    bool isLikelyMissingComma() {
+      if (_matchesIdentifier() &&
+          _tokenMatches(_currentToken.next, TokenType.COLON) &&
+          leftParenthesis is BeginToken &&
+          leftParenthesis.endToken != null) {
+        _reportErrorForToken(
+            ParserErrorCode.EXPECTED_TOKEN, _currentToken.previous, [',']);
+        return true;
+      }
+      return false;
+    }
+
     //
     // Even though unnamed arguments must all appear before any named arguments,
     // we allow them to appear in any order so that we can recover faster.
     //
     bool wasInInitializer = _inInitializer;
     _inInitializer = false;
     try {
+      Token previousStartOfArgument = _currentToken;
       Expression argument = parseArgument();
       List<Expression> arguments = <Expression>[argument];
       bool foundNamedArgument = argument is NamedExpression;
       bool generatedError = false;
-      while (_optional(TokenType.COMMA)) {
+      while (_optional(TokenType.COMMA) ||
+          (isLikelyMissingComma() &&
+              previousStartOfArgument != _currentToken)) {
         if (_matches(TokenType.CLOSE_PAREN)) {
           break;
         }
+        previousStartOfArgument = _currentToken;
         argument = parseArgument();
         arguments.add(argument);
         if (argument is NamedExpression) {
           foundNamedArgument = true;
         } else if (foundNamedArgument) {
           if (!generatedError) {
             if (!argument.isSynthetic) {
               // Report the error, once, but allow the arguments to be in any
               // order in the AST.
               _reportErrorForCurrentToken(
@@ skipping 7781 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }