Replace :! binding syntax with phase keywords and contextual defaults (#7479)

Implement the toolchain side of proposal #7254, removing the `:!`
binding
syntax for generic and template parameters in favor of the keywords
`generic`,
`template`, and `runtime` plus contextual defaults for phase.

For valid programs this is semantics-preserving: each binding resolves
to the
same phase, and produces the same SemIR, as it did under `:!`/`:`. The
parser
derives a binding's phase from its syntactic context plus any explicit
phase
keyword; new diagnostics and error recovery for misused keywords are
described
below.

Implementation details for each component:

- Lexer: remove the `:!` (`ColonExclaim`) token, move its virtual
parse-node
  budget onto `:`, and add the `generic` and `runtime` keywords.
- Parser: thread a `BindingContext` (`ExplicitParam`, `DeducedParam`, or
`CompileTimeEntityParam`) from declaration introducers down through
parameter
lists to each binding pattern, using a one-token lookahead to
distinguish a
name-qualifier parameter list from a declaration's own final list.
Parameters
of a compile-time entity (`class`, `interface`, `constraint`, `choice`,
`alias`, `export`, `namespace`) and deduced `[]` parameters default to
checked
generic; explicit function parameters and local bindings default to
runtime.
`HandleBindingPattern` resolves the phase from that context plus the
keyword: a
`generic` keyword needs no node of its own (the phase is carried by the
  binding's node kind), while a `runtime` keyword is preserved as a
`RuntimeBindingName` node so `check` can name it in a diagnostic. A
phase
keyword that is merely redundant with the contextual default is
diagnosed
  here, without invalidating the parse tree.
- Check: a phase keyword that is invalid for its context (for example
`runtime`
on a checked-generic parameter) is diagnosed here, and recovers by
building an
error binding that still introduces the name so that later uses of it do
not
  produce cascading errors.

The removed `:!` syntax is now rejected as an ordinary parse error.

The `form`/`:?`/`->?` ("extended types") portion of proposal #7254 is
left for a
separate change.

Assisted-by: Claude Code

toolchain/parse/handle_let.cpp

@@ -19,33 +19,47 @@ auto HandleLet(Context& context) -> void {
 
   context.PushStateForPattern(StateKind::Pattern, /*in_var_pattern=*/false,
                               /*in_unused_pattern=*/false,
+                              BindingContext::ExplicitParam,
                               PrecedenceGroup::ForTopLevelPattern());
 }
 
 auto HandleAssociatedConstant(Context& context) -> void {
   auto state = context.PopState();
 
-  // Parse the associated constant pattern: identifier :! type
+  // Parse the associated constant pattern: identifier : type. The binding is a
+  // checked generic by context, so no phase keyword is used.
   auto identifier = context.ConsumeIf(Lex::TokenKind::Identifier);
   if (!identifier) {
-    CARBON_DIAGNOSTIC(ExpectedAssociatedConstantIdentifier, Error,
-                      "expected identifier in associated constant declaration");
-    context.emitter().Emit(*context.position(),
-                           ExpectedAssociatedConstantIdentifier);
+    auto kind = context.PositionKind();
+    if (kind == Lex::TokenKind::Generic || kind == Lex::TokenKind::Runtime ||
+        kind == Lex::TokenKind::Template) {
+      // Diagnose a phase keyword specifically, rather than reporting a missing
+      // associated constant name.
+      CARBON_DIAGNOSTIC(
+          PhaseKeywordInAssociatedConstant, Error,
+          "phase keyword is not allowed on an associated constant");
+      context.emitter().Emit(*context.position(),
+                             PhaseKeywordInAssociatedConstant);
+    } else {
+      CARBON_DIAGNOSTIC(
+          ExpectedAssociatedConstantIdentifier, Error,
+          "expected identifier in associated constant declaration");
+      context.emitter().Emit(*context.position(),
+                             ExpectedAssociatedConstantIdentifier);
+    }
     state.has_error = true;
   }
 
-  auto colon_exclaim = context.ConsumeIf(Lex::TokenKind::ColonExclaim);
-  if (identifier && !colon_exclaim) {
-    CARBON_DIAGNOSTIC(ExpectedAssociatedConstantColonExclaim, Error,
-                      "found runtime binding pattern in associated constant "
-                      "declaration; expected a `:!` binding");
+  auto colon = context.ConsumeIf(Lex::TokenKind::Colon);
+  if (identifier && !colon) {
+    CARBON_DIAGNOSTIC(ExpectedAssociatedConstantColon, Error,
+                      "expected `:` in associated constant declaration");
     context.emitter().Emit(*context.position(),
-                           ExpectedAssociatedConstantColonExclaim);
+                           ExpectedAssociatedConstantColon);
     state.has_error = true;
   }
 
-  if (!identifier || !colon_exclaim) {
+  if (!identifier || !colon) {
     auto end_token = context.SkipPastLikelyEnd(*(context.position() - 1));
     context.AddNode(NodeKind::AssociatedConstantDecl, end_token,
                     /*has_error=*/true);
@@ -54,7 +68,7 @@ auto HandleAssociatedConstant(Context& context) -> void {
   }
 
   context.AddLeafNode(NodeKind::IdentifierNameNotBeforeSignature, *identifier);
-  state.token = *colon_exclaim;
+  state.token = *colon;
   context.PushState(state, StateKind::LetFinishAsAssociatedConstant);
   context.PushState(state, StateKind::LetAfterPatternAsAssociatedConstant);
   context.PushState(StateKind::Expr);