[cxx-interop] Support lifetime_capture_by in ClangImporter

Import it as lifetime dependencies.

rdar://137671377

Author: Gabor Horvath

lib/ClangImporter/ImportDecl.cpp

@@ -25,6 +25,7 @@
 #include "swift/AST/ConformanceLookup.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsClangImporter.h"
+#include "swift/AST/LifetimeDependence.h"
 #include "swift/ClangImporter/ClangImporter.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Expr.h"
@@ -56,6 +57,7 @@
 #include "swift/Strings.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
+#include "clang/AST/Attrs.inc"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjCCommon.h"
@@ -66,6 +68,7 @@
 #include "clang/Sema/Lookup.h"
 
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
@@ -3892,10 +3895,10 @@ namespace {
       auto swiftParams = result->getParameters();
       bool hasSelf =
           result->hasImplicitSelfDecl() && !isa<ConstructorDecl>(result);
-      SmallBitVector inheritLifetimeParamIndicesForReturn(swiftParams->size() +
-                                                          hasSelf);
-      SmallBitVector scopedLifetimeParamIndicesForReturn(swiftParams->size() +
-                                                         hasSelf);
+      const auto dependencyVecSize = swiftParams->size() + hasSelf;
+      SmallBitVector inheritLifetimeParamIndicesForReturn(dependencyVecSize);
+      SmallBitVector scopedLifetimeParamIndicesForReturn(dependencyVecSize);
+      std::map<unsigned, SmallBitVector> inheritedArgDependences;
       for (auto [idx, param] : llvm::enumerate(decl->parameters())) {
         if (param->hasAttr<clang::LifetimeBoundAttr>()) {
           warnForEscapableReturnType();
@@ -3904,6 +3907,26 @@ namespace {
           else
             inheritLifetimeParamIndicesForReturn[idx] = true;
         }
+        if (const auto *captureAttr = param->getAttr<clang::LifetimeCaptureByAttr>()) {
+          // FIXME: support scoped inheritance. This is not straightforward as const T& is imported as taking a value
+          //        and we assume the address of T would not escape. An annotation in this case contradicts our assumptions.
+          //        We should diagnose that, and support this for the non-const case.
+          if (swiftParams->get(idx)->getInterfaceType()->isEscapable())
+            continue;
+          for (auto param : captureAttr->params()) {
+            // FIXME: Swift assumes no escaping to globals. We should diagnose this.
+            if (param == clang::LifetimeCaptureByAttr::GLOBAL || param == clang::LifetimeCaptureByAttr::UNKNOWN || param == clang::LifetimeCaptureByAttr::INVALID)
+              continue;
+
+            if (isa<clang::CXXMethodDecl>(decl) && param == clang::LifetimeCaptureByAttr::THIS) {
+              auto [it, inserted] = inheritedArgDependences.try_emplace(result->getSelfIndex(), SmallBitVector(dependencyVecSize));
+              it->second[idx] = true;
+            } else {
+              auto [it, inserted] = inheritedArgDependences.try_emplace(param, SmallBitVector(dependencyVecSize));
+              it->second[idx] = true;
+            }
+          }
+        }
       }
       if (implicitObjectParamIsLifetimeBound(decl)) {
         warnForEscapableReturnType();
@@ -3914,6 +3937,11 @@ namespace {
           inheritLifetimeParamIndicesForReturn[idx] = true;
       }
 
+      for (auto& [idx, inheritedDepVec]: inheritedArgDependences) {
+        lifetimeDependencies.push_back(LifetimeDependenceInfo(inheritedDepVec.any() ? IndexSubset::get(Impl.SwiftContext,
+                                   inheritedDepVec): nullptr, nullptr, idx, /*isImmortal=*/false));
+      }
+
       if (inheritLifetimeParamIndicesForReturn.any() ||
           scopedLifetimeParamIndicesForReturn.any())
         lifetimeDependencies.push_back(LifetimeDependenceInfo(

test/Interop/Cxx/class/nonescapable-lifetimebound.swift

@@ -82,6 +82,29 @@ View returnsImmortal() SWIFT_RETURNS_INDEPENDENT_VALUE {
     return View();
 }
 
+void copyView(View view1 [[clang::lifetime_capture_by(view2)]], View &view2) {
+    view2 = view1;
+}
+
+struct SWIFT_NONESCAPABLE CaptureView {
+    CaptureView() : view(nullptr) {}
+    CaptureView(View p [[clang::lifetimebound]]) : view(p) {}
+
+    void captureView(View v [[clang::lifetime_capture_by(this)]]) {
+        view = v;
+    }
+
+    void handOut(View &v) const [[clang::lifetime_capture_by(v)]] {
+       v = view; 
+    }
+
+    View view;
+};
+
+CaptureView getCaptureView(const Owner& owner [[clang::lifetimebound]]) {
+    return CaptureView(View{&owner.data});
+}
+
 // CHECK: sil [clang makeOwner] {{.*}}: $@convention(c) () -> Owner
 // CHECK: sil [clang getView] {{.*}} : $@convention(c) (@in_guaranteed Owner) -> @lifetime(borrow 0) @autoreleased View
 // CHECK: sil [clang getViewFromFirst] {{.*}} : $@convention(c) (@in_guaranteed Owner, @in_guaranteed Owner) -> @lifetime(borrow 0) @autoreleased View
@@ -100,7 +123,7 @@ import Test
 public func test() {
     let o = makeOwner()
     let o2 = makeOwner()
-    let v1 = getView(o)
+    var v1 = getView(o)
     let v2 = getViewFromFirst(o, o2)
     let _ = getViewFromEither(o, o2)
     let _ = o.handOutView()
@@ -109,4 +132,9 @@ public func test() {
     let defaultView = View()
     let _ = OtherView(defaultView)
     let _ = returnsImmortal()
+    // FIXME: triggers crash in StaticExclusivityCheck pass.
+    //copyView(v2, &v1)
+    //var cv = getCaptureView(o)
+    //cv.captureView(v1)
+    //cv.handOut(&v1)
 }