Switch class to use a blanket impl for Destroy (#6125)

Right now, the class destroy impl is incorrectly generated (first
discussed [in
Discord](https://discord.com/channels/655572317891461132/941071822756143115/1418614787449032826)).
If we want it to be correct, deferred definition logic would need to be
added, and the declaration would need to be moved inside the `class`
scope (along with whatever generic logic that needs).

This instead switches to a blanket impl, to avoid creating latent bugs
with generating the `impl` and function body in the wrong scope. This
approach uses the same blanket impl as aggregate destruction that was
added by #6098.

The intent here is to allow progress on other parts of `Destroy`. For
example, under this model the implementation of the function body could
be done as part of lowering the specific.

Author: jonmeow

toolchain/check/BUILD

@@ -41,7 +41,6 @@ cc_library(
         "impl.cpp",
         "impl_lookup.cpp",
         "impl_validation.cpp",
-        "implicit_type_impls.cpp",
         "import.cpp",
         "import_ref.cpp",
         "inst.cpp",
@@ -95,7 +94,6 @@ cc_library(
         "impl.h",
         "impl_lookup.h",
         "impl_validation.h",
-        "implicit_type_impls.h",
         "import.h",
         "import_ref.h",
         "inst.h",

toolchain/check/check.cpp

@@ -470,7 +470,7 @@ auto CheckParseTrees(
        check_index < static_cast<int>(ready_to_check.size()); ++check_index) {
     auto* unit_info = ready_to_check[check_index];
     CheckUnit(unit_info, &tree_and_subtrees_getters, fs, clang_invocation,
-              options.gen_implicit_type_impls, options.vlog_stream)
+              options.vlog_stream)
         .Run();
     for (auto* incoming_import : unit_info->incoming_imports) {
       --incoming_import->imports_remaining;
@@ -519,7 +519,7 @@ auto CheckParseTrees(
     for (auto& unit_info : unit_infos) {
       if (unit_info.imports_remaining > 0) {
         CheckUnit(&unit_info, &tree_and_subtrees_getters, fs, clang_invocation,
-                  options.gen_implicit_type_impls, options.vlog_stream)
+                  options.vlog_stream)
             .Run();
       }
     }

toolchain/check/check.h

@@ -42,11 +42,6 @@ struct CheckParseTreesOptions {
   // Whether to import the prelude.
   bool prelude_import = false;
 
-  // Whether to generate standard `impl`s for types, such as `Core.Destroy`.
-  // This only controls generation of the `impl`; code which expects the `impl`
-  // is expected to fail.
-  bool gen_implicit_type_impls = true;
-
   // If set, enables verbose output.
   llvm::raw_ostream* vlog_stream = nullptr;
 

toolchain/check/check_unit.cpp

@@ -60,7 +60,7 @@ CheckUnit::CheckUnit(
     const Parse::GetTreeAndSubtreesStore* tree_and_subtrees_getters,
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
     std::shared_ptr<clang::CompilerInvocation> clang_invocation,
-    bool gen_implicit_type_impls, llvm::raw_ostream* vlog_stream)
+    llvm::raw_ostream* vlog_stream)
     : unit_and_imports_(unit_and_imports),
       tree_and_subtrees_getter_(tree_and_subtrees_getters->Get(
           unit_and_imports->unit->sem_ir->check_ir_id())),
@@ -71,8 +71,7 @@ CheckUnit::CheckUnit(
       context_(&emitter_, tree_and_subtrees_getter_,
                unit_and_imports_->unit->sem_ir,
                GetImportedIRCount(unit_and_imports),
-               unit_and_imports_->unit->total_ir_count, gen_implicit_type_impls,
-               vlog_stream) {}
+               unit_and_imports_->unit->total_ir_count, vlog_stream) {}
 
 auto CheckUnit::Run() -> void {
   Timings::ScopedTiming timing(unit_and_imports_->unit->timings, "check");

toolchain/check/check_unit.h

@@ -128,7 +128,7 @@ class CheckUnit {
       const Parse::GetTreeAndSubtreesStore* tree_and_subtrees_getters,
       llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
       std::shared_ptr<clang::CompilerInvocation> clang_invocation,
-      bool gen_implicit_type_impls, llvm::raw_ostream* vlog_stream);
+      llvm::raw_ostream* vlog_stream);
 
   // Produces and checks the IR for the provided unit.
   auto Run() -> void;

toolchain/check/context.cpp

@@ -16,12 +16,11 @@ namespace Carbon::Check {
 Context::Context(DiagnosticEmitterBase* emitter,
                  Parse::GetTreeAndSubtreesFn tree_and_subtrees_getter,
                  SemIR::File* sem_ir, int imported_ir_count, int total_ir_count,
-                 bool gen_implicit_type_impls, llvm::raw_ostream* vlog_stream)
+                 llvm::raw_ostream* vlog_stream)
     : emitter_(emitter),
       tree_and_subtrees_getter_(tree_and_subtrees_getter),
       sem_ir_(sem_ir),
       total_ir_count_(total_ir_count),
-      gen_implicit_type_impls_(gen_implicit_type_impls),
       vlog_stream_(vlog_stream),
       node_stack_(sem_ir->parse_tree(), vlog_stream),
       inst_block_stack_("inst_block_stack_", *sem_ir, vlog_stream),

toolchain/check/context.h

@@ -58,8 +58,7 @@ class Context {
   explicit Context(DiagnosticEmitterBase* emitter,
                    Parse::GetTreeAndSubtreesFn tree_and_subtrees_getter,
                    SemIR::File* sem_ir, int imported_ir_count,
-                   int total_ir_count, bool gen_implicit_type_impls,
-                   llvm::raw_ostream* vlog_stream);
+                   int total_ir_count, llvm::raw_ostream* vlog_stream);
 
   // Marks an implementation TODO. Always returns false.
   auto TODO(SemIR::LocId loc_id, std::string label) -> bool;
@@ -93,8 +92,6 @@ class Context {
     return parse_tree().tokens();
   }
 
-  auto gen_implicit_type_impls() -> bool { return gen_implicit_type_impls_; }
-
   auto vlog_stream() -> llvm::raw_ostream* { return vlog_stream_; }
 
   auto node_stack() -> NodeStack& { return node_stack_; }
@@ -330,10 +327,6 @@ class Context {
   // The total number of files.
   int total_ir_count_;
 
-  // Whether to generate standard `impl`s for types, such as `Core.Destroy`; see
-  // `CheckParseTreesOptions`.
-  bool gen_implicit_type_impls_;
-
   // Whether to print verbose output.
   llvm::raw_ostream* vlog_stream_;
 

toolchain/check/handle_class.cpp

@@ -15,7 +15,6 @@
 #include "toolchain/check/generic.h"
 #include "toolchain/check/handle.h"
 #include "toolchain/check/impl.h"
-#include "toolchain/check/implicit_type_impls.h"
 #include "toolchain/check/import.h"
 #include "toolchain/check/import_ref.h"
 #include "toolchain/check/inst.h"
@@ -567,8 +566,6 @@ auto HandleParseNode(Context& context, Parse::ClassDefinitionId node_id)
   auto class_id =
       context.node_stack().Pop<Parse::NodeKind::ClassDefinitionStart>();
 
-  MakeClassDestroyImpl(context, class_id);
-
   // The class type is now fully defined. Compute its object representation.
   ComputeClassObjectRepr(context, node_id, class_id,
                          context.field_decls_stack().PeekArray(),

toolchain/check/impl_lookup.cpp

@@ -550,16 +550,18 @@ static auto TypeCanAggregateDestroy(Context& context,
       context.constant_values().GetInstId(query_self_const_id));
   CARBON_KIND_SWITCH(inst) {
     case CARBON_KIND(SemIR::ClassType class_type): {
-      // Carbon classes will generate a `Destroy` impl, but we use this to
-      // provide destruction for `Cpp`-scoped classes.
-      // TODO: Don't provide this for C++ types that lack a destructor.
       auto class_info = context.classes().Get(class_type.class_id);
-      return context.name_scopes().Get(class_info.scope_id).is_cpp_scope();
+      // Incomplete classes can't be destroyed.
+      // TODO: Return false if the object repr doesn't impl `Destroy`.
+      // TODO: Return false for C++ types that lack a destructor.
+      return class_info.is_complete();
     }
     case SemIR::ArrayType::Kind:
     case SemIR::MaybeUnformedType::Kind:
     case SemIR::StructType::Kind:
     case SemIR::TupleType::Kind:
+      // TODO: Return false for types that indirectly reference a type that
+      // doesn't impl `Destroy`.
       return true;
     default:
       return false;