[cxx-interop] Cache specialized function templates.

This not only prevents us from creating a bunch of FuncDecls but actually is required to prevent duplicate symbol errors.

Author: zoecarver

lib/ClangImporter/ClangImporter.cpp

@@ -5527,6 +5527,9 @@ ClangImporter::getCXXFunctionTemplateSpecialization(SubstitutionMap subst,
   if (!newFn)
     return ConcreteDeclRef(decl);
 
+  if (Impl.specializedFunctionTemplates.count(newFn))
+    return ConcreteDeclRef(Impl.specializedFunctionTemplates[newFn]);
+
   auto newDecl = cast_or_null<ValueDecl>(
       decl->getASTContext().getClangModuleLoader()->importDeclDirectly(
           newFn));
@@ -5548,6 +5551,7 @@ ClangImporter::getCXXFunctionTemplateSpecialization(SubstitutionMap subst,
     }
   }
 
+  Impl.specializedFunctionTemplates[newFn] = newDecl;
   return ConcreteDeclRef(newDecl);
 }
 

lib/ClangImporter/ImporterImpl.h

@@ -572,7 +572,16 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
 
   /// Keep track of cxx function names, params etc in order to
   /// allow for de-duping functions that differ strictly on "constness".
-  llvm::DenseMap<llvm::StringRef, std::pair<llvm::DenseSet<clang::FunctionDecl *>, llvm::DenseSet<clang::FunctionDecl *>>> cxxMethods;
+  llvm::DenseMap<llvm::StringRef,
+                 std::pair<
+                     llvm::DenseSet<clang::FunctionDecl *>,
+                     llvm::DenseSet<clang::FunctionDecl *>>>
+      cxxMethods;
+
+  // Cache for already-specialized function templates and any thunks they may
+  // have.
+  llvm::DenseMap<clang::FunctionDecl *, ValueDecl *>
+      specializedFunctionTemplates;
 
   /// Keeps track of the Clang functions that have been turned into
   /// properties.

test/Interop/Cxx/templates/dependent-types.swift

@@ -23,6 +23,15 @@ DependentTypesTestSuite.test("Different dependent inferred by arg.") {
   expectEqual(m.getValue(), 42)
 }
 
+DependentTypesTestSuite.test("Instanciate the same function twice") {
+  // Intentionally test the same thing twice.
+  let m = dependantReturnTypeInffered(42) as! M<Int>
+  expectEqual(m.getValue(), 42)
+
+  let m2 = dependantReturnTypeInffered(42) as! M<Int>
+  expectEqual(m2.getValue(), 42)
+}
+
 DependentTypesTestSuite.test("Multiple arguments (inferred type).") {
   let m = multipleArgs(M<Int>(value: 40), 2, 10) as! M<Int>
   expectEqual(m.getValue(), 42)

test/Interop/Cxx/templates/template-type-parameter-not-in-signature.swift

@@ -17,6 +17,12 @@ TemplateNotInSignatureTestSuite.test("Function with defaulted template type para
   expectEqual(y, 10)
 }
 
+TemplateNotInSignatureTestSuite.test("Instanciate the same function template twice.") {
+  // Intentionally test the same thing twice.
+  templateTypeParamNotUsedInSignature(T: Int.self)
+  templateTypeParamNotUsedInSignature(T: Int.self)
+}
+
 TemplateNotInSignatureTestSuite.test("Pointer types") {
   var x = 1
   x = templateTypeParamUsedInReferenceParam(&x)