[Property Wrappers] Store property wrapper "init from projection" expressions

in PropertyWrapperBackingPropertyInfo.

Author: hborla

include/swift/AST/PropertyWrappers.h

@@ -153,6 +153,14 @@ struct PropertyWrapperLValueness {
 
 void simple_display(llvm::raw_ostream &os, PropertyWrapperLValueness l);
 
+/// Given the initializer for a property with an attached property wrapper,
+/// dig out the wrapped value placeholder for the original initialization
+/// expression.
+///
+/// \note The wrapped value placeholder is injected for properties that can
+/// 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 backing property.
@@ -162,30 +170,67 @@ struct PropertyWrapperBackingPropertyInfo {
   /// of the original wrapped property prefixed with \c $
   VarDecl *projectionVar = nullptr;
 
-  /// An expression that initializes the backing property from a value of
-  /// the original property's type (e.g., via `init(wrappedValue:)`), or
-  /// \c NULL if the backing property can only be initialized directly.
-  Expr *initializeFromOriginal = nullptr;
+private:
+  struct {
+    /// An expression that initializes the backing property from a value of
+    /// the original property's type via \c init(wrappedValue:) if supported
+    /// by the wrapper type.
+    Expr *expr = nullptr;
+
+    /// When \c expr is not null, the opaque value that is used as
+    /// a placeholder for a value of the original property's type.
+    PropertyWrapperValuePlaceholderExpr *placeholder = nullptr;
+  } wrappedValueInit;
+
+  struct {
+    /// An expression that initializes the backing property from a value of
+    /// the synthesized projection type via \c init(projectedValue:) if
+    /// supported by the wrapper type.
+    Expr *expr = nullptr;
+
+    /// When \c expr is not null, the opaque value that is used as
+    /// a placeholder for a value of the projection type.
+    PropertyWrapperValuePlaceholderExpr *placeholder = nullptr;
+  } projectedValueInit;
+
+public:
+  PropertyWrapperBackingPropertyInfo() { }
 
-  /// When \c initializeFromOriginal is non-NULL, the opaque value that
-  /// is used as a stand-in for a value of the original property's type.
-  PropertyWrapperValuePlaceholderExpr *wrappedValuePlaceholder = nullptr;
+  PropertyWrapperBackingPropertyInfo(VarDecl *backingVar, VarDecl *projectionVar)
+      : backingVar(backingVar), projectionVar(projectionVar) { }
 
-  PropertyWrapperBackingPropertyInfo() { }
-  
-  PropertyWrapperBackingPropertyInfo(VarDecl *backingVar,
-                                     VarDecl *projectionVar,
-                                     Expr *initializeFromOriginal,
-                                     PropertyWrapperValuePlaceholderExpr *placeholder)
-    : backingVar(backingVar), projectionVar(projectionVar),
-      initializeFromOriginal(initializeFromOriginal),
-      wrappedValuePlaceholder(placeholder) { }
+  PropertyWrapperBackingPropertyInfo(VarDecl *backingVar, VarDecl *projectionVar,
+                                     Expr *wrappedValueInitExpr,
+                                     Expr *projectedValueInitExpr)
+      : backingVar(backingVar), projectionVar(projectionVar) {
+    wrappedValueInit.expr = wrappedValueInitExpr;
+    if (wrappedValueInitExpr) {
+      wrappedValueInit.placeholder = findWrappedValuePlaceholder(wrappedValueInitExpr);
+    }
+
+    projectedValueInit.expr = projectedValueInitExpr;
+    if (projectedValueInitExpr) {
+      projectedValueInit.placeholder = findWrappedValuePlaceholder(projectedValueInitExpr);
+    }
+  }
 
   /// Whether this is a valid property wrapper.
   bool isValid() const {
     return backingVar != nullptr;
   }
 
+  bool hasInitFromWrappedValue() const {
+    return wrappedValueInit.expr != nullptr;
+  }
+
+  Expr *getInitFromWrappedValue() {
+    return wrappedValueInit.expr;
+  }
+
+  PropertyWrapperValuePlaceholderExpr *getWrappedValuePlaceholder() {
+    return wrappedValueInit.placeholder;
+  }
+
   explicit operator bool() const { return isValid(); }
 
   friend bool operator==(const PropertyWrapperBackingPropertyInfo &lhs,
@@ -203,14 +248,6 @@ void simple_display(
     llvm::raw_ostream &out,
     const PropertyWrapperBackingPropertyInfo &backingInfo);
 
-/// Given the initializer for a property with an attached property wrapper,
-/// dig out the wrapped value placeholder for the original initialization
-/// expression.
-///
-/// \note The wrapped value placeholder is injected for properties that can
-/// be initialized out-of-line using an expression of the wrapped property type.
-PropertyWrapperValuePlaceholderExpr *findWrappedValuePlaceholder(Expr *init);
-
 } // end namespace swift
 
 #endif // SWIFT_AST_PROPERTY_WRAPPERS_H

lib/AST/Decl.cpp

@@ -6034,10 +6034,10 @@ bool VarDecl::isPropertyMemberwiseInitializedWithWrappedType() const {
 
 Type VarDecl::getPropertyWrapperInitValueInterfaceType() const {
   auto wrapperInfo = getPropertyWrapperBackingPropertyInfo();
-  if (!wrapperInfo || !wrapperInfo.wrappedValuePlaceholder)
+  if (!wrapperInfo || !wrapperInfo.getWrappedValuePlaceholder())
     return Type();
 
-  Type valueInterfaceTy = wrapperInfo.wrappedValuePlaceholder->getType();
+  Type valueInterfaceTy = wrapperInfo.getWrappedValuePlaceholder()->getType();
   if (valueInterfaceTy->hasArchetype())
     valueInterfaceTy = valueInterfaceTy->mapTypeOutOfContext();
 

lib/SILGen/SILGen.cpp

@@ -900,8 +900,8 @@ void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {
               ->isPropertyMemberwiseInitializedWithWrappedType()) {
         auto wrapperInfo =
             originalProperty->getPropertyWrapperBackingPropertyInfo();
-        assert(wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue());
-        init = wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue();
+        assert(wrapperInfo.getWrappedValuePlaceholder()->getOriginalWrappedValue());
+        init = wrapperInfo.getWrappedValuePlaceholder()->getOriginalWrappedValue();
       }
     }
 
@@ -934,12 +934,12 @@ void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {
     PrettyStackTraceSILFunction X(
         "silgen emitPropertyWrapperBackingInitializer", f);
     auto wrapperInfo = var->getPropertyWrapperBackingPropertyInfo();
-    assert(wrapperInfo.initializeFromOriginal);
-    f->createProfiler(wrapperInfo.initializeFromOriginal, constant,
+    assert(wrapperInfo.hasInitFromWrappedValue());
+    f->createProfiler(wrapperInfo.getInitFromWrappedValue(), constant,
                       ForDefinition);
     auto varDC = var->getInnermostDeclContext();
     SILGenFunction SGF(*this, *f, varDC);
-    SGF.emitGeneratorFunction(constant, wrapperInfo.initializeFromOriginal);
+    SGF.emitGeneratorFunction(constant, wrapperInfo.getInitFromWrappedValue());
     postEmitFunction(constant, f);
     break;
   }

lib/SILGen/SILGenConstructor.cpp

@@ -117,7 +117,7 @@ static RValue maybeEmitPropertyWrapperInitFromValue(
     return std::move(arg);
 
   auto wrapperInfo = originalProperty->getPropertyWrapperBackingPropertyInfo();
-  if (!wrapperInfo || !wrapperInfo.initializeFromOriginal)
+  if (!wrapperInfo || !wrapperInfo.hasInitFromWrappedValue())
     return std::move(arg);
 
   return SGF.emitApplyOfPropertyWrapperBackingInitializer(loc, originalProperty,
@@ -246,7 +246,7 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
         // the property wrapper backing initializer.
         if (auto *wrappedVar = field->getOriginalWrappedProperty()) {
           auto wrappedInfo = wrappedVar->getPropertyWrapperBackingPropertyInfo();
-          auto *placeholder = wrappedInfo.wrappedValuePlaceholder;
+          auto *placeholder = wrappedInfo.getWrappedValuePlaceholder();
           if (placeholder && placeholder->getOriginalWrappedValue()) {
             auto arg = SGF.emitRValue(placeholder->getOriginalWrappedValue());
             maybeEmitPropertyWrapperInitFromValue(SGF, Loc, field, subs,
@@ -291,7 +291,7 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
       // memberwise initialized, use the original wrapped value if it exists.
       if (auto *wrappedVar = field->getOriginalWrappedProperty()) {
         auto wrappedInfo = wrappedVar->getPropertyWrapperBackingPropertyInfo();
-        auto *placeholder = wrappedInfo.wrappedValuePlaceholder;
+        auto *placeholder = wrappedInfo.getWrappedValuePlaceholder();
         if (placeholder && placeholder->getOriginalWrappedValue()) {
           init = placeholder->getOriginalWrappedValue();
         }

lib/SILGen/SILGenDecl.cpp

@@ -1190,7 +1190,7 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
     if (var && var->getDeclContext()->isLocalContext()) {
       if (auto *orig = var->getOriginalWrappedProperty()) {
         auto wrapperInfo = orig->getPropertyWrapperBackingPropertyInfo();
-        Init = wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue();
+        Init = wrapperInfo.getWrappedValuePlaceholder()->getOriginalWrappedValue();
 
         auto value = emitRValue(Init);
         emitApplyOfPropertyWrapperBackingInitializer(SILLocation(PBD), orig,
@@ -1225,7 +1225,7 @@ void SILGenFunction::visitVarDecl(VarDecl *D) {
   if (D->getAttrs().hasAttribute<CustomAttr>()) {
     // Emit the property wrapper backing initializer if necessary.
     auto wrapperInfo = D->getPropertyWrapperBackingPropertyInfo();
-    if (wrapperInfo && wrapperInfo.initializeFromOriginal)
+    if (wrapperInfo && wrapperInfo.hasInitFromWrappedValue())
       SGM.emitPropertyWrapperBackingInitializer(D);
   }
 

lib/SILGen/SILGenFunction.cpp

@@ -929,12 +929,12 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, Expr *value,
       auto var = cast<VarDecl>(function.getDecl());
       auto wrappedInfo = var->getPropertyWrapperBackingPropertyInfo();
       auto param = params->get(0);
-      auto *placeholder = wrappedInfo.wrappedValuePlaceholder;
+      auto *placeholder = wrappedInfo.getWrappedValuePlaceholder();
       opaqueValue.emplace(
           *this, placeholder->getOpaqueValuePlaceholder(),
           maybeEmitValueOfLocalVarDecl(param, AccessKind::Read));
 
-      assert(value == wrappedInfo.initializeFromOriginal);
+      assert(value == wrappedInfo.getInitFromWrappedValue());
     }
 
     emitReturnExpr(Loc, value);

lib/SILGen/SILGenLValue.cpp

@@ -1307,7 +1307,7 @@ namespace {
         // If this is not a wrapper property that can be initialized from
         // a value of the wrapped type, we can't perform the initialization.
         auto wrapperInfo = VD->getPropertyWrapperBackingPropertyInfo();
-        if (!wrapperInfo.initializeFromOriginal)
+        if (!wrapperInfo.hasInitFromWrappedValue())
           return false;
 
         bool isAssignmentToSelfParamInInit =
@@ -1322,14 +1322,14 @@ namespace {
         // If this var isn't in a type context, assignment will always use the setter
         // if there is an initial value.
         if (!VD->getDeclContext()->isTypeContext() &&
-            wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue())
+            wrapperInfo.getWrappedValuePlaceholder()->getOriginalWrappedValue())
           return false;
 
         // If this property wrapper uses autoclosure in it's initializer,
         // the argument types of the setter and initializer shall be
         // different, so we don't rewrite an assignment into an
         // initialization.
-        return !wrapperInfo.wrappedValuePlaceholder->isAutoClosure();
+        return !wrapperInfo.getWrappedValuePlaceholder()->isAutoClosure();
       }
 
       return false;

lib/SILGen/SILGenType.cpp

@@ -1135,7 +1135,7 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
     // If this variable has an attached property wrapper with an initialization
     // function, emit the backing initializer function.
     if (auto wrapperInfo = vd->getPropertyWrapperBackingPropertyInfo()) {
-      if (wrapperInfo.initializeFromOriginal && !vd->isStatic()) {
+      if (wrapperInfo.hasInitFromWrappedValue() && !vd->isStatic()) {
         SGM.emitPropertyWrapperBackingInitializer(vd);
       }
     }

lib/Sema/CodeSynthesis.cpp

@@ -266,7 +266,7 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
           varInterfaceType = var->getPropertyWrapperInitValueInterfaceType();
 
           auto wrapperInfo = var->getPropertyWrapperBackingPropertyInfo();
-          isAutoClosure = wrapperInfo.wrappedValuePlaceholder->isAutoClosure();
+          isAutoClosure = wrapperInfo.getWrappedValuePlaceholder()->isAutoClosure();
         } else {
           varInterfaceType = backingPropertyType;
         }

lib/Sema/TypeCheckStorage.cpp

@@ -2736,7 +2736,7 @@ PropertyWrapperBackingPropertyInfoRequest::evaluate(Evaluator &evaluator,
                                                  wrapperInfo.projectedValueVar);
     }
 
-    return PropertyWrapperBackingPropertyInfo(backingVar, projectionVar, nullptr, nullptr);
+    return PropertyWrapperBackingPropertyInfo(backingVar, projectionVar);
   }
 
   if (!wrapperInfo)
@@ -2834,8 +2834,7 @@ PropertyWrapperBackingPropertyInfoRequest::evaluate(Evaluator &evaluator,
   // value.
   if (!wrappedValue && (!var->allAttachedPropertyWrappersHaveWrappedValueInit() ||
                         initializer)) {
-    return PropertyWrapperBackingPropertyInfo(
-        backingVar, storageVar, nullptr, nullptr);
+    return PropertyWrapperBackingPropertyInfo(backingVar, storageVar);
   }
 
   // Form the initialization of the backing property from a value of the
@@ -2845,11 +2844,11 @@ PropertyWrapperBackingPropertyInfoRequest::evaluate(Evaluator &evaluator,
         ctx, var->getSourceRange(), var->getType(), /*wrappedValue=*/nullptr);
     typeCheckSynthesizedWrapperInitializer(
         pbd, backingVar, parentPBD, initializer);
-    wrappedValue = findWrappedValuePlaceholder(initializer);
   }
 
   return PropertyWrapperBackingPropertyInfo(backingVar, storageVar,
-                                            initializer, wrappedValue);
+                                            /*wrappedValueInitExpr=*/initializer,
+                                            /*projectedValueInitExpr=*/nullptr);
 }
 
 VarDecl *