Merge branch 'trunk' into toolchain-overload-diagnostics

Author: zygoloid

.codespell_ignore

@@ -2,6 +2,7 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+AggregateT
 ArchType
 atleast
 circularly

core/prelude/destroy.carbon

@@ -4,13 +4,35 @@
 
 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.
 interface Destroy {
   fn Op[addr self: Self*]();
 }
 
-// Provide a default blanket impl for trivial destruction.
-impl forall [T:! type] T as Destroy {
+// Add destruction for essential builtin types. This can't be done earlier
+// because `Destroy` is using them.
+// TODO: This should match trivial destruction.
+impl bool as Destroy {
+  fn Op[addr self: Self*]() = "no_op";
+}
+impl type as Destroy {
+  fn Op[addr self: Self*]() = "no_op";
+}
+impl forall [PointeeT:! type] PointeeT* as Destroy {
   fn Op[addr self: Self*]() = "no_op";
 }
+
+// Handles builtin aggregate type destruction.
+private fn CanAggregateDestroy() -> type = "type.can_aggregate_destroy";
+impl forall [AggregateT:! CanAggregateDestroy()] AggregateT as Destroy {
+  fn Op[addr self: Self*]() = "type.aggregate_destroy";
+}
+
+// `const` instances always use the non-`const` destructor.
+impl forall [NonConstT:! Destroy] const NonConstT as Destroy {
+  fn Op[addr self: Self*]() { (self unsafe as NonConstT*)->(Destroy.Op)(); }
+}

examples/interop/cpp/hello_world.carbon

@@ -5,8 +5,8 @@
 import Cpp inline "#include <cstdio>";
 
 fn Run() {
-  // TODO: Requires operator <<, declaration type Var (cout) and class with
-  // virtual bases (basic_ostream).
+  // TODO: Requires member operator << and class with virtual bases
+  // (basic_ostream).
   // Cpp.std.cout << "Hello world!\n";
 
   // TODO: Requires variadic function.
@@ -20,7 +20,7 @@ fn Run() {
 
   // TODO: Requires Core.String API.
   // let message: str = "Hello world!\n\n";
-  // for (c: Core.Char in msg) {
+  // for (c: Core.Char in message) {
   //   Cpp.putchar((c as u8) as i32);
   // }
 

toolchain/check/class.cpp

@@ -214,7 +214,7 @@ static auto BuildVtable(Context& context, Parse::ClassDefinitionId node_id,
         override_fn.virtual_index = vtable.size();
         CARBON_CHECK(override_fn.virtual_index == fn.virtual_index);
       } else if (auto base_vtable_specific_function =
-                     context.sem_ir().insts().TryGetAs<SemIR::SpecificFunction>(
+                     context.insts().TryGetAs<SemIR::SpecificFunction>(
                          derived_vtable_entry_id)) {
         if (derived_vtable_entry_const_id.is_symbolic()) {
           // Create a new instruction here that is otherwise identical to

toolchain/check/context.h

@@ -299,7 +299,7 @@ class Context {
   auto types() -> SemIR::TypeStore& { return sem_ir().types(); }
   // Instructions should be added with `AddInst` or `AddInstInNoBlock` from
   // `inst.h`. This is `const` to prevent accidental misuse.
-  auto insts() -> const SemIR::InstStore& { return sem_ir().insts(); }
+  auto insts() const -> const SemIR::InstStore& { return sem_ir().insts(); }
   auto constant_values() -> SemIR::ConstantValueStore& {
     return sem_ir().constant_values();
   }

toolchain/check/convert.cpp

@@ -63,7 +63,7 @@ static auto CopyValueToTemporary(Context& context, SemIR::InstId init_id)
     -> SemIR::InstId {
   // TODO: Consider using `None` to mean that we immediately materialize and
   // initialize a temporary, rather than two separate instructions.
-  auto init = context.sem_ir().insts().Get(init_id);
+  auto init = context.insts().Get(init_id);
   auto temporary_id = AddInst<SemIR::TemporaryStorage>(
       context, SemIR::LocId(init_id), {.type_id = init.type_id()});
   return AddInstWithCleanup<SemIR::Temporary>(context, SemIR::LocId(init_id),

toolchain/check/cpp/import.cpp

@@ -13,6 +13,7 @@
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/UnresolvedSet.h"
+#include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
@@ -598,8 +599,7 @@ static auto IsDeclInjectedClassName(const Context& context,
   CARBON_CHECK(ast_context.getCanonicalTagType(scope_record_decl) ==
                ast_context.getCanonicalTagType(record_decl));
 
-  auto class_decl =
-      context.sem_ir().insts().GetAs<SemIR::ClassDecl>(clang_decl.inst_id);
+  auto class_decl = context.insts().GetAs<SemIR::ClassDecl>(clang_decl.inst_id);
   CARBON_CHECK(name_id ==
                context.sem_ir().classes().Get(class_decl.class_id).name_id);
   return true;
@@ -1623,6 +1623,21 @@ static auto ImportFunction(Context& context, SemIR::LocId loc_id,
       AddPlaceholderInstInNoBlock(context, Parse::NodeId::None, function_decl);
   context.imports().push_back(decl_id);
 
+  auto virtual_modifier = SemIR::Function::VirtualModifier::None;
+  int32_t virtual_index = -1;
+  if (auto* method_decl = dyn_cast<clang::CXXMethodDecl>(clang_decl)) {
+    if (method_decl->size_overridden_methods()) {
+      virtual_modifier = SemIR::Function::VirtualModifier::Override;
+    } else if (method_decl->isVirtual()) {
+      virtual_modifier = SemIR::Function::VirtualModifier::Virtual;
+    }
+    if (virtual_modifier != SemIR::Function::VirtualModifier::None) {
+      // TODO: Add support for Microsoft/non-Itanium vtables.
+      virtual_index = dyn_cast<clang::ItaniumVTableContext>(
+                          context.ast_context().getVTableContext())
+                          ->getMethodVTableIndex(method_decl);
+    }
+  }
   auto function_info = SemIR::Function{
       {.name_id = GetFunctionName(context, clang_decl),
        .parent_scope_id = GetParentNameScopeId(context, clang_decl),
@@ -1640,7 +1655,8 @@ static auto ImportFunction(Context& context, SemIR::LocId loc_id,
        .definition_id = SemIR::InstId::None},
       {.call_params_id = function_params_insts->call_params_id,
        .return_slot_pattern_id = function_params_insts->return_slot_pattern_id,
-       .virtual_modifier = SemIR::FunctionFields::VirtualModifier::None,
+       .virtual_modifier = virtual_modifier,
+       .virtual_index = virtual_index,
        .self_param_id = FindSelfPattern(
            context, function_params_insts->implicit_param_patterns_id),
        .clang_decl_id = context.sem_ir().clang_decls().Add(
@@ -1675,14 +1691,6 @@ auto ImportCppFunctionDecl(Context& context, SemIR::LocId loc_id,
     return SemIR::ErrorInst::InstId;
   }
 
-  if (auto* method_decl = dyn_cast<clang::CXXMethodDecl>(clang_decl)) {
-    if (method_decl->isVirtual()) {
-      context.TODO(loc_id, "Unsupported: Virtual function");
-      MarkFailedDecl(context, clang_decl);
-      return SemIR::ErrorInst::InstId;
-    }
-  }
-
   CARBON_CHECK(clang_decl->getFunctionType()->isFunctionProtoType(),
                "Not Prototype function (non-C++ code)");
 
@@ -2142,6 +2150,15 @@ auto ImportNameFromCpp(Context& context, SemIR::LocId loc_id,
         builder.Note(loc_id, InCppNameLookup, name_id);
       });
 
+  if (auto class_decl = context.insts().TryGetAs<SemIR::ClassDecl>(
+          context.name_scopes().Get(scope_id).inst_id());
+      class_decl.has_value()) {
+    if (!context.types().IsComplete(
+            context.classes().Get(class_decl->class_id).self_type_id)) {
+      return SemIR::ScopeLookupResult::MakeError();
+    }
+  }
+
   auto lookup = ClangLookupName(context, scope_id, name_id);
   if (!lookup) {
     SemIR::InstId builtin_inst_id =

toolchain/check/deduce.cpp

@@ -113,11 +113,6 @@ class DeductionWorklist {
       case SemIR::IdKind::None:
       case SemIR::IdKind::For<SemIR::ClassId>:
       case SemIR::IdKind::For<SemIR::IntKind>:
-      // Decided on 2025-04-02 not to do deduction through facet types, because
-      // types can implement a generic interface multiple times with different
-      // arguments. See:
-      // https://docs.google.com/document/d/1Iut5f2TQBrtBNIduF4vJYOKfw7MbS8xH_J01_Q4e6Rk/edit?pli=1&resourcekey=0-mc_vh5UzrzXfU4kO-3tOjA&tab=t.0#heading=h.95phmuvxog9n
-      case SemIR::IdKind::For<SemIR::FacetTypeId>:
         break;
       case CARBON_KIND(SemIR::InstId inst_id): {
         Add(inst_id, SemIR::InstId(arg));

toolchain/check/eval.cpp

@@ -674,7 +674,6 @@ static auto GetConstantValue(EvalContext& eval_context,
   SemIR::FacetTypeInfo info = GetConstantFacetTypeInfo(
       eval_context, SemIR::LocId::None,
       eval_context.facet_types().Get(facet_type_id), phase);
-  // TODO: Return `facet_type_id` if we can detect nothing has changed.
   return eval_context.facet_types().Add(info);
 }
 

toolchain/check/impl_lookup.cpp

@@ -548,7 +548,22 @@ static auto TypeCanAggregateDestroy(Context& context,
     -> bool {
   auto inst = context.insts().Get(
       context.constant_values().GetInstId(query_self_const_id));
-  return inst.Is<SemIR::StructType>() || inst.Is<SemIR::TupleType>();
+  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();
+    }
+    case SemIR::ArrayType::Kind:
+    case SemIR::MaybeUnformedType::Kind:
+    case SemIR::StructType::Kind:
+    case SemIR::TupleType::Kind:
+      return true;
+    default:
+      return false;
+  }
 }
 
 auto LookupImplWitness(Context& context, SemIR::LocId loc_id,