[AST] NonCopyableGenerics: Expand hasInverseMarking to support associated type declarations

This is required for `ASTPrinter` to wrap the protocol that has
associated type with inverses in a feature block.

Author: xedin

include/swift/AST/Decl.h

@@ -3933,6 +3933,10 @@ class AssociatedTypeDecl : public TypeDecl {
         TypeDecl::getOverriddenDecl());
   }
 
+  /// Determine whether this type has ~<target>` stated as
+  /// one of its inherited types.
+  InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
+
   /// Retrieve the set of associated types overridden by this associated
   /// type.
   llvm::TinyPtrVector<AssociatedTypeDecl *> getOverriddenDecls() const;

lib/AST/ASTPrinter.cpp

@@ -3382,23 +3382,40 @@ static bool hasInverse(
   if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
     if (auto *nominal = extension->getSelfNominalTypeDecl())
       return hasInverse(nominal, ip, isRelevantInverse);
+    return false;
   }
 
-  if (auto *TD = dyn_cast<TypeDecl>(decl))
-    return isRelevantInverse(TD->hasInverseMarking(ip));
+  auto hasInverseInType = [&](Type type) {
+    return type.findIf([&](Type type) -> bool {
+      if (auto *typeDecl = getTypeDecl(type))
+        return hasInverse(typeDecl, ip, isRelevantInverse);
+      return false;
+    });
+  };
 
-  if (auto value = dyn_cast<ValueDecl>(decl)) {
-    // Check for noncopyable types in the types of this declaration.
-    if (Type type = value->getInterfaceType()) {
-      bool foundInverse = type.findIf([&](Type type) -> bool {
-        if (auto *typeDecl = getTypeDecl(type))
-          return hasInverse(typeDecl, ip, isRelevantInverse);
-        return false;
-      });
+  if (auto *TD = dyn_cast<TypeDecl>(decl)) {
+    if (auto *alias = dyn_cast<TypeAliasDecl>(TD))
+      return hasInverseInType(alias->getUnderlyingType());
 
-      if (foundInverse)
+    if (auto *NTD = dyn_cast<NominalTypeDecl>(TD)) {
+      if (isRelevantInverse(NTD->hasInverseMarking(ip)))
         return true;
     }
+
+    if (auto *P = dyn_cast<ProtocolDecl>(TD)) {
+      // Check the protocol's associated types too.
+      return llvm::any_of(
+          P->getAssociatedTypeMembers(), [&](AssociatedTypeDecl *ATD) {
+            return isRelevantInverse(ATD->hasInverseMarking(ip));
+          });
+    }
+
+    return false;
+  }
+
+  if (auto *VD = dyn_cast<ValueDecl>(decl)) {
+    if (VD->hasInterfaceType())
+      return hasInverseInType(VD->getInterfaceType());
   }
 
   return false;

lib/AST/Decl.cpp

@@ -6675,6 +6675,16 @@ bool NominalTypeDecl::hasMarking(InvertibleProtocolKind target) const {
   return mark;
 }
 
+InverseMarking::Mark
+AssociatedTypeDecl::hasInverseMarking(InvertibleProtocolKind target) const {
+  auto &ctx = getASTContext();
+
+  if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+    return InverseMarking::Mark();
+
+  return findInverseInInheritance(getInherited(), target);
+}
+
 InverseMarking::Mark
 NominalTypeDecl::hasInverseMarking(InvertibleProtocolKind target) const {
   switch (target) {
@@ -6720,12 +6730,6 @@ NominalTypeDecl::hasInverseMarking(InvertibleProtocolKind target) const {
   if (!gpList)
     return InverseMarking::Mark();
 
-  auto isInverseTarget = [&](Type t) -> bool {
-    if (auto pct = t->getAs<ProtocolCompositionType>())
-      return pct->getInverses().contains(target);
-    return false;
-  };
-
   llvm::SmallSet<GenericTypeParamDecl *, 4> params;
 
   // Scan the inheritance clauses of generic parameters only for an inverse.