Merge pull request #77588 from swiftlang/gaborh/conditional-escapability

[cxx-interop] Support conditional escapability

Author: Xazax-hun

include/swift/AST/DiagnosticsClangImporter.def

@@ -308,5 +308,10 @@ NOTE(forward_declared_protocol_clashes_with_imported_objc_Swift_protocol, none,
 WARNING(return_escapable_with_lifetimebound, none, "the returned type '%0' is annotated as escapable; it cannot have lifetime dependencies", (StringRef))
 WARNING(return_nonescapable_without_lifetimebound, none, "the returned type '%0' is annotated as non-escapable; its lifetime dependencies must be annotated", (StringRef))
 
+ERROR(unknown_template_parameter,none,
+  "template parameter '%0' does not exist", (StringRef))
+ERROR(type_template_parameter_expected,none,
+  "template parameter '%0' expected to be a type parameter", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/ClangImporter/ClangImporterRequests.h

@@ -22,6 +22,7 @@
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/SimpleRequest.h"
 #include "swift/Basic/Statistic.h"
+#include "swift/ClangImporter/ClangImporter.h"
 #include "clang/AST/Type.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/TinyPtrVector.h"
@@ -504,14 +505,16 @@ enum class CxxEscapability { Escapable, NonEscapable, Unknown };
 
 struct EscapabilityLookupDescriptor final {
   const clang::Type *type;
+  ClangImporter::Implementation &impl;
+  bool annotationOnly = true;
 
   friend llvm::hash_code hash_value(const EscapabilityLookupDescriptor &desc) {
     return llvm::hash_combine(desc.type);
   }
 
   friend bool operator==(const EscapabilityLookupDescriptor &lhs,
                          const EscapabilityLookupDescriptor &rhs) {
-    return lhs.type == rhs.type;
+    return lhs.type == rhs.type && lhs.annotationOnly == rhs.annotationOnly;
   }
 
   friend bool operator!=(const EscapabilityLookupDescriptor &lhs,

lib/ClangImporter/ClangImporter.cpp

@@ -52,7 +52,9 @@
 #include "swift/Subsystems.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Mangle.h"
+#include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileEntry.h"
@@ -84,6 +86,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/CAS/CASReference.h"
 #include "llvm/CAS/ObjectStore.h"
 #include "llvm/Support/Casting.h"
@@ -5055,24 +5058,59 @@ TinyPtrVector<ValueDecl *> CXXNamespaceMemberLookup::evaluate(
 CxxEscapability
 ClangTypeEscapability::evaluate(Evaluator &evaluator,
                                 EscapabilityLookupDescriptor desc) const {
+  bool hadUnknown = false;
+  auto evaluateEscapability = [&](const clang::Type *type) {
+    auto escapability = evaluateOrDefault(
+        evaluator,
+        ClangTypeEscapability({type, desc.impl, desc.annotationOnly}),
+        CxxEscapability::Unknown);
+    if (escapability == CxxEscapability::Unknown)
+      hadUnknown = true;
+    return escapability;
+  };
+
   auto desugared = desc.type->getUnqualifiedDesugaredType();
   if (const auto *recordType = desugared->getAs<clang::RecordType>()) {
-    if (importer::hasNonEscapableAttr(recordType->getDecl()))
+    auto recordDecl = recordType->getDecl();
+    if (hasNonEscapableAttr(recordDecl))
       return CxxEscapability::NonEscapable;
-    if (importer::hasEscapableAttr(recordType->getDecl()))
+    if (hasEscapableAttr(recordDecl))
       return CxxEscapability::Escapable;
-    auto recordDecl = recordType->getDecl();
+    auto conditionalParams =
+        importer::getConditionalEscapableAttrParams(recordDecl);
+    if (!conditionalParams.empty()) {
+      auto specDecl = cast<clang::ClassTemplateSpecializationDecl>(recordDecl);
+      auto templateDecl = specDecl->getSpecializedTemplate();
+      SmallVector<std::pair<unsigned, StringRef>, 4> argumentsToCheck;
+      for (auto [idx, param] :
+           llvm::enumerate(*templateDecl->getTemplateParameters())) {
+        if (conditionalParams.erase(param->getName()))
+          argumentsToCheck.push_back(std::make_pair(idx, param->getName()));
+      }
+      HeaderLoc loc{recordDecl->getLocation()};
+      for (auto name : conditionalParams)
+        desc.impl.diagnose(loc, diag::unknown_template_parameter, name);
+
+      auto &argList = specDecl->getTemplateArgs();
+      for (auto argToCheck : argumentsToCheck) {
+        auto arg = argList[argToCheck.first];
+        if (arg.getKind() != clang::TemplateArgument::Type) {
+          desc.impl.diagnose(loc, diag::type_template_parameter_expected,
+                             argToCheck.second);
+          return CxxEscapability::Unknown;
+        }
+
+        auto argEscapability = evaluateEscapability(
+            arg.getAsType()->getUnqualifiedDesugaredType());
+        if (argEscapability == CxxEscapability::NonEscapable)
+          return CxxEscapability::NonEscapable;
+      }
+      return hadUnknown ? CxxEscapability::Unknown : CxxEscapability::Escapable;
+    }
+    if (desc.annotationOnly)
+      return CxxEscapability::Unknown;
     auto cxxRecordDecl = dyn_cast<clang::CXXRecordDecl>(recordDecl);
     if (!cxxRecordDecl || cxxRecordDecl->isAggregate()) {
-      bool hadUnknown = false;
-      auto evaluateEscapability = [&](const clang::Type *type) {
-        auto escapability = evaluateOrDefault(
-            evaluator, ClangTypeEscapability({type}), CxxEscapability::Unknown);
-        if (escapability == CxxEscapability::Unknown)
-          hadUnknown = true;
-        return escapability;
-      };
-
       if (cxxRecordDecl) {
         for (auto base : cxxRecordDecl->bases()) {
           auto baseEscapability = evaluateEscapability(
@@ -5092,12 +5130,16 @@ ClangTypeEscapability::evaluate(Evaluator &evaluator,
       return hadUnknown ? CxxEscapability::Unknown : CxxEscapability::Escapable;
     }
   }
+  if (desc.annotationOnly)
+    return CxxEscapability::Unknown;
   if (desugared->isArrayType()) {
     auto elemTy = cast<clang::ArrayType>(desugared)
                       ->getElementType()
                       ->getUnqualifiedDesugaredType();
-    return evaluateOrDefault(evaluator, ClangTypeEscapability({elemTy}),
-                             CxxEscapability::Unknown);
+    return evaluateOrDefault(
+        evaluator,
+        ClangTypeEscapability({elemTy, desc.impl, desc.annotationOnly}),
+        CxxEscapability::Unknown);
   }
 
   // Base cases
@@ -7530,6 +7572,29 @@ bool importer::hasEscapableAttr(const clang::RecordDecl *decl) {
   return hasSwiftAttribute(decl, "Escapable");
 }
 
+std::set<StringRef>
+importer::getConditionalEscapableAttrParams(const clang::RecordDecl *decl) {
+  std::set<StringRef> result;
+  if (!decl->hasAttrs())
+    return result;
+  for (auto attr : decl->getAttrs()) {
+    if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
+      if (swiftAttr->getAttribute().starts_with("escapable_if:")) {
+        StringRef params = swiftAttr->getAttribute().drop_front(
+            StringRef("escapable_if:").size());
+        auto commaPos = params.find(',');
+        StringRef nextParam = params.take_front(commaPos);
+        while (!nextParam.empty() && commaPos != StringRef::npos) {
+          result.insert(nextParam.trim());
+          params = params.drop_front(nextParam.size() + 1);
+          commaPos = params.find(',');
+          nextParam = params.take_front(commaPos);
+        }
+      }
+  }
+  return result;
+}
+
 /// Recursively checks that there are no pointers in any fields or base classes.
 /// Does not check C++ records with specific API annotations.
 static bool hasPointerInSubobjects(const clang::CXXRecordDecl *decl) {

lib/ClangImporter/ImportDecl.cpp

@@ -2186,7 +2186,10 @@ namespace {
       }
 
       if (Impl.SwiftContext.LangOpts.hasFeature(Feature::NonescapableTypes) &&
-          importer::hasNonEscapableAttr(decl)) {
+          evaluateOrDefault(
+              Impl.SwiftContext.evaluator,
+              ClangTypeEscapability({decl->getTypeForDecl(), Impl}),
+              CxxEscapability::Unknown) == CxxEscapability::NonEscapable) {
         result->getAttrs().add(new (Impl.SwiftContext)
                                    NonEscapableAttr(/*Implicit=*/true));
       }
@@ -3930,7 +3933,11 @@ namespace {
       else if (auto *ctordecl = dyn_cast<clang::CXXConstructorDecl>(decl)) {
         // Assume default constructed view types have no dependencies.
         if (ctordecl->isDefaultConstructor() &&
-            importer::hasNonEscapableAttr(ctordecl->getParent()))
+            evaluateOrDefault(
+                Impl.SwiftContext.evaluator,
+                ClangTypeEscapability(
+                    {ctordecl->getParent()->getTypeForDecl(), Impl}),
+                CxxEscapability::Unknown) == CxxEscapability::NonEscapable)
           lifetimeDependencies.push_back(immortalLifetime);
       }
       if (lifetimeDependencies.empty()) {
@@ -8240,8 +8247,10 @@ bool swift::importer::isMutabilityAttr(const clang::SwiftAttrAttr *swiftAttr) {
          swiftAttr->getAttribute() == "nonmutating";
 }
 
-static bool importAsUnsafe(ASTContext &context, const clang::NamedDecl *decl,
+static bool importAsUnsafe(ClangImporter::Implementation &impl,
+                           const clang::NamedDecl *decl,
                            const Decl *MappedDecl) {
+  auto &context = impl.SwiftContext;
   if (!context.LangOpts.hasFeature(Feature::SafeInterop) ||
       !context.LangOpts.hasFeature(Feature::AllowUnsafeAttribute))
     return false;
@@ -8255,10 +8264,10 @@ static bool importAsUnsafe(ASTContext &context, const clang::NamedDecl *decl,
     return false;
 
   if (const auto *record = dyn_cast<clang::RecordDecl>(decl))
-    return evaluateOrDefault(context.evaluator,
-                             ClangTypeEscapability({record->getTypeForDecl()}),
-                             CxxEscapability::Unknown) ==
-           CxxEscapability::Unknown;
+    return evaluateOrDefault(
+               context.evaluator,
+               ClangTypeEscapability({record->getTypeForDecl(), impl, false}),
+               CxxEscapability::Unknown) == CxxEscapability::Unknown;
 
   return false;
 }
@@ -8440,7 +8449,7 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
       }
     }
 
-    if (seenUnsafe || importAsUnsafe(SwiftContext, ClangDecl, MappedDecl)) {
+    if (seenUnsafe || importAsUnsafe(*this, ClangDecl, MappedDecl)) {
       auto attr = new (SwiftContext) UnsafeAttr(/*implicit=*/!seenUnsafe);
       MappedDecl->getAttrs().add(attr);
     }

lib/ClangImporter/ImporterImpl.h

@@ -2042,6 +2042,9 @@ bool hasNonEscapableAttr(const clang::RecordDecl *decl);
 
 bool hasEscapableAttr(const clang::RecordDecl *decl);
 
+std::set<StringRef>
+getConditionalEscapableAttrParams(const clang::RecordDecl *decl);
+
 bool isViewType(const clang::CXXRecordDecl *decl);
 
 } // end namespace importer

lib/ClangImporter/SwiftBridging/swift/bridging

@@ -39,6 +39,12 @@
 
 #define _CXX_INTEROP_STRINGIFY(_x) #_x
 
+#define _CXX_INTEROP_CONCAT_(a,b,c,d,e,f,g,i,j,k,l,m,n,o,p,...)         \
+  #a "," #b "," #c "," #d "," #e "," #f "," #g "," #i "," #j "," #k "," \
+  #l "," #m "," #n "," #o "," #p
+#define _CXX_INTEROP_CONCAT(...) \
+  _CXX_INTEROP_CONCAT_(__VA_ARGS__,,,,,,,,,,,,,,,,,)
+
 /// Specifies that a C++ `class` or `struct` is reference-counted using
 /// the given `retain` and `release` functions. This annotation lets Swift import
 /// such a type as reference counted type in Swift, taking advantage of Swift's
@@ -172,6 +178,11 @@
 #define SWIFT_ESCAPABLE \
   __attribute__((swift_attr("Escapable")))
 
+/// Specifies that a C++ `class` or `struct` should be imported as a escapable
+/// Swift value if all of the specified template arguments are escapable.
+#define SWIFT_ESCAPABLE_IF(...) \
+  __attribute__((swift_attr("escapable_if:" _CXX_INTEROP_CONCAT(__VA_ARGS__))))
+
 /// Specifies that the return value is passed as owned for C++ functions and
 /// methods returning types annotated as `SWIFT_SHARED_REFERENCE`
 #define SWIFT_RETURNS_RETAINED __attribute__((swift_attr("returns_retained")))
@@ -196,6 +207,7 @@
 #define SWIFT_NONCOPYABLE
 #define SWIFT_NONESCAPABLE
 #define SWIFT_ESCAPABLE
+#define SWIFT_ESCAPABLE_IF(...)
 #define SWIFT_RETURNS_RETAINED
 #define SWIFT_RETURNS_UNRETAINED
 

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

@@ -37,6 +37,30 @@ View g(int* x) {
     return View(x);
 }
 
+template<typename F, typename S>
+struct SWIFT_ESCAPABLE_IF(F, S) MyPair {
+    F first;
+    S second;
+};
+
+MyPair<View, Owner> h1(int* x);
+MyPair<Owner, View> h2(int* x);
+MyPair<Owner, Owner> h3(int* x);
+
+template<typename F, typename S>
+struct SWIFT_ESCAPABLE_IF(F, Missing) MyPair2 {
+    F first;
+    S second;
+};
+
+template<typename F, int S>
+struct SWIFT_ESCAPABLE_IF(F, S) MyType {
+    F field;
+};
+
+MyPair2<Owner, Owner> i1();
+MyType<Owner, 0> i2();
+
 //--- test.swift
 
 import Test
@@ -50,7 +74,18 @@ public func noAnnotations() -> View {
     // CHECK-NOT: nonescapable.h:19
     f2(nil, nil)
     // CHECK: nonescapable.h:23:6: warning: the returned type 'View' is annotated as non-escapable; its lifetime dependencies must be annotated
-    // CHECKL nonescapable.h:23:6: error: cannot infer lifetime dependence, no parameters found that are either ~Escapable or Escapable with a borrowing ownership
+    // CHECK: nonescapable.h:23:6: error: cannot infer lifetime dependence, no parameters found that are either ~Escapable or Escapable with a borrowing ownership
     g(nil)
+    h1(nil)
+    // CHECK: nonescapable.h:33:21: error: cannot infer lifetime dependence, no parameters found that are either ~Escapable or Escapable with a borrowing ownership
+    h2(nil)
+    // CHECK: nonescapable.h:34:21: error: cannot infer lifetime dependence, no parameters found that are either ~Escapable or Escapable with a borrowing ownership
+    h3(nil)
+    i1()
+    // CHECK: nonescapable.h:38:39: error: template parameter 'Missing' does not exist
+    i2()
+    // CHECK: nonescapable.h:44:33: error: template parameter 'S' expected to be a type parameter
+    // CHECK-NOT: error
+    // CHECK-NOT: warning
     return View()
 }