Merge pull request #27727 from theblixguy/fix/SR-11603

[PropertyWrappers] Fix lvalue computation in buildStorageReference

Author: theblixguy

lib/Sema/TypeCheckStorage.cpp

@@ -743,19 +743,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 (underlyingVars.size() > 0) {
-    isMemberLValue = underlyingVars[0]->isGetterMutating();
+  if (auto mut = propertyWrapperMutability(accessor->getStorage())) {
+    isMemberLValue = mut->first;
     if (isLValue)
-      isMemberLValue |= underlyingVars[0]->isSetterMutating();
+      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

@@ -519,6 +519,28 @@ extension UsesMyPublished {
   }
 }
 
+// SR-11603 - crash due to incorrect lvalue computation
+@propertyWrapper
+struct StructWrapper<T> {
+  var wrappedValue: T
+}
+
+@propertyWrapper
+class ClassWrapper<T> {
+  var wrappedValue: T
+  init(wrappedValue: T) {
+    self.wrappedValue = wrappedValue
+  }
+}
+
+struct SR_11603 {
+  @StructWrapper @ClassWrapper var prop: Int
+
+  func foo() {
+    prop = 1234
+  }
+}
+
 // 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

validation-test/compiler_crashers_2/sr11637.swift

@@ -0,0 +1,21 @@
+// RUN: not --crash %target-swift-frontend -primary-file %s -emit-silgen
+
+// REQUIRES: asserts
+
+@propertyWrapper
+struct MutatingGetNonMutatingSetWrapper<T> {
+  private var fixed: T
+  
+  var wrappedValue: T {
+    mutating get { fixed }
+    nonmutating set { }
+  }
+  
+  init(wrappedValue initialValue: T) {
+    fixed = initialValue
+  }
+}
+
+struct Foo {
+  @MutatingGetNonMutatingSetWrapper var text: String
+}