Merge pull request #41658 from zoecarver/import-ref-to-template-return-tyeps

[cxx-interop] Support references to template types.

Author: zoecarver

lib/ClangImporter/ImportType.cpp

@@ -1863,6 +1863,17 @@ ImportedType ClangImporter::Implementation::importFunctionParamsAndReturnType(
           dyn_cast<clang::TemplateTypeParmType>(clangDecl->getReturnType())) {
     importedType = {findGenericTypeInGenericDecls(templateType, genericParams),
                     false};
+  } else if ((isa<clang::PointerType>(clangDecl->getReturnType()) ||
+          isa<clang::ReferenceType>(clangDecl->getReturnType())) &&
+         isa<clang::TemplateTypeParmType>(clangDecl->getReturnType()->getPointeeType())) {
+    auto pointeeType = clangDecl->getReturnType()->getPointeeType();
+    auto templateParamType = cast<clang::TemplateTypeParmType>(pointeeType);
+    PointerTypeKind pointerKind = pointeeType.getQualifiers().hasConst()
+                                      ? PTK_UnsafePointer
+                                      : PTK_UnsafeMutablePointer;
+    auto genericType =
+        findGenericTypeInGenericDecls(templateParamType, genericParams);
+    importedType = {genericType->wrapInPointer(pointerKind), false};
   } else if (!(isa<clang::RecordType>(clangDecl->getReturnType()) ||
                isa<clang::TemplateSpecializationType>(clangDecl->getReturnType())) ||
              // TODO: we currently don't lazily load operator return types, but

test/Interop/Cxx/reference/Inputs/reference.h

@@ -28,4 +28,10 @@ void dontImportAtomicRef(_Atomic(int)&) { }
 
 void takeConstRef(const int &);
 
+template<class T>
+T &refToTemplate(T &t) { return t; }
+
+template<class T>
+const T &constRefToTemplate(const T &t) { return t; }
+
 #endif // TEST_INTEROP_CXX_REFERENCE_INPUTS_REFERENCE_H

test/Interop/Cxx/reference/reference-module-interface.swift

@@ -12,6 +12,8 @@
 // CHECK: func setConstStaticIntRvalueRef(_: Int32)
 // CHECK: func getFuncRef() -> @convention(c) () -> Int32
 // CHECK: func getFuncRvalueRef() -> @convention(c) () -> Int32
+// CHECK: func refToTemplate<T>(_ t: inout T) -> UnsafeMutablePointer<T>
+// CHECK: func constRefToTemplate<T>(_ t: T) -> UnsafePointer<T>
 
 // CHECK-NOT: refToDependent
 // CHECK-NOT: dontImportAtomicRef

test/Interop/Cxx/reference/reference.swift

@@ -87,4 +87,18 @@ ReferenceTestSuite.test("pod-struct-const-lvalue-reference") {
   expectEqual(getStaticInt(), 78)
 }
 
+ReferenceTestSuite.test("reference to template") {
+  var val: CInt = 53
+  let ref = refToTemplate(&val)
+  expectEqual(53, ref.pointee)
+  ref.pointee = 42
+  expectEqual(42, val)
+}
+
+ReferenceTestSuite.test("const reference to template") {
+  var val: CInt = 53
+  let ref = constRefToTemplate(val)
+  expectEqual(53, ref.pointee)
+}
+
 runAllTests()