Drop fn destroy support (#6136)

`fn destroy` is being removed per decision on #6124. It seems like the
relevant decision will result in no more keyword-based function names,
so this is removing all related support.

Author: jonmeow

core/prelude/destroy.carbon

@@ -7,8 +7,8 @@ package Core library "prelude/destroy";
 import library "prelude/types/bool";
 import library "prelude/types/int_literal";
 
-// Object destruction, including running `fn destroy()`. Note this is distinct
-// from memory deallocation.
+// Destroys objects. Note this is distinct from memory deallocation.
+// TODO: Switch to `Destructor`+`Destroy` model.
 interface Destroy {
   fn Op[addr self: Self*]();
 }

toolchain/check/handle_function.cpp

@@ -64,9 +64,7 @@ auto HandleParseNode(Context& context, Parse::ReturnTypeId node_id) -> bool {
   // not on the pattern stacks yet. They are only needed in that case if we have
   // a return type, which we now know that we do.
   if (context.node_stack().PeekNodeKind() ==
-          Parse::NodeKind::IdentifierNameNotBeforeParams ||
-      context.node_stack().PeekNodeKind() ==
-          Parse::NodeKind::KeywordNameNotBeforeParams) {
+      Parse::NodeKind::IdentifierNameNotBeforeParams) {
     context.pattern_block_stack().Push();
     context.full_pattern_stack().PushFullPattern(
         FullPatternStack::Kind::ExplicitParamList);
@@ -365,81 +363,6 @@ static auto RequestVtableIfVirtual(
   context.vtable_stack().AddInstId(decl_id);
 }
 
-// Validates the `destroy` function's signature. May replace invalid values for
-// recovery.
-static auto ValidateIfDestroy(Context& context, bool is_redecl,
-                              std::optional<SemIR::Inst> parent_scope_inst,
-                              SemIR::Function& function_info) -> void {
-  if (function_info.name_id != SemIR::NameId::Destroy) {
-    return;
-  }
-
-  // For recovery, always force explicit parameters to be empty. We do this
-  // before any of the returns for simplicity.
-  auto orig_param_patterns_id = function_info.param_patterns_id;
-  function_info.param_patterns_id = SemIR::InstBlockId::Empty;
-
-  // Use differences on merge to diagnose remaining issues.
-  if (is_redecl) {
-    return;
-  }
-
-  if (!parent_scope_inst || !parent_scope_inst->Is<SemIR::ClassDecl>()) {
-    CARBON_DIAGNOSTIC(DestroyFunctionOutsideClass, Error,
-                      "declaring `fn destroy` in non-class scope");
-    context.emitter().Emit(function_info.latest_decl_id(),
-                           DestroyFunctionOutsideClass);
-    return;
-  }
-
-  if (!function_info.self_param_id.has_value()) {
-    CARBON_DIAGNOSTIC(DestroyFunctionMissingSelf, Error,
-                      "missing implicit `self` parameter");
-    context.emitter().Emit(function_info.latest_decl_id(),
-                           DestroyFunctionMissingSelf);
-    return;
-  }
-
-  // `self` must be the only implicit parameter.
-  if (auto block =
-          context.inst_blocks().Get(function_info.implicit_param_patterns_id);
-      block.size() > 1) {
-    // Point at the first non-`self` parameter.
-    auto param_id = block[function_info.self_param_id == block[0] ? 1 : 0];
-    CARBON_DIAGNOSTIC(DestroyFunctionUnexpectedImplicitParam, Error,
-                      "unexpected implicit parameter");
-    context.emitter().Emit(param_id, DestroyFunctionUnexpectedImplicitParam);
-    return;
-  }
-
-  if (!orig_param_patterns_id.has_value()) {
-    CARBON_DIAGNOSTIC(DestroyFunctionPositionalParams, Error,
-                      "missing empty explicit parameter list");
-    context.emitter().Emit(function_info.latest_decl_id(),
-                           DestroyFunctionPositionalParams);
-    return;
-  }
-
-  if (orig_param_patterns_id != SemIR::InstBlockId::Empty) {
-    CARBON_DIAGNOSTIC(DestroyFunctionNonEmptyExplicitParams, Error,
-                      "unexpected parameter");
-    context.emitter().Emit(context.inst_blocks().Get(orig_param_patterns_id)[0],
-                           DestroyFunctionNonEmptyExplicitParams);
-    return;
-  }
-
-  if (auto return_type_id =
-          function_info.GetDeclaredReturnType(context.sem_ir());
-      return_type_id.has_value() &&
-      return_type_id != GetTupleType(context, {})) {
-    CARBON_DIAGNOSTIC(DestroyFunctionIncorrectReturnType, Error,
-                      "incorrect return type; must be unspecified or `()`");
-    context.emitter().Emit(function_info.return_slot_pattern_id,
-                           DestroyFunctionIncorrectReturnType);
-    return;
-  }
-}
-
 // Diagnoses when positional params aren't supported. Reassigns the pattern
 // block if needed.
 static auto DiagnosePositionalParams(Context& context,
@@ -505,12 +428,6 @@ static auto BuildFunctionDecl(Context& context,
     function_info.definition_id = decl_id;
   }
 
-  // Analyze standard function signatures before positional parameters, so that
-  // we can have more specific diagnostics and recovery.
-  bool is_redecl =
-      name_context.state == DeclNameStack::NameContext::State::Resolved;
-  ValidateIfDestroy(context, is_redecl, parent_scope_inst, function_info);
-
   DiagnosePositionalParams(context, function_info);
 
   TryMergeRedecl(context, node_id, name_context, function_decl, function_info,

toolchain/check/handle_name.cpp

@@ -140,38 +140,6 @@ auto HandleParseNode(Context& context, Parse::IdentifierNameExprId node_id)
   return true;
 }
 
-// Returns the `NameId` for a keyword node.
-static auto GetKeywordAsNameId(
-    Context& context, Parse::NodeIdOneOf<Parse::KeywordNameNotBeforeParamsId,
-                                         Parse::KeywordNameBeforeParamsId>
-                          node_id) -> SemIR::NameId {
-  auto token = context.parse_tree().node_token(node_id);
-  switch (auto token_kind = context.tokens().GetKind(token)) {
-    case Lex::TokenKind::Destroy:
-      return SemIR::NameId::Destroy;
-    default:
-      CARBON_FATAL("Unexpected token kind: {0}", token_kind);
-  }
-}
-
-auto HandleParseNode(Context& context,
-                     Parse::KeywordNameNotBeforeParamsId node_id) -> bool {
-  // The parent is responsible for binding the name.
-  context.node_stack().Push(node_id, GetKeywordAsNameId(context, node_id));
-  return true;
-}
-
-auto HandleParseNode(Context& context, Parse::KeywordNameBeforeParamsId node_id)
-    -> bool {
-  // Push a pattern block stack entry to handle the parameter pattern.
-  context.pattern_block_stack().Push();
-  context.full_pattern_stack().PushFullPattern(
-      FullPatternStack::Kind::ImplicitParamList);
-  // The parent is responsible for binding the name.
-  context.node_stack().Push(node_id, GetKeywordAsNameId(context, node_id));
-  return true;
-}
-
 auto HandleParseNode(Context& context, Parse::BaseNameId node_id) -> bool {
   context.node_stack().Push(node_id, SemIR::NameId::Base);
   return true;
@@ -219,18 +187,6 @@ auto HandleParseNode(Context& context,
   return ApplyNameQualifier(context);
 }
 
-auto HandleParseNode(Context& context,
-                     Parse::KeywordNameQualifierWithParamsId /*node_id*/)
-    -> bool {
-  return ApplyNameQualifier(context);
-}
-
-auto HandleParseNode(Context& context,
-                     Parse::KeywordNameQualifierWithoutParamsId /*node_id*/)
-    -> bool {
-  return ApplyNameQualifier(context);
-}
-
 auto HandleParseNode(Context& context, Parse::DesignatorExprId node_id)
     -> bool {
   SemIR::NameId name_id = context.node_stack().PopName();

toolchain/check/node_stack.h

@@ -496,8 +496,6 @@ class NodeStack {
       case Parse::NodeKind::ImportIntroducer:
       case Parse::NodeKind::IndexExprStart:
       case Parse::NodeKind::InvalidParseStart:
-      case Parse::NodeKind::KeywordNameQualifierWithParams:
-      case Parse::NodeKind::KeywordNameQualifierWithoutParams:
       case Parse::NodeKind::LibraryIntroducer:
       case Parse::NodeKind::LibrarySpecifier:
       case Parse::NodeKind::InlineImportSpecifier:

toolchain/check/scope_stack.h

@@ -295,8 +295,8 @@ class ScopeStack {
   // A stack for scope context.
   llvm::SmallVector<ScopeStackEntry> scope_stack_;
 
-  // A stack of `destroy` functions to call. This only has entries inside of
-  // function bodies, where destruction on scope exit is required.
+  // A stack of instances to destroy. This only has entries inside of function
+  // bodies, where destruction on scope exit is required.
   ArrayStack<SemIR::InstId> destroy_id_stack_;
 
   // Information about non-lexical scopes. This is a subset of the entries and