Revert "Ensure that we do not turn rvalues into lvalues"

This reverts commit 4b59301.

Author: DougGregor

include/swift/AST/Decl.h

@@ -5757,8 +5757,9 @@ class AbstractStorageDecl : public ValueDecl {
   /// Determine whether references to this storage declaration may appear
   /// on the left-hand side of an assignment, as the operand of a
   /// `&` or 'inout' operator, or as a component in a writable key path.
-  bool isSettable(const DeclContext *useDC) const {
-    switch (mutability(useDC)) {
+  bool isSettable(const DeclContext *useDC,
+                  const DeclRefExpr *base = nullptr) const {
+    switch (mutability(useDC, base)) {
       case StorageMutability::Immutable:
         return false;
       case StorageMutability::Mutable:
@@ -5769,9 +5770,8 @@ class AbstractStorageDecl : public ValueDecl {
 
   /// Determine the mutability of this storage declaration when
   /// accessed from a given declaration context.
-  StorageMutability mutability(
-      const DeclContext *useDC,
-      std::optional<const DeclRefExpr *> base = std::nullopt) const;
+  StorageMutability mutability(const DeclContext *useDC,
+                               const DeclRefExpr *base = nullptr) const;
 
   /// Determine the mutability of this storage declaration when
   /// accessed from a given declaration context in Swift.
@@ -5781,7 +5781,7 @@ class AbstractStorageDecl : public ValueDecl {
   /// writes in Swift.
   StorageMutability mutabilityInSwift(
       const DeclContext *useDC,
-      std::optional<const DeclRefExpr *> base = std::nullopt) const;
+      const DeclRefExpr *base = nullptr) const;
 
   /// Determine whether references to this storage declaration in Swift may
   /// appear on the left-hand side of an assignment, as the operand of a
@@ -5790,8 +5790,9 @@ class AbstractStorageDecl : public ValueDecl {
   /// This method is equivalent to \c isSettable with the exception of
   /// 'optional' storage requirements, which lack support for direct writes
   /// in Swift.
-  bool isSettableInSwift(const DeclContext *useDC) const {
-    switch (mutabilityInSwift(useDC)) {
+  bool isSettableInSwift(const DeclContext *useDC,
+                         const DeclRefExpr *base = nullptr) const {
+    switch (mutabilityInSwift(useDC, base)) {
       case StorageMutability::Immutable:
         return false;
       case StorageMutability::Mutable:
@@ -6113,9 +6114,8 @@ class VarDecl : public AbstractStorageDecl {
 
   /// Determine the mutability of this variable declaration when
   /// accessed from a given declaration context.
-  StorageMutability mutability(
-      const DeclContext *useDC,
-      std::optional<const DeclRefExpr *> base = std::nullopt) const;
+  StorageMutability mutability(const DeclContext *useDC,
+                               const DeclRefExpr *base = nullptr) const;
 
   /// Return the parent pattern binding that may provide an initializer for this
   /// VarDecl.  This returns null if there is none associated with the VarDecl.

lib/AST/Decl.cpp

@@ -3093,7 +3093,7 @@ bool AbstractStorageDecl::isSetterMutating() const {
 
 StorageMutability 
 AbstractStorageDecl::mutability(const DeclContext *useDC,
-                                std::optional<const DeclRefExpr *> base ) const {
+                                const DeclRefExpr *base) const {
   if (auto vd = dyn_cast<VarDecl>(this))
     return vd->mutability(useDC, base);
 
@@ -3109,10 +3109,8 @@ AbstractStorageDecl::mutability(const DeclContext *useDC,
 /// 'optional' storage requirements, which lack support for direct
 /// writes in Swift.
 StorageMutability
-AbstractStorageDecl::mutabilityInSwift(
-    const DeclContext *useDC,
-    std::optional<const DeclRefExpr *> base
-) const {
+AbstractStorageDecl::mutabilityInSwift(const DeclContext *useDC,
+                                       const DeclRefExpr *base) const {
   // TODO: Writing to an optional storage requirement is not supported in Swift.
   if (getAttrs().hasAttribute<OptionalAttr>()) {
     return StorageMutability::Immutable;
@@ -7302,7 +7300,7 @@ static StorageMutability storageIsMutable(bool isMutable) {
 /// is a let member in an initializer.
 StorageMutability
 VarDecl::mutability(const DeclContext *UseDC,
-                    std::optional<const DeclRefExpr *> base) const {
+                    const DeclRefExpr *base) const {
   // Parameters are settable or not depending on their ownership convention.
   if (auto *PD = dyn_cast<ParamDecl>(this))
     return storageIsMutable(!PD->isImmutableInFunctionBody());
@@ -7312,12 +7310,9 @@ VarDecl::mutability(const DeclContext *UseDC,
   if (!isLet()) {
     if (hasInitAccessor()) {
       if (auto *ctor = dyn_cast_or_null<ConstructorDecl>(UseDC)) {
-        // If we're referencing 'self.', it's initializable.
-        if (!base ||
-            (*base && ctor->getImplicitSelfDecl() == (*base)->getDecl()))
-          return StorageMutability::Initializable;
-
-        return storageIsMutable(supportsMutation());
+        if (base && ctor->getImplicitSelfDecl() != base->getDecl())
+          return storageIsMutable(supportsMutation());
+        return StorageMutability::Initializable;
       }
     }
 
@@ -7375,18 +7370,17 @@ VarDecl::mutability(const DeclContext *UseDC,
         getDeclContext()->getSelfNominalTypeDecl())
       return StorageMutability::Immutable;
 
+    if (base && CD->getImplicitSelfDecl() != base->getDecl())
+      return StorageMutability::Immutable;
+
     // If this is a convenience initializer (i.e. one that calls
     // self.init), then let properties are never mutable in it.  They are
     // only mutable in designated initializers.
     auto initKindAndExpr = CD->getDelegatingOrChainedInitKind();
     if (initKindAndExpr.initKind == BodyInitKind::Delegating)
       return StorageMutability::Immutable;
 
-    // If we were given a base and it is 'self', it's initializable.
-    if (!base || (*base && CD->getImplicitSelfDecl() == (*base)->getDecl()))
-      return StorageMutability::Initializable;
-
-    return StorageMutability::Immutable;
+    return StorageMutability::Initializable;
   }
 
   // If the 'let' has a value bound to it but has no PBD, then it is