Merge pull request #62838 from xedin/type-wrappers-and-swiftinterfaces

xedin · web-flow · commit ce4ec0842a4c · 2023-01-05T00:37:13.000-08:00
[Sema] TypeWrappers: If type wrapper comes from `.swiftinterface` use synthesized decls
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -3546,23 +3546,6 @@ class GetTypeWrapper
   bool isCached() const { return true; }
 };
 
-/// Return a type of the type wrapper (if any) associated with the given
-/// declaration.
-class GetTypeWrapperType
-    : public SimpleRequest<GetTypeWrapperType, Type(NominalTypeDecl *),
-                           RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  Type evaluate(Evaluator &evaluator, NominalTypeDecl *) const;
-
-public:
-  bool isCached() const { return true; }
-};
-
 /// Inject or get `$Storage` type which has all of the stored properties
 /// of the given type with a type wrapper.
 class GetTypeWrapperStorage
@@ -3762,23 +3745,6 @@ 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
@@ -404,9 +404,6 @@ SWIFT_REQUEST(TypeChecker, GetSourceFileAsyncNode,
 SWIFT_REQUEST(TypeChecker, GetTypeWrapper,
               Optional<TypeWrapperInfo>(NominalTypeDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, GetTypeWrapperType,
-              Type(NominalTypeDecl *),
-              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetTypeWrapperStorage,
               TypeDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
@@ -443,9 +440,6 @@ 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
@@ -21,17 +21,18 @@ namespace swift {
 
 struct TypeWrapperInfo {
   CustomAttr *Attr;
+  Type AttrType;
   NominalTypeDecl *Wrapper;
   NominalTypeDecl *AttachedTo;
   bool IsInferred;
 
-  TypeWrapperInfo(CustomAttr *attr, NominalTypeDecl *wrapperDecl,
+  TypeWrapperInfo(CustomAttr *attr, Type attrType, NominalTypeDecl *wrapperDecl,
                   NominalTypeDecl *attachedTo, bool isInferred)
-      : Attr(attr), Wrapper(wrapperDecl), AttachedTo(attachedTo),
-        IsInferred(isInferred) {}
+      : Attr(attr), AttrType(attrType), Wrapper(wrapperDecl),
+        AttachedTo(attachedTo), IsInferred(isInferred) {}
 
   TypeWrapperInfo asInferred() const {
-    return {Attr, Wrapper, AttachedTo, true};
+    return {Attr, AttrType, Wrapper, AttachedTo, true};
   }
 };
 
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -2949,19 +2949,7 @@ static bool usesFeatureSpecializeAttributeWithAvailability(Decl *decl) {
 }
 
 static bool usesFeatureTypeWrappers(Decl *decl) {
-  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);
+  return false;
 }
 
 static bool usesFeatureRuntimeDiscoverableAttrs(Decl *decl) {
diff --git a/lib/AST/TypeWrapper.cpp b/lib/AST/TypeWrapper.cpp
@@ -44,53 +44,3 @@ bool VarDecl::isTypeWrapperLocalStorageForInitializer() const {
   }
   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/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -362,7 +362,7 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
       params.push_back(arg);
     }
   } else if (ICK == ImplicitConstructorKind::TypeWrapperStorage) {
-    accessLevel = AccessLevel::Public;
+    accessLevel = decl->getTypeWrapperStorageDecl()->getFormalAccess();
 
     auto typeWrapperInfo = decl->getTypeWrapper();
     assert(typeWrapperInfo);
@@ -1657,14 +1657,29 @@ ConstructorDecl *SynthesizeTypeWrappedTypeStorageWrapperInitializer::evaluate(
   if (!wrappedType->hasTypeWrapper())
     return nullptr;
 
+  auto &ctx = wrappedType->getASTContext();
+
+  // .swiftinterfaces have both attribute and a synthesized member
+  // (if it's public), so in this case we need use existing declaration
+  // if available.
+  {
+    auto parentSF = wrappedType->getDeclContext()->getParentSourceFile();
+    if (parentSF && parentSF->Kind == SourceFileKind::Interface) {
+      DeclName initName(ctx, DeclBaseName::createConstructor(),
+                        /*labels=*/{ctx.Id_storageWrapper});
+      auto results = wrappedType->lookupDirect(initName);
+      if (results.size() == 1)
+        return cast<ConstructorDecl>(results.front());
+    }
+  }
+
   // `@typeWrapperIgnored` properties suppress this initializer.
   if (llvm::any_of(wrappedType->getMembers(), [&](Decl *member) {
         return member->getAttrs().hasAttribute<TypeWrapperIgnoredAttr>();
       }))
     return nullptr;
 
   // Create the implicit type wrapper storage constructor.
-  auto &ctx = wrappedType->getASTContext();
   auto ctor = createImplicitConstructor(
       wrappedType, ImplicitConstructorKind::TypeWrapperStorage, ctx);
   wrappedType->addMember(ctor);
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -3826,7 +3826,16 @@ void AttributeChecker::visitPropertyWrapperAttr(PropertyWrapperAttr *attr) {
 }
 
 void AttributeChecker::visitTypeWrapperAttr(TypeWrapperAttr *attr) {
-  if (!Ctx.LangOpts.hasFeature(Feature::TypeWrappers)) {
+  auto isEnabled = [&]() {
+    if (Ctx.LangOpts.hasFeature(Feature::TypeWrappers))
+      return true;
+
+    // Accept attributes that come from swiftinterface files.
+    auto *parentSF = D->getDeclContext()->getParentSourceFile();
+    return parentSF && parentSF->Kind == SourceFileKind::Interface;
+  };
+
+  if (!isEnabled()) {
     diagnose(attr->getLocation(), diag::type_wrappers_are_experimental);
     attr->setInvalid();
     return;
diff --git a/lib/Sema/TypeCheckTypeWrapper.cpp b/lib/Sema/TypeCheckTypeWrapper.cpp
@@ -26,6 +26,17 @@
 
 using namespace swift;
 
+/// Check whether given declaration comes from the .swiftinterface file.
+static bool inSwiftInterfaceContext(NominalTypeDecl *typeDecl) {
+  auto *SF = typeDecl->getDeclContext()->getParentSourceFile();
+  return SF && SF->Kind == SourceFileKind::Interface;
+}
+
+static ValueDecl *findMember(NominalTypeDecl *typeDecl, Identifier memberName) {
+  auto members = typeDecl->lookupDirect(memberName);
+  return members.size() == 1 ? members.front() : nullptr;
+}
+
 static PatternBindingDecl *injectVariable(DeclContext *DC, Identifier name,
                                           Type type,
                                           VarDecl::Introducer introducer,
@@ -119,9 +130,19 @@ static void getTypeWrappers(NominalTypeDecl *decl,
       continue;
 
     auto *typeWrapper = nominal->getAttrs().getAttribute<TypeWrapperAttr>();
-    if (typeWrapper && typeWrapper->isValid())
+    if (typeWrapper && typeWrapper->isValid()) {
+      auto attrType = evaluateOrDefault(
+          ctx.evaluator,
+          CustomAttrTypeRequest{mutableAttr, decl,
+                                CustomAttrTypeKind::TypeWrapper},
+          Type());
+
+      if (!attrType || attrType->hasError())
+        continue;
+
       typeWrappers.push_back(
-          {mutableAttr, nominal, decl, /*isInferred=*/false});
+          {mutableAttr, attrType, nominal, decl, /*isInferred=*/false});
+    }
   }
 
   // Do not allow transitive protocol inference between protocols.
@@ -184,24 +205,6 @@ GetTypeWrapper::evaluate(Evaluator &evaluator, NominalTypeDecl *decl) const {
   return typeWrappers.front();
 }
 
-Type GetTypeWrapperType::evaluate(Evaluator &evaluator,
-                                  NominalTypeDecl *decl) const {
-  auto typeWrapperInfo = decl->getTypeWrapper();
-  if (!typeWrapperInfo)
-    return Type();
-
-  auto type = evaluateOrDefault(
-      evaluator,
-      CustomAttrTypeRequest{typeWrapperInfo->Attr, decl->getDeclContext(),
-                            CustomAttrTypeKind::TypeWrapper},
-      Type());
-
-  if (!type || type->hasError()) {
-    return ErrorType::get(decl->getASTContext());
-  }
-  return type;
-}
-
 VarDecl *NominalTypeDecl::getTypeWrapperProperty() const {
   auto *mutableSelf = const_cast<NominalTypeDecl *>(this);
   return evaluateOrDefault(getASTContext().evaluator,
@@ -284,6 +287,15 @@ TypeDecl *GetTypeWrapperStorage::evaluate(Evaluator &evaluator,
 
   auto &ctx = parent->getASTContext();
 
+  // .swiftinterfaces have both attribute and a synthesized member
+  // (if it's public), so in this case we need use existing declaration
+  // if available.
+  if (inSwiftInterfaceContext(parent)) {
+    if (auto *storage = dyn_cast_or_null<TypeDecl>(
+            findMember(parent, ctx.Id_TypeWrapperStorage)))
+      return storage;
+  }
+
   TypeDecl *storage = nullptr;
   if (isa<ProtocolDecl>(parent)) {
     // If type wrapper is associated with a protocol, we need to
@@ -320,13 +332,19 @@ GetTypeWrapperProperty::evaluate(Evaluator &evaluator,
   if (!typeWrapper)
     return nullptr;
 
+  // .swiftinterfaces have both attribute and a synthesized member
+  // (if it's public), so in this case we need use existing declaration
+  // if available.
+  if (inSwiftInterfaceContext(parent)) {
+    if (auto *storage = dyn_cast_or_null<VarDecl>(
+            findMember(parent, ctx.Id_TypeWrapperProperty)))
+      return storage;
+  }
+
   auto *storage = parent->getTypeWrapperStorageDecl();
   assert(storage);
 
-  auto *typeWrapperType =
-      evaluateOrDefault(ctx.evaluator, GetTypeWrapperType{parent}, Type())
-          ->castTo<AnyGenericType>();
-  assert(typeWrapperType);
+  auto *typeWrapperType = typeWrapper->AttrType->castTo<AnyGenericType>();
 
   // $storage: Wrapper<<ParentType>, <ParentType>.$Storage>
   auto propertyTy = BoundGenericType::get(
diff --git a/test/ModuleInterface/type_wrappers.swift b/test/ModuleInterface/type_wrappers.swift
@@ -32,7 +32,6 @@ public struct Wrapper<W, S> {
 
 // CHECK: @TypeWrappers.Wrapper public class Test<T> where T : Swift.StringProtocol {
 // CHECK:   public init(a: Swift.Int, b: [T])
-// CHECK:   public init(storageWrapper: TypeWrappers.Wrapper<TypeWrappers.Test<T>, TypeWrappers.Test<T>.$Storage>)
 // CHECK: }
 
 @Wrapper
diff --git a/test/Serialization/type_wrapper_in_swiftinterface.swift b/test/Serialization/type_wrapper_in_swiftinterface.swift
