[cxx-interop] Fix linker errors when a template is used from different modules

If a templated C++ class is used from two different C++ modules, and those modules are included in Swift, Clang will create different two different redecls for the class & its methods.

For each of the methods, only one of the redecls would actually have a body, the other would have empty bodies. That prevents `ClangDeclFinder` from properly finding the symbols referenced from a method body, leading to a linker error in some cases, when the first redecl is missing a body.

This prevents `std::string` from being used on Linux:
```
/tmp/use-std-string-2dd593.o:use-std-string-2dd593.o:function void std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_construct<char*>(char*, char*, std::forward_iterator_tag): error: undefined reference to 'bool __gnu_cxx::__is_null_pointer<char>(char*)'
/tmp/use-std-string-2dd593.o:use-std-string-2dd593.o:function void std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_construct<char*>(char*, char*, std::forward_iterator_tag): error: undefined reference to 'std::iterator_traits<char*>::difference_type std::distance<char*>(char*, char*)'
clang-13: error: linker command failed with exit code 1 (use -v to see invocation)
<unknown>:0: error: link command failed with exit code 1 (use -v to see invocation)
```

Author: egorzhdan

lib/IRGen/GenClangDecl.cpp

@@ -86,15 +86,15 @@ class ClangDeclFinder
 // the initializer of the variable.
 clang::Decl *getDeclWithExecutableCode(clang::Decl *decl) {
   if (auto fd = dyn_cast<clang::FunctionDecl>(decl)) {
-    // If this is a potentially not-yet-instanciated template, we might
-    // still have a body.
-    if (fd->getTemplateInstantiationPattern())
-      return fd;
-
     const clang::FunctionDecl *definition;
     if (fd->hasBody(definition)) {
       return const_cast<clang::FunctionDecl *>(definition);
     }
+
+    // If this is a potentially not-yet-instanciated template, we might
+    // still have a body.
+    if (fd->getTemplateInstantiationPattern())
+      return fd;
   } else if (auto vd = dyn_cast<clang::VarDecl>(decl)) {
     clang::VarDecl *initializingDecl = vd->getInitializingDeclaration();
     if (initializingDecl) {

test/Interop/Cxx/templates/instantiation-in-multiple-modules/Inputs/a.h

@@ -0,0 +1,10 @@
+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_A_H
+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_A_H
+
+#include "wrapper.h"
+
+WrapperInt getWrapperIntA() {
+  return WrapperInt();
+}
+
+#endif // TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_A_H

test/Interop/Cxx/templates/instantiation-in-multiple-modules/Inputs/b.h

@@ -0,0 +1,10 @@
+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_B_H
+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_B_H
+
+#include "wrapper.h"
+
+WrapperInt getWrapperIntB() {
+  return WrapperInt();
+}
+
+#endif // TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_B_H

test/Interop/Cxx/templates/instantiation-in-multiple-modules/Inputs/module.modulemap

@@ -0,0 +1,17 @@
+module Wrapper {
+  header "wrapper.h"
+  export *
+  requires cplusplus
+}
+
+module A {
+  header "a.h"
+  export *
+  requires cplusplus
+}
+
+module B {
+  header "b.h"
+  export *
+  requires cplusplus
+}

test/Interop/Cxx/templates/instantiation-in-multiple-modules/Inputs/wrapper.h

@@ -0,0 +1,16 @@
+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_WRAPPER_H
+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_WRAPPER_H
+
+template <typename T>
+struct Wrapper {
+  T t;
+  int i = 0;
+
+  void foo() { i++; }
+
+  Wrapper() { foo(); }
+};
+
+typedef Wrapper<int> WrapperInt;
+
+#endif // TEST_INTEROP_CXX_TEMPLATES_INPUTS_MULTIPLE_MODULES_WRAPPER_H

test/Interop/Cxx/templates/instantiation-in-multiple-modules/instantiation-in-multiple-modules-irgen.swift

@@ -0,0 +1,10 @@
+// RUN: %target-swift-emit-ir %s -I %S/Inputs -enable-cxx-interop | %FileCheck %s
+
+import A
+import B
+// Both A and B reference WrapperInt, and clang will instantiate two different redecls for WrapperInt.
+
+let w = WrapperInt()
+// The constructor of Wrapper calls Wrapper::foo, we need to make sure that Wrapper::foo is emitted,
+// otherwise a linker error occurs.
+// CHECK: define linkonce_odr{{( dso_local)?}} void @{{_ZN7WrapperIiE3fooEv|"\?foo@\?\$Wrapper@H@@QEAAXXZ"}}

test/Interop/Cxx/templates/instantiation-in-multiple-modules/instantiation-in-multiple-modules.swift

@@ -0,0 +1,17 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-cxx-interop)
+//
+// REQUIRES: executable_test
+
+import A
+import B
+import StdlibUnittest
+
+var TemplatesTestSuite = TestSuite("TemplatesTestSuite")
+
+TemplatesTestSuite.test("instantiation-in-multiple-modules") {
+  var w = WrapperInt()
+  // Make sure that WrapperInt::foo gets called.
+  expectEqual(w.i, 1)
+}
+
+runAllTests()