[cxx-interop] Support conditional escapability

This PR adds a variadic macro that builds a SwiftAttr string containing
the names of the template type parameters that need to be escapable for
the type to be considered escapable. It also adds logic to interpret
this annotation.

rdar://139065437

Author: Gabor Horvath

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()
 }