[front end] Use code... instead of template....

This is part of a series of CLs that will standardize CFE error
reporting to always use `codeFoo.withArguments(...)` when reporting
errors that take arguments and `codeFoo` when reporting errors that
don't take arguments, rather than `templateFoo.withArguments(...)`
when reporting errors that take arguments and `messageFoo` when
reporting errors that don't take arguments. This change will have two
advantages:

- It will lend greater consistency to the CFE codebase, by allowing
  the same `code...` objects to be used both to name error codes
  (e.g., in test expectations) and to report errors. This will allow
  everything associated with a certain error code to be found using a
  single invocation of "Find References" in the editor, rather than
  having to search separately for uses of the code and the message or
  template.

- It should hopefully make the experience of writing code that reports
  errors more pleasant, since it will no longer be necessary to look
  up an error to see whether it takes arguments before using it;
  instead, the developer will be able to type the name of the message
  `code...` declaration, and then use autocompletion to see whether
  `.withArguments(...)` is required.

In this CL, the references to the `template...` declarations that
define errors are changed to the equivalent `code...`
declarations. There is no functional change, since these declarations
denote the same constant object. In follow-up CLs, the `template...`
declarations will be removed, and then a similar set of changes will
be made to replace references to `message...` declarations with
references to the corresponding `code...` declaration.

Tested: normal trybots
Change-Id: I178bd2072349088f342bc39cfc789bcb5c7ef19e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/442732
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Srujan Gaddam <[email protected]>
Reviewed-by: Derek Xu <[email protected]>

Author: stereotype441

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

@@ -9,12 +9,12 @@ import 'flags.dart';
 /// enabled.
 Message getExperimentNotEnabledMessage(ExperimentalFlag experimentalFlag) {
   if (experimentalFlag.isEnabledByDefault) {
-    return templateExperimentNotEnabled.withArguments(
+    return codeExperimentNotEnabled.withArguments(
       experimentalFlag.name,
       experimentalFlag.experimentEnabledVersion.toText(),
     );
   } else {
-    return templateExperimentNotEnabledOffByDefault.withArguments(
+    return codeExperimentNotEnabledOffByDefault.withArguments(
       experimentalFlag.name,
     );
   }

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

@@ -27,7 +27,7 @@ class BlockKind {
   );
   static const BlockKind enumDeclaration = const BlockKind._(
     'enum declaration',
-    template: codes.templateExpectedEnumBody,
+    template: codes.codeExpectedEnumBody,
   );
   static const BlockKind extensionDeclaration = const BlockKind._(
     'extension declaration',
@@ -43,7 +43,7 @@ class BlockKind {
   );
   static const BlockKind functionBody = const BlockKind._(
     'function body',
-    template: codes.templateExpectedFunctionBody,
+    template: codes.codeExpectedFunctionBody,
   );
   static const BlockKind invalid = const BlockKind._('invalid');
   static const BlockKind mixinDeclaration = const BlockKind._(

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

@@ -2,8 +2,7 @@
 // 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.
 
-import '../messages/codes.dart'
-    show Message, Template, templateExpectedIdentifier;
+import '../messages/codes.dart' show Message, Template, codeExpectedIdentifier;
 
 import '../scanner/token.dart'
     show Keyword, Token, TokenIsAExtension, TokenType;
@@ -301,7 +300,7 @@ abstract class IdentifierContext {
     this.isScopeReference = false,
     this.isBuiltInIdentifierAllowed = true,
     bool? allowedInConstantExpression,
-    this.recoveryTemplate = templateExpectedIdentifier,
+    this.recoveryTemplate = codeExpectedIdentifier,
   }) : this.allowedInConstantExpression =
            // Generally, declarations are legal in constant expressions.  A
            // continuation doesn't affect constant expressions: if what it's