[messages] Generalize runtime types of analyzer message constants.

Changes the runtime types of the diagnostic message constants for the
analyzer from derived classes like `ParserErrorWithoutArguments`,
`ParserErrorTemplate`, or `ParserErrorCode` to the corresponding base
classes (`DiagnosticWithoutArgumentsImpl`, `DiagnosticWithArguments`,
or `DiagnosticCodeWithExpectedTypes`). The static types of the
constants are unchanged.

This allows the generated `...Template` classes (which derived from
`DiagnosticWithArguments`) and `...WithoutArguments` classes (which
used `DiagnosticWithoutArguments` as a mixin) to be removed.

Classes such as `ParserErrorCode`, `WarningCode`, etc. remain, but
they are now used solely as namespaces for the generated
constants. They will be removed in a later CL.

The runtime types of the diagnostic message constants for lints are
not changed. They remain `LinterLintWithoutArguments`,
`LinterLintTemplate`, and `LinterLintCode`, so that clients of the
analyzer public API can still identify lint codes by checking whether
they are subtypes of the public API class `LintCode`.

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

Author: stereotype441

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

@@ -337,7 +337,7 @@ abstract class DiagnosticCodeImpl extends DiagnosticCode {
 
 /// Private subtype of [DiagnosticCode] that supports runtime checking of
 /// parameter types.
-abstract class DiagnosticCodeWithExpectedTypes extends DiagnosticCodeImpl {
+class DiagnosticCodeWithExpectedTypes extends DiagnosticCodeImpl {
   final List<ExpectedType>? expectedTypes;
 
   const DiagnosticCodeWithExpectedTypes({
@@ -568,15 +568,27 @@ class DiagnosticType implements Comparable<DiagnosticType> {
 ///
 /// This class provides a [withArguments] getter, which can be used to supply
 /// arguments and produce a [LocatableDiagnostic].
-abstract class DiagnosticWithArguments<T extends Function>
-    implements DiagnosticCode {
+class DiagnosticWithArguments<T extends Function>
+    extends DiagnosticCodeWithExpectedTypes {
   /// Function accepting named arguments and returning [LocatableDiagnostic].
   ///
   /// The value returned by this function can
   /// be associated with a location in the source code using the
   /// [LocatableDiagnostic.at] method, and then the result can be passed to
   /// [DiagnosticReporter.reportError].
-  T get withArguments;
+  final T withArguments;
+
+  const DiagnosticWithArguments({
+    required super.name,
+    required super.problemMessage,
+    super.correctionMessage,
+    super.hasPublishedDocs = false,
+    super.isUnresolvedIdentifier = false,
+    required super.type,
+    required super.uniqueName,
+    required super.expectedTypes,
+    required this.withArguments,
+  });
 }
 
 /// Common functionality for [DiagnosticCode]-derived classes that represent
@@ -609,6 +621,26 @@ base mixin DiagnosticWithoutArguments on DiagnosticCodeImpl
       new LocatableDiagnosticImpl(code, arguments, contextMessages: messages);
 }
 
+/// Concrete implementation of [DiagnosticWithoutArguments], used for diagnostic
+/// messages that don't take any arguments.
+///
+/// This needs to be a separate class from [DiagnosticWithoutArguments] because
+/// [DiagnosticWithoutArguments] is a mixin.
+final class DiagnosticWithoutArgumentsImpl
+    extends DiagnosticCodeWithExpectedTypes
+    with DiagnosticWithoutArguments {
+  const DiagnosticWithoutArgumentsImpl({
+    required super.name,
+    required super.problemMessage,
+    super.correctionMessage,
+    super.hasPublishedDocs = false,
+    super.isUnresolvedIdentifier = false,
+    required super.type,
+    required super.uniqueName,
+    super.expectedTypes,
+  });
+}
+
 /// Expected type of a diagnostic code's parameter.
 enum ExpectedType { element, int, name, object, string, token, type, uri }
 

pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_error_code.g.dart

@@ -26,19 +26,21 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0, required Object p1})
   >
-  conflictingKey = TransformSetErrorTemplate(
+  conflictingKey = DiagnosticWithArguments(
     name: 'conflicting_key',
     problemMessage: "The key '{0}' can't be used when '{1}' is also used.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.conflicting_key',
     withArguments: _withArgumentsConflictingKey,
     expectedTypes: [ExpectedType.object, ExpectedType.object],
   );
 
   /// No parameters.
   static const DiagnosticWithoutArguments expectedPrimary =
-      TransformSetErrorWithoutArguments(
+      DiagnosticWithoutArgumentsImpl(
         name: 'expected_primary',
         problemMessage: "Expected either an identifier or a string literal.",
+        type: DiagnosticType.COMPILE_TIME_ERROR,
         uniqueName: 'TransformSetErrorCode.expected_primary',
         expectedTypes: [],
       );
@@ -49,10 +51,11 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0, required Object p1})
   >
-  incompatibleElementKind = TransformSetErrorTemplate(
+  incompatibleElementKind = DiagnosticWithArguments(
     name: 'incompatible_element_kind',
     problemMessage:
         "An element of kind '{0}' can't be replaced by an element of kind '{1}'.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.incompatible_element_kind',
     withArguments: _withArgumentsIncompatibleElementKind,
     expectedTypes: [ExpectedType.object, ExpectedType.object],
@@ -64,10 +67,11 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0, required Object p1})
   >
-  invalidChangeForKind = TransformSetErrorTemplate(
+  invalidChangeForKind = DiagnosticWithArguments(
     name: 'invalid_change_for_kind',
     problemMessage:
         "A change of type '{0}' can't be used for an element of kind '{1}'.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.invalid_change_for_kind',
     withArguments: _withArgumentsInvalidChangeForKind,
     expectedTypes: [ExpectedType.object, ExpectedType.object],
@@ -78,9 +82,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  invalidCharacter = TransformSetErrorTemplate(
+  invalidCharacter = DiagnosticWithArguments(
     name: 'invalid_character',
     problemMessage: "Invalid character '{0}'.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.invalid_character',
     withArguments: _withArgumentsInvalidCharacter,
     expectedTypes: [ExpectedType.object],
@@ -91,9 +96,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  invalidKey = TransformSetErrorTemplate(
+  invalidKey = DiagnosticWithArguments(
     name: 'invalid_key',
     problemMessage: "Keys must be of type 'String' but found the type '{0}'.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.invalid_key',
     withArguments: _withArgumentsInvalidKey,
     expectedTypes: [ExpectedType.object],
@@ -104,20 +110,22 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  invalidParameterStyle = TransformSetErrorTemplate(
+  invalidParameterStyle = DiagnosticWithArguments(
     name: 'invalid_parameter_style',
     problemMessage: "The parameter style must be one of the following: {0}.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.invalid_parameter_style',
     withArguments: _withArgumentsInvalidParameterStyle,
     expectedTypes: [ExpectedType.object],
   );
 
   /// No parameters.
   static const DiagnosticWithoutArguments
-  invalidRequiredIf = TransformSetErrorWithoutArguments(
+  invalidRequiredIf = DiagnosticWithoutArgumentsImpl(
     name: 'invalid_required_if',
     problemMessage:
         "The key 'requiredIf' can only be used with optional named parameters.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.invalid_required_if',
     expectedTypes: [],
   );
@@ -133,10 +141,11 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
       required Object p2,
     })
   >
-  invalidValue = TransformSetErrorTemplate(
+  invalidValue = DiagnosticWithArguments(
     name: 'invalid_value',
     problemMessage:
         "The value of '{0}' should be of type '{1}' but is of type '{2}'.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.invalid_value',
     withArguments: _withArgumentsInvalidValue,
     expectedTypes: [
@@ -152,9 +161,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0, required Object p1})
   >
-  invalidValueOneOf = TransformSetErrorTemplate(
+  invalidValueOneOf = DiagnosticWithArguments(
     name: 'invalid_value_one_of',
     problemMessage: "The value of '{0}' must be one of the following: '{1}'.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.invalid_value_one_of',
     withArguments: _withArgumentsInvalidValueOneOf,
     expectedTypes: [ExpectedType.object, ExpectedType.object],
@@ -165,9 +175,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  missingKey = TransformSetErrorTemplate(
+  missingKey = DiagnosticWithArguments(
     name: 'missing_key',
     problemMessage: "Missing the required key '{0}'.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.missing_key',
     withArguments: _withArgumentsMissingKey,
     expectedTypes: [ExpectedType.object],
@@ -178,19 +189,21 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  missingOneOfMultipleKeys = TransformSetErrorTemplate(
+  missingOneOfMultipleKeys = DiagnosticWithArguments(
     name: 'missing_one_of_multiple_keys',
     problemMessage: "Exactly one of the following keys must be provided: {0}.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.missing_one_of_multiple_keys',
     withArguments: _withArgumentsMissingOneOfMultipleKeys,
     expectedTypes: [ExpectedType.object],
   );
 
   /// No parameters.
   static const DiagnosticWithoutArguments missingTemplateEnd =
-      TransformSetErrorWithoutArguments(
+      DiagnosticWithoutArgumentsImpl(
         name: 'missing_template_end',
         problemMessage: "Missing the end brace for the template.",
+        type: DiagnosticType.COMPILE_TIME_ERROR,
         uniqueName: 'TransformSetErrorCode.missing_template_end',
         expectedTypes: [],
       );
@@ -200,19 +213,21 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  missingToken = TransformSetErrorTemplate(
+  missingToken = DiagnosticWithArguments(
     name: 'missing_token',
     problemMessage: "Expected to find {0}.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.missing_token',
     withArguments: _withArgumentsMissingToken,
     expectedTypes: [ExpectedType.object],
   );
 
   /// No parameters.
   static const DiagnosticWithoutArguments missingUri =
-      TransformSetErrorWithoutArguments(
+      DiagnosticWithoutArgumentsImpl(
         name: 'missing_uri',
         problemMessage: "At least one URI must be provided.",
+        type: DiagnosticType.COMPILE_TIME_ERROR,
         uniqueName: 'TransformSetErrorCode.missing_uri',
         expectedTypes: [],
       );
@@ -222,9 +237,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  undefinedVariable = TransformSetErrorTemplate(
+  undefinedVariable = DiagnosticWithArguments(
     name: 'undefined_variable',
     problemMessage: "The variable '{0}' isn't defined.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.undefined_variable',
     withArguments: _withArgumentsUndefinedVariable,
     expectedTypes: [ExpectedType.object],
@@ -235,9 +251,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  unexpectedTransformSetToken = TransformSetErrorTemplate(
+  unexpectedTransformSetToken = DiagnosticWithArguments(
     name: 'unexpected_transform_set_token',
     problemMessage: "Didn't expect to find {0}.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.unexpected_transform_set_token',
     withArguments: _withArgumentsUnexpectedTransformSetToken,
     expectedTypes: [ExpectedType.object],
@@ -248,9 +265,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  unknownAccessor = TransformSetErrorTemplate(
+  unknownAccessor = DiagnosticWithArguments(
     name: 'unknown_accessor',
     problemMessage: "The accessor '{0}' is invalid.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.unknown_accessor',
     withArguments: _withArgumentsUnknownAccessor,
     expectedTypes: [ExpectedType.object],
@@ -261,30 +279,33 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  unsupportedKey = TransformSetErrorTemplate(
+  unsupportedKey = DiagnosticWithArguments(
     name: 'unsupported_key',
     problemMessage: "The key '{0}' isn't supported.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.unsupported_key',
     withArguments: _withArgumentsUnsupportedKey,
     expectedTypes: [ExpectedType.object],
   );
 
   /// No parameters.
   static const DiagnosticWithoutArguments unsupportedStatic =
-      TransformSetErrorWithoutArguments(
+      DiagnosticWithoutArgumentsImpl(
         name: 'unsupported_static',
         problemMessage:
             "The key 'static' is only supported for elements in a class, enum, "
             "extension, or mixin.",
+        type: DiagnosticType.COMPILE_TIME_ERROR,
         uniqueName: 'TransformSetErrorCode.unsupported_static',
         expectedTypes: [],
       );
 
   /// No parameters.
   static const DiagnosticWithoutArguments unsupportedVersion =
-      TransformSetErrorWithoutArguments(
+      DiagnosticWithoutArgumentsImpl(
         name: 'unsupported_version',
         problemMessage: "Only version '1' is supported at this time.",
+        type: DiagnosticType.COMPILE_TIME_ERROR,
         uniqueName: 'TransformSetErrorCode.unsupported_version',
         expectedTypes: [],
       );
@@ -295,9 +316,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0, required Object p1})
   >
-  wrongToken = TransformSetErrorTemplate(
+  wrongToken = DiagnosticWithArguments(
     name: 'wrong_token',
     problemMessage: "Expected to find {0}, but found {1}.",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.wrong_token',
     withArguments: _withArgumentsWrongToken,
     expectedTypes: [ExpectedType.object, ExpectedType.object],
@@ -308,9 +330,10 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
   static const DiagnosticWithArguments<
     LocatableDiagnostic Function({required Object p0})
   >
-  yamlSyntaxError = TransformSetErrorTemplate(
+  yamlSyntaxError = DiagnosticWithArguments(
     name: 'yaml_syntax_error',
     problemMessage: "Parse error: {0}",
+    type: DiagnosticType.COMPILE_TIME_ERROR,
     uniqueName: 'TransformSetErrorCode.yaml_syntax_error',
     withArguments: _withArgumentsYamlSyntaxError,
     expectedTypes: [ExpectedType.object],
@@ -459,36 +482,3 @@ class TransformSetErrorCode extends DiagnosticCodeWithExpectedTypes {
     return LocatableDiagnosticImpl(TransformSetErrorCode.yamlSyntaxError, [p0]);
   }
 }
-
-final class TransformSetErrorTemplate<T extends Function>
-    extends TransformSetErrorCode
-    implements DiagnosticWithArguments<T> {
-  @override
-  final T withArguments;
-
-  /// Initialize a newly created error code to have the given [name].
-  const TransformSetErrorTemplate({
-    required super.name,
-    required super.problemMessage,
-    super.correctionMessage,
-    super.hasPublishedDocs = false,
-    super.isUnresolvedIdentifier = false,
-    required super.uniqueName,
-    required super.expectedTypes,
-    required this.withArguments,
-  });
-}
-
-final class TransformSetErrorWithoutArguments extends TransformSetErrorCode
-    with DiagnosticWithoutArguments {
-  /// Initialize a newly created error code to have the given [name].
-  const TransformSetErrorWithoutArguments({
-    required super.name,
-    required super.problemMessage,
-    super.correctionMessage,
-    super.hasPublishedDocs = false,
-    super.isUnresolvedIdentifier = false,
-    required super.uniqueName,
-    required super.expectedTypes,
-  });
-}