Merge pull request swiftlang#34109 from hborla/local-property-wrappers

[Property Wrappers] Support local property wrappers

Author: hborla

include/swift/AST/Decl.h

@@ -4842,6 +4842,14 @@ class VarDecl : public AbstractStorageDecl {
   /// property wrapper with a \c projectedValue .
   VarDecl *getPropertyWrapperProjectionVar() const;
 
+  /// Visit all auxiliary declarations to this VarDecl.
+  ///
+  /// An auxiliary declaration is a declaration synthesized by the compiler to support
+  /// this VarDecl, such as synthesized property wrapper variables.
+  ///
+  /// \note this function only visits auxiliary decls that are not part of the AST.
+  void visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)>) const;
+
   /// Retrieve the backing storage property for a lazy property.
   VarDecl *getLazyStorageProperty() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -5216,8 +5216,6 @@ ERROR(property_wrapper_mutating_get_composed_to_get_only,none,
       "property wrapper %0 with a mutating getter cannot be composed inside "
       "get-only property wrapper %1", (TypeLoc, TypeLoc))
 
-ERROR(property_wrapper_local,none,
-      "property wrappers are not yet supported on local properties", ())
 ERROR(property_wrapper_top_level,none,
       "property wrappers are not yet supported in top-level code", ())
 ERROR(property_wrapper_let, none,

lib/AST/Decl.cpp

@@ -5835,6 +5835,17 @@ VarDecl *VarDecl::getPropertyWrapperProjectionVar() const {
   return getPropertyWrapperBackingPropertyInfo().projectionVar;
 }
 
+void VarDecl::visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)> visit) const {
+  if (getDeclContext()->isTypeContext())
+    return;
+
+  if (auto *backingVar = getPropertyWrapperBackingProperty())
+    visit(backingVar);
+
+  if (auto *projectionVar = getPropertyWrapperProjectionVar())
+    visit(projectionVar);
+}
+
 VarDecl *VarDecl::getLazyStorageProperty() const {
   auto &ctx = getASTContext();
   auto mutableThis = const_cast<VarDecl *>(this);

lib/AST/UnqualifiedLookup.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/ModuleNameLookup.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
+#include "swift/AST/PropertyWrappers.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/Basic/SourceManager.h"
@@ -564,8 +565,22 @@ bool ASTScopeDeclConsumerForUnqualifiedLookup::consume(
       }
     }
 
-    if (!value->getName().matchesRef(factory.Name.getFullName()))
-      continue;
+    auto fullName = factory.Name.getFullName();
+    if (!value->getName().matchesRef(fullName)) {
+      bool foundMatch = false;
+      if (auto *varDecl = dyn_cast<VarDecl>(value)) {
+        // Check if the name matches any auxiliary decls not in the AST
+        varDecl->visitAuxiliaryDecls([&](VarDecl *auxiliaryVar) {
+          if (auxiliaryVar->ValueDecl::getName().matchesRef(fullName)) {
+            value = auxiliaryVar;
+            foundMatch = true;
+          }
+        });
+      }
+
+      if (!foundMatch)
+        continue;
+    }
 
     // In order to preserve the behavior of the existing context-based lookup,
     // which finds all results for non-local variables at the top level instead

lib/Parse/ParseExpr.cpp

@@ -2228,7 +2228,7 @@ Expr *Parser::parseExprIdentifier() {
   }
 
   Expr *E;
-  if (D == nullptr) {
+  if (D == nullptr || D->getAttrs().hasAttribute<CustomAttr>()) {
     if (name.getBaseName().isEditorPlaceholder()) {
       IDSyntaxContext.setCreateSyntax(SyntaxKind::EditorPlaceholderExpr);
       return parseExprEditorPlaceholder(IdentTok, name.getBaseIdentifier());

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()->isTypeContext())) {
     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,6 +1172,22 @@ 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);
@@ -1189,6 +1206,18 @@ void SILGenFunction::visitPatternBindingDecl(PatternBindingDecl *PBD) {
 void SILGenFunction::visitVarDecl(VarDecl *D) {
   // We handle emitting the variable storage when we see the pattern binding.
 
+  // Emit the property wrapper backing initializer if necessary.
+  auto wrapperInfo = D->getPropertyWrapperBackingPropertyInfo();
+  if (wrapperInfo && wrapperInfo.initializeFromOriginal)
+    SGM.emitPropertyWrapperBackingInitializer(D);
+
+  D->visitAuxiliaryDecls([&](VarDecl *var) {
+    if (auto *patternBinding = var->getParentPatternBinding())
+      visitPatternBindingDecl(patternBinding);
+
+    visit(var);
+  });
+
   // Emit the variable's accessors.
   D->visitEmittedAccessors([&](AccessorDecl *accessor) {
     SGM.emitFunction(accessor);

lib/SILGen/SILGenFunction.cpp

@@ -187,13 +187,18 @@ void SILGenFunction::emitCaptures(SILLocation loc,
   // Partial applications take ownership of the context parameters, so we'll
   // need to pass ownership rather than merely guaranteeing parameters.
   bool canGuarantee;
+  bool captureCanEscape = true;
   switch (purpose) {
   case CaptureEmission::PartialApplication:
     canGuarantee = false;
     break;
   case CaptureEmission::ImmediateApplication:
     canGuarantee = true;
     break;
+  case CaptureEmission::AssignByWrapper:
+    canGuarantee = false;
+    captureCanEscape = false;
+    break;
   }
 
   auto expansion = getTypeExpansionContext();
@@ -381,7 +386,8 @@ void SILGenFunction::emitCaptures(SILLocation loc,
         } else {
           capturedArgs.push_back(emitManagedRetain(loc, Entry.box));
         }
-        escapesToMark.push_back(entryValue);
+        if (captureCanEscape)
+          escapesToMark.push_back(entryValue);
       } else {
         // Address only 'let' values are passed by box.  This isn't great, in
         // that a variable captured by multiple closures will be boxed for each

lib/SILGen/SILGenFunction.h

@@ -115,6 +115,11 @@ enum class CaptureEmission {
   /// Captures are being emitted for partial application to form a closure
   /// value.
   PartialApplication,
+  /// Captures are being emitted for partial application of a local property
+  /// wrapper setter for assign_by_wrapper. Captures are guaranteed to not
+  /// escape, because assign_by_wrapper will not use the setter if the captured
+  /// variable is not initialized.
+  AssignByWrapper,
 };
 
 /// Different ways in which an l-value can be emitted.

lib/SILGen/SILGenLValue.cpp

@@ -1314,6 +1314,17 @@ namespace {
             IsOnSelfParameter &&
             isa<ConstructorDecl>(SGF.FunctionDC->getAsDecl());
 
+        // Assignment to a wrapped property can only be re-written to initialization for
+        // members of `self` in an initializer, and for local variables.
+        if (!(isAssignmentToSelfParamInInit || VD->getDeclContext()->isLocalContext()))
+          return false;
+
+        // 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())
+          return false;
+
         // If we have a nonmutating setter on a value type, the call
         // captures all of 'self' and we cannot rewrite an assignment
         // into an initialization.
@@ -1403,7 +1414,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 +1445,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 +1484,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::AssignByWrapper, 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);