[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/ClangImporter/ImportType.cpp

@@ -2455,6 +2455,13 @@ ClangImporter::Implementation::importParameterType(
     llvm::function_ref<void(Diagnostic &&)> addImportDiagnosticFn) {
   auto paramTy = desugarIfElaborated(param->getType());
 
+  // 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;
@@ -2483,6 +2490,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.
@@ -2731,8 +2749,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 =

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/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.