[NFC][Property Wrappers] Split PropertyWrapperBackingPropertyInfoRequest into

two separate requests - one to synthesize the auxiliary declarations, and
another to compute how the backing storage is initialized.

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,33 @@ 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:
+  PropertyWrapperAuxiliaryVariables() {}
+
+  PropertyWrapperAuxiliaryVariables(VarDecl *backingVar, VarDecl *projectionVar)
+      : backingVar(backingVar), projectionVar(projectionVar) {}
+
+  /// 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 +220,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 +235,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 +251,7 @@ struct PropertyWrapperBackingPropertyInfo {
     return projectedValueInit.expr != nullptr;
   }
 
-  Expr *getInitFromProjectedValue() {
+  Expr *getInitFromProjectedValue() const {
     return projectedValueInit.expr;
   }
 
@@ -255,14 +262,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 +270,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,7 +724,28 @@ class PropertyWrapperBackingPropertyInfoRequest :
   friend SimpleRequest;
 
   // Evaluation.
-  PropertyWrapperBackingPropertyInfo
+  PropertyWrapperAuxiliaryVariables
+  evaluate(Evaluator &evaluator, VarDecl *var) const;
+
+public:
+  // Caching
+  bool isCached() const;
+};
+
+/// 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;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  PropertyWrapperInitializerInfo
   evaluate(Evaluator &evaluator, VarDecl *var) const;
 
 public:

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -186,8 +186,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, PropertyWrapperInitializerInfoRequest,
+              PropertyWrapperInitializerInfo(VarDecl *), Cached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PropertyWrapperWrappedValueVarRequest,
               VarDecl *(VarDecl *), Cached,

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,11 +5973,11 @@ 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 {
@@ -6038,11 +6048,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

@@ -488,7 +488,12 @@ bool PropertyWrapperBackingPropertyTypeRequest::isCached() const {
   return !var->getAttrs().isEmpty();
 }
 
-bool PropertyWrapperBackingPropertyInfoRequest::isCached() const {
+bool PropertyWrapperAuxiliaryVariablesRequest::isCached() const {
+  auto var = std::get<0>(getStorage());
+  return !var->getAttrs().isEmpty() || var->hasImplicitPropertyWrapper();
+}
+
+bool PropertyWrapperInitializerInfoRequest::isCached() const {
   auto var = std::get<0>(getStorage());
   return !var->getAttrs().isEmpty() || var->hasImplicitPropertyWrapper();
 }
@@ -520,10 +525,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 << " }";
 }