[SILGen] Teach SIlGen to emit local property wrappers

Author: hborla

lib/SIL/IR/SILDeclRef.cpp

@@ -487,7 +487,8 @@ IsSerialized_t SILDeclRef::isSerialized() const {
 
   // Stored property initializers are inlinable if the type is explicitly
   // marked as @frozen.
-  if (isStoredPropertyInitializer() || isPropertyWrapperBackingInitializer()) {
+  if (isStoredPropertyInitializer() || (isPropertyWrapperBackingInitializer() &&
+      !d->getDeclContext()->isLocalContext())) {
     auto *nominal = cast<NominalTypeDecl>(d->getDeclContext());
     auto scope =
       nominal->getFormalAccessScope(/*useDC=*/nullptr,

lib/SILGen/SILGenDecl.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/PropertyWrappers.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/SIL/FormalLinkage.h"
 #include "swift/SIL/PrettyStackTrace.h"
@@ -1171,13 +1172,36 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
   // the initialization. Otherwise, mark it uninitialized for DI to resolve.
   if (auto *Init = PBD->getExecutableInit(idx)) {
     FullExpr Scope(Cleanups, CleanupLocation(Init));
+
+    auto *var = PBD->getSingleVar();
+    if (var && var->getDeclContext()->isLocalContext()) {
+      if (auto *orig = var->getOriginalWrappedProperty()) {
+        auto wrapperInfo = orig->getPropertyWrapperBackingPropertyInfo();
+        Init = wrapperInfo.wrappedValuePlaceholder->getOriginalWrappedValue();
+
+        auto value = emitRValue(Init);
+        emitApplyOfPropertyWrapperBackingInitializer(SILLocation(PBD), orig,
+                                                     getForwardingSubstitutionMap(),
+                                                     std::move(value))
+          .forwardInto(*this, SILLocation(PBD), initialization.get());
+        return;
+      }
+    }
+
     emitExprInto(Init, initialization.get(), SILLocation(PBD));
   } else {
     initialization->finishUninitialized(*this);
   }
 }
 
 void SILGenFunction::visitPatternBindingDecl(PatternBindingDecl *PBD) {
+  // Visit (local) property wrapper backing var first
+  auto *singleVar = PBD->getSingleVar();
+  if (singleVar && singleVar->hasAttachedPropertyWrapper() &&
+      singleVar->getDeclContext()->isLocalContext()) {
+    auto *backingVar = singleVar->getPropertyWrapperBackingProperty();
+    visitPatternBindingDecl(backingVar->getParentPatternBinding());
+  }
 
   // Allocate the variables and build up an Initialization over their
   // allocated storage.
@@ -1189,6 +1213,18 @@ void SILGenFunction::visitPatternBindingDecl(PatternBindingDecl *PBD) {
 void SILGenFunction::visitVarDecl(VarDecl *D) {
   // We handle emitting the variable storage when we see the pattern binding.
 
+  // Visit property wrapper synthesized accessors first.
+  if (D->hasAttachedPropertyWrapper() && D->getDeclContext()->isLocalContext()) {
+    auto wrapperInfo = D->getPropertyWrapperBackingPropertyInfo();
+    if (!wrapperInfo)
+      return;
+
+    SGM.emitPropertyWrapperBackingInitializer(D);
+    visit(wrapperInfo.backingVar);
+    if (wrapperInfo.projectionVar)
+      visit(wrapperInfo.projectionVar);
+  }
+
   // Emit the variable's accessors.
   D->visitEmittedAccessors([&](AccessorDecl *accessor) {
     SGM.emitFunction(accessor);

lib/SILGen/SILGenLValue.cpp

@@ -1403,7 +1403,7 @@ namespace {
       assert(getAccessorDecl()->isSetter());
       SILDeclRef setter = Accessor;
 
-      if (IsOnSelfParameter && canRewriteSetAsPropertyWrapperInit(SGF) &&
+      if (canRewriteSetAsPropertyWrapperInit(SGF) &&
           !Storage->isStatic() &&
           isBackingVarVisible(cast<VarDecl>(Storage),
                               SGF.FunctionDC)) {
@@ -1434,7 +1434,9 @@ namespace {
 
         // Get the address of the storage property.
         ManagedValue proj;
-        if (BaseFormalType->mayHaveSuperclass()) {
+        if (!BaseFormalType) {
+          proj = SGF.maybeEmitValueOfLocalVarDecl(backingVar);
+        } else if (BaseFormalType->mayHaveSuperclass()) {
           RefElementComponent REC(backingVar, LValueOptions(), varStorageType,
                                   typeData);
           proj = std::move(REC).project(SGF, loc, base);
@@ -1471,33 +1473,51 @@ namespace {
                          .SILFnType)
                   .getValue();
 
-        } else
+        } else {
           setterFRef = SGF.emitGlobalFunctionRef(loc, setter, setterInfo);
+        }
+
         CanSILFunctionType setterTy = setterFRef->getType().castTo<SILFunctionType>();
         SILFunctionConventions setterConv(setterTy, SGF.SGM.M);
 
-        SILValue capturedBase;
-        unsigned argIdx = setterConv.getNumSILArguments() - 1;
-        if (setterConv.getSILArgumentConvention(argIdx).isInoutConvention()) {
-          capturedBase = base.getValue();
-        } else {
-          capturedBase = base.copy(SGF, loc).forward(SGF);
-        }
+        // Emit captures for the setter
+        SmallVector<SILValue, 4> capturedArgs;
+        auto captureInfo = SGF.SGM.Types.getLoweredLocalCaptures(setter);
+        if (!captureInfo.getCaptures().empty()) {
+          SmallVector<ManagedValue, 4> captures;
+          SGF.emitCaptures(loc, setter, CaptureEmission::PartialApplication, captures);
 
-        // If the base is a reference and the setter expects a value, emit a
-        // load. This pattern is emitted for property wrappers with a
-        // nonmutating setter, for example.
-        if (base.getType().isAddress() &&
-            base.getType().getObjectType() ==
-                setterConv.getSILArgumentType(argIdx,
-                                              SGF.getTypeExpansionContext())) {
-          capturedBase = SGF.B.createTrivialLoadOr(
-              loc, capturedBase, LoadOwnershipQualifier::Take);
+          for (auto capture : captures)
+            capturedArgs.push_back(capture.forward(SGF));
+        } else {
+          assert(base);
+
+          SILValue capturedBase;
+          unsigned argIdx = setterConv.getNumSILArguments() - 1;
+
+          if (setterConv.getSILArgumentConvention(argIdx).isInoutConvention()) {
+            capturedBase = base.getValue();
+          } else {
+            capturedBase = base.copy(SGF, loc).forward(SGF);
+          }
+
+          // If the base is a reference and the setter expects a value, emit a
+          // load. This pattern is emitted for property wrappers with a
+          // nonmutating setter, for example.
+          if (base.getType().isAddress() &&
+              base.getType().getObjectType() ==
+                  setterConv.getSILArgumentType(argIdx,
+                                                SGF.getTypeExpansionContext())) {
+            capturedBase = SGF.B.createTrivialLoadOr(
+                loc, capturedBase, LoadOwnershipQualifier::Take);
+          }
+
+          capturedArgs.push_back(capturedBase);
         }
 
         PartialApplyInst *setterPAI =
           SGF.B.createPartialApply(loc, setterFRef,
-                                   Substitutions, { capturedBase },
+                                   Substitutions, capturedArgs,
                                    ParameterConvention::Direct_Guaranteed);
         ManagedValue setterFn = SGF.emitManagedRValueWithCleanup(setterPAI);