[cxx-interop] Add ability to specify protocol conformance on C++ side.

Author: zoecarver

include/swift/AST/Attr.h

@@ -167,9 +167,7 @@ class DeclAttribute : public AttributeBase {
       kind : 1
     );
 
-    SWIFT_INLINE_BITFIELD(SynthesizedProtocolAttr, DeclAttribute,
-                          NumKnownProtocolKindBits+1,
-      kind : NumKnownProtocolKindBits,
+    SWIFT_INLINE_BITFIELD(SynthesizedProtocolAttr, DeclAttribute, 1,
       isUnchecked : 1
     );
 
@@ -1364,22 +1362,22 @@ class ObjCBridgedAttr : public DeclAttribute {
 /// synthesized conformances.
 class SynthesizedProtocolAttr : public DeclAttribute {
   LazyConformanceLoader *Loader;
+  ProtocolDecl *protocol;
 
 public:
-  SynthesizedProtocolAttr(KnownProtocolKind protocolKind,
+  SynthesizedProtocolAttr(ProtocolDecl *protocol,
                           LazyConformanceLoader *Loader,
                           bool isUnchecked)
     : DeclAttribute(DAK_SynthesizedProtocol, SourceLoc(), SourceRange(),
-                    /*Implicit=*/true), Loader(Loader)
+                    /*Implicit=*/true), Loader(Loader), protocol(protocol)
   {
-    Bits.SynthesizedProtocolAttr.kind = unsigned(protocolKind);
     Bits.SynthesizedProtocolAttr.isUnchecked = unsigned(isUnchecked);
   }
 
   /// Retrieve the known protocol kind naming the protocol to be
   /// synthesized.
-  KnownProtocolKind getProtocolKind() const {
-    return KnownProtocolKind(Bits.SynthesizedProtocolAttr.kind);
+  ProtocolDecl *getProtocol() const {
+    return protocol;
   }
 
   bool isUnchecked() const {

lib/AST/ASTPrinter.cpp

@@ -7069,13 +7069,14 @@ swift::getInheritedForPrinting(
   llvm::SetVector<ProtocolDecl *> protocols;
   llvm::TinyPtrVector<ProtocolDecl *> uncheckedProtocols;
   for (auto attr : decl->getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
-    if (auto *proto = ctx.getProtocol(attr->getProtocolKind())) {
+    if (auto *proto = attr->getProtocol()) {
       // The SerialExecutor conformance is only synthesized on the root
       // actor class, so we can just test resilience immediately.
       if (proto->isSpecificProtocol(KnownProtocolKind::SerialExecutor) &&
           cast<ClassDecl>(decl)->isResilient())
         continue;
-      if (attr->getProtocolKind() == KnownProtocolKind::RawRepresentable &&
+      if (proto->getKnownProtocolKind() &&
+          *proto->getKnownProtocolKind() == KnownProtocolKind::RawRepresentable &&
           isa<EnumDecl>(decl) &&
           cast<EnumDecl>(decl)->hasRawType())
         continue;

lib/AST/ConformanceLookupTable.cpp

@@ -920,7 +920,7 @@ ConformanceLookupTable::getConformance(NominalTypeDecl *nominal,
       // Find a SynthesizedProtocolAttr corresponding to the protocol.
       for (auto attr : conformingNominal->getAttrs()
              .getAttributes<SynthesizedProtocolAttr>()) {
-        auto otherProto = ctx.getProtocol(attr->getProtocolKind());
+        auto otherProto = attr->getProtocol();
         if (otherProto == impliedProto) {
           // Set the conformance loader to the loader stashed inside
           // the attribute.

lib/AST/ProtocolConformance.cpp

@@ -1052,49 +1052,48 @@ void NominalTypeDecl::prepareConformanceTable() const {
 
   SmallPtrSet<ProtocolDecl *, 2> protocols;
 
-  auto addSynthesized = [&](KnownProtocolKind kind) {
-    if (auto *proto = getASTContext().getProtocol(kind)) {
-      if (protocols.count(proto) == 0) {
-        ConformanceTable->addSynthesizedConformance(
-            mutableThis, proto, mutableThis);
-        protocols.insert(proto);
-      }
+  auto addSynthesized = [&](ProtocolDecl *proto) {
+    llvm::dbgs() << "S\n";
+    if (protocols.count(proto) == 0) {
+      ConformanceTable->addSynthesizedConformance(
+          mutableThis, proto, mutableThis);
+      protocols.insert(proto);
     }
   };
 
   // Add protocols for any synthesized protocol attributes.
   for (auto attr : getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
-    addSynthesized(attr->getProtocolKind());
+    addSynthesized(attr->getProtocol());
   }
 
   // Add any implicit conformances.
   if (auto theEnum = dyn_cast<EnumDecl>(mutableThis)) {
     if (theEnum->hasCases() && theEnum->hasOnlyCasesWithoutAssociatedValues()) {
       // Simple enumerations conform to Equatable.
-      addSynthesized(KnownProtocolKind::Equatable);
+      addSynthesized(ctx.getProtocol(KnownProtocolKind::Equatable));
 
       // Simple enumerations conform to Hashable.
-      addSynthesized(KnownProtocolKind::Hashable);
+      addSynthesized(ctx.getProtocol(KnownProtocolKind::Hashable));
     }
 
     // Enumerations with a raw type conform to RawRepresentable.
     if (theEnum->hasRawType() && !theEnum->getRawType()->hasError()) {
-      addSynthesized(KnownProtocolKind::RawRepresentable);
+      addSynthesized(ctx.getProtocol(KnownProtocolKind::RawRepresentable));
     }
   }
 
   // Actor classes conform to the actor protocol.
   if (auto classDecl = dyn_cast<ClassDecl>(mutableThis)) {
     if (classDecl->isDistributedActor()) {
-      addSynthesized(KnownProtocolKind::DistributedActor);
+      addSynthesized(ctx.getProtocol(KnownProtocolKind::DistributedActor));
     } else if (classDecl->isActor()) {
-      addSynthesized(KnownProtocolKind::Actor);
+      addSynthesized(ctx.getProtocol(KnownProtocolKind::Actor));
     }
   }
 
   // Global actors conform to the GlobalActor protocol.
   if (mutableThis->getAttrs().hasAttribute<GlobalActorAttr>()) {
-    addSynthesized(KnownProtocolKind::GlobalActor);
+    addSynthesized(ctx.getProtocol(KnownProtocolKind::GlobalActor));
   }
 }
 

lib/ClangImporter/ImportDecl.cpp

@@ -430,7 +430,7 @@ void ClangImporter::Implementation::addSynthesizedProtocolAttrs(
 
   for (auto kind : synthesizedProtocolAttrs) {
     nominal->getAttrs().add(
-        new (ctx) SynthesizedProtocolAttr(kind, this, isUnchecked));
+        new (ctx) SynthesizedProtocolAttr(ctx.getProtocol(kind), this, isUnchecked));
   }
 }
 
@@ -2611,23 +2611,56 @@ namespace {
       }
 
       auto result = VisitRecordDecl(decl);
+      if (!result)
+        return nullptr;
 
-      if (auto classDecl = dyn_cast_or_null<ClassDecl>(result))
+      if (auto classDecl = dyn_cast<ClassDecl>(result))
         validateForeignReferenceType(decl, classDecl);
 
       // If this module is declared as a C++ module, try to synthesize
       // conformances to Swift protocols from the Cxx module.
       auto clangModule = decl->getOwningModule();
       if (clangModule && requiresCPlusPlus(clangModule)) {
-        if (auto structDecl = dyn_cast_or_null<NominalTypeDecl>(result)) {
-          conformToCxxIteratorIfNeeded(Impl, structDecl, decl);
-          conformToCxxSequenceIfNeeded(Impl, structDecl, decl);
-        }
+        auto nominalDecl = cast<NominalTypeDecl>(result);
+        conformToCxxIteratorIfNeeded(Impl, nominalDecl, decl);
+        conformToCxxSequenceIfNeeded(Impl, nominalDecl, decl);
       }
 
+      addExplicitProtocolConformances(cast<NominalTypeDecl>(result));
+
       return result;
     }
 
+    void addExplicitProtocolConformances(NominalTypeDecl *decl) {
+      auto clangDecl = decl->getClangDecl();
+
+      SmallVector<ValueDecl *, 2> results;
+      auto conformsToAttr =
+          llvm::find_if(clangDecl->getAttrs(), [](auto *attr) {
+            if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
+              return swiftAttr->getAttribute().startswith("conforms_to:");
+            return false;
+          });
+      if (conformsToAttr == clangDecl->getAttrs().end())
+        return;
+
+      auto name = cast<clang::SwiftAttrAttr>(*conformsToAttr)
+                      ->getAttribute()
+                      .drop_front(StringRef("conforms_to:").size())
+                      .str();
+
+      for (auto &module : Impl.SwiftContext.getLoadedModules()) {
+        module.second->lookupValue(Impl.SwiftContext.getIdentifier(name),
+                                   NLKind::UnqualifiedLookup, results);
+      }
+      for (auto proto : results) {
+        if (auto protocol = dyn_cast<ProtocolDecl>(proto)) {
+          decl->getAttrs().add(
+              new (Impl.SwiftContext) SynthesizedProtocolAttr(protocol, &Impl, false));
+        }
+      }
+    }
+
     bool isSpecializationDepthGreaterThan(
         const clang::ClassTemplateSpecializationDecl *decl, unsigned maxDepth) {
       for (auto arg : decl->getTemplateArgs().asArray()) {
@@ -5126,10 +5159,11 @@ static bool conformsToProtocolInOriginalModule(NominalTypeDecl *nominal,
   if (inheritanceListContainsProtocol(nominal, proto))
     return true;
 
-  for (auto attr : nominal->getAttrs().getAttributes<SynthesizedProtocolAttr>())
-    if (auto *otherProto = ctx.getProtocol(attr->getProtocolKind()))
-      if (otherProto == proto || otherProto->inheritsFrom(proto))
-        return true;
+  for (auto attr : nominal->getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
+    auto *otherProto = attr->getProtocol();
+    if (otherProto == proto || otherProto->inheritsFrom(proto))
+      return true;
+  }
 
   // Only consider extensions from the original module...or from an overlay
   // or the Swift half of a mixed-source framework.

test/Interop/Cxx/class/Inputs/conforms-to.h

@@ -0,0 +1,20 @@
+#ifndef TEST_INTEROP_CXX_CLASS_INPUTS_DESTRUCTORS_H
+#define TEST_INTEROP_CXX_CLASS_INPUTS_DESTRUCTORS_H
+
+struct
+    __attribute__((swift_attr("conforms_to:Testable")))
+    HasTest {
+  void test() const;
+};
+
+struct
+    __attribute__((swift_attr("conforms_to:Playable")))
+    __attribute__((swift_attr("import_reference")))
+    __attribute__((swift_attr("retain:immortal")))
+    __attribute__((swift_attr("release:immortal")))
+    HasPlay {
+  void play() const;
+};
+
+
+#endif // TEST_INTEROP_CXX_CLASS_INPUTS_DESTRUCTORS_H

test/Interop/Cxx/class/Inputs/module.modulemap

@@ -126,3 +126,8 @@ module ForwardDeclaredInNamespace {
   header "forward-declared-in-namespace.h"
   requires cplusplus
 }
+
+module ConformsTo {
+  header "conforms-to.h"
+  requires cplusplus
+}

test/Interop/Cxx/class/conforms-to.swift

@@ -0,0 +1,27 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown -I %S/Inputs -enable-experimental-cxx-interop
+
+import ConformsTo
+
+protocol Testable {
+    func test()
+}
+
+protocol Playable {
+    func play()
+}
+
+func callee(_ _: Testable) {
+
+}
+
+func caller(_ x: HasTest) {
+    callee(x)
+}
+
+func callee(_ _: Playable) {
+
+}
+
+func caller(_ x: Playable) {
+    callee(x)
+}