[NFC] SIL: Typed begin_borrow's isFixed.

Author: nate-chandler

include/swift/SIL/SILBuilder.h

@@ -826,7 +826,8 @@ class SILBuilder {
   BeginBorrowInst *createBeginBorrow(
       SILLocation Loc, SILValue LV, IsLexical_t isLexical = IsNotLexical,
       HasPointerEscape_t hasPointerEscape = DoesNotHavePointerEscape,
-      bool fromVarDecl = false, bool fixed = false) {
+      bool fromVarDecl = false,
+      BeginBorrowInst::IsFixed_t fixed = BeginBorrowInst::IsNotFixed) {
     assert(getFunction().hasOwnership());
     assert(!LV->getType().isAddress());
     return insert(new (getModule())

include/swift/SIL/SILInstruction.h

@@ -4563,15 +4563,22 @@ class BeginBorrowInst
 
   USE_SHARED_UINT8;
 
+public:
+  enum IsFixed_t : bool {
+    IsNotFixed = false,
+    IsFixed = true,
+  };
+
+private:
   BeginBorrowInst(SILDebugLocation DebugLoc, SILValue LValue,
                   IsLexical_t isLexical, HasPointerEscape_t hasPointerEscape,
-                  bool fromVarDecl, bool fixed)
+                  bool fromVarDecl, IsFixed_t fixed)
       : UnaryInstructionBase(DebugLoc, LValue,
                              LValue->getType().getObjectType()) {
     sharedUInt8().BeginBorrowInst.lexical = isLexical;
     sharedUInt8().BeginBorrowInst.pointerEscape = hasPointerEscape;
     sharedUInt8().BeginBorrowInst.fromVarDecl = fromVarDecl;
-    sharedUInt8().BeginBorrowInst.fixed = fixed;
+    sharedUInt8().BeginBorrowInst.fixed = (bool)fixed;
   }
 
 public:
@@ -4610,8 +4617,8 @@ class BeginBorrowInst
 
   /// Whether the borrow scope is fixed during move checking and should be
   /// treated as an opaque use of the value.
-  bool isFixed() const {
-    return sharedUInt8().BeginBorrowInst.fixed;
+  IsFixed_t isFixed() const {
+    return IsFixed_t(sharedUInt8().BeginBorrowInst.fixed);
   }
 
   /// Return a range over all EndBorrow instructions for this BeginBorrow.

lib/SIL/Parser/ParseSIL.cpp

@@ -3743,7 +3743,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     auto isLexical = IsNotLexical;
     auto hasPointerEscape = DoesNotHavePointerEscape;
     bool fromVarDecl = false;
-    bool fixed = false;
+    auto fixed = BeginBorrowInst::IsNotFixed;
 
     StringRef AttrName;
     SourceLoc AttrLoc;
@@ -3755,7 +3755,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       else if (AttrName == "var_decl")
         fromVarDecl = true;
       else if (AttrName == "fixed")
-        fixed = true;
+        fixed = BeginBorrowInst::IsFixed;
       else {
         P.diagnose(InstLoc.getSourceLoc(),
                    diag::sil_invalid_attribute_for_instruction, AttrName,

lib/SILGen/SILGenBuilder.cpp

@@ -1102,21 +1102,20 @@ SILGenBuilder::createFormalAccessOpaqueConsumeBeginAccess(SILLocation loc,
   return SGF.emitFormalAccessManagedRValueWithCleanup(loc, access);
 }
 
-ManagedValue SILGenBuilder::createBeginBorrow(SILLocation loc,
-                                              ManagedValue value,
-                                              IsLexical_t isLexical,
-                                              bool isFixed) {
+ManagedValue
+SILGenBuilder::createBeginBorrow(SILLocation loc, ManagedValue value,
+                                 IsLexical_t isLexical,
+                                 BeginBorrowInst::IsFixed_t isFixed) {
   auto *newValue =
       SILBuilder::createBeginBorrow(loc, value.getValue(), isLexical,
                                     DoesNotHavePointerEscape, false, isFixed);
   SGF.emitManagedBorrowedRValueWithCleanup(newValue);
   return ManagedValue::forBorrowedObjectRValue(newValue);
 }
 
-ManagedValue SILGenBuilder::createFormalAccessBeginBorrow(SILLocation loc,
-                                                          ManagedValue value,
-                                                          IsLexical_t isLexical,
-                                                          bool isFixed) {
+ManagedValue SILGenBuilder::createFormalAccessBeginBorrow(
+    SILLocation loc, ManagedValue value, IsLexical_t isLexical,
+    BeginBorrowInst::IsFixed_t isFixed) {
   auto *newValue =
       SILBuilder::createBeginBorrow(loc, value.getValue(), isLexical,
                                     DoesNotHavePointerEscape, false, isFixed);

lib/SILGen/SILGenBuilder.h

@@ -479,14 +479,13 @@ class SILGenBuilder : public SILBuilder {
                                                           ManagedValue address);
 
   using SILBuilder::createBeginBorrow;
-  ManagedValue createBeginBorrow(SILLocation loc, ManagedValue value,
-                                 IsLexical_t isLexical = IsNotLexical,
-                                 bool isFixed = false);
+  ManagedValue createBeginBorrow(
+      SILLocation loc, ManagedValue value, IsLexical_t isLexical = IsNotLexical,
+      BeginBorrowInst::IsFixed_t isFixed = BeginBorrowInst::IsNotFixed);
 
-  ManagedValue
-  createFormalAccessBeginBorrow(SILLocation loc, ManagedValue value,
-                                IsLexical_t isLexical = IsNotLexical,
-                                bool isFixed = false);
+  ManagedValue createFormalAccessBeginBorrow(
+      SILLocation loc, ManagedValue value, IsLexical_t isLexical = IsNotLexical,
+      BeginBorrowInst::IsFixed_t isFixed = BeginBorrowInst::IsNotFixed);
 
   using SILBuilder::createMoveValue;
   ManagedValue createMoveValue(SILLocation loc, ManagedValue value,

lib/SILGen/SILGenLValue.cpp

@@ -4394,7 +4394,7 @@ LValue SILGenLValue::visitBindOptionalExpr(BindOptionalExpr *e,
         }
       } else {
         optBase = SGF.B.createFormalAccessBeginBorrow(e, optBase, IsNotLexical,
-                                                      /*fixed*/ true);
+                                                      BeginBorrowInst::IsFixed);
       }
     }
   } else {

lib/SILGen/SILGenPattern.cpp

@@ -3408,11 +3408,12 @@ void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
           } else {
             // Initiate a fixed borrow on the subject, so that it's treated as
             // opaque by the move checker.
-            subjectMV = subjectUndergoesFormalAccess
-                            ? B.createFormalAccessBeginBorrow(
-                                  S, subjectMV, IsNotLexical, /*fixed*/ true)
-                            : B.createBeginBorrow(S, subjectMV, IsNotLexical,
-                                                  /*fixed*/ true);
+            subjectMV =
+                subjectUndergoesFormalAccess
+                    ? B.createFormalAccessBeginBorrow(
+                          S, subjectMV, IsNotLexical, BeginBorrowInst::IsFixed)
+                    : B.createBeginBorrow(S, subjectMV, IsNotLexical,
+                                          BeginBorrowInst::IsFixed);
           }
           return {subjectMV, CastConsumptionKind::BorrowAlways};
 
@@ -3440,8 +3441,8 @@ void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
           if (subjectMV.getType().isAddress()) {
             subjectMV = B.createOpaqueBorrowBeginAccess(S, subjectMV);
           } else {
-            subjectMV =
-                B.createBeginBorrow(S, subjectMV, IsNotLexical, /*fixed*/ true);
+            subjectMV = B.createBeginBorrow(S, subjectMV, IsNotLexical,
+                                            BeginBorrowInst::IsFixed);
           }
           return {subjectMV, CastConsumptionKind::BorrowAlways};
         }

lib/Serialization/DeserializeSIL.cpp

@@ -2272,7 +2272,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     auto isLexical = IsLexical_t(Attr & 0x1);
     auto hasPointerEscape = HasPointerEscape_t((Attr >> 1) & 0x1);
     bool fromVarDecl = (Attr >> 2) & 0x1;
-    bool isFixed = (Attr >> 3) & 0x1;
+    auto isFixed = BeginBorrowInst::IsFixed_t((Attr >> 3) & 0x1);
     ResultInst = Builder.createBeginBorrow(
         Loc,
         getLocalValue(