Merge pull request swiftlang#36521 from hborla/property-wrapper-request-refactoring

[Property Wrappers] Rework the dependencies between property wrapper requests.

Author: hborla

include/swift/AST/ASTTypeIDZone.def

@@ -26,7 +26,8 @@ SWIFT_TYPEID(GenericSignature)
 SWIFT_TYPEID(ImplicitImportList)
 SWIFT_TYPEID(ImplicitMemberAction)
 SWIFT_TYPEID(ParamSpecifier)
-SWIFT_TYPEID(PropertyWrapperBackingPropertyInfo)
+SWIFT_TYPEID(PropertyWrapperAuxiliaryVariables)
+SWIFT_TYPEID(PropertyWrapperInitializerInfo)
 SWIFT_TYPEID(PropertyWrapperTypeInfo)
 SWIFT_TYPEID(Requirement)
 SWIFT_TYPEID(ResilienceExpansion)

include/swift/AST/ASTTypeIDs.h

@@ -54,7 +54,8 @@ enum class ParamSpecifier : uint8_t;
 class PostfixOperatorDecl;
 class PrecedenceGroupDecl;
 class PrefixOperatorDecl;
-struct PropertyWrapperBackingPropertyInfo;
+struct PropertyWrapperAuxiliaryVariables;
+class PropertyWrapperInitializerInfo;
 struct PropertyWrapperTypeInfo;
 enum class CtorInitializerKind;
 struct PropertyWrapperLValueness;

include/swift/AST/Decl.h

@@ -82,7 +82,8 @@ namespace swift {
   class ParameterTypeFlags;
   class Pattern;
   struct PrintOptions;
-  struct PropertyWrapperBackingPropertyInfo;
+  struct PropertyWrapperAuxiliaryVariables;
+  class PropertyWrapperInitializerInfo;
   struct PropertyWrapperTypeInfo;
   struct PropertyWrapperMutability;
   class ProtocolDecl;
@@ -4957,10 +4958,15 @@ class VarDecl : public AbstractStorageDecl {
   /// unbound generic types. It will be the type of the backing property.
   Type getPropertyWrapperBackingPropertyType() const;
 
-  /// Retrieve information about the backing properties of the attached
-  /// property wrapper.
-  PropertyWrapperBackingPropertyInfo
-      getPropertyWrapperBackingPropertyInfo() const;
+  /// If there is an attached property wrapper, retrieve the synthesized
+  /// auxiliary variables.
+  PropertyWrapperAuxiliaryVariables
+      getPropertyWrapperAuxiliaryVariables() const;
+
+  /// If there is an attached property wrapper, retrieve information about
+  /// how to initialize the backing property.
+  PropertyWrapperInitializerInfo
+      getPropertyWrapperInitializerInfo() const;
 
   /// Retrieve information about the mutability of the composed
   /// property wrappers.

include/swift/AST/PropertyWrappers.h

@@ -170,16 +170,39 @@ void simple_display(llvm::raw_ostream &os, PropertyWrapperLValueness l);
 /// be initialized out-of-line using an expression of the wrapped property type.
 PropertyWrapperValuePlaceholderExpr *findWrappedValuePlaceholder(Expr *init);
 
-/// Describes the backing property of a property that has an attached wrapper.
-struct PropertyWrapperBackingPropertyInfo {
+/// The synthesized auxiliary declarations for a wrapped property, including the
+/// backing property wrapper, the projected value variable, and if the wrapped
+/// declaration is a parameter, the local wrapped value variable.
+struct PropertyWrapperAuxiliaryVariables {
   /// The backing property.
   VarDecl *backingVar = nullptr;
 
   /// The synthesized projection property, if any. When present, this takes the name
   /// of the original wrapped property prefixed with \c $
   VarDecl *projectionVar = nullptr;
 
-private:
+  /// The synthesized local wrapped value property, which shadows the original wrapped
+  /// declaration if it is a parameter.
+  VarDecl *localWrappedValueVar = nullptr;
+
+  PropertyWrapperAuxiliaryVariables() {}
+
+  PropertyWrapperAuxiliaryVariables(VarDecl *backingVar, VarDecl *projectionVar,
+                                    VarDecl *localWrappedValueVar = nullptr)
+      : backingVar(backingVar), projectionVar(projectionVar),
+        localWrappedValueVar(localWrappedValueVar) {}
+
+  /// Whether this is a valid property wrapper.
+  bool isValid() const {
+    return backingVar != nullptr;
+  }
+
+  explicit operator bool() const { return isValid(); }
+};
+
+/// Describes how to initialize the backing storage of a property with
+/// an attached wrapper.
+class PropertyWrapperInitializerInfo {
   struct {
     /// An expression that initializes the backing property from a value of
     /// the original property's type via \c init(wrappedValue:) if supported
@@ -203,15 +226,10 @@ struct PropertyWrapperBackingPropertyInfo {
   } projectedValueInit;
 
 public:
-  PropertyWrapperBackingPropertyInfo() { }
-
-  PropertyWrapperBackingPropertyInfo(VarDecl *backingVar, VarDecl *projectionVar)
-      : backingVar(backingVar), projectionVar(projectionVar) { }
+  PropertyWrapperInitializerInfo() { }
 
-  PropertyWrapperBackingPropertyInfo(VarDecl *backingVar, VarDecl *projectionVar,
-                                     Expr *wrappedValueInitExpr,
-                                     Expr *projectedValueInitExpr)
-      : backingVar(backingVar), projectionVar(projectionVar) {
+  PropertyWrapperInitializerInfo(Expr *wrappedValueInitExpr,
+                                 Expr *projectedValueInitExpr) {
     wrappedValueInit.expr = wrappedValueInitExpr;
     if (wrappedValueInitExpr) {
       wrappedValueInit.placeholder = findWrappedValuePlaceholder(wrappedValueInitExpr);
@@ -223,16 +241,11 @@ struct PropertyWrapperBackingPropertyInfo {
     }
   }
 
-  /// Whether this is a valid property wrapper.
-  bool isValid() const {
-    return backingVar != nullptr;
-  }
-
   bool hasInitFromWrappedValue() const {
     return wrappedValueInit.expr != nullptr;
   }
 
-  Expr *getInitFromWrappedValue() {
+  Expr *getInitFromWrappedValue() const {
     return wrappedValueInit.expr;
   }
 
@@ -244,7 +257,7 @@ struct PropertyWrapperBackingPropertyInfo {
     return projectedValueInit.expr != nullptr;
   }
 
-  Expr *getInitFromProjectedValue() {
+  Expr *getInitFromProjectedValue() const {
     return projectedValueInit.expr;
   }
 
@@ -255,14 +268,6 @@ struct PropertyWrapperBackingPropertyInfo {
   bool hasSynthesizedInitializers() const {
     return hasInitFromWrappedValue() || hasInitFromProjectedValue();
   }
-
-  explicit operator bool() const { return isValid(); }
-
-  friend bool operator==(const PropertyWrapperBackingPropertyInfo &lhs,
-                         const PropertyWrapperBackingPropertyInfo &rhs) {
-    // FIXME: Can't currently compare expressions.
-    return lhs.backingVar == rhs.backingVar;
-  }
 };
 
 void simple_display(
@@ -271,7 +276,11 @@ void simple_display(
 
 void simple_display(
     llvm::raw_ostream &out,
-    const PropertyWrapperBackingPropertyInfo &backingInfo);
+    const PropertyWrapperInitializerInfo &initInfo);
+
+void simple_display(
+    llvm::raw_ostream &out,
+    const PropertyWrapperAuxiliaryVariables &auxiliaryVars);
 
 } // end namespace swift
 

include/swift/AST/TypeCheckRequests.h

@@ -44,7 +44,7 @@ class DefaultArgumentExpr;
 class ClosureExpr;
 class GenericParamList;
 class PrecedenceGroupDecl;
-struct PropertyWrapperBackingPropertyInfo;
+class PropertyWrapperInitializerInfo;
 struct PropertyWrapperLValueness;
 struct PropertyWrapperMutability;
 class RequirementRepr;
@@ -712,11 +712,10 @@ class PropertyWrapperLValuenessRequest :
   bool isCached() const;
 };
 
-/// Request information about the backing property for properties that have
-/// attached property wrappers.
-class PropertyWrapperBackingPropertyInfoRequest :
-    public SimpleRequest<PropertyWrapperBackingPropertyInfoRequest,
-                         PropertyWrapperBackingPropertyInfo(VarDecl *),
+/// Request the synthesized auxiliary declarations for a wrapped property.
+class PropertyWrapperAuxiliaryVariablesRequest :
+    public SimpleRequest<PropertyWrapperAuxiliaryVariablesRequest,
+                         PropertyWrapperAuxiliaryVariables(VarDecl *),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -725,19 +724,19 @@ class PropertyWrapperBackingPropertyInfoRequest :
   friend SimpleRequest;
 
   // Evaluation.
-  PropertyWrapperBackingPropertyInfo
+  PropertyWrapperAuxiliaryVariables
   evaluate(Evaluator &evaluator, VarDecl *var) const;
 
 public:
   // Caching
   bool isCached() const;
 };
 
-/// Request the synthesized local wrapped value var for a parameter
-/// that has an attached property wrapper.
-class PropertyWrapperWrappedValueVarRequest :
-    public SimpleRequest<PropertyWrapperWrappedValueVarRequest,
-                         VarDecl *(VarDecl *),
+/// Request information about initialization of the backing property
+/// for properties that have attached property wrappers.
+class PropertyWrapperInitializerInfoRequest :
+    public SimpleRequest<PropertyWrapperInitializerInfoRequest,
+                         PropertyWrapperInitializerInfo(VarDecl *),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -746,7 +745,8 @@ class PropertyWrapperWrappedValueVarRequest :
   friend SimpleRequest;
 
   // Evaluation.
-  VarDecl *evaluate(Evaluator &evaluator, VarDecl *var) const;
+  PropertyWrapperInitializerInfo
+  evaluate(Evaluator &evaluator, VarDecl *var) const;
 
 public:
   // Caching

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -189,11 +189,11 @@ SWIFT_REQUEST(TypeChecker, PatternBindingEntryRequest,
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PrimarySourceFilesRequest,
               ArrayRef<SourceFile *>(ModuleDecl *), Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, PropertyWrapperBackingPropertyInfoRequest,
-              PropertyWrapperBackingPropertyInfo(VarDecl *), Cached,
+SWIFT_REQUEST(TypeChecker, PropertyWrapperAuxiliaryVariablesRequest,
+              PropertyWrapperAuxiliaryVariables(VarDecl *), Cached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, PropertyWrapperWrappedValueVarRequest,
-              VarDecl *(VarDecl *), Cached,
+SWIFT_REQUEST(TypeChecker, PropertyWrapperInitializerInfoRequest,
+              PropertyWrapperInitializerInfo(VarDecl *), Cached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PropertyWrapperBackingPropertyTypeRequest,
               Type(VarDecl *), Cached, NoLocationInfo)

lib/AST/ASTContext.cpp

@@ -5020,7 +5020,7 @@ VarDecl *VarDecl::getOriginalWrappedProperty(
   if (!kind)
     return original;
 
-  auto wrapperInfo = original->getPropertyWrapperBackingPropertyInfo();
+  auto wrapperInfo = original->getPropertyWrapperAuxiliaryVariables();
   switch (*kind) {
   case PropertyWrapperSynthesizedPropertyKind::Backing:
     return this == wrapperInfo.backingVar ? original : nullptr;

lib/AST/Decl.cpp

@@ -5931,14 +5931,24 @@ Type VarDecl::getPropertyWrapperBackingPropertyType() const {
       Type());
 }
 
-PropertyWrapperBackingPropertyInfo
-VarDecl::getPropertyWrapperBackingPropertyInfo() const {
+PropertyWrapperAuxiliaryVariables
+VarDecl::getPropertyWrapperAuxiliaryVariables() const {
   auto &ctx = getASTContext();
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(
       ctx.evaluator,
-      PropertyWrapperBackingPropertyInfoRequest{mutableThis},
-      PropertyWrapperBackingPropertyInfo());
+      PropertyWrapperAuxiliaryVariablesRequest{mutableThis},
+      PropertyWrapperAuxiliaryVariables());
+}
+
+PropertyWrapperInitializerInfo
+VarDecl::getPropertyWrapperInitializerInfo() const {
+  auto &ctx = getASTContext();
+  auto mutableThis = const_cast<VarDecl *>(this);
+  return evaluateOrDefault(
+      ctx.evaluator,
+      PropertyWrapperInitializerInfoRequest{mutableThis},
+      PropertyWrapperInitializerInfo());
 }
 
 Optional<PropertyWrapperMutability>
@@ -5963,20 +5973,15 @@ VarDecl::getPropertyWrapperSynthesizedPropertyKind() const {
 }
 
 VarDecl *VarDecl::getPropertyWrapperBackingProperty() const {
-  return getPropertyWrapperBackingPropertyInfo().backingVar;
+  return getPropertyWrapperAuxiliaryVariables().backingVar;
 }
 
 VarDecl *VarDecl::getPropertyWrapperProjectionVar() const {
-  return getPropertyWrapperBackingPropertyInfo().projectionVar;
+  return getPropertyWrapperAuxiliaryVariables().projectionVar;
 }
 
 VarDecl *VarDecl::getPropertyWrapperWrappedValueVar() const {
-  auto &ctx = getASTContext();
-  auto mutableThis = const_cast<VarDecl *>(this);
-  return evaluateOrDefault(
-      ctx.evaluator,
-      PropertyWrapperWrappedValueVarRequest{mutableThis},
-      nullptr);
+  return getPropertyWrapperAuxiliaryVariables().localWrappedValueVar;
 }
 
 void VarDecl::visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)> visit) const {
@@ -6038,11 +6043,11 @@ bool VarDecl::isPropertyMemberwiseInitializedWithWrappedType() const {
 }
 
 Type VarDecl::getPropertyWrapperInitValueInterfaceType() const {
-  auto wrapperInfo = getPropertyWrapperBackingPropertyInfo();
-  if (!wrapperInfo || !wrapperInfo.getWrappedValuePlaceholder())
+  auto initInfo = getPropertyWrapperInitializerInfo();
+  if (!initInfo.getWrappedValuePlaceholder())
     return Type();
 
-  Type valueInterfaceTy = wrapperInfo.getWrappedValuePlaceholder()->getType();
+  Type valueInterfaceTy = initInfo.getWrappedValuePlaceholder()->getType();
   if (valueInterfaceTy->hasArchetype())
     valueInterfaceTy = valueInterfaceTy->mapTypeOutOfContext();
 

lib/AST/NameLookup.cpp

@@ -28,6 +28,7 @@
 #include "swift/AST/ModuleNameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/ParameterList.h"
+#include "swift/AST/PropertyWrappers.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/STLExtras.h"
@@ -1673,8 +1674,10 @@ static void installPropertyWrapperMembersIfNeeded(NominalTypeDecl *target,
     if (auto var = dyn_cast<VarDecl>(member)) {
       if (var->hasAttachedPropertyWrapper()) {
         auto sourceFile = var->getDeclContext()->getParentSourceFile();
-        if (sourceFile && sourceFile->Kind != SourceFileKind::Interface)
-          (void)var->getPropertyWrapperBackingProperty();
+        if (sourceFile && sourceFile->Kind != SourceFileKind::Interface) {
+          (void)var->getPropertyWrapperAuxiliaryVariables();
+          (void)var->getPropertyWrapperInitializerInfo();
+        }
       }
     }
   }

lib/AST/TypeCheckRequests.cpp

@@ -485,15 +485,16 @@ bool AttachedPropertyWrapperTypeRequest::isCached() const {
 
 bool PropertyWrapperBackingPropertyTypeRequest::isCached() const {
   auto var = std::get<0>(getStorage());
-  return !var->getAttrs().isEmpty();
+  return !var->getAttrs().isEmpty() &&
+         !(isa<ParamDecl>(var) && isa<ClosureExpr>(var->getDeclContext()));
 }
 
-bool PropertyWrapperBackingPropertyInfoRequest::isCached() const {
+bool PropertyWrapperAuxiliaryVariablesRequest::isCached() const {
   auto var = std::get<0>(getStorage());
   return !var->getAttrs().isEmpty() || var->hasImplicitPropertyWrapper();
 }
 
-bool PropertyWrapperWrappedValueVarRequest::isCached() const {
+bool PropertyWrapperInitializerInfoRequest::isCached() const {
   auto var = std::get<0>(getStorage());
   return !var->getAttrs().isEmpty() || var->hasImplicitPropertyWrapper();
 }
@@ -520,10 +521,21 @@ void swift::simple_display(
 
 void swift::simple_display(
     llvm::raw_ostream &out,
-    const PropertyWrapperBackingPropertyInfo &backingInfo) {
+    const PropertyWrapperInitializerInfo &initInfo) {
+  out << "{";
+  if (initInfo.hasInitFromWrappedValue())
+    initInfo.getInitFromWrappedValue()->dump(out);
+  if (initInfo.hasInitFromProjectedValue())
+    initInfo.getInitFromProjectedValue()->dump(out);
+  out << " }";
+}
+
+void swift::simple_display(
+    llvm::raw_ostream &out,
+    const PropertyWrapperAuxiliaryVariables &auxiliaryVars) {
   out << "{ ";
-  if (backingInfo.backingVar)
-    backingInfo.backingVar->dumpRef(out);
+  if (auxiliaryVars.backingVar)
+    auxiliaryVars.backingVar->dumpRef(out);
   out << " }";
 }