[messages] Replace remaining CFE analyzerCode values.

Replaces the remaining `analyzerCode: FOO` entries in
`pkg/_fe_analyzer_shared/messages.yaml` with `psuedoSharedCode: FOO`
entries. A `pseudoSharedCode` entry carries two pieces of information:
it indicates that the error code is "pseudo-shared" (meaning that
there is manually maintained logic that translates it from a CFE
diagnostic to an analyzer diagnostic), and it provides an enum value
that can be used by the manually maintained logic to identify which
analyzer error to translate to.

In the few cases where diagnostic had a `pseudoShared: true`
annotation but no `analyzerCode`, a fresh `pseudoSharedCode` is
introduced.

The diagnostic code generation logic is updated accordingly. The logic
that translates CFE diagnostics to analyzer diagnostics is also
updated.

This change carries two benefits:

- It more accurately reflects reality; calling these codes
  `analyzerCode` was inaccurate because there was no automated process
  to verify that they corresponded to actual analyzer error codes, and
  in fact in many cases they didn't.

- It avoids confusion with the `analyzerCode` values in
  `pkg/_fe_analyzer_shared/messages.yaml`, which _do_ in fact
  correspond to actual analyzer error codes.

Change-Id: I6a6a69640fe4b04da0296086d052be46126a1ebd
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/453102
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

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

@@ -2,6 +2,9 @@
 // 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.
 
+/// @docImport 'package:_fe_analyzer_shared/src/scanner/errors.dart';
+/// @docImport 'package:analyzer/src/fasta/ast_builder.dart';
+/// @docImport 'package:analyzer/src/fasta/error_converter.dart';
 library _fe_analyzer_shared.messages.codes;
 
 import 'dart:convert' show JsonEncoder, json;
@@ -28,14 +31,26 @@ class Code {
   /// this error to its corresponding Analyzer error.
   final int index;
 
-  final List<AnalyzerCode>? analyzerCodes;
+  /// Enumerated value that can be used to map this [Code] to a corresponding
+  /// analyzer code.
+  ///
+  /// If this value is non-null, then manually maintained logic (such as
+  /// that in [translateErrorToken], [AstBuilder.addProblem],
+  /// [AstBuilder.handleRecoverableError], or
+  /// [FastaErrorReporter.reportMessage]) can use it to translate to a
+  /// corresponding analyzer error code.
+  ///
+  /// Note that error codes that require translation in this way are not truly
+  /// shared (hence the name "pseudoSharedCode"). Truly shared error codes are
+  /// mapped to corresponding analyzer error codes using [index].
+  final PseudoSharedCode? pseudoSharedCode;
 
   final CfeSeverity severity;
 
   const Code(
     this.name, {
     this.index = -1,
-    this.analyzerCodes,
+    this.pseudoSharedCode,
     this.severity = CfeSeverity.error,
   });
 
@@ -83,7 +98,7 @@ class MessageCode extends Code implements Message {
   const MessageCode(
     super.name, {
     super.index,
-    super.analyzerCodes,
+    super.pseudoSharedCode,
     super.severity,
     required this.problemMessage,
     this.correctionMessage,
@@ -124,7 +139,7 @@ class Template<TOld extends Function, T extends Function> extends Code {
     required this.withArgumentsOld,
     required this.withArguments,
     super.index = -1,
-    super.analyzerCodes,
+    super.pseudoSharedCode,
     super.severity = CfeSeverity.error,
   });
 

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

@@ -30,12 +30,12 @@ void translateErrorToken(ErrorToken token, ReportError reportError) {
   }
 
   Code errorCode = token.errorCode;
-  switch (errorCode.analyzerCodes?.first) {
-    case AnalyzerCode.encoding:
+  switch (errorCode.pseudoSharedCode) {
+    case PseudoSharedCode.encoding:
       reportError(ScannerErrorCode.encoding, charOffset, null);
       return;
 
-    case AnalyzerCode.unterminatedStringLiteral:
+    case PseudoSharedCode.unterminatedStringLiteral:
       // TODO(paulberry,ahe): Fasta reports the error location as the entire
       // string; analyzer expects the end of the string.
       reportError(
@@ -45,7 +45,7 @@ void translateErrorToken(ErrorToken token, ReportError reportError) {
       );
       return;
 
-    case AnalyzerCode.unterminatedMultiLineComment:
+    case PseudoSharedCode.unterminatedMultiLineComment:
       // TODO(paulberry,ahe): Fasta reports the error location as the entire
       // comment; analyzer expects the end of the comment.
       reportError(
@@ -55,27 +55,27 @@ void translateErrorToken(ErrorToken token, ReportError reportError) {
       );
       return;
 
-    case AnalyzerCode.missingDigit:
+    case PseudoSharedCode.missingDigit:
       // TODO(paulberry,ahe): Fasta reports the error location as the entire
       // number; analyzer expects the end of the number.
       charOffset = endOffset - 1;
       return _makeError(ScannerErrorCode.missingDigit, null);
 
-    case AnalyzerCode.missingHexDigit:
+    case PseudoSharedCode.missingHexDigit:
       // TODO(paulberry,ahe): Fasta reports the error location as the entire
       // number; analyzer expects the end of the number.
       charOffset = endOffset - 1;
       return _makeError(ScannerErrorCode.missingHexDigit, null);
 
-    case AnalyzerCode.illegalCharacter:
+    case PseudoSharedCode.illegalCharacter:
       // We can safely assume `token.character` is non-`null` because this error
       // is only reported when there is a character associated with the token.
       return _makeError(ScannerErrorCode.illegalCharacter, [token.character!]);
 
-    case AnalyzerCode.unexpectedSeparatorInNumber:
+    case PseudoSharedCode.unexpectedSeparatorInNumber:
       return _makeError(ScannerErrorCode.unexpectedSeparatorInNumber, null);
 
-    case AnalyzerCode.unsupportedOperator:
+    case PseudoSharedCode.unsupportedOperator:
       return _makeError(ScannerErrorCode.unsupportedOperator, [
         (token as UnsupportedOperator).token.lexeme,
       ]);
@@ -101,7 +101,7 @@ void translateErrorToken(ErrorToken token, ReportError reportError) {
         return _makeError(ScannerErrorCode.missingIdentifier, null);
       }
       throw new UnimplementedError(
-        '$errorCode "${errorCode.analyzerCodes?.first}"',
+        '$errorCode "${errorCode.pseudoSharedCode}"',
       );
   }
 }

pkg/_fe_analyzer_shared/lib/src/scanner/errors.dart

@@ -31,7 +31,7 @@ import 'package:_fe_analyzer_shared/src/messages/codes.dart'
         codeExperimentNotEnabled,
         codeExtraneousModifier,
         codeInternalProblemUnhandled,
-        AnalyzerCode;
+        PseudoSharedCode;
 import 'package:_fe_analyzer_shared/src/parser/parser.dart'
     show
         Assert,
@@ -223,10 +223,8 @@ class AstBuilder extends StackListener {
     List<LocatedMessage>? context,
   }) {
     if (directives.isEmpty &&
-        (message.code.analyzerCodes?.contains(
-              AnalyzerCode.nonPartOfDirectiveInPart,
-            ) ??
-            false)) {
+        message.code.pseudoSharedCode ==
+            PseudoSharedCode.nonPartOfDirectiveInPart) {
       message = codeDirectiveAfterDeclaration;
     }
     diagnosticReporter.reportMessage(message, charOffset, length);
@@ -5632,7 +5630,7 @@ class AstBuilder extends StackListener {
       if (isDartLibrary) return;
     }
     debugEvent("Error: ${message.problemMessage}");
-    if (message.code.analyzerCodes == null && startToken is ErrorToken) {
+    if (message.code.pseudoSharedCode == null && startToken is ErrorToken) {
       translateErrorToken(startToken, diagnosticReporter.reportScannerError);
     } else {
       int offset = startToken.offset;