[cxx-interop] Diagnose misuses of escapability and lifetimebound

When a type is explicitly annotated as escapable or non-escapable it has
requirements about the lifetime annotations. This patch introduces
diagnostics to detect that.

Author: Gabor Horvath

include/swift/AST/DiagnosticsClangImporter.def

@@ -289,5 +289,8 @@ NOTE(forward_declared_protocol_clashes_with_imported_objc_Swift_protocol, none,
      "its name conflicts with a %1 in module %2",
      (const clang::NamedDecl*, StringRef, StringRef))
 
+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))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/ClangImporter/ImportDecl.cpp

@@ -57,6 +57,7 @@
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjCCommon.h"
+#include "clang/AST/Type.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
@@ -3852,11 +3853,36 @@ namespace {
       return result;
     }
 
+    static bool isNonEscapableAnnotatedType(const clang::Type *t) {
+      if (const auto *rd = t->getAsRecordDecl()) {
+        return hasNonEscapableAttr(rd);
+      }
+      return false;
+    }
+
+    static bool isEscapableAnnotatedType(const clang::Type *t) {
+      if (const auto *rd = t->getAsRecordDecl()) {
+        return hasEscapableAttr(rd);
+      }
+      return false;
+    }
+
     void addLifetimeDependencies(const clang::FunctionDecl *decl,
                                  AbstractFunctionDecl *result) {
       if (decl->getTemplatedKind() == clang::FunctionDecl::TK_FunctionTemplate)
         return;
 
+      auto retType = decl->getReturnType();
+      auto warnForEscapableReturnType = [&] {
+        if (isEscapableAnnotatedType(retType.getTypePtr())) {
+          Impl.addImportDiagnostic(
+              decl,
+              Diagnostic(diag::return_escapable_with_lifetimebound,
+                         Impl.SwiftContext.AllocateCopy(retType.getAsString())),
+              decl->getLocation());
+        }
+      };
+
       auto swiftParams = result->getParameters();
       bool hasSelf = result->hasImplicitSelfDecl() && !isa<ConstructorDecl>(result);
       SmallVector<LifetimeDependenceInfo, 1> lifetimeDependencies;
@@ -3866,13 +3892,15 @@ namespace {
                                                          hasSelf);
       for (auto [idx, param] : llvm::enumerate(decl->parameters())) {
         if (param->hasAttr<clang::LifetimeBoundAttr>()) {
+          warnForEscapableReturnType();
           if (swiftParams->get(idx)->getInterfaceType()->isEscapable())
             scopedLifetimeParamIndicesForReturn[idx] = true;
           else
             inheritLifetimeParamIndicesForReturn[idx] = true;
         }
       }
       if (implicitObjectParamIsLifetimeBound(decl)) {
+        warnForEscapableReturnType();
         auto idx = result->getSelfIndex();
         if (result->getImplicitSelfDecl()->getInterfaceType()->isEscapable())
           scopedLifetimeParamIndicesForReturn[idx] = true;
@@ -3900,11 +3928,20 @@ namespace {
           lifetimeDependencies.push_back(
               LifetimeDependenceInfo(nullptr, nullptr, 0, /*isImmortal*/ true));
       }
-      if (!lifetimeDependencies.empty()) {
+      if (lifetimeDependencies.empty()) {
+        if (isNonEscapableAnnotatedType(retType.getTypePtr())) {
+          Impl.addImportDiagnostic(
+              decl,
+              Diagnostic(diag::return_nonescapable_without_lifetimebound,
+                         Impl.SwiftContext.AllocateCopy(retType.getAsString())),
+              decl->getLocation());
+        }
+      } else {
         Impl.SwiftContext.evaluator.cacheOutput(
             LifetimeDependenceInfoRequest{result},
             Impl.SwiftContext.AllocateCopy(lifetimeDependencies));
       }
+      Impl.diagnoseTargetDirectly(decl);
     }
 
     void finishFuncDecl(const clang::FunctionDecl *decl,

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

@@ -19,11 +19,35 @@ private:
     const int *member;
 };
 
+struct SWIFT_ESCAPABLE Owner {
+    int data;
+};
+
+Owner f(int* x [[clang::lifetimebound]]) { 
+    return Owner{0};
+}
+
+Owner f2(int* x [[clang::lifetimebound]], int* y [[clang::lifetimebound]]) { 
+    return Owner{0};
+}
+
+View g(int* x) {
+    return View(x);
+}
+
 //--- test.swift
 
 import Test
 
 // CHECK: error: cannot infer lifetime dependence, no parameters found that are either ~Escapable or Escapable with a borrowing ownership
 public func noAnnotations() -> View {
-    View()
+    // CHECK: nonescapable.h:15:7: warning: the returned type 'Owner' is annotated as escapable; it cannot have lifetime dependencies
+    f(nil)
+    // CHECK: nonescapable.h:19:7: warning: the returned type 'Owner' is annotated as escapable; it cannot have lifetime dependencies
+    // No duplicate warning for f2:
+    // 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
+    g(nil)
+    return View()
 }