[parser] Better recovery for extra stuff in enum and using enum as identifier

Fixes #48371

Change-Id: I93331485c884c89c179c2fa332f3f975db9507f7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/234043
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Jens Johansen <[email protected]>

Author: jensjoha

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -7476,6 +7476,37 @@ const MessageCode messageMoreThanOneSuperInitializer = const MessageCode(
     analyzerCodes: <String>["MULTIPLE_SUPER_INITIALIZERS"],
     problemMessage: r"""Can't have more than one 'super' initializer.""");
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String string,
+        String
+            string2)> templateMultipleClauses = const Template<
+        Message Function(String string, String string2)>(
+    problemMessageTemplate:
+        r"""Each '#string' definition can have at most one '#string2' clause.""",
+    correctionMessageTemplate:
+        r"""Try combining all of the '#string2' clauses into a single clause.""",
+    withArguments: _withArgumentsMultipleClauses);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String string, String string2)>
+    codeMultipleClauses =
+    const Code<Message Function(String string, String string2)>(
+        "MultipleClauses",
+        index: 121);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsMultipleClauses(String string, String string2) {
+  if (string.isEmpty) throw 'No string provided';
+  if (string2.isEmpty) throw 'No string provided';
+  return new Message(codeMultipleClauses,
+      problemMessage:
+          """Each '${string}' definition can have at most one '${string2}' clause.""",
+      correctionMessage: """Try combining all of the '${string2}' clauses into a single clause.""",
+      arguments: {'string': string, 'string2': string2});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeMultipleExtends = messageMultipleExtends;
 
@@ -8369,6 +8400,37 @@ const MessageCode messageOperatorWithTypeParameters = const MessageCode(
         r"""Types parameters aren't allowed when defining an operator.""",
     correctionMessage: r"""Try removing the type parameters.""");
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String string,
+        String
+            string2)> templateOutOfOrderClauses = const Template<
+        Message Function(String string, String string2)>(
+    problemMessageTemplate:
+        r"""The '#string' clause must come before the '#string2' clause.""",
+    correctionMessageTemplate:
+        r"""Try moving the '#string' clause before the '#string2' clause.""",
+    withArguments: _withArgumentsOutOfOrderClauses);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String string, String string2)>
+    codeOutOfOrderClauses =
+    const Code<Message Function(String string, String string2)>(
+        "OutOfOrderClauses",
+        index: 122);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsOutOfOrderClauses(String string, String string2) {
+  if (string.isEmpty) throw 'No string provided';
+  if (string2.isEmpty) throw 'No string provided';
+  return new Message(codeOutOfOrderClauses,
+      problemMessage:
+          """The '${string}' clause must come before the '${string2}' clause.""",
+      correctionMessage: """Try moving the '${string}' clause before the '${string2}' clause.""",
+      arguments: {'string': string, 'string2': string2});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(String name)> templateOverriddenMethodCause =
     const Template<Message Function(String name)>(
@@ -10323,6 +10385,15 @@ Message _withArgumentsUnexpectedToken(Token token) {
       arguments: {'lexeme': token});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeUnexpectedTokens = messageUnexpectedTokens;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageUnexpectedTokens = const MessageCode(
+    "UnexpectedTokens",
+    index: 123,
+    problemMessage: r"""Unexpected tokens.""");
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(String string, Token token)>
     templateUnmatchedToken =

pkg/_fe_analyzer_shared/lib/src/parser/identifier_context_impl.dart

@@ -124,8 +124,12 @@ class CombinatorIdentifierContext extends IdentifierContext {
     }
 
     // Recovery
-    if (isOneOfOrEof(identifier, followingValues) ||
-        looksLikeStartOfNextTopLevelDeclaration(identifier)) {
+    if (isOneOfOrEof(identifier, followingValues)) {
+      identifier = parser.insertSyntheticIdentifier(token, this,
+          message: codes.templateExpectedIdentifier.withArguments(identifier));
+    } else if (looksLikeStartOfNextTopLevelDeclaration(identifier) &&
+        (identifier.next == null ||
+            !isOneOfOrEof(identifier.next!, followingValues))) {
       identifier = parser.insertSyntheticIdentifier(token, this,
           message: codes.templateExpectedIdentifier.withArguments(identifier));
     } else {
@@ -603,8 +607,12 @@ class ImportPrefixIdentifierContext extends IdentifierContext {
         isOneOfOrEof(identifier.next!, followingValues)) {
       parser.reportRecoverableErrorWithToken(
           identifier, codes.templateBuiltInIdentifierInDeclaration);
-    } else if (looksLikeStartOfNextTopLevelDeclaration(identifier) ||
-        isOneOfOrEof(identifier, followingValues)) {
+    } else if (looksLikeStartOfNextTopLevelDeclaration(identifier) &&
+        (identifier.next == null ||
+            !isOneOfOrEof(identifier.next!, followingValues))) {
+      identifier = parser.insertSyntheticIdentifier(token, this,
+          message: codes.templateExpectedIdentifier.withArguments(identifier));
+    } else if (isOneOfOrEof(identifier, followingValues)) {
       identifier = parser.insertSyntheticIdentifier(token, this,
           message: codes.templateExpectedIdentifier.withArguments(identifier));
     } else {
@@ -802,8 +810,12 @@ class LibraryIdentifierContext extends IdentifierContext {
     }
 
     // Recovery
-    if (isOneOfOrEof(identifier, followingValues) ||
-        looksLikeStartOfNextTopLevelDeclaration(identifier)) {
+    if (isOneOfOrEof(identifier, followingValues)) {
+      identifier = parser.insertSyntheticIdentifier(token, this,
+          message: codes.templateExpectedIdentifier.withArguments(identifier));
+    } else if (looksLikeStartOfNextTopLevelDeclaration(identifier) &&
+        (identifier.next == null ||
+            !isOneOfOrEof(identifier.next!, followingValues))) {
       identifier = parser.insertSyntheticIdentifier(token, this,
           message: codes.templateExpectedIdentifier.withArguments(identifier));
     } else {

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -76,6 +76,9 @@ import 'identifier_context.dart'
         looksLikeExpressionStart,
         okNextValueInFormalParameter;
 
+import 'identifier_context_impl.dart'
+    show looksLikeStartOfNextTopLevelDeclaration;
+
 import 'listener.dart' show Listener;
 
 import 'literal_entry_info.dart'
@@ -2005,11 +2008,140 @@ class Parser {
     token = computeTypeParamOrArg(
             token, /* inDeclaration = */ true, /* allowsVariance = */ true)
         .parseVariables(token, this);
+    List<String> lookForNext = const ['{', 'with', 'implements'];
+    if (!isOneOf(token.next!, lookForNext)) {
+      // Recovery: Possible unexpected tokens before any clauses.
+      Token? skipToken = recoverySmallLookAheadSkipTokens(token, lookForNext);
+      if (skipToken != null) {
+        token = skipToken;
+      }
+    }
+
+    Token beforeWith = token;
     token = parseEnumWithClauseOpt(token);
+
+    while (!isOneOf(token.next!, const ['{', 'implements'])) {
+      // Recovery: Skip unexpected tokens and more with clauses.
+      // Note that if we find a "with" we've seen one already (otherwise the
+      // parseEnumWithClauseOpt call above would have found this 'with').
+      Token? skipToken = recoveryEnumWith(token,
+              codes.templateMultipleClauses.withArguments("enum", "with")) ??
+          recoverySmallLookAheadSkipTokens(token, lookForNext);
+
+      if (skipToken != null) {
+        // Skipped tokens.
+        token = skipToken;
+      } else {
+        break;
+      }
+    }
+
     token = parseClassOrMixinOrEnumImplementsOpt(token);
+
+    bool? hasWithClauses;
+    while (!optional('{', token.next!)) {
+      if (hasWithClauses == null) {
+        hasWithClauses = optional('with', beforeWith.next!);
+      }
+
+      // Recovery: Skip unexpected tokens and more with/implements clauses.
+      Token? skipToken = recoveryEnumWith(
+          token,
+          hasWithClauses
+              ? codes.templateMultipleClauses.withArguments("enum", "with")
+              : codes.templateOutOfOrderClauses
+                  .withArguments("with", "implements"));
+      if (skipToken != null) {
+        hasWithClauses = true;
+      }
+      if (skipToken == null) {
+        // Note that if we find a "implements" we've seen one already (otherwise
+        // the parseClassOrMixinOrEnumImplementsOpt call above would have found
+        // this 'implements').
+        skipToken = recoveryEnumImplements(token,
+            codes.templateMultipleClauses.withArguments("enum", "implements"));
+      }
+      if (skipToken == null) {
+        skipToken = recoverySmallLookAheadSkipTokens(token, lookForNext);
+      }
+
+      if (skipToken != null) {
+        // Skipped tokens.
+        token = skipToken;
+      } else {
+        break;
+      }
+    }
+
     return token;
   }
 
+  Token? recoveryEnumWith(Token token, codes.Message message) {
+    if (optional('with', token.next!)) {
+      reportRecoverableError(token.next!, message);
+      Listener originalListener = listener;
+      listener = new NullListener();
+      token = parseEnumWithClauseOpt(token);
+      listener = originalListener;
+      return token;
+    }
+    return null;
+  }
+
+  Token? recoveryEnumImplements(Token token, codes.Message message) {
+    if (optional('implements', token.next!)) {
+      reportRecoverableError(token.next!, message);
+      Listener originalListener = listener;
+      listener = new NullListener();
+      token = parseClassOrMixinOrEnumImplementsOpt(token);
+      listener = originalListener;
+      return token;
+    }
+    return null;
+  }
+
+  /// Allow a small lookahead (currently up to 3 tokens) trying to find any in
+  /// [lookFor].
+  ///
+  /// If any wanted token is found an error is issued about unexpected tokens,
+  /// and the last skipped token is returned.
+  /// Otherwise null is returned.
+  Token? recoverySmallLookAheadSkipTokens(
+      final Token token, Iterable<String> lookFor) {
+    // Recovery: Allow a small lookahead for '{'. E.g. the user might be in
+    // the middle of writing 'with' or 'implements'.
+    Token skipToken = token.next!;
+    bool foundWanted = false;
+
+    if (looksLikeStartOfNextTopLevelDeclaration(skipToken)) return null;
+
+    int skipped = 0;
+    while (skipped < 3) {
+      skipped++;
+      if (isOneOf(skipToken.next!, lookFor)) {
+        foundWanted = true;
+        break;
+      }
+
+      skipToken = skipToken.next!;
+      if (looksLikeStartOfNextTopLevelDeclaration(skipToken)) return null;
+    }
+
+    if (foundWanted) {
+      // Give error and skip the tokens.
+      if (skipped == 1) {
+        reportRecoverableError(
+            skipToken, codes.templateUnexpectedToken.withArguments(skipToken));
+      } else {
+        reportRecoverableErrorWithEnd(
+            token.next!, skipToken, codes.messageUnexpectedTokens);
+      }
+      return skipToken;
+    }
+
+    return null;
+  }
+
   Token parseEnumElement(Token token) {
     Token beginToken = token;
     token = parseMetadataStar(token);

pkg/analysis_server/test/services/completion/dart/location/enum_test.dart

@@ -29,7 +29,6 @@ class EnumDeclarationTest2 extends AbstractCompletionDriverTest
   @override
   TestingCompletionProtocol get protocol => TestingCompletionProtocol.version2;
 
-  @FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/48371')
   Future<void> test_afterName_w() async {
     var response = await getTestCodeSuggestions('''
 enum E w^ {

pkg/analyzer/lib/error/error.dart

@@ -841,6 +841,7 @@ const List<ErrorCode> errorCodeValues = [
   ParserErrorCode.MIXED_PARAMETER_GROUPS,
   ParserErrorCode.MIXIN_DECLARES_CONSTRUCTOR,
   ParserErrorCode.MODIFIER_OUT_OF_ORDER,
+  ParserErrorCode.MULTIPLE_CLAUSES,
   ParserErrorCode.MULTIPLE_EXTENDS_CLAUSES,
   ParserErrorCode.MULTIPLE_IMPLEMENTS_CLAUSES,
   ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES,
@@ -864,6 +865,7 @@ const List<ErrorCode> errorCodeValues = [
   ParserErrorCode.NON_USER_DEFINABLE_OPERATOR,
   ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS,
   ParserErrorCode.NULL_AWARE_CASCADE_OUT_OF_ORDER,
+  ParserErrorCode.OUT_OF_ORDER_CLAUSES,
   ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT,
   ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP,
   ParserErrorCode.PREFIX_AFTER_COMBINATOR,
@@ -887,6 +889,7 @@ const List<ErrorCode> errorCodeValues = [
   ParserErrorCode.TYPEDEF_IN_CLASS,
   ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP,
   ParserErrorCode.UNEXPECTED_TOKEN,
+  ParserErrorCode.UNEXPECTED_TOKENS,
   ParserErrorCode.VAR_AND_TYPE,
   ParserErrorCode.VAR_AS_TYPE_NAME,
   ParserErrorCode.VAR_CLASS,

pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart

@@ -135,6 +135,9 @@ final fastaAnalyzerErrorCodes = <ErrorCode?>[
   ParserErrorCode.CONSTRUCTOR_WITH_TYPE_ARGUMENTS,
   ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR,
   ParserErrorCode.TYPE_PARAMETER_ON_OPERATOR,
+  ParserErrorCode.MULTIPLE_CLAUSES,
+  ParserErrorCode.OUT_OF_ORDER_CLAUSES,
+  ParserErrorCode.UNEXPECTED_TOKENS,
 ];
 
 class ParserErrorCode extends ErrorCode {
@@ -1294,6 +1297,13 @@ class ParserErrorCode extends ErrorCode {
     correctionMessage: "Try re-ordering the modifiers.",
   );
 
+  static const ParserErrorCode MULTIPLE_CLAUSES = ParserErrorCode(
+    'MULTIPLE_CLAUSES',
+    "Each '{0}' definition can have at most one '{1}' clause.",
+    correctionMessage:
+        "Try combining all of the '{1}' clauses into a single clause.",
+  );
+
   static const ParserErrorCode MULTIPLE_EXTENDS_CLAUSES = ParserErrorCode(
     'MULTIPLE_EXTENDS_CLAUSES',
     "Each class definition can have at most one extends clause.",
@@ -1468,6 +1478,12 @@ class ParserErrorCode extends ErrorCode {
         "sequence.",
   );
 
+  static const ParserErrorCode OUT_OF_ORDER_CLAUSES = ParserErrorCode(
+    'OUT_OF_ORDER_CLAUSES',
+    "The '{0}' clause must come before the '{1}' clause.",
+    correctionMessage: "Try moving the '{0}' clause before the '{1}' clause.",
+  );
+
   static const ParserErrorCode POSITIONAL_AFTER_NAMED_ARGUMENT =
       ParserErrorCode(
     'POSITIONAL_AFTER_NAMED_ARGUMENT',
@@ -1636,6 +1652,11 @@ class ParserErrorCode extends ErrorCode {
     correctionMessage: "Try removing the text.",
   );
 
+  static const ParserErrorCode UNEXPECTED_TOKENS = ParserErrorCode(
+    'UNEXPECTED_TOKENS',
+    "Unexpected tokens.",
+  );
+
   static const ParserErrorCode VAR_AND_TYPE = ParserErrorCode(
     'VAR_AND_TYPE',
     "Variables can't be declared using both 'var' and a type name.",