[cxx-interop] Builtin functions should ignore return type nullability to be compatible with C interop

In C interop mode, the return type of builtin functions like 'memcpy' drops any nullability
specifiers from their return type, and preserves it on the declared return type. Thus, in C
mode the imported return type of such functions is always optional. However, in C++ interop mode, the
return type of builtin functions can preseve the nullability specifiers on their return type,
and thus the imported return type of such functions can be non-optional, if the type is annotated with
`_Nonnull`. The difference between these two modes can break cross-module Swift serialization, as
Swift will no longer be able to resolve an x-ref such as 'memcpy' from a Swift module that uses
C interop, within a Swift context that uses C++ interop. In order to avoid the x-ref resolution
failure, normalize the return type's nullability for builtin functions in C++ interop mode, to
match the imported type in C interop mode.

This fixed an issue when using 'memcpy' from the Android NDK in a x-module context, like
between Foundation (that inlines it) and another user module.

Author: hyp

lib/ClangImporter/ImportType.cpp

@@ -2223,6 +2223,24 @@ ImportedType ClangImporter::Implementation::importFunctionReturnType(
   if (auto elaborated =
           dyn_cast<clang::ElaboratedType>(returnType))
     returnType = elaborated->desugar();
+  // In C interop mode, the return type of builtin functions like 'memcpy' drops
+  // any nullability specifiers from their return type, and preserves it on the
+  // declared return type. Thus, in C mode the imported return type of such
+  // functions is always optional. However, in C++ interop mode, the return type
+  // of builtin functions can preseve the nullability specifiers on their return
+  // type, and thus the imported return type of such functions can be
+  // non-optional, if the type is annotated with
+  // `_Nonnull`. The difference between these two modes can break cross-module
+  // Swift serialization, as Swift will no longer be able to resolve an x-ref
+  // such as 'memcpy' from a Swift module that uses C interop, within a Swift
+  // context that uses C++ interop. In order to avoid the x-ref resolution
+  // failure, normalize the return type's nullability for builtin functions in
+  // C++ interop mode, to match the imported type in C interop mode.
+  if (SwiftContext.LangOpts.EnableCXXInterop && clangDecl->getBuiltinID() &&
+      isa<clang::AttributedType>(returnType)) {
+    if (cast<clang::AttributedType>(returnType)->getImmediateNullability())
+      clang::AttributedType::stripOuterNullability(returnType);
+  }
 
   // Specialized templates need to match the args/result exactly (i.e.,
   // ptr -> ptr not ptr -> Optional<ptr>).

test/Interop/Cxx/function/Inputs/custom-string-builtins.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void* _Nonnull memcpy(void* _Nonnull, const void* _Nonnull, size_t);
+
+void* _Nonnull memcpy42(void* _Nonnull, const void* _Nonnull, size_t);
+
+#ifdef __cplusplus
+}
+#endif

test/Interop/Cxx/function/Inputs/module.modulemap

@@ -2,3 +2,8 @@ module DefaultArguments {
   header "default-arguments.h"
   export *
 }
+
+module CustomStringBuiltins {
+  header "custom-string-builtins.h"
+  export *
+}

test/Interop/Cxx/function/builtin-nullability-return-type-typechecker.swift

@@ -0,0 +1,12 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown -I %S/Inputs -cxx-interoperability-mode=default
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown -I %S/Inputs
+
+import CustomStringBuiltins
+
+public func testMemcpyOptionalReturn(p: UnsafeMutableRawPointer, e: UnsafeRawPointer) {
+  // This 'memcpy' is a builtin and is always an optional, regardless of _Nonnull.
+  let x = CustomStringBuiltins.memcpy(p, e, 1)!
+
+  // Not a builtin, _Nonnull makes it a non-optional.
+  let y = CustomStringBuiltins.memcpy42(p, e, 1)! // expected-error {{cannot force unwrap value of non-optional type 'UnsafeMutableRawPointer'}}
+}