[messages] Extract computation of constantStyle.

Extracts the computation of `concreteClassName` and `staticType` from
`MessageWithAnalyzerCode.toAnalyzerCode` to a late field,
`constantStyle`, that encapsulates these values. The late field also
captures information about what kind of diagnostic constant should be
code generated, and if it should be a diagnostic constant that
supports `withArguments`, what the parameters of `withArguments`
should be.

This paves the way for a follow-up CL that will move the diagnostic
constants to top level declarations; this logic will require multiple
methods in `MessageWithAnalyzerCode` to refer to the constant style.

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

Author: stereotype441

pkg/analyzer_utilities/lib/analyzer_message_constant_style.dart

@@ -0,0 +1,51 @@
+// Copyright (c) 2025, 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.
+
+/// Encapsulates information about how to generate an analyzer diagnostic
+/// message constant, including the style of constant to generate (e.g. with
+/// arguments or without) and the classes that should be referenced by the
+/// generated code.
+sealed class ConstantStyle {
+  /// The concrete class name that should be used to construct the constant.
+  final String concreteClassName;
+
+  /// The static type of the constant that should be generated.
+  final String staticType;
+
+  ConstantStyle({required this.concreteClassName, required this.staticType});
+}
+
+/// [ConstantStyle] object indicating that an "old style" constant should be
+/// generated (one that does not support the new analyzer literate API for
+/// constants).
+// TODO(paulberry): finish supporting the literate API in all analyzer messages
+// and eliminate this.
+class OldConstantStyle extends ConstantStyle {
+  OldConstantStyle({
+    required super.concreteClassName,
+    required super.staticType,
+  });
+}
+
+/// [ConstantStyle] object indicating that a constant should be generated that
+/// supports a `.withArguments` getter.
+class WithArgumentsConstantStyle extends ConstantStyle {
+  /// The parameters that should be accepted by the `.withArguments` getter.
+  final String withArgumentsParams;
+
+  WithArgumentsConstantStyle({
+    required super.concreteClassName,
+    required super.staticType,
+    required this.withArgumentsParams,
+  });
+}
+
+/// [ConstantStyle] object indicating that a constant should be generated that
+/// doesn't require any arguments.
+class WithoutArgumentsConstantStyle extends ConstantStyle {
+  WithoutArgumentsConstantStyle({
+    required super.concreteClassName,
+    required super.staticType,
+  });
+}

pkg/analyzer_utilities/lib/analyzer_messages.dart

@@ -9,6 +9,7 @@ import 'dart:convert';
 import 'dart:io';
 
 import 'package:analyzer_testing/package_root.dart' as pkg_root;
+import 'package:analyzer_utilities/analyzer_message_constant_style.dart';
 import 'package:analyzer_utilities/extensions/string.dart';
 import 'package:analyzer_utilities/messages.dart';
 import 'package:analyzer_utilities/tools.dart';
@@ -550,6 +551,42 @@ class DiagnosticClassInfo {
 /// Interface class for diagnostic messages that have an analyzer code, and thus
 /// can be reported by the analyzer.
 mixin MessageWithAnalyzerCode on Message {
+  late ConstantStyle constantStyle = () {
+    var usesParameters = [problemMessage, correctionMessage].any(
+      (value) =>
+          value != null && value.any((part) => part is TemplateParameterPart),
+    );
+    var baseClasses = analyzerCode.diagnosticClass.type.baseClasses;
+    if (parameters.isNotEmpty && !usesParameters) {
+      throw 'Error code declares parameters using a `parameters` entry, but '
+          "doesn't use them";
+    } else if (parameters.values.any((p) => !p.type.isSupportedByAnalyzer)) {
+      // Do not generate literate API yet.
+      return OldConstantStyle(
+        concreteClassName: baseClasses.withExpectedTypesClass,
+        staticType: 'DiagnosticCode',
+      );
+    } else if (parameters.isNotEmpty) {
+      // Parameters are present so generate a diagnostic template (with
+      // `.withArguments` support).
+      var withArgumentsParams = parameters.entries
+          .map((p) => 'required ${p.value.type.analyzerName} ${p.key}')
+          .join(', ');
+      var templateParameters =
+          '<LocatableDiagnostic Function({$withArgumentsParams})>';
+      return WithArgumentsConstantStyle(
+        concreteClassName: baseClasses.withArgumentsClass,
+        staticType: 'DiagnosticWithArguments$templateParameters',
+        withArgumentsParams: withArgumentsParams,
+      );
+    } else {
+      return WithoutArgumentsConstantStyle(
+        concreteClassName: baseClasses.withoutArgumentsImplClass,
+        staticType: baseClasses.withoutArgumentsClass,
+      );
+    }
+  }();
+
   late final DiagnosticClassInfo diagnosticClassInfo =
       analyzerCode.diagnosticClass;
 
@@ -583,44 +620,20 @@ mixin MessageWithAnalyzerCode on Message {
   }) {
     var diagnosticCode = analyzerCode.snakeCaseName;
     var correctionMessage = this.correctionMessage;
-    var parameters = this.parameters;
-    var usesParameters = [problemMessage, correctionMessage].any(
-      (value) =>
-          value != null && value.any((part) => part is TemplateParameterPart),
-    );
-    String concreteClassName;
-    String staticType;
     String? withArgumentsName;
     var baseClasses = analyzerCode.diagnosticClass.type.baseClasses;
-    if (parameters.isNotEmpty && !usesParameters) {
-      throw 'Error code declares parameters using a `parameters` entry, but '
-          "doesn't use them";
-    } else if (parameters.values.any((p) => !p.type.isSupportedByAnalyzer)) {
-      // Do not generate literate API yet.
-      concreteClassName = baseClasses.withExpectedTypesClass;
-      staticType = 'DiagnosticCode';
-    } else if (parameters.isNotEmpty) {
-      // Parameters are present so generate a diagnostic template (with
-      // `.withArguments` support).
-      concreteClassName = baseClasses.withArgumentsClass;
-      var withArgumentsParams = parameters.entries
-          .map((p) => 'required ${p.value.type.analyzerName} ${p.key}')
-          .join(', ');
+    var ConstantStyle(:concreteClassName, :staticType) = constantStyle;
+    if (constantStyle case WithArgumentsConstantStyle(
+      :var withArgumentsParams,
+    )) {
       var argumentNames = parameters.keys.join(', ');
       withArgumentsName = '_withArguments${analyzerCode.pascalCaseName}';
-      var templateParameters =
-          '<LocatableDiagnostic Function({$withArgumentsParams})>';
-      staticType = 'DiagnosticWithArguments$templateParameters';
       memberAccumulator.staticMethods[withArgumentsName] =
           '''
 static LocatableDiagnostic $withArgumentsName({$withArgumentsParams}) {
   return LocatableDiagnosticImpl(
     ${diagnosticClassInfo.name}.$constantName, [$argumentNames]);
 }''';
-    } else {
-      // Parameters are not present so generate a "withoutArguments" constant.
-      concreteClassName = baseClasses.withoutArgumentsImplClass;
-      staticType = baseClasses.withoutArgumentsClass;
     }
 
     var constant = StringBuffer();