[Clang importer] Diagnose various issues with the new "destroy:"

When we cannot respect the "destroy:" annotation, mark the type as
deprecated with a message thst says why there is a problem. There are
various potential problems:

* Multiple conflicting destroy functions
* Destroy functions that don't meet the pattern
* Type isn't imported as a move-only type
* Type has a non-trivial destructor (in C++)

(cherry picked from commit 63135e8)

Author: DougGregor

lib/ClangImporter/ImportDecl.cpp

@@ -2666,103 +2666,13 @@ namespace {
         }
       }
 
-      // A type imported as noncopyable, check whether an explicit deinit
-      // should be introduced to call a user-defined "destroy" function.
-      if (recordHasMoveOnlySemantics(decl)) {
-        addExplicitDeinitIfRequired(result, decl);
-      }
+      // If we need it, add an explicit "deinit" to this type.
+      synthesizer.addExplicitDeinitIfRequired(result, decl);
 
       result->setMemberLoader(&Impl, 0);
       return result;
     }
 
-    /// Find an explicitly-provided "destroy" operation specified for the
-    /// given Clang type and return it.
-    static FuncDecl *findExplicitDestroy(
-        NominalTypeDecl *nominal, const clang::TypeDecl *clangType) {
-      if (!clangType->hasAttrs())
-        return nullptr;
-
-      llvm::TinyPtrVector<FuncDecl *> matchingDestroyFuncs;
-      for (auto attr : clangType->getAttrs()) {
-        auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr);
-        if (!swiftAttr)
-          continue;
-
-        auto attributeName = swiftAttr->getAttribute();
-        if (!attributeName.starts_with("destroy:"))
-          continue;
-
-        auto destroyFuncName = attributeName.drop_front(strlen("destroy:"));
-        auto decls = getValueDeclsForName(
-            clangType, nominal->getASTContext(), destroyFuncName);
-        for (auto decl : decls) {
-          auto func = dyn_cast<FuncDecl>(decl);
-          if (!func)
-            continue;
-
-          auto params = func->getParameters();
-          if (params->size() != 1)
-            continue;
-
-          if (!params->get(0)->getInterfaceType()->isEqual(
-                  nominal->getDeclaredInterfaceType()))
-            continue;
-
-          matchingDestroyFuncs.push_back(func);
-        }
-      }
-
-      if (matchingDestroyFuncs.size() == 1)
-        return matchingDestroyFuncs[0];
-
-      return nullptr;
-    }
-
-    /// Function body synthesizer for a deinit of a noncopyable type, which
-    /// passes "self" to the given "destroy" function.
-    static std::pair<BraceStmt *, bool>
-    synthesizeDeinitBodyForCustomDestroy(
-        AbstractFunctionDecl *deinitFunc, void *opaqueDestroyFunc) {
-      auto deinit = cast<DestructorDecl>(deinitFunc);
-      auto destroyFunc = static_cast<FuncDecl *>(opaqueDestroyFunc);
-
-      ASTContext &ctx = deinit->getASTContext();
-      auto funcRef = new (ctx) DeclRefExpr(
-          destroyFunc, DeclNameLoc(), /*Implicit=*/true);
-      auto selfRef = new (ctx) DeclRefExpr(
-          deinit->getImplicitSelfDecl(), DeclNameLoc(), /*Implicit=*/true);
-      auto callExpr = CallExpr::createImplicit(
-          ctx, funcRef,
-          ArgumentList::createImplicit(
-            ctx,
-            { Argument(SourceLoc(), Identifier(), selfRef)}
-          )
-      );
-
-      auto braceStmt = BraceStmt::createImplicit(ctx, { ASTNode(callExpr) });
-      return std::make_pair(braceStmt, /*typechecked=*/false);
-    }
-
-    /// For a type that is imported as noncopyable, look for an
-    /// explicitly-provided "destroy" operation. If present, introduce a deinit
-    /// that calls it.
-    void addExplicitDeinitIfRequired(
-        NominalTypeDecl *nominal, const clang::TypeDecl *clangType) {
-      auto destroyFunc = findExplicitDestroy(nominal, clangType);
-      if (!destroyFunc)
-        return;
-
-      ASTContext &ctx = Impl.SwiftContext;
-      auto destructor = new (ctx) DestructorDecl(SourceLoc(), nominal);
-      destructor->setSynthesized(true);
-      destructor->copyFormalAccessFrom(nominal, /*sourceIsParentContext*/true);
-      destructor->setBodySynthesizer(
-          synthesizeDeinitBodyForCustomDestroy, destroyFunc);
-
-      nominal->addMember(destructor);
-    }
-
     void validatePrivateFileIDAttributes(const clang::CXXRecordDecl *decl) {
       auto anns = importer::getPrivateFileIDAttrs(decl);
 

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -20,7 +20,7 @@
 #include "swift/AST/Pattern.h"
 #include "swift/AST/Stmt.h"
 #include "swift/Basic/Assertions.h"
-#include "swift/ClangImporter/CXXMethodBridging.h"
+#include "swift/ClangImporter/ClangImporterRequests.h"
 #include "clang/AST/Mangle.h"
 #include "clang/Sema/DelayedDiagnostic.h"
 
@@ -2729,3 +2729,216 @@ SwiftDeclSynthesizer::synthesizeStaticFactoryForCXXForeignRef(
 
   return synthesizedFactories;
 }
+
+/// Mark the given declaration as always deprecated for the given reason.
+static void markDeprecated(Decl *decl, llvm::Twine message) {
+  ASTContext &ctx = decl->getASTContext();
+  decl->getAttrs().add(
+      AvailableAttr::createUniversallyDeprecated(
+        ctx, ctx.AllocateCopy(message.str())));
+}
+
+/// Find an explicitly-provided "destroy" operation specified for the
+/// given Clang type and return it.
+FuncDecl *SwiftDeclSynthesizer::findExplicitDestroy(
+    NominalTypeDecl *nominal, const clang::RecordDecl *clangType) {
+  if (!clangType->hasAttrs())
+    return nullptr;
+
+  llvm::SmallPtrSet<FuncDecl *, 2> matchingDestroyFuncs;
+  llvm::TinyPtrVector<FuncDecl *> nonMatchingDestroyFuncs;
+  for (auto attr : clangType->getAttrs()) {
+    auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr);
+    if (!swiftAttr)
+      continue;
+
+    auto destroyFuncName = swiftAttr->getAttribute();
+    if (!destroyFuncName.consume_front("destroy:"))
+      continue;
+
+    auto decls = getValueDeclsForName(
+        clangType, nominal->getASTContext(), destroyFuncName);
+    for (auto decl : decls) {
+      auto func = dyn_cast<FuncDecl>(decl);
+      if (!func)
+        continue;
+
+      auto params = func->getParameters();
+      if (params->size() != 1) {
+        nonMatchingDestroyFuncs.push_back(func);
+        continue;
+      }
+
+      if (!params->get(0)->getInterfaceType()->isEqual(
+              nominal->getDeclaredInterfaceType())) {
+        nonMatchingDestroyFuncs.push_back(func);
+        continue;
+      }
+
+      matchingDestroyFuncs.insert(func);
+    }
+  }
+
+  switch (matchingDestroyFuncs.size()) {
+  case 0:
+    if (!nonMatchingDestroyFuncs.empty()) {
+      markDeprecated(
+          nominal,
+          "destroy function '" +
+           nonMatchingDestroyFuncs.front()->getName().getBaseName()
+             .userFacingName() +
+           "' must have a single parameter with type '" +
+           nominal->getDeclaredInterfaceType().getString() + "'");
+    }
+
+    return nullptr;
+
+  case 1:
+    // Handled below.
+    break;
+
+  default: {
+    auto iter = matchingDestroyFuncs.begin();
+    auto first = *iter++;
+    auto second = *iter;
+    markDeprecated(
+        nominal,
+        "multiple destroy operations ('" +
+          first->getName().getBaseName().userFacingName() +
+          "' and '" +
+          second->getName().getBaseName().userFacingName() +
+          "') provided for type");
+    return nullptr;
+  }
+  }
+
+  auto destroyFunc = *matchingDestroyFuncs.begin();
+
+  // If this type isn't imported as noncopyable, we can't respect the request
+  // for a destroy operation.
+  ASTContext &ctx = ImporterImpl.SwiftContext;
+  auto semanticsKind = evaluateOrDefault(
+      ctx.evaluator,
+      CxxRecordSemantics({clangType, ctx, &ImporterImpl}), {});
+  switch (semanticsKind) {
+  case CxxRecordSemanticsKind::Owned:
+  case CxxRecordSemanticsKind::Reference:
+    if (auto cxxRecord = dyn_cast<clang::CXXRecordDecl>(clangType)) {
+      if (!cxxRecord->hasTrivialDestructor()) {
+        markDeprecated(
+            nominal,
+            "destroy operation '" +
+              destroyFunc->getName().getBaseName().userFacingName() +
+              "' is not allowed on types with a non-trivial destructor");
+        return nullptr;
+      }
+    }
+
+    LLVM_FALLTHROUGH;
+
+  case CxxRecordSemanticsKind::Trivial:
+    markDeprecated(
+        nominal,
+        "destroy operation '" +
+          destroyFunc->getName().getBaseName().userFacingName() +
+          "' is only allowed on non-copyable types; "
+          "did you mean to use SWIFT_NONCOPYABLE?");
+    return nullptr;
+
+  case CxxRecordSemanticsKind::Iterator:
+  case CxxRecordSemanticsKind::MissingLifetimeOperation:
+  case CxxRecordSemanticsKind::SwiftClassType:
+    return nullptr;
+
+  case CxxRecordSemanticsKind::MoveOnly:
+  case CxxRecordSemanticsKind::UnavailableConstructors:
+    // Handled below.
+    break;
+  }
+  if (semanticsKind != CxxRecordSemanticsKind::MoveOnly) {
+    return nullptr;
+  }
+
+  return destroyFunc;
+}
+
+/// Function body synthesizer for a deinit of a noncopyable type, which
+/// passes "self" to the given "destroy" function.
+static std::pair<BraceStmt *, bool>
+synthesizeDeinitBodyForCustomDestroy(
+    AbstractFunctionDecl *deinitFunc, void *opaqueDestroyFunc) {
+  auto deinit = cast<DestructorDecl>(deinitFunc);
+  auto destroyFunc = static_cast<FuncDecl *>(opaqueDestroyFunc);
+
+  ASTContext &ctx = deinit->getASTContext();
+  auto funcRef = new (ctx) DeclRefExpr(
+      destroyFunc, DeclNameLoc(), /*Implicit=*/true);
+  auto selfRef = new (ctx) DeclRefExpr(
+      deinit->getImplicitSelfDecl(), DeclNameLoc(), /*Implicit=*/true);
+  auto callExpr = CallExpr::createImplicit(
+      ctx, funcRef,
+      ArgumentList::createImplicit(
+        ctx,
+        { Argument(SourceLoc(), Identifier(), selfRef)}
+      )
+  );
+
+  auto braceStmt = BraceStmt::createImplicit(ctx, { ASTNode(callExpr) });
+  return std::make_pair(braceStmt, /*typechecked=*/false);
+}
+
+void SwiftDeclSynthesizer::addExplicitDeinitIfRequired(
+    NominalTypeDecl *nominal, const clang::RecordDecl *clangType) {
+  auto destroyFunc = findExplicitDestroy(nominal, clangType);
+  if (!destroyFunc)
+    return;
+
+  ASTContext &ctx = nominal->getASTContext();
+  auto destructor = new (ctx) DestructorDecl(SourceLoc(), nominal);
+  destructor->setSynthesized(true);
+  destructor->copyFormalAccessFrom(nominal, /*sourceIsParentContext*/true);
+  destructor->setBodySynthesizer(
+      synthesizeDeinitBodyForCustomDestroy, destroyFunc);
+
+  nominal->addMember(destructor);
+}
+
+FuncDecl *SwiftDeclSynthesizer::makeAvailabilityDomainPredicate(
+    const clang::VarDecl *var) {
+  ASTContext &ctx = ImporterImpl.SwiftContext;
+  clang::ASTContext &clangCtx = var->getASTContext();
+  auto featureInfo =
+      clangCtx.getFeatureAvailInfo(const_cast<clang::VarDecl *>(var));
+
+  // If the decl doesn't represent and availability domain, skip it.
+  if (featureInfo.first.empty())
+    return nullptr;
+
+  // Only dynamic availability domains require a predicate function.
+  if (featureInfo.second.Kind != clang::FeatureAvailKind::Dynamic)
+    return nullptr;
+
+  if (!featureInfo.second.Call)
+    return nullptr;
+
+  // Synthesize `func __swift_XYZ_isAvailable() -> Builtin.Int1 { ... }`.
+  std::string s;
+  llvm::raw_string_ostream os(s);
+  os << "__swift_" << featureInfo.first << "_isAvailable";
+  DeclName funcName(ctx, DeclBaseName(ctx.getIdentifier(s)),
+                    ParameterList::createEmpty(ctx));
+
+  auto funcDecl = FuncDecl::createImplicit(
+      ctx, StaticSpellingKind::None, funcName, SourceLoc(), /*Async=*/false,
+      /*Throws=*/false, Type(), {}, ParameterList::createEmpty(ctx),
+      BuiltinIntegerType::get(1, ctx), ImporterImpl.ImportedHeaderUnit);
+  funcDecl->setBodySynthesizer(synthesizeAvailabilityDomainPredicateBody,
+                               (void *)var);
+  funcDecl->setAccess(AccessLevel::Public);
+  funcDecl->getAttrs().add(new (ctx)
+                               AlwaysEmitIntoClientAttr(/*IsImplicit=*/true));
+
+  ImporterImpl.availabilityDomainPredicates[var] = funcDecl;
+
+  return funcDecl;
+}

lib/ClangImporter/SwiftDeclSynthesizer.h

@@ -341,8 +341,20 @@ class SwiftDeclSynthesizer {
   synthesizeStaticFactoryForCXXForeignRef(
       const clang::CXXRecordDecl *cxxRecordDecl);
 
+  /// Look for an explicitly-provided "destroy" operation. If one exists
+  /// and the type has been imported as noncopyable, add an explicit `deinit`
+  /// that calls that destroy operation.
+  void addExplicitDeinitIfRequired(
+      NominalTypeDecl *nominal, const clang::RecordDecl *clangType);
+
 private:
   Type getConstantLiteralType(Type type, ConstantConvertKind convertKind);
+
+  /// Find an explicitly-provided "destroy" operation specified for the
+  /// given Clang type and return it.
+  FuncDecl *findExplicitDestroy(
+      NominalTypeDecl *nominal, const clang::RecordDecl *clangType);
+
 };
 
 } // namespace swift

test/Interop/C/struct/Inputs/noncopyable-struct.h

@@ -8,12 +8,44 @@ typedef struct __attribute__((swift_attr("~Copyable"))) __attribute__((swift_att
   void *storage;
 } NonCopyableWithDeinit;
 
+typedef struct __attribute__((swift_attr("destroy:freeCopyableType"))) CopyableType {
+  void *storage;
+} CopyableType;
+
+typedef struct __attribute__((swift_attr("~Copyable"))) __attribute__((swift_attr("destroy:freeMultiNonCopyable1"))) __attribute__((swift_attr("destroy:freeMultiNonCopyable2"))) MultiNonCopyableType {
+  void *storage;
+} MultiNonCopyableType;
+
+typedef struct __attribute__((swift_attr("~Copyable"))) __attribute__((swift_attr("destroy:badDestroy1"))) BadDestroyNonCopyableType {
+  void *storage;
+} BadDestroyNonCopyableType;
+
+typedef struct __attribute__((swift_attr("~Copyable"))) __attribute__((swift_attr("destroy:badDestroy2"))) BadDestroyNonCopyableType2 {
+  void *storage;
+} BadDestroyNonCopyableType2;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 void freeNonCopyableWithDeinit(NonCopyableWithDeinit ncd);
+void freeCopyableType(CopyableType ct);
+
+
+void freeMultiNonCopyable1(MultiNonCopyableType ct);
+void freeMultiNonCopyable2(MultiNonCopyableType ct);
+
+void badDestroy1(void);
+void badDestroy2(BadDestroyNonCopyableType2 *ptr);
 
 #ifdef __cplusplus
+
+struct __attribute__((swift_attr("~Copyable"))) __attribute__((swift_attr("destroy:extraDestroy"))) ExtraDestroy {
+  void *storage;
+
+  ~ExtraDestroy() { }
+};
+
+void extraDestroy(ExtraDestroy);
 }
 #endif