Pass around whether storage is mutable as an enum instead of a bool.

Author: rjmccall

include/swift/AST/Decl.h

@@ -4143,15 +4143,15 @@ class AbstractStorageDecl : public ValueDecl {
 
 protected:
   AbstractStorageDecl(DeclKind Kind, DeclContext *DC, DeclName Name,
-                      SourceLoc NameLoc, bool supportsMutation)
+                      SourceLoc NameLoc, StorageIsMutable_t supportsMutation)
     : ValueDecl(Kind, DC, Name, NameLoc) {
     Bits.AbstractStorageDecl.HasStorage = true;
     Bits.AbstractStorageDecl.SupportsMutation = supportsMutation;
     Bits.AbstractStorageDecl.IsGetterMutating = false;
     Bits.AbstractStorageDecl.IsSetterMutating = true;
   }
 
-  void setSupportsMutationIfStillStored(bool supportsMutation) {
+  void setSupportsMutationIfStillStored(StorageIsMutable_t supportsMutation) {
     if (auto ptr = Accessors.getPointer()) {
       auto impl = ptr->getImplInfo();
       if (!impl.isSimpleStored()) return;
@@ -4210,8 +4210,8 @@ class AbstractStorageDecl : public ValueDecl {
   /// don't support mutation (e.g. to initialize them), and sometimes we
   /// can't mutate things that do support mutation (e.g. because their
   /// setter is private).
-  bool supportsMutation() const {
-    return Bits.AbstractStorageDecl.SupportsMutation;
+  StorageIsMutable_t supportsMutation() const {
+    return StorageIsMutable_t(Bits.AbstractStorageDecl.SupportsMutation);
   }
 
   /// Are there any accessors for this declaration, including implicit ones?
@@ -4452,7 +4452,8 @@ class VarDecl : public AbstractStorageDecl {
 
   VarDecl(DeclKind Kind, bool IsStatic, Specifier Sp, bool IsCaptureList,
           SourceLoc NameLoc, Identifier Name, DeclContext *DC)
-    : AbstractStorageDecl(Kind, DC, Name, NameLoc, !isImmutableSpecifier(Sp))
+    : AbstractStorageDecl(Kind, DC, Name, NameLoc,
+                          StorageIsMutable_t(!isImmutableSpecifier(Sp)))
   {
     Bits.VarDecl.IsStatic = IsStatic;
     Bits.VarDecl.Specifier = static_cast<unsigned>(Sp);
@@ -4853,7 +4854,7 @@ class SubscriptDecl : public GenericContext, public AbstractStorageDecl {
                 GenericParamList *GenericParams)
     : GenericContext(DeclContextKind::SubscriptDecl, Parent),
       AbstractStorageDecl(DeclKind::Subscript, Parent, Name, SubscriptLoc,
-                          /*supports mutation (will be overwritten)*/ true),
+                          /*will be overwritten*/ StorageIsNotMutable),
       ArrowLoc(ArrowLoc), Indices(nullptr), ElementTy(ElementTy) {
     setIndices(Indices);
     setGenericParams(GenericParams);

include/swift/AST/StorageImpl.h

@@ -22,6 +22,11 @@
 
 namespace swift {
 
+enum StorageIsMutable_t : bool {
+  StorageIsNotMutable = false,
+  StorageIsMutable = true
+};
+
 // Note that the values of these enums line up with %select values in
 // diagnostics.
 enum class AccessorKind {
@@ -309,16 +314,17 @@ class StorageImplInfo {
 #endif
   }
 
-  static StorageImplInfo getSimpleStored(bool supportsMutation) {
+  static StorageImplInfo getSimpleStored(StorageIsMutable_t isMutable) {
     return { ReadImplKind::Stored,
-             supportsMutation ? WriteImplKind::Stored
-                              : WriteImplKind::Immutable,
-             supportsMutation ? ReadWriteImplKind::Stored
-                              : ReadWriteImplKind::Immutable };
+             isMutable ? WriteImplKind::Stored
+                       : WriteImplKind::Immutable,
+             isMutable ? ReadWriteImplKind::Stored
+                       : ReadWriteImplKind::Immutable };
   }
 
-  static StorageImplInfo getOpaque(bool supportsMutation) {
-    return (supportsMutation ? getMutableOpaque() : getImmutableOpaque());
+  static StorageImplInfo getOpaque(StorageIsMutable_t isMutable) {
+    return (isMutable ? getMutableOpaque()
+                      : getImmutableOpaque());
   }
 
   /// Describe the implementation of a immutable property implemented opaquely.
@@ -332,8 +338,9 @@ class StorageImplInfo {
              ReadWriteImplKind::MaterializeForSet };
   }
 
-  static StorageImplInfo getComputed(bool supportsMutation) {
-    return (supportsMutation ? getMutableComputed() : getImmutableComputed());
+  static StorageImplInfo getComputed(StorageIsMutable_t isMutable) {
+    return (isMutable ? getMutableComputed()
+                      : getImmutableComputed());
   }
 
   /// Describe the implementation of an immutable property implemented
@@ -362,8 +369,8 @@ class StorageImplInfo {
   }
 
   /// Does this describe storage that supports mutation?
-  bool supportsMutation() const {
-    return getWriteImpl() != WriteImplKind::Immutable;
+  StorageIsMutable_t supportsMutation() const {
+    return StorageIsMutable_t(getWriteImpl() != WriteImplKind::Immutable);
   }
 
   ReadImplKind getReadImpl() const {

lib/AST/Decl.cpp

@@ -4577,7 +4577,8 @@ bool VarDecl::isSelfParameter() const {
 
 void VarDecl::setSpecifier(Specifier specifier) {
   Bits.VarDecl.Specifier = static_cast<unsigned>(specifier);
-  setSupportsMutationIfStillStored(!isImmutableSpecifier(specifier));
+  setSupportsMutationIfStillStored(
+                          StorageIsMutable_t(!isImmutableSpecifier(specifier)));
 }
 
 bool VarDecl::isAnonClosureParam() const {

lib/Parse/ParseDecl.cpp

@@ -4768,7 +4768,7 @@ Parser::ParsedAccessors::classify(Parser &P, AbstractStorageDecl *storage,
   // Allow the sil_stored attribute to override all the accessors we parsed
   // when making the final classification.
   if (attrs.hasAttribute<SILStoredAttr>()) {
-    return StorageImplInfo::getSimpleStored(Set != nullptr);
+    return StorageImplInfo::getSimpleStored(StorageIsMutable_t(Set != nullptr));
   }
 
   return StorageImplInfo(readImpl, writeImpl, readWriteImpl);

lib/Sema/CodeSynthesis.cpp

@@ -1836,8 +1836,9 @@ static void maybeAddAccessorsToBehaviorStorage(TypeChecker &TC, VarDecl *var) {
 
     SmallVector<AccessorDecl*, 2> accessors;
     accessors.push_back(getter);
-    if (setter) accessors.push_back(setter);
-    var->setAccessors(StorageImplInfo::getComputed(setter != nullptr),
+    auto isMutable = StorageIsMutable_t(setter != nullptr);
+    if (isMutable) accessors.push_back(setter);
+    var->setAccessors(StorageImplInfo::getComputed(isMutable),
                       SourceLoc(), accessors, SourceLoc());
 
     // Save the conformance and 'value' decl for later type checking.