Rename SILArgument::isEscaping -> SILArgument::hasPointerEscape

Author: meg-gupta

include/swift/SIL/SILArgument.h

@@ -76,20 +76,20 @@ class SILArgument : public ValueBase {
   SILArgument(ValueKind subClassKind, SILBasicBlock *inputParentBlock,
               SILType type, ValueOwnershipKind ownershipKind,
               const ValueDecl *inputDecl = nullptr, bool reborrow = false,
-              bool escaping = false);
+              bool pointerEscape = false);
 
   // A special constructor, only intended for use in
   // SILBasicBlock::replacePHIArg and replaceFunctionArg.
   explicit SILArgument(ValueKind subClassKind, SILType type,
                        ValueOwnershipKind ownershipKind,
                        const ValueDecl *inputDecl = nullptr,
-                       bool reborrow = false, bool escaping = false)
+                       bool reborrow = false, bool pointerEscape = false)
       : ValueBase(subClassKind, type), parentBlock(nullptr), decl(inputDecl) {
     sharedUInt8().SILArgument.valueOwnershipKind = uint8_t(ownershipKind);
     // When the optimizer creates reborrows, reborrow flag needs to be set by
     // calling setReborrow.
     sharedUInt8().SILArgument.reborrow = false;
-    sharedUInt8().SILArgument.escaping = false;
+    sharedUInt8().SILArgument.pointerEscape = false;
   }
 
 public:
@@ -119,8 +119,8 @@ class SILArgument : public ValueBase {
     return getOwnershipKind() == OwnershipKind::Guaranteed && !isReborrow();
   }
 
-  bool isEscaping() const {
-    return ValueOwnershipKind(sharedUInt8().SILArgument.escaping);
+  bool hasPointerEscape() const {
+    return ValueOwnershipKind(sharedUInt8().SILArgument.pointerEscape);
   }
 
   void setOwnershipKind(ValueOwnershipKind newKind) {
@@ -131,8 +131,8 @@ class SILArgument : public ValueBase {
     sharedUInt8().SILArgument.reborrow = isReborrow;
   }
 
-  void setEscaping(bool isEscaping) {
-    sharedUInt8().SILArgument.escaping = isEscaping;
+  void setEscaping(bool hasPointerEscape) {
+    sharedUInt8().SILArgument.pointerEscape = hasPointerEscape;
   }
 
   SILBasicBlock *getParent() const { return parentBlock; }
@@ -260,17 +260,18 @@ class SILPhiArgument : public SILArgument {
   SILPhiArgument(SILBasicBlock *parentBlock, SILType type,
                  ValueOwnershipKind ownershipKind,
                  const ValueDecl *decl = nullptr, bool isReborrow = false,
-                 bool isEscaping = false)
+                 bool hasPointerEscape = false)
       : SILArgument(ValueKind::SILPhiArgument, parentBlock, type, ownershipKind,
-                    decl, isReborrow, isEscaping) {}
+                    decl, isReborrow, hasPointerEscape) {}
 
   // A special constructor, only intended for use in
   // SILBasicBlock::replacePHIArg.
   explicit SILPhiArgument(SILType type, ValueOwnershipKind ownershipKind,
                           const ValueDecl *decl = nullptr,
-                          bool isReborrow = false, bool isEscaping = false)
+                          bool isReborrow = false,
+                          bool hasPointerEscape = false)
       : SILArgument(ValueKind::SILPhiArgument, type, ownershipKind, decl,
-                    isReborrow, isEscaping) {}
+                    isReborrow, hasPointerEscape) {}
 
 public:
   /// Return true if this is block argument is a phi, as opposed to a terminator

include/swift/SIL/SILCloner.h

@@ -735,7 +735,7 @@ void SILCloner<ImplClass>::clonePhiArgs(SILBasicBlock *oldBB) {
   for (auto *Arg : oldBB->getSILPhiArguments()) {
     SILValue mappedArg = mappedBB->createPhiArgument(
         getOpType(Arg->getType()), Arg->getOwnershipKind(), Arg->getDecl(),
-        Arg->isReborrow(), Arg->isEscaping());
+        Arg->isReborrow(), Arg->hasPointerEscape());
 
     asImpl().mapValue(Arg, mappedArg);
   }

include/swift/SIL/SILNode.h

@@ -205,7 +205,7 @@ class alignas(8) SILNode :
     SHARED_FIELD(SILArgument, uint8_t
                  valueOwnershipKind : NumVOKindBits,
                  reborrow : 1,
-                 escaping : 1);
+                 pointerEscape : 1);
 
     SHARED_FIELD(DebugValueInst, uint8_t
                  poisonRefs : 1,

lib/SIL/IR/SILArgument.cpp

@@ -28,12 +28,12 @@ SILArgument::SILArgument(ValueKind subClassKind,
                          SILBasicBlock *inputParentBlock, SILType type,
                          ValueOwnershipKind ownershipKind,
                          const ValueDecl *inputDecl, bool reborrow,
-                         bool escaping)
+                         bool pointerEscape)
     : ValueBase(subClassKind, type), parentBlock(inputParentBlock),
       decl(inputDecl) {
   sharedUInt8().SILArgument.valueOwnershipKind = uint8_t(ownershipKind);
   sharedUInt8().SILArgument.reborrow = reborrow;
-  sharedUInt8().SILArgument.escaping = escaping;
+  sharedUInt8().SILArgument.pointerEscape = pointerEscape;
   inputParentBlock->insertArgument(inputParentBlock->args_end(), this);
 }
 

lib/SIL/IR/SILPrinter.cpp

@@ -683,7 +683,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     if (i.IsReborrow)
       *this << "@reborrow ";
     if (i.IsEscaping)
-      *this << "@escaping ";
+      *this << "@pointer_escape ";
     if (i.OwnershipKind && *i.OwnershipKind != OwnershipKind::None) {
       *this << "@" << i.OwnershipKind.value() << " ";
     }
@@ -720,7 +720,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     return {Ctx.getID(arg),          arg->getType(),
             arg->isNoImplicitCopy(), arg->getLifetimeAnnotation(),
             arg->isClosureCapture(), arg->isReborrow(),
-            arg->isEscaping()};
+            arg->hasPointerEscape()};
   }
 
   SILValuePrinterInfo getIDAndTypeAndOwnership(SILValue V) {
@@ -734,11 +734,11 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
             arg->getLifetimeAnnotation(),
             arg->isClosureCapture(),
             arg->isReborrow(),
-            arg->isEscaping()};
+            arg->hasPointerEscape()};
   }
   SILValuePrinterInfo getIDAndTypeAndOwnership(SILArgument *arg) {
     return {Ctx.getID(arg), arg->getType(), arg->getOwnershipKind(),
-            arg->isReborrow(), arg->isEscaping()};
+            arg->isReborrow(), arg->hasPointerEscape()};
   }
 
   //===--------------------------------------------------------------------===//

lib/SIL/Parser/ParseSIL.cpp

@@ -6810,10 +6810,10 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
         bool foundLexical = false;
         bool foundEagerMove = false;
         bool foundReborrow = false;
-        bool foundEscaping = false;
+        bool hasPointerEscape = false;
         while (auto attributeName = parseOptionalAttribute(
                    {"noImplicitCopy", "_lexical", "_eagerMove",
-                    "closureCapture", "reborrow", "escaping"})) {
+                    "closureCapture", "reborrow", "pointer_escape"})) {
           if (*attributeName == "noImplicitCopy")
             foundNoImplicitCopy = true;
           else if (*attributeName == "_lexical")
@@ -6824,8 +6824,8 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
             foundClosureCapture = true;
           else if (*attributeName == "reborrow")
             foundReborrow = true;
-          else if (*attributeName == "escaping")
-            foundEscaping = true;
+          else if (*attributeName == "pointer_escape")
+            hasPointerEscape = true;
           else {
             llvm_unreachable("Unexpected attribute!");
           }
@@ -6857,7 +6857,7 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
           fArg->setClosureCapture(foundClosureCapture);
           fArg->setLifetimeAnnotation(lifetime);
           fArg->setReborrow(foundReborrow);
-          fArg->setEscaping(foundEscaping);
+          fArg->setEscaping(hasPointerEscape);
           Arg = fArg;
 
           // Today, we construct the ownership kind straight from the function
@@ -6874,7 +6874,7 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
           }
         } else {
           Arg = BB->createPhiArgument(Ty, OwnershipKind, /*decl*/ nullptr,
-                                      foundReborrow, foundEscaping);
+                                      foundReborrow, hasPointerEscape);
         }
         setLocalValue(Arg, Name, NameLoc);
       } while (P.consumeIf(tok::comma));

lib/SILOptimizer/Utils/LoopUtils.cpp

@@ -129,7 +129,7 @@ static SILBasicBlock *insertBackedgeBlock(SILLoop *L, DominanceInfo *DT,
   for (auto *BBArg : Header->getArguments()) {
     BBArgs.push_back(BEBlock->createPhiArgument(
         BBArg->getType(), BBArg->getOwnershipKind(), /* decl */ nullptr,
-        BBArg->isReborrow(), BBArg->isEscaping()));
+        BBArg->isReborrow(), BBArg->hasPointerEscape()));
   }
 
   // Arbitrarily pick one of the predecessor's branch locations.

lib/Serialization/DeserializeSIL.cpp

@@ -973,7 +973,7 @@ SILBasicBlock *SILDeserializer::readSILBasicBlock(SILFunction *Fn,
     SILType SILArgTy = getSILType(ArgTy, ValueCategory, Fn);
     auto OwnershipKind = ValueOwnershipKind((Args[I + 1] >> 8) & 0x7);
     auto reborrow = (Args[I + 1] >> 11) & 0x1;
-    auto escaping = (Args[I + 1] >> 12) & 0x1;
+    auto pointerEscape = (Args[I + 1] >> 12) & 0x1;
     if (IsEntry) {
       auto *fArg = CurrentBB->createFunctionArgument(SILArgTy);
       bool isNoImplicitCopy = (Args[I + 1] >> 13) & 0x1;
@@ -987,7 +987,8 @@ SILBasicBlock *SILDeserializer::readSILBasicBlock(SILFunction *Fn,
       Arg = fArg;
     } else {
       Arg = CurrentBB->createPhiArgument(SILArgTy, OwnershipKind,
-                                         /*decl*/ nullptr, reborrow, escaping);
+                                         /*decl*/ nullptr, reborrow,
+                                         pointerEscape);
     }
     LastValueID = LastValueID + 1;
     setLocalValue(Arg, LastValueID);

lib/Serialization/SerializeSIL.cpp

@@ -644,7 +644,7 @@ void SILSerializer::writeSILBasicBlock(const SILBasicBlock &BB) {
     packedMetadata |= unsigned(SA->getType().getCategory()); // 8 bits
     packedMetadata |= unsigned(SA->getOwnershipKind()) << 8; // 3 bits
     packedMetadata |= unsigned(SA->isReborrow()) << 11;      // 1 bit
-    packedMetadata |= unsigned(SA->isEscaping()) << 12;      // 1 bit
+    packedMetadata |= unsigned(SA->hasPointerEscape()) << 12; // 1 bit
     if (auto *SFA = dyn_cast<SILFunctionArgument>(SA)) {
       packedMetadata |= unsigned(SFA->isNoImplicitCopy()) << 13;      // 1 bit
       packedMetadata |= unsigned(SFA->getLifetimeAnnotation()) << 14; // 2 bits