Merge pull request #62586 from xedin/rdar-103270262

xedin · web-flow · commit 7b08b30e84f4 · 2022-12-15T17:49:19.000-08:00
[AST/Sema] TypeWrappers: Fix a couple of issues with attribute inference from protocols
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -35,6 +35,7 @@
 #include "swift/AST/StorageImpl.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/TypeWalker.h"
+#include "swift/AST/TypeWrappers.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/ArrayRefView.h"
 #include "swift/Basic/Compiler.h"
@@ -3903,7 +3904,7 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   bool hasTypeWrapper() const { return bool(getTypeWrapper()); }
 
   /// Return a type wrapper (if any) associated with this type.
-  NominalTypeDecl *getTypeWrapper() const;
+  Optional<TypeWrapperInfo> getTypeWrapper() const;
 
   /// If this declaration has a type wrapper return a property that
   /// is used for all type wrapper related operations (mainly for
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -64,6 +64,7 @@ struct TypeWitnessAndDecl;
 class ValueDecl;
 enum class OpaqueReadOwnership: uint8_t;
 class StorageImplInfo;
+struct TypeWrapperInfo;
 
 /// Display a nominal type or extension thereof.
 void simple_display(
@@ -3522,15 +3523,17 @@ class GetSourceFileAsyncNode
 
 /// Return a type wrapper (if any) associated with the given declaration.
 class GetTypeWrapper
-    : public SimpleRequest<GetTypeWrapper, NominalTypeDecl *(NominalTypeDecl *),
+    : public SimpleRequest<GetTypeWrapper,
+                           Optional<TypeWrapperInfo>(NominalTypeDecl *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  NominalTypeDecl *evaluate(Evaluator &evaluator, NominalTypeDecl *) const;
+  Optional<TypeWrapperInfo> evaluate(Evaluator &evaluator,
+                                     NominalTypeDecl *) const;
 
 public:
   bool isCached() const { return true; }
@@ -3752,6 +3755,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,
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -402,7 +402,7 @@ SWIFT_REQUEST(TypeChecker, GetSourceFileAsyncNode,
               AwaitExpr *(const SourceFile *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetTypeWrapper,
-              NominalTypeDecl *(NominalTypeDecl *),
+              Optional<TypeWrapperInfo>(NominalTypeDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetTypeWrapperType,
               Type(NominalTypeDecl *),
@@ -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)
diff --git a/include/swift/AST/TypeWrappers.h b/include/swift/AST/TypeWrappers.h
@@ -0,0 +1,40 @@
+//===--------- TypeWrappers.h - Type Wrapper ASTs ---------------*- C++ -*-===//
+//
+// 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 defines helper types for type wrappers.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_TYPE_WRAPPERS_H
+#define SWIFT_AST_TYPE_WRAPPERS_H
+
+namespace swift {
+
+struct TypeWrapperInfo {
+  CustomAttr *Attr;
+  NominalTypeDecl *Wrapper;
+  NominalTypeDecl *AttachedTo;
+  bool IsInferred;
+
+  TypeWrapperInfo(CustomAttr *attr, NominalTypeDecl *wrapperDecl,
+                  NominalTypeDecl *attachedTo, bool isInferred)
+      : Attr(attr), Wrapper(wrapperDecl), AttachedTo(attachedTo),
+        IsInferred(isInferred) {}
+
+  TypeWrapperInfo asInferred() const {
+    return {Attr, Wrapper, AttachedTo, true};
+  }
+};
+
+} // end namespace swift
+
+#endif // SWIFT_AST_TYPE_WRAPPERS_H
diff --git a/lib/AST/ASTPrinter.cpp b/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"
@@ -1179,6 +1180,16 @@ void PrintAST::printAttributes(const Decl *D) {
 
   D->getAttrs().print(Printer, Options, D);
 
+  // We need to check whether this is a type with an inferred
+  // type wrapper attribute and if so print it explicitly.
+  if (auto *NTD = dyn_cast<NominalTypeDecl>(D)) {
+    auto typeWrapperInfo = NTD->getTypeWrapper();
+    // The attribute has been inferred and we have to print it.
+    if (typeWrapperInfo && typeWrapperInfo->IsInferred) {
+      typeWrapperInfo->Attr->print(Printer, Options, D);
+    }
+  }
+
   // Print the implicit 'final' attribute.
   if (auto VD = dyn_cast<ValueDecl>(D)) {
     auto VarD = dyn_cast<VarDecl>(D);
@@ -2936,7 +2947,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) {
diff --git a/lib/AST/CMakeLists.txt b/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
 
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -6599,14 +6599,6 @@ bool VarDecl::isMemberwiseInitialized(bool preferDeclaredProperties) const {
   return true;
 }
 
-bool VarDecl::isTypeWrapperLocalStorageForInitializer() const {
-  if (auto *ctor =
-          dyn_cast_or_null<ConstructorDecl>(getDeclContext()->getAsDecl())) {
-    return this == ctor->getLocalTypeWrapperStorageVar();
-  }
-  return false;
-}
-
 bool VarDecl::isLet() const {
   // An awful hack that stabilizes the value of 'isLet' for ParamDecl instances.
   //
@@ -8891,14 +8883,6 @@ bool ConstructorDecl::isObjCZeroParameterWithLongSelector() const {
   return params->get(0)->getInterfaceType()->isVoid();
 }
 
-VarDecl *ConstructorDecl::getLocalTypeWrapperStorageVar() const {
-  auto &ctx = getASTContext();
-  auto *mutableSelf = const_cast<ConstructorDecl *>(this);
-  return evaluateOrDefault(
-      ctx.evaluator, SynthesizeLocalVariableForTypeWrapperStorage{mutableSelf},
-      nullptr);
-}
-
 DestructorDecl::DestructorDecl(SourceLoc DestructorLoc, DeclContext *Parent)
   : AbstractFunctionDecl(DeclKind::Destructor, Parent,
                          DeclBaseName::createDestructor(), DestructorLoc,
diff --git a/lib/AST/TypeWrapper.cpp b/lib/AST/TypeWrapper.cpp
@@ -0,0 +1,96 @@
+//===--- 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"
+#include "swift/AST/TypeWrappers.h"
+
+using namespace swift;
+
+Optional<TypeWrapperInfo> NominalTypeDecl::getTypeWrapper() const {
+  auto *mutableSelf = const_cast<NominalTypeDecl *>(this);
+  return evaluateOrDefault(getASTContext().evaluator,
+                           GetTypeWrapper{mutableSelf},
+                           Optional<TypeWrapperInfo>());
+}
+
+VarDecl *ConstructorDecl::getLocalTypeWrapperStorageVar() const {
+  auto &ctx = getASTContext();
+  auto *mutableSelf = const_cast<ConstructorDecl *>(this);
+  return evaluateOrDefault(
+      ctx.evaluator, SynthesizeLocalVariableForTypeWrapperStorage{mutableSelf},
+      nullptr);
+}
+
+bool VarDecl::isTypeWrapperLocalStorageForInitializer() const {
+  if (auto *ctor =
+          dyn_cast_or_null<ConstructorDecl>(getDeclContext()->getAsDecl())) {
+    return this == ctor->getLocalTypeWrapperStorageVar();
+  }
+  return false;
+}
+
+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;
+}
diff --git a/lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp b/lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp
@@ -1257,8 +1257,9 @@ void LifetimeChecker::injectTypeWrapperStorageInitalization() {
       {
         bool isClass = isa<ClassDecl>(parentType);
 
-        auto typeWrapper = parentType->getTypeWrapper();
-        auto *typeWrapperInit = typeWrapper->getTypeWrapperInitializer();
+        auto typeWrapperInfo = parentType->getTypeWrapper();
+        auto *typeWrapperInit =
+            typeWrapperInfo->Wrapper->getTypeWrapperInitializer();
         SILValue typeWrapperInitRef = createInitRef(typeWrapperInit);
 
         auto *self = TheMemory.findUninitializedSelfValue();
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -364,7 +364,10 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
   } else if (ICK == ImplicitConstructorKind::TypeWrapperStorage) {
     accessLevel = AccessLevel::Public;
 
-    auto *typeWrapper = decl->getTypeWrapper();
+    auto typeWrapperInfo = decl->getTypeWrapper();
+    assert(typeWrapperInfo);
+
+    auto *typeWrapper = typeWrapperInfo->Wrapper;
 
     auto *arg = new (ctx) ParamDecl(SourceLoc(), Loc, ctx.Id_storageWrapper,
                                     Loc, ctx.Id_storageWrapper, decl);
diff --git a/lib/Sema/TypeCheckTypeWrapper.cpp b/lib/Sema/TypeCheckTypeWrapper.cpp
diff --git a/test/ModuleInterface/type_wrappers.swift b/test/ModuleInterface/type_wrappers.swift
