[PropertyWrappers] Refactor property wrapper mutability check into local function and use it to check if self requires an lvalue

Author: theblixguy

lib/Sema/TypeCheckStorage.cpp

@@ -735,23 +735,40 @@ static Expr *buildStorageReference(AccessorDecl *accessor,
   }
 
   bool isMemberLValue = isLValue;
+  auto propertyWrapperMutability =
+      [&](Decl *decl) -> Optional<std::pair<bool, bool>> {
+    if (accessor->isCoroutine())
+      return None;
+    auto var = dyn_cast<VarDecl>(decl);
+    if (!var)
+      return None;
+    auto mut = var->getPropertyWrapperMutability();
+    if (!mut)
+      return None;
+    return std::make_pair(mut->Getter == PropertyWrapperMutability::Mutating,
+                          mut->Setter == PropertyWrapperMutability::Mutating);
+  };
 
-  // If we're acessing a property wrapper, determine if the
+  // If we're accessing a property wrapper, determine if the
   // intermediate access requires an lvalue.
-  if (!accessor->isCoroutine()) {
-    if (auto var = dyn_cast<VarDecl>(accessor->getStorage())) {
-      if (auto mut = var->getPropertyWrapperMutability()) {
-        isMemberLValue = mut->Getter == PropertyWrapperMutability::Mutating;
-        if (isLValue)
-          isMemberLValue |= mut->Setter == PropertyWrapperMutability::Mutating;
-      }
-    }
+  if (auto mut = propertyWrapperMutability(accessor->getStorage())) {
+    isMemberLValue = mut->first;
+    if (isLValue)
+      isMemberLValue |= mut->second;
   }
 
   bool isSelfLValue = storage->isGetterMutating();
   if (isMemberLValue)
     isSelfLValue |= storage->isSetterMutating();
 
+  // If we're accessing a property wrapper, determine if
+  // the self requires an lvalue.
+  if (auto mut = propertyWrapperMutability(storage)) {
+    isSelfLValue = mut->first;
+    if (isMemberLValue)
+      isSelfLValue |= mut->second;
+  }
+
   Expr *selfDRE =
     buildSelfReference(selfDecl, selfAccessKind, isSelfLValue,
                        ctx);

test/SILGen/property_wrappers.swift

@@ -534,14 +534,32 @@ class ClassWrapper<T> {
 }
 
 
-struct SR_11603 {
+struct SR_11603_1 {
   @StructWrapper @ClassWrapper var prop: Int
 
   func foo() {
     prop = 1234
   }
 }
 
+@propertyWrapper
+struct MutatingGetNonMutatingSetWrapper<T> {
+  private var fixed: T
+  
+  var wrappedValue: T {
+    mutating get { fixed }
+    nonmutating set { }
+  }
+  
+  init(wrappedValue initialValue: T) {
+    fixed = initialValue
+  }
+}
+
+struct SR_11603_2 {
+  @MutatingGetNonMutatingSetWrapper var text: String = "" 
+}
+
 // CHECK-LABEL: sil_vtable ClassUsingWrapper {
 // CHECK-NEXT:  #ClassUsingWrapper.x!getter.1: (ClassUsingWrapper) -> () -> Int : @$s17property_wrappers17ClassUsingWrapperC1xSivg   // ClassUsingWrapper.x.getter
 // CHECK-NEXT:  #ClassUsingWrapper.x!setter.1: (ClassUsingWrapper) -> (Int) -> () : @$s17property_wrappers17ClassUsingWrapperC1xSivs // ClassUsingWrapper.x.setter