C++ Interop: Support getting void* from C++ functions and passing void* it to C++ function

This defines `Cpp.void` as a custom type.
`Cpp.void*` is mapped to C++ `void*`.
Not supported yet: Conversions from and to other pointer types.

Author: bricknerb

toolchain/check/cpp/import.cpp

@@ -1137,6 +1137,10 @@ static auto MapBuiltinType(Context& context, SemIR::LocId loc_id,
               context.ints().Add(ast_context.getTypeSize(qual_type))));
     }
     // TODO: Handle floating-point types that map to named aliases.
+  } else if (type.isVoidType()) {
+    return ExprAsType(context, Parse::NodeId::None,
+                      context.types().GetInstId(GetSingletonType(
+                          context, SemIR::CustomCppVoidType::TypeInstId)));
   }
 
   return TypeExpr::None;
@@ -2074,6 +2078,7 @@ static auto LookupBuiltinTypes(Context& context, SemIR::LocId loc_id,
           .Case("float", ast_context.FloatTy)
           .Case("double", ast_context.DoubleTy)
           .Case("long_double", ast_context.LongDoubleTy)
+          .Case("void", ast_context.VoidTy)
           .Default(clang::QualType());
   if (builtin_type.isNull()) {
     return SemIR::InstId::None;

toolchain/check/cpp/type_mapping.cpp

@@ -180,6 +180,22 @@ static auto MapNonWrapperType(Context& context, SemIR::InstId inst_id,
   }
 }
 
+// If `type_id` is `Cpp.void` and the last wrapper type in `wrapper_types` is a
+// pointer, pops the pointer wrapper and returns non nullable `void*` QualType.
+// Otherwise returns a null QualType.
+static auto TryMapVoidPointer(Context& context, SemIR::TypeId type_id,
+                              llvm::SmallVector<SemIR::TypeId>& wrapper_types)
+    -> clang::QualType {
+  if (type_id == SemIR::CustomCppVoidType::TypeId && !wrapper_types.empty() &&
+      context.types().Is<SemIR::PointerType>(wrapper_types.back())) {
+    wrapper_types.pop_back();
+    return context.ast_context().getAttributedType(
+        clang::attr::TypeNonNull, context.ast_context().VoidPtrTy,
+        context.ast_context().VoidPtrTy);
+  }
+  return clang::QualType();
+}
+
 // Maps a Carbon type to a C++ type. Accepts an InstId, representing a value
 // whose type is mapped to a C++ type. Returns `clang::QualType` if the mapping
 // succeeds, or `clang::QualType::isNull()` if the type is not supported.
@@ -204,9 +220,13 @@ static auto MapToCppType(Context& context, SemIR::InstId inst_id)
     wrapper_types.push_back(orig_type_id);
   }
 
-  clang::QualType mapped_type = MapNonWrapperType(context, inst_id, type_id);
+  clang::QualType mapped_type =
+      TryMapVoidPointer(context, type_id, wrapper_types);
   if (mapped_type.isNull()) {
-    return mapped_type;
+    mapped_type = MapNonWrapperType(context, inst_id, type_id);
+    if (mapped_type.isNull()) {
+      return mapped_type;
+    }
   }
 
   for (auto wrapper_type_id : llvm::reverse(wrapper_types)) {

toolchain/check/testdata/basics/raw_sem_ir/builtins.carbon

@@ -20,7 +20,7 @@
 // CHECK:STDOUT:   import_ir_insts: {}
 // CHECK:STDOUT:   clang_decls:     {}
 // CHECK:STDOUT:   name_scopes:
-// CHECK:STDOUT:     name_scope00000000: {inst: inst0000000E, parent_scope: name_scope<none>, has_error: false, extended_scopes: [], names: {}}
+// CHECK:STDOUT:     name_scope00000000: {inst: inst0000000F, parent_scope: name_scope<none>, has_error: false, extended_scopes: [], names: {}}
 // CHECK:STDOUT:   entity_names:    {}
 // CHECK:STDOUT:   cpp_global_vars: {}
 // CHECK:STDOUT:   functions:       {}
@@ -42,6 +42,7 @@
 // CHECK:STDOUT:     'inst(BoolType)':  {kind: BoolType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(BoundMethodType)': {kind: BoundMethodType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(CharLiteralType)': {kind: CharLiteralType, type: type(TypeType)}
+// CHECK:STDOUT:     'inst(CustomCppVoidType)': {kind: CustomCppVoidType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(ErrorInst)': {kind: ErrorInst, type: type(Error)}
 // CHECK:STDOUT:     'inst(FloatLiteralType)': {kind: FloatLiteralType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(ImplWitnessTablePlaceholder)': {kind: ImplWitnessTablePlaceholder, type: type(TypeType)}
@@ -51,14 +52,15 @@
 // CHECK:STDOUT:     'inst(SpecificFunctionType)': {kind: SpecificFunctionType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(VtableType)': {kind: VtableType, type: type(TypeType)}
 // CHECK:STDOUT:     'inst(WitnessType)': {kind: WitnessType, type: type(TypeType)}
-// CHECK:STDOUT:     inst0000000E:    {kind: Namespace, arg0: name_scope00000000, arg1: inst<none>, type: type(inst(NamespaceType))}
+// CHECK:STDOUT:     inst0000000F:    {kind: Namespace, arg0: name_scope00000000, arg1: inst<none>, type: type(inst(NamespaceType))}
 // CHECK:STDOUT:   constant_values:
 // CHECK:STDOUT:     values:
 // CHECK:STDOUT:       'inst(TypeType)':  concrete_constant(inst(TypeType))
 // CHECK:STDOUT:       'inst(AutoType)':  concrete_constant(inst(AutoType))
 // CHECK:STDOUT:       'inst(BoolType)':  concrete_constant(inst(BoolType))
 // CHECK:STDOUT:       'inst(BoundMethodType)': concrete_constant(inst(BoundMethodType))
 // CHECK:STDOUT:       'inst(CharLiteralType)': concrete_constant(inst(CharLiteralType))
+// CHECK:STDOUT:       'inst(CustomCppVoidType)': concrete_constant(inst(CustomCppVoidType))
 // CHECK:STDOUT:       'inst(ErrorInst)': concrete_constant(inst(ErrorInst))
 // CHECK:STDOUT:       'inst(FloatLiteralType)': concrete_constant(inst(FloatLiteralType))
 // CHECK:STDOUT:       'inst(ImplWitnessTablePlaceholder)': concrete_constant(inst(ImplWitnessTablePlaceholder))
@@ -68,13 +70,13 @@
 // CHECK:STDOUT:       'inst(SpecificFunctionType)': concrete_constant(inst(SpecificFunctionType))
 // CHECK:STDOUT:       'inst(VtableType)': concrete_constant(inst(VtableType))
 // CHECK:STDOUT:       'inst(WitnessType)': concrete_constant(inst(WitnessType))
-// CHECK:STDOUT:       inst0000000E:    concrete_constant(inst0000000E)
+// CHECK:STDOUT:       inst0000000F:    concrete_constant(inst0000000F)
 // CHECK:STDOUT:     symbolic_constants: {}
 // CHECK:STDOUT:   inst_blocks:
 // CHECK:STDOUT:     inst_block_empty: {}
 // CHECK:STDOUT:     exports:         {}
 // CHECK:STDOUT:     imports:         {}
 // CHECK:STDOUT:     global_init:     {}
 // CHECK:STDOUT:     inst_block60000004:
-// CHECK:STDOUT:       0:               inst0000000E
+// CHECK:STDOUT:       0:               inst0000000F
 // CHECK:STDOUT: ...