[SIL] NFC: Typed move_value's hasPointerEscape.

Author: nate-chandler

include/swift/SIL/SILBuilder.h

@@ -1425,10 +1425,10 @@ class SILBuilder {
                                                      operand, poisonRefs));
   }
 
-  MoveValueInst *createMoveValue(SILLocation loc, SILValue operand,
-                                 IsLexical_t isLexical = IsNotLexical,
-                                 bool hasPointerEscape = false,
-                                 bool fromVarDecl = false) {
+  MoveValueInst *createMoveValue(
+      SILLocation loc, SILValue operand, IsLexical_t isLexical = IsNotLexical,
+      HasPointerEscape_t hasPointerEscape = DoesNotHavePointerEscape,
+      bool fromVarDecl = false) {
     assert(getFunction().hasOwnership());
     assert(!operand->getType().isTrivial(getFunction()) &&
            "Should not be passing trivial values to this api. Use instead "
@@ -2848,10 +2848,10 @@ class SILBuilder {
 
   /// Convenience function that is a no-op for trivial values and inserts a
   /// move_value on non-trivial instructions.
-  SILValue emitMoveValueOperation(SILLocation Loc, SILValue v,
-                                  IsLexical_t isLexical = IsNotLexical,
-                                  bool hasPointerEscape = false,
-                                  bool fromVarDecl = false) {
+  SILValue emitMoveValueOperation(
+      SILLocation Loc, SILValue v, IsLexical_t isLexical = IsNotLexical,
+      HasPointerEscape_t hasPointerEscape = DoesNotHavePointerEscape,
+      bool fromVarDecl = false) {
     assert(!v->getType().isAddress());
     if (v->getType().isTrivial(*getInsertionBB()->getParent()))
       return v;

include/swift/SIL/SILInstruction.h

@@ -8680,10 +8680,11 @@ class MoveValueInst
   USE_SHARED_UINT8;
 
   MoveValueInst(SILDebugLocation DebugLoc, SILValue operand,
-                IsLexical_t isLexical, bool hasPointerEscape, bool fromVarDecl)
+                IsLexical_t isLexical, HasPointerEscape_t hasPointerEscape,
+                bool fromVarDecl)
       : UnaryInstructionBase(DebugLoc, operand, operand->getType()) {
     sharedUInt8().MoveValueInst.lexical = (bool)isLexical;
-    sharedUInt8().MoveValueInst.pointerEscape = hasPointerEscape;
+    sharedUInt8().MoveValueInst.pointerEscape = (bool)hasPointerEscape;
     sharedUInt8().MoveValueInst.fromVarDecl = fromVarDecl;
   }
 
@@ -8705,8 +8706,8 @@ class MoveValueInst
     sharedUInt8().MoveValueInst.lexical = (bool)IsNotLexical;
   }
 
-  bool hasPointerEscape() const {
-    return sharedUInt8().MoveValueInst.pointerEscape;
+  HasPointerEscape_t hasPointerEscape() const {
+    return HasPointerEscape_t(sharedUInt8().MoveValueInst.pointerEscape);
   }
   void setHasPointerEscape(bool pointerEscape) {
     sharedUInt8().MoveValueInst.pointerEscape = pointerEscape;

lib/SIL/Parser/ParseSIL.cpp

@@ -3495,7 +3495,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
   case SILInstructionKind::MoveValueInst: {
     bool allowsDiagnostics = false;
     auto isLexical = IsNotLexical;
-    bool hasPointerEscape = false;
+    auto hasPointerEscape = DoesNotHavePointerEscape;
     bool fromVarDecl = false;
 
     StringRef AttrName;
@@ -3506,7 +3506,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       else if (AttrName == "lexical")
         isLexical = IsLexical;
       else if (AttrName == "pointer_escape")
-        hasPointerEscape = true;
+        hasPointerEscape = HasPointerEscape;
       else if (AttrName == "var_decl")
         fromVarDecl = true;
       else {

lib/SILGen/SILGenDecl.cpp

@@ -842,7 +842,7 @@ class LetValueInitialization : public Initialization {
     // that the move checker knows to check this variable.
     if (vd->isNoImplicitCopy()) {
       value = SGF.B.createMoveValue(PrologueLoc, value, IsLexical,
-                                    /*hasPointerEscape=*/false,
+                                    DoesNotHavePointerEscape,
                                     /*fromVarDecl=*/true);
       value =
           SGF.B.createOwnedCopyableToMoveOnlyWrapperValue(PrologueLoc, value);
@@ -860,7 +860,7 @@ class LetValueInitialization : public Initialization {
 
     if (value->getOwnershipKind() == OwnershipKind::Owned)
       return SGF.B.createMoveValue(PrologueLoc, value, isLexical,
-                                   /*hasPointerEscape=*/false,
+                                   DoesNotHavePointerEscape,
                                    /*fromVarDecl=*/true);
 
     return SGF.B.createBeginBorrow(PrologueLoc, value, isLexical,

lib/Serialization/DeserializeSIL.cpp

@@ -2372,13 +2372,13 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     auto Ty = MF->getType(TyID);
     bool AllowsDiagnostics = Attr & 0x1;
     IsLexical_t isLexical = IsLexical_t((Attr >> 1) & 0x1);
-    bool IsEscaping = (Attr >> 2) & 0x1;
+    auto isEscaping = HasPointerEscape_t((Attr >> 2) & 0x1);
     bool IsFromVarDecl = (Attr >> 3) & 0x1;
     auto *MVI = Builder.createMoveValue(
         Loc,
         getLocalValue(Builder.maybeGetFunction(), ValID,
                       getSILType(Ty, (SILValueCategory)TyCategory, Fn)),
-        isLexical, IsEscaping, IsFromVarDecl);
+        isLexical, isEscaping, IsFromVarDecl);
     MVI->setAllowsDiagnostics(AllowsDiagnostics);
     ResultInst = MVI;
     break;