[ASTPrinter] Expand type wrapper feature coverage

`usesFeatureTypeWrappers` should return `true` for all of
the declarations that use the feature directly or indirectly
e.g. type wrapper types, type wrapped types, and types with
conformance to a type wrapped protocol (with or without wrapper
attribute inference).

Author: xedin

include/swift/AST/TypeCheckRequests.h

@@ -3752,6 +3752,23 @@ class GetTypeWrapperInitializer
   bool isCached() const { return true; }
 };
 
+/// Check whether this is a protocol that has a type wrapper attribute
+/// or one of its dependencies does.
+class UsesTypeWrapperFeature
+    : public SimpleRequest<UsesTypeWrapperFeature, bool(NominalTypeDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, NominalTypeDecl *) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Find the definition of a given macro.
 class MacroDefinitionRequest
     : public SimpleRequest<MacroDefinitionRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -443,6 +443,9 @@ SWIFT_REQUEST(TypeChecker, ContinueTargetRequest,
 SWIFT_REQUEST(TypeChecker, GetTypeWrapperInitializer,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, UsesTypeWrapperFeature,
+              bool(NominalTypeDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, MacroDefinitionRequest,
               MacroDefinition(MacroDecl *),
               Cached, NoLocationInfo)

lib/AST/ASTPrinter.cpp

@@ -37,6 +37,7 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/SILLayout.h"
 #include "swift/AST/Stmt.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeVisitor.h"
 #include "swift/AST/TypeWalker.h"
 #include "swift/AST/Types.h"
@@ -2935,7 +2936,19 @@ static bool usesFeatureSpecializeAttributeWithAvailability(Decl *decl) {
 }
 
 static bool usesFeatureTypeWrappers(Decl *decl) {
-  return decl->getAttrs().hasAttribute<TypeWrapperAttr>();
+  NullablePtr<NominalTypeDecl> typeDecl;
+
+  if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
+    typeDecl = extension->getExtendedNominal();
+  } else {
+    typeDecl = dyn_cast<NominalTypeDecl>(decl);
+  }
+
+  if (!typeDecl)
+    return false;
+
+  return evaluateOrDefault(decl->getASTContext().evaluator,
+                           UsesTypeWrapperFeature{typeDecl.get()}, false);
 }
 
 static bool usesFeatureRuntimeDiscoverableAttrs(Decl *decl) {

lib/AST/CMakeLists.txt

@@ -116,6 +116,7 @@ add_swift_host_library(swiftAST STATIC
   TypeRefinementContext.cpp
   TypeRepr.cpp
   TypeWalker.cpp
+  TypeWrapper.cpp
   UnqualifiedLookup.cpp
   USRGeneration.cpp
 

lib/AST/TypeWrapper.cpp

@@ -0,0 +1,78 @@
+//===--- TypeWrapper.cpp - Type Traversal ---------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements functionality related to type wrapper feature.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/ASTContext.h"
+#include "swift/AST/Decl.h"
+#include "swift/AST/TypeCheckRequests.h"
+#include "swift/AST/TypeResolutionStage.h"
+
+using namespace swift;
+
+NominalTypeDecl *NominalTypeDecl::getTypeWrapper() const {
+  auto *mutableSelf = const_cast<NominalTypeDecl *>(this);
+  return evaluateOrDefault(getASTContext().evaluator,
+                           GetTypeWrapper{mutableSelf}, nullptr);
+}
+
+bool UsesTypeWrapperFeature::evaluate(Evaluator &evaluator,
+                                      NominalTypeDecl *decl) const {
+  // This is a type wrapper type.
+  if (decl->getAttrs().hasAttribute<TypeWrapperAttr>())
+    return true;
+
+  // This is a type wrapped type.
+  if (decl->hasTypeWrapper())
+    return true;
+
+  // This type could be depending on a type wrapper feature
+  // indirectly by conforming to a protocol with a type
+  // wrapper attribute. To determine that we need to walk
+  // protocol dependency chains and check each one.
+
+  auto &ctx = decl->getASTContext();
+
+  auto usesTypeWrapperFeature = [&](ProtocolDecl *protocol) {
+    return evaluateOrDefault(ctx.evaluator, UsesTypeWrapperFeature{protocol},
+                             false);
+  };
+
+  for (unsigned i : indices(decl->getInherited())) {
+    auto inheritedType = evaluateOrDefault(
+        ctx.evaluator,
+        InheritedTypeRequest{decl, i, TypeResolutionStage::Interface}, Type());
+
+    if (!(inheritedType && inheritedType->isConstraintType()))
+      continue;
+
+    if (auto *protocol =
+        dyn_cast_or_null<ProtocolDecl>(inheritedType->getAnyNominal())) {
+      if (usesTypeWrapperFeature(protocol))
+        return true;
+    }
+
+    if (auto composition = inheritedType->getAs<ProtocolCompositionType>()) {
+      for (auto member : composition->getMembers()) {
+        if (auto *protocol =
+                dyn_cast_or_null<ProtocolDecl>(member->getAnyNominal())) {
+          if (usesTypeWrapperFeature(protocol))
+            return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -77,12 +77,6 @@ VarDecl *VarDecl::getUnderlyingTypeWrapperStorage() const {
                            nullptr);
 }
 
-NominalTypeDecl *NominalTypeDecl::getTypeWrapper() const {
-  auto *mutableSelf = const_cast<NominalTypeDecl *>(this);
-  return evaluateOrDefault(getASTContext().evaluator,
-                           GetTypeWrapper{mutableSelf}, nullptr);
-}
-
 struct TypeWrapperAttrInfo {
   CustomAttr *Attr;
   NominalTypeDecl *Wrapper;