[cxx-interop] Import nullability of templated function parameters correctly

This teaches ClangImporter to respect the `_Nonnull`/`_Nullable` arguments on templated function parameters.

Previously Swift would only import a non-annotated function overload. Using an overload that has either  `_Nonnull` or `_Nullable` would result in a compiler error. The non-annotated overload would get imported with incorrect nullability: Swift would always assume non-null pointers, which was inconsistent with non-templated function parameters, which are mapped to implicitly unwrapped optionals.

With this change all three possible overloads are imported, and all of them get the correct nullability in Swift.

rdar://151939344

Author: egorzhdan

lib/AST/ClangTypeConverter.cpp

@@ -881,8 +881,15 @@ ClangTypeConverter::convertClangDecl(Type type, const clang::Decl *clangDecl) {
 
   if (auto clangTypeDecl = dyn_cast<clang::TypeDecl>(clangDecl)) {
     auto qualType = ctx.getTypeDeclType(clangTypeDecl);
-    if (type->isForeignReferenceType())
+    if (type->isForeignReferenceType()) {
       qualType = ctx.getPointerType(qualType);
+      auto nonNullAttr = new (ctx) clang::TypeNonNullAttr(
+          ctx,
+          clang::AttributeCommonInfo(
+              clang::SourceRange(), clang::AttributeCommonInfo::AT_TypeNonNull,
+              clang::AttributeCommonInfo::Form::Implicit()));
+      qualType = ctx.getAttributedType(nonNullAttr, qualType, qualType);
+    }
 
     return qualType.getUnqualifiedType();
   }

lib/ClangImporter/ImportType.cpp

@@ -2458,6 +2458,13 @@ ClangImporter::Implementation::importParameterType(
   auto paramTy = desugarIfElaborated(param->getType());
   paramTy = desugarIfBoundsAttributed(paramTy);
 
+  // If this type has a _Nullable/_Nonnull attribute, drop it, since we already
+  // have that information in optionalityOfParam.
+  if (auto attributedTy = dyn_cast<clang::AttributedType>(paramTy)) {
+    if (attributedTy->getImmediateNullability())
+      clang::AttributedType::stripOuterNullability(paramTy);
+  }
+
   ImportTypeKind importKind = paramIsCompletionHandler
                                   ? ImportTypeKind::CompletionHandlerParameter
                                   : ImportTypeKind::Parameter;
@@ -2486,6 +2493,17 @@ ClangImporter::Implementation::importParameterType(
                                        pointerKind));
       return std::nullopt;
     }
+    switch (optionalityOfParam) {
+    case OTK_Optional:
+      swiftParamTy = OptionalType::get(swiftParamTy);
+      break;
+    case OTK_ImplicitlyUnwrappedOptional:
+      swiftParamTy = OptionalType::get(swiftParamTy);
+      isParamTypeImplicitlyUnwrapped = true;
+      break;
+    case OTK_None:
+      break;
+    }
   } else if (isa<clang::ReferenceType>(paramTy) &&
              isa<clang::TemplateTypeParmType>(paramTy->getPointeeType())) {
     // We don't support universal reference, bail.
@@ -2734,8 +2752,6 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
     }
 
     bool knownNonNull = !nonNullArgs.empty() && nonNullArgs[index];
-    // Specialized templates need to match the args/result exactly.
-    knownNonNull |= clangDecl->isFunctionTemplateSpecialization();
 
     // Check nullability of the parameter.
     OptionalTypeKind optionalityOfParam =

stdlib/public/Cxx/CxxSpan.swift

@@ -66,7 +66,7 @@ public protocol CxxSpan<Element> {
   associatedtype Size: BinaryInteger
 
   init()
-  init(_ unsafePointer : UnsafePointer<Element>, _ count: Size)
+  init(_ unsafePointer: UnsafePointer<Element>!, _ count: Size)
 
   func size() -> Size
   func __dataUnsafe() -> UnsafePointer<Element>?
@@ -136,7 +136,7 @@ public protocol CxxMutableSpan<Element> {
   associatedtype Size: BinaryInteger
 
   init()
-  init(_ unsafeMutablePointer : UnsafeMutablePointer<Element>, _ count: Size)
+  init(_ unsafeMutablePointer: UnsafeMutablePointer<Element>!, _ count: Size)
 
   func size() -> Size
   func __dataUnsafe() -> UnsafeMutablePointer<Element>?

stdlib/public/Cxx/cxxshim/libcxxshim.h

@@ -1,2 +1,4 @@
 template <class From, class To>
-To __swift_interopStaticCast(From from) { return static_cast<To>(from); }
+To _Nonnull __swift_interopStaticCast(From _Nonnull from) {
+  return static_cast<To>(from);
+}

test/Interop/Cxx/stdlib/use-std-span-typechecker.swift

@@ -15,7 +15,5 @@ arr.withUnsafeBufferPointer { ubpointer in
 arr.withUnsafeBufferPointer { ubpointer in 
     // FIXME: this crashes the compiler once we import span's templated ctors as Swift generics.
     let _ = ConstSpanOfInt(ubpointer.baseAddress, ubpointer.count)
-    // expected-error@-1 {{value of optional type 'UnsafePointer<Int32>?' must be unwrapped to a value of type 'UnsafePointer<Int32>'}}
-    // expected-note@-2 {{coalesce using '??' to provide a default when the optional value contains 'nil'}}
-    // expected-note@-3 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}
+    // expected-warning@-1 {{'init(_:_:)' is deprecated: use 'init(_:)' instead.}}
 }

test/Interop/Cxx/swiftify-import/bounds-attrs-in-template.swift

@@ -5,10 +5,10 @@
 // RUN: %target-swift-frontend -plugin-path %swift-plugin-dir -I %t/Inputs -cxx-interoperability-mode=default -enable-experimental-feature SafeInteropWrappers %t/template.swift -dump-macro-expansions -emit-ir -o %t/out -verify
 // RUN: %target-swift-ide-test -plugin-path %swift-plugin-dir -I %t/Inputs -cxx-interoperability-mode=default -enable-experimental-feature SafeInteropWrappers -print-module -module-to-print=Template -source-filename=x | %FileCheck %s
 
-// CHECK: func cb_template<T>(_ p: UnsafePointer<T>, _ size: Int{{.*}}) -> UnsafePointer<T>
-// CHECK: func eb_template<T>(_ p: UnsafePointer<T>, _ end: UnsafePointer<T>) -> UnsafePointer<T>
-// CHECK: func s_template<T>(_ p: UnsafePointer<T>) -> UnsafePointer<T>
-// CHECK: func ui_template<T>(_ p: UnsafePointer<T>) -> UnsafePointer<T>
+// CHECK: func cb_template<T>(_ p: UnsafePointer<T>!, _ size: Int{{.*}}) -> UnsafePointer<T>
+// CHECK: func eb_template<T>(_ p: UnsafePointer<T>!, _ end: UnsafePointer<T>!) -> UnsafePointer<T>
+// CHECK: func s_template<T>(_ p: UnsafePointer<T>!) -> UnsafePointer<T>
+// CHECK: func ui_template<T>(_ p: UnsafePointer<T>!) -> UnsafePointer<T>
 
 //--- Inputs/module.modulemap
 module Template {

test/Interop/Cxx/templates/Inputs/function-templates.h

@@ -120,7 +120,9 @@ template <class T> bool constLvalueReferenceToBool(const T &t) { return t; }
 
 template <class T> void forwardingReference(T &&) {}
 
-template <class T> void PointerTemplateParameter(T*){}
+template <class T> bool pointerTemplateParameter(T *t) { return t; }
+template <class T> bool pointerTemplateParameterNonnull(T *_Nonnull t) { return t; }
+template <class T> bool pointerTemplateParameterNullable(T *_Nullable t) { return t; }
 
 template <typename F> void callFunction(F f) { f(); }
 template <typename F, typename T> void callFunctionWithParam(F f, T t) { f(t); }

test/Interop/Cxx/templates/defaulted-template-type-parameter-module-interface.swift

@@ -21,6 +21,6 @@
 // TODO-CHECK: func defaultedTemplatePointerTypeParam<T>(_ t: UnsafeMutablePointer<T>)
 // TODO-CHECK: func defaultedTemplatePointerPointerTypeParam<T>(_ t: UnsafeMutablePointer<OpaquePointer?>!)
 
-// CHECK: func defaultedTemplatePointerTypeParam<T>(_ t: UnsafeMutablePointer<T>)
+// CHECK: func defaultedTemplatePointerTypeParam<T>(_ t: UnsafeMutablePointer<T>!)
 // We don't support references to dependent types (rdar://89034440).
 // CHECK-NOT: defaultedTemplatePointerReferenceTypeParam

test/Interop/Cxx/templates/function-template-module-interface.swift

@@ -20,7 +20,10 @@
 
 // CHECK: func lvalueReference<T>(_ ref: inout T)
 // CHECK: func constLvalueReference<T>(_: T)
-// CHECK: func PointerTemplateParameter<T>(_: UnsafeMutablePointer<T>)
+
+// CHECK: func pointerTemplateParameter<T>(_ t: UnsafeMutablePointer<T>!) -> Bool
+// CHECK: func pointerTemplateParameterNonnull<T>(_ t: UnsafeMutablePointer<T>) -> Bool
+// CHECK: func pointerTemplateParameterNullable<T>(_ t: UnsafeMutablePointer<T>?) -> Bool
 
 // CHECK: enum Orbiters {
 // CHECK:   static func galileo<T>(_: T)

test/Interop/Cxx/templates/function-template.swift

@@ -39,6 +39,26 @@ FunctionTemplateTestSuite.test("constLvalueReferenceToBool<T> where T == Bool")
   expectFalse(constLvalueReferenceToBool(false))
 }
 
+var nilPtr: UnsafeMutablePointer<CInt>? = nil
+var nilPtrIOU: UnsafeMutablePointer<CInt>! = nil
+var nonNilPtr: UnsafeMutablePointer<CInt> = .init(bitPattern: 123)!
+
+FunctionTemplateTestSuite.test("pointerTemplateParameter<T>") {
+  expectFalse(pointerTemplateParameter(nilPtr))
+  expectFalse(pointerTemplateParameter(nilPtrIOU))
+  expectTrue(pointerTemplateParameter(nonNilPtr))
+}
+
+FunctionTemplateTestSuite.test("pointerTemplateParameterNonnull<T>") {
+  expectTrue(pointerTemplateParameterNonnull(nonNilPtr))
+}
+
+FunctionTemplateTestSuite.test("pointerTemplateParameterNullable<T>") {
+  expectFalse(pointerTemplateParameterNullable(nilPtr))
+  expectFalse(pointerTemplateParameterNullable(nilPtrIOU))
+  expectTrue(pointerTemplateParameterNullable(nonNilPtr))
+}
+
 // TODO: Generics, Any, and Protocols should be tested here but need to be
 // better supported in ClangTypeConverter first.