Add parsing for 'fn destroy' (#5045)

Syntax is proposed in #5017, but has already been discussed with leads.
Semantics is left as a TODO.

---------

Co-authored-by: josh11b <15258583+josh11b@users.noreply.github.com>

toolchain/parse/handle_decl_name_and_params.cpp

@@ -2,67 +2,87 @@
 // Exceptions. See /LICENSE for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#include "toolchain/lex/token_index.h"
 #include "toolchain/parse/context.h"
 #include "toolchain/parse/handle.h"
 
 namespace Carbon::Parse {
 
-auto HandleDeclNameAndParams(Context& context) -> void {
-  auto state = context.PopState();
-
-  auto identifier = context.ConsumeIf(Lex::TokenKind::Identifier);
-  if (!identifier) {
-    Lex::TokenIndex token = *context.position();
-    if (context.tokens().GetKind(token) == Lex::TokenKind::FileEnd) {
-      // The end of file is an unhelpful diagnostic location. Instead, use the
-      // introducer token.
-      token = state.token;
-    }
-    if (state.token == *context.position()) {
-      CARBON_DIAGNOSTIC(ExpectedDeclNameAfterPeriod, Error,
-                        "`.` should be followed by a name");
-      context.emitter().Emit(token, ExpectedDeclNameAfterPeriod);
-    } else {
-      CARBON_DIAGNOSTIC(ExpectedDeclName, Error,
-                        "`{0}` introducer should be followed by a name",
-                        Lex::TokenKind);
-      context.emitter().Emit(token, ExpectedDeclName,
-                             context.tokens().GetKind(state.token));
-    }
-    context.ReturnErrorOnState();
-    context.AddInvalidParse(*context.position());
-    return;
-  }
-
+// Adds a leaf node for the name, and updates the state stack for parameter
+// handling.
+static auto HandleName(Context& context, Context::StateStackEntry state,
+                       Lex::TokenIndex name_token,
+                       NodeKind not_before_params_kind,
+                       NodeKind not_before_params_qualifier_kind,
+                       NodeKind before_params_kind) -> void {
   switch (context.PositionKind()) {
     case Lex::TokenKind::Period:
-      context.AddLeafNode(NodeKind::IdentifierNameNotBeforeParams, *identifier);
-      context.AddNode(NodeKind::NameQualifierWithoutParams,
+      context.AddLeafNode(not_before_params_kind, name_token);
+      context.AddNode(not_before_params_qualifier_kind,
                       context.ConsumeChecked(Lex::TokenKind::Period),
                       state.has_error);
       context.PushState(State::DeclNameAndParams);
       break;
 
     case Lex::TokenKind::OpenSquareBracket:
-      context.AddLeafNode(NodeKind::IdentifierNameBeforeParams, *identifier);
+      context.AddLeafNode(before_params_kind, name_token);
       state.state = State::DeclNameAndParamsAfterImplicit;
       context.PushState(state);
       context.PushState(State::PatternListAsImplicit);
       break;
 
     case Lex::TokenKind::OpenParen:
-      context.AddLeafNode(NodeKind::IdentifierNameBeforeParams, *identifier);
+      context.AddLeafNode(before_params_kind, name_token);
       state.state = State::DeclNameAndParamsAfterParams;
       context.PushState(state);
       context.PushState(State::PatternListAsExplicit);
       break;
 
     default:
-      context.AddLeafNode(NodeKind::IdentifierNameNotBeforeParams, *identifier);
+      context.AddLeafNode(not_before_params_kind, name_token);
       break;
   }
 }
 
+auto HandleDeclNameAndParams(Context& context) -> void {
+  auto state = context.PopState();
+
+  if (auto identifier = context.ConsumeIf(Lex::TokenKind::Identifier)) {
+    HandleName(context, state, *identifier,
+               NodeKind::IdentifierNameNotBeforeParams,
+               NodeKind::IdentifierNameQualifierWithoutParams,
+               NodeKind::IdentifierNameBeforeParams);
+    return;
+  }
+
+  if (auto keyword = context.ConsumeIf(Lex::TokenKind::Destroy)) {
+    HandleName(context, state, *keyword, NodeKind::KeywordNameNotBeforeParams,
+               NodeKind::KeywordNameQualifierWithoutParams,
+               NodeKind::KeywordNameBeforeParams);
+    return;
+  }
+
+  Lex::TokenIndex token = *context.position();
+  if (context.tokens().GetKind(token) == Lex::TokenKind::FileEnd) {
+    // The end of file is an unhelpful diagnostic location. Instead, use the
+    // introducer token.
+    token = state.token;
+  }
+  if (state.token == *context.position()) {
+    CARBON_DIAGNOSTIC(ExpectedDeclNameAfterPeriod, Error,
+                      "`.` should be followed by a name");
+    context.emitter().Emit(token, ExpectedDeclNameAfterPeriod);
+  } else {
+    CARBON_DIAGNOSTIC(ExpectedDeclName, Error,
+                      "`{0}` introducer should be followed by a name",
+                      Lex::TokenKind);
+    context.emitter().Emit(token, ExpectedDeclName,
+                           context.tokens().GetKind(state.token));
+  }
+  context.ReturnErrorOnState();
+  context.AddInvalidParse(*context.position());
+}
+
 auto HandleDeclNameAndParamsAfterImplicit(Context& context) -> void {
   auto state = context.PopState();