Merge pull request #40867 from zoecarver/interop-fix-linker-errors

[cxx-interop] Fix linker errors when using std-vector.

Author: zoecarver

lib/IRGen/GenClangDecl.cpp

@@ -40,6 +40,7 @@ class ClangDeclFinder
         isa<clang::VarDecl>(DRE->getDecl())) {
       callback(DRE->getDecl());
     }
+
     return true;
   }
 
@@ -56,6 +57,17 @@ class ClangDeclFinder
     callback(CXXCE->getConstructor());
     return true;
   }
+
+  bool VisitVarDecl(clang::VarDecl *VD) {
+    if (auto cxxRecord = VD->getType()->getAsCXXRecordDecl())
+      if (auto dtor = cxxRecord->getDestructor())
+        callback(dtor);
+
+    return true;
+  }
+
+  bool shouldVisitTemplateInstantiations() const { return true; }
+  bool shouldVisitImplicitCode() const { return true; }
 };
 
 // If any (re)declaration of `decl` contains executable code, returns that
@@ -65,6 +77,11 @@ 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);
@@ -100,7 +117,7 @@ void IRGenModule::emitClangDecl(const clang::Decl *decl) {
   SmallVector<const clang::Decl *, 8> stack;
   stack.push_back(decl);
 
-  ClangDeclFinder refFinder([&](const clang::Decl *D) {
+  auto callback = [&](const clang::Decl *D) {
     for (auto *DC = D->getDeclContext();; DC = DC->getParent()) {
       // Check that this is not a local declaration inside a function.
       if (DC->isFunctionOrMethod()) {
@@ -117,31 +134,55 @@ void IRGenModule::emitClangDecl(const clang::Decl *decl) {
     if (!GlobalClangDecls.insert(D->getCanonicalDecl()).second) {
       return;
     }
+
     stack.push_back(D);
-  });
+  };
+
+  ClangDeclFinder refFinder(callback);
 
   while (!stack.empty()) {
     auto *next = const_cast<clang::Decl *>(stack.pop_back_val());
+
+    // If a function calls another method in a class template specialization, we
+    // need to instantiate that other function. Do that here.
+    if (auto *fn = dyn_cast<clang::FunctionDecl>(next)) {
+      // Make sure that this method is part of a class template specialization.
+      if (fn->getTemplateInstantiationPattern())
+        Context.getClangModuleLoader()
+            ->getClangSema()
+            .InstantiateFunctionDefinition(fn->getLocation(), fn);
+    }
+
     if (clang::Decl *executableDecl = getDeclWithExecutableCode(next)) {
         refFinder.TraverseDecl(executableDecl);
         next = executableDecl;
     }
 
+    // Unfortunately, implicitly defined CXXDestructorDecls don't have a real
+    // body, so we need to traverse these manually.
+    if (auto *dtor = dyn_cast<clang::CXXDestructorDecl>(next)) {
+      auto cxxRecord = dtor->getParent();
+
+      for (auto field : cxxRecord->fields()) {
+        if (auto fieldCxxRecord = field->getType()->getAsCXXRecordDecl())
+          if (auto *fieldDtor = fieldCxxRecord->getDestructor())
+            callback(fieldDtor);
+      }
+
+      for (auto base : cxxRecord->bases()) {
+        if (auto baseCxxRecord = base.getType()->getAsCXXRecordDecl())
+          if (auto *baseDtor = baseCxxRecord->getDestructor())
+            callback(baseDtor);
+      }
+    }
+
     if (auto var = dyn_cast<clang::VarDecl>(next))
       if (!var->isFileVarDecl())
         continue;
     if (isa<clang::FieldDecl>(next)) {
       continue;
     }
-    // If a method calls another method in a class template specialization, we
-    // need to instantiate that other method. Do that here.
-    if (auto *method = dyn_cast<clang::CXXMethodDecl>(next)) {
-      // Make sure that this method is part of a class template specialization.
-      if (method->getTemplateInstantiationPattern())
-        Context.getClangModuleLoader()
-            ->getClangSema()
-            .InstantiateFunctionDefinition(method->getLocation(), method);
-    }
+
     ClangCodeGen->HandleTopLevelDecl(clang::DeclGroupRef(next));
   }
 }

lib/IRGen/GenDecl.cpp

@@ -468,6 +468,10 @@ void IRGenModule::emitSourceFile(SourceFile &SF) {
 
   if (ObjCInterop)
     this->addLinkLibrary(LinkLibrary("objc", LibraryKind::Library));
+
+  // Automatically with libc++ when possible.
+  if (Context.LangOpts.EnableCXXInterop && Context.LangOpts.Target.isOSDarwin())
+    this->addLinkLibrary(LinkLibrary("c++", LibraryKind::Library));
 
   // FIXME: It'd be better to have the driver invocation or build system that
   // executes the linker introduce these compatibility libraries, since at

lib/IRGen/GenStruct.cpp

@@ -81,12 +81,7 @@ static clang::CXXDestructorDecl *getCXXDestructor(SILType type) {
       dyn_cast<clang::CXXRecordDecl>(structDecl->getClangDecl());
   if (!cxxRecordDecl)
     return nullptr;
-  for (auto member : cxxRecordDecl->methods()) {
-    if (auto dest = dyn_cast<clang::CXXDestructorDecl>(member)) {
-      return dest;
-    }
-  }
-  return nullptr;
+  return cxxRecordDecl->getDestructor();
 }
 
 namespace {

test/Interop/Cxx/stdlib/Inputs/module.modulemap

@@ -0,0 +1,3 @@
+module StdVector {
+  header "std-vector.h"
+}

test/Interop/Cxx/stdlib/Inputs/std-vector.h

@@ -0,0 +1,10 @@
+#ifndef TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H
+#define TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H
+
+#include <vector>
+
+using Vector = std::vector<int>;
+
+inline Vector initVector() { return {}; }
+
+#endif // TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H

test/Interop/Cxx/stdlib/use-std-vector.swift

@@ -0,0 +1,61 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-cxx-interop)
+//
+// REQUIRES: executable_test
+//
+// Enable this everywhere once we have a solution for modularizing libstdc++: rdar://87654514
+// REQUIRES: OS=macosx
+
+import StdlibUnittest
+import StdVector
+import std.vector
+
+var StdVectorTestSuite = TestSuite("StdVector")
+
+extension Vector : RandomAccessCollection {
+  public var startIndex: Int { 0 }
+  public var endIndex: Int { size() }
+}
+
+StdVectorTestSuite.test("init") {
+    let v = Vector()
+    expectEqual(v.size(), 0)
+    expectTrue(v.empty())
+}
+
+StdVectorTestSuite.test("push back") {
+    var v = Vector()
+    var _42: CInt = 42
+    v.push_back(&_42)
+    expectEqual(v.size(), 1)
+    expectFalse(v.empty())
+    expectEqual(v[0], 42)
+}
+
+func fill(vector v: inout Vector) {
+    var _1: CInt = 1, _2: CInt = 2, _3: CInt = 3
+    v.push_back(&_1)
+    v.push_back(&_2)
+    v.push_back(&_3)
+}
+
+StdVectorTestSuite.test("for loop") {
+    var v = Vector()
+    fill(vector: &v)
+
+    var count: CInt = 1
+    for e in v {
+        expectEqual(e, count)
+        count += 1
+    }
+    expectEqual(count, 4)
+}
+
+StdVectorTestSuite.test("map") {
+    var v = Vector()
+    fill(vector: &v)
+
+    let a = v.map { $0 + 5 }
+    expectEqual(a, [6, 7, 8])
+}
+
+runAllTests()

test/Interop/Cxx/templates/Inputs/define-referenced-inline.h

@@ -0,0 +1,56 @@
+#ifndef TEST_INTEROP_CXX_TEMPLATES_INPUTS_DEFINE_REFERENCED_INLINE_TYPES_H
+#define TEST_INTEROP_CXX_TEMPLATES_INPUTS_DEFINE_REFERENCED_INLINE_TYPES_H
+
+template <class T>
+inline void inlineFn1(T) { }
+
+template <class T>
+inline void inlineFn2(T) { }
+
+inline void inlineFn3() { }
+
+template<class T>
+struct HasInlineDtor {
+  inline ~HasInlineDtor() { inlineFn1(T()); }
+};
+
+template<class T>
+struct CtorCallsInlineFn {
+  CtorCallsInlineFn(T x) { inlineFn2(x); }
+};
+
+template<class T>
+struct HasInlineStaticMember {
+  inline static void member() { inlineFn3(); }
+};
+
+template<class T>
+struct ChildWithInlineCtorDtor1 {
+  inline ChildWithInlineCtorDtor1() { HasInlineStaticMember<T>::member(); }
+  inline ~ChildWithInlineCtorDtor1() { HasInlineStaticMember<T>::member(); }
+};
+
+template<class T>
+struct ChildWithInlineCtorDtor2 {
+  inline ChildWithInlineCtorDtor2() { HasInlineStaticMember<T>::member(); }
+  inline ~ChildWithInlineCtorDtor2() { HasInlineStaticMember<T>::member(); }
+};
+
+template<class T>
+struct ParentWithChildWithInlineCtorDtor : ChildWithInlineCtorDtor1<T> {};
+
+template<class T>
+struct HolderWithChildWithInlineCtorDtor {
+  ChildWithInlineCtorDtor2<T> x;
+};
+
+template<class T>
+struct DtorCallsInlineMethod {
+  inline void unique_name() {}
+
+  ~DtorCallsInlineMethod() {
+    unique_name();
+  }
+};
+
+#endif // TEST_INTEROP_CXX_TEMPLATES_INPUTS_DEFINE_REFERENCED_INLINE_TYPES_H

test/Interop/Cxx/templates/Inputs/module.modulemap

@@ -127,3 +127,8 @@ module TemplateTypeParameterNotInSignature {
   header "template-type-parameter-not-in-signature.h"
   requires cplusplus
 }
+
+module DefineReferencedInline {
+  header "define-referenced-inline.h"
+  requires cplusplus
+}

test/Interop/Cxx/templates/define-referenced-inline.swift

@@ -0,0 +1,21 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-cxx-interop -Xcc -fno-exceptions)
+//
+// REQUIRES: executable_test
+//
+// Enable this everywhere once we have a solution for modularizing libstdc++: rdar://87654514
+// REQUIRES: OS=macosx
+
+import DefineReferencedInline
+import StdlibUnittest
+
+var TemplatesTestSuite = TestSuite("TemplatesTestSuite")
+
+TemplatesTestSuite.test("tests") {
+  let a = CtorCallsInlineFn<CInt>(0)
+  let b = HasInlineDtor<CInt>()
+  let c = ParentWithChildWithInlineCtorDtor<CInt>()
+  let d = HolderWithChildWithInlineCtorDtor<CInt>()
+  let e = DtorCallsInlineMethod<CInt>()
+}
+
+runAllTests()