Merge pull request swiftlang#28493 from gottesmm/pr-29cc76c7ab2ff93438398e13a6657e50a043a1ce

Author: swift-ci

include/swift/SIL/SILArgument.h

@@ -62,29 +62,52 @@ struct SILArgumentKind {
 };
 
 class SILArgument : public ValueBase {
-  void operator=(const SILArgument &) = delete;
-  void operator delete(void *Ptr, size_t) SWIFT_DELETE_OPERATOR_DELETED
+  friend class SILBasicBlock;
+
+  SILBasicBlock *parentBlock;
+  const ValueDecl *decl;
+
+protected:
+  SILArgument(ValueKind subClassKind, SILBasicBlock *inputParentBlock,
+              SILType type, ValueOwnershipKind ownershipKind,
+              const ValueDecl *inputDecl = nullptr);
+
+  SILArgument(ValueKind subClassKind, SILBasicBlock *inputParentBlock,
+              SILBasicBlock::arg_iterator positionInArgumentArray, SILType type,
+              ValueOwnershipKind ownershipKind,
+              const ValueDecl *inputDecl = nullptr);
 
-  SILBasicBlock *ParentBB;
-  const ValueDecl *Decl;
+  // A special constructor, only intended for use in
+  // SILBasicBlock::replacePHIArg and replaceFunctionArg.
+  explicit SILArgument(ValueKind subClassKind, SILType type,
+                       ValueOwnershipKind ownershipKind,
+                       const ValueDecl *inputDecl = nullptr)
+      : ValueBase(subClassKind, type, IsRepresentative::Yes),
+        parentBlock(nullptr), decl(inputDecl) {
+    Bits.SILArgument.VOKind = static_cast<unsigned>(ownershipKind);
+  }
 
 public:
+  void operator=(const SILArgument &) = delete;
+  void operator delete(void *, size_t) SWIFT_DELETE_OPERATOR_DELETED;
+
   ValueOwnershipKind getOwnershipKind() const {
     return static_cast<ValueOwnershipKind>(Bits.SILArgument.VOKind);
   }
-  void setOwnershipKind(ValueOwnershipKind NewKind) {
-    Bits.SILArgument.VOKind = static_cast<unsigned>(NewKind);
+
+  void setOwnershipKind(ValueOwnershipKind newKind) {
+    Bits.SILArgument.VOKind = static_cast<unsigned>(newKind);
   }
 
-  SILBasicBlock *getParent() { return ParentBB; }
-  const SILBasicBlock *getParent() const { return ParentBB; }
+  SILBasicBlock *getParent() { return parentBlock; }
+  const SILBasicBlock *getParent() const { return parentBlock; }
 
   SILFunction *getFunction();
   const SILFunction *getFunction() const;
 
   SILModule &getModule() const;
 
-  const ValueDecl *getDecl() const { return Decl; }
+  const ValueDecl *getDecl() const { return decl; }
 
   static bool classof(const SILInstruction *) = delete;
   static bool classof(const SILUndef *) = delete;
@@ -94,31 +117,32 @@ class SILArgument : public ValueBase {
   }
 
   unsigned getIndex() const {
-    ArrayRef<SILArgument *> Args = getParent()->getArguments();
-    for (unsigned i = 0, e = Args.size(); i != e; ++i)
-      if (Args[i] == this)
-        return i;
+    for (auto p : llvm::enumerate(getParent()->getArguments())) {
+      if (p.value() == this) {
+        return p.index();
+      }
+    }
     llvm_unreachable("SILArgument not argument of its parent BB");
   }
 
   /// Return true if this block argument is actually a phi argument as
   /// opposed to a cast or projection.
-  bool isPhiArgument();
+  bool isPhiArgument() const;
 
   /// If this argument is a phi, return the incoming phi value for the given
   /// predecessor BB. If this argument is not a phi, return an invalid SILValue.
-  SILValue getIncomingPhiValue(SILBasicBlock *predBB);
+  SILValue getIncomingPhiValue(SILBasicBlock *predBlock) const;
 
   /// If this argument is a phi, populate `OutArray` with the incoming phi
   /// values for each predecessor BB. If this argument is not a phi, return
   /// false.
-  bool getIncomingPhiValues(llvm::SmallVectorImpl<SILValue> &ReturnedPhiValues);
+  bool getIncomingPhiValues(SmallVectorImpl<SILValue> &returnedPhiValues) const;
 
   /// If this argument is a phi, populate `OutArray` with each predecessor block
   /// and its incoming phi value. If this argument is not a phi, return false.
-  bool getIncomingPhiValues(
-      llvm::SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>>
-          &ReturnedPredAndPhiValuePairs);
+  bool
+  getIncomingPhiValues(SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>>
+                           &returnedPredAndPhiValuePairs) const;
 
   /// Returns true if we were able to find a single terminator operand value for
   /// each predecessor of this arguments basic block. The found values are
@@ -127,7 +151,8 @@ class SILArgument : public ValueBase {
   /// Note: this peeks through any projections or cast implied by the
   /// terminator. e.g. the incoming value for a switch_enum payload argument is
   /// the enum itself (the operand of the switch_enum).
-  bool getSingleTerminatorOperands(llvm::SmallVectorImpl<SILValue> &OutArray);
+  bool getSingleTerminatorOperands(
+      SmallVectorImpl<SILValue> &returnedSingleTermOperands) const;
 
   /// Returns true if we were able to find single terminator operand values for
   /// each predecessor of this arguments basic block. The found values are
@@ -137,7 +162,8 @@ class SILArgument : public ValueBase {
   /// terminator. e.g. the incoming value for a switch_enum payload argument is
   /// the enum itself (the operand of the switch_enum).
   bool getSingleTerminatorOperands(
-      llvm::SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>> &OutArray);
+      SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>>
+          &returnedSingleTermOperands) const;
 
   /// If this SILArgument's parent block has a single predecessor whose
   /// terminator has a single operand, return the incoming operand of the
@@ -153,56 +179,61 @@ class SILArgument : public ValueBase {
   }
 
 protected:
-  SILArgument(ValueKind SubClassKind, SILBasicBlock *ParentBB, SILType Ty,
-              ValueOwnershipKind OwnershipKind,
-              const ValueDecl *D = nullptr);
-  SILArgument(ValueKind SubClassKind, SILBasicBlock *ParentBB,
-              SILBasicBlock::arg_iterator Pos, SILType Ty,
-              ValueOwnershipKind OwnershipKind,
-              const ValueDecl *D = nullptr);
-
-  // A special constructor, only intended for use in
-  // SILBasicBlock::replacePHIArg and replaceFunctionArg.
-  explicit SILArgument(ValueKind SubClassKind, SILType Ty,
-                       ValueOwnershipKind OwnershipKind,
-                       const ValueDecl *D = nullptr)
-      : ValueBase(SubClassKind, Ty, IsRepresentative::Yes), ParentBB(nullptr),
-        Decl(D) {
-    Bits.SILArgument.VOKind = static_cast<unsigned>(OwnershipKind);
+  void setParent(SILBasicBlock *newParentBlock) {
+    parentBlock = newParentBlock;
   }
-  void setParent(SILBasicBlock *P) { ParentBB = P; }
-
-  friend SILBasicBlock;
 };
 
 class SILPhiArgument : public SILArgument {
+  friend class SILBasicBlock;
+
+  SILPhiArgument(SILBasicBlock *parentBlock, SILType type,
+                 ValueOwnershipKind ownershipKind,
+                 const ValueDecl *decl = nullptr)
+      : SILArgument(ValueKind::SILPhiArgument, parentBlock, type, ownershipKind,
+                    decl) {}
+
+  SILPhiArgument(SILBasicBlock *parentBlock,
+                 SILBasicBlock::arg_iterator argArrayInsertPt, SILType type,
+                 ValueOwnershipKind ownershipKind,
+                 const ValueDecl *decl = nullptr)
+      : SILArgument(ValueKind::SILPhiArgument, parentBlock, argArrayInsertPt,
+                    type, ownershipKind, decl) {}
+
+  // A special constructor, only intended for use in
+  // SILBasicBlock::replacePHIArg.
+  explicit SILPhiArgument(SILType type, ValueOwnershipKind ownershipKind,
+                          const ValueDecl *decl = nullptr)
+      : SILArgument(ValueKind::SILPhiArgument, type, ownershipKind, decl) {}
+
 public:
   /// Return true if this is block argument is actually a phi argument as
   /// opposed to a cast or projection.
-  bool isPhiArgument();
+  bool isPhiArgument() const;
 
   /// If this argument is a phi, return the incoming phi value for the given
   /// predecessor BB. If this argument is not a phi, return an invalid SILValue.
   ///
   /// FIXME: Once SILPhiArgument actually implies that it is a phi argument,
   /// this will be guaranteed to return a valid SILValue.
-  SILValue getIncomingPhiValue(SILBasicBlock *BB);
+  SILValue getIncomingPhiValue(SILBasicBlock *predBlock) const;
 
   /// If this argument is a phi, populate `OutArray` with the incoming phi
   /// values for each predecessor BB. If this argument is not a phi, return
   /// false.
   ///
   /// FIXME: Once SILPhiArgument actually implies that it is a phi argument,
   /// this will always succeed.
-  bool getIncomingPhiValues(llvm::SmallVectorImpl<SILValue> &OutArray);
+  bool getIncomingPhiValues(SmallVectorImpl<SILValue> &returnedPhiValues) const;
 
   /// If this argument is a phi, populate `OutArray` with each predecessor block
   /// and its incoming phi value. If this argument is not a phi, return false.
   ///
   /// FIXME: Once SILPhiArgument actually implies that it is a phi argument,
   /// this will always succeed.
-  bool getIncomingPhiValues(
-      llvm::SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>> &OutArray);
+  bool
+  getIncomingPhiValues(SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>>
+                           &returnedPredAndPhiValuePairs) const;
 
   /// Returns true if we were able to find a single terminator operand value for
   /// each predecessor of this arguments basic block. The found values are
@@ -211,7 +242,8 @@ class SILPhiArgument : public SILArgument {
   /// Note: this peeks through any projections or cast implied by the
   /// terminator. e.g. the incoming value for a switch_enum payload argument is
   /// the enum itself (the operand of the switch_enum).
-  bool getSingleTerminatorOperands(llvm::SmallVectorImpl<SILValue> &OutArray);
+  bool getSingleTerminatorOperands(
+      SmallVectorImpl<SILValue> &returnedSingleTermOperands) const;
 
   /// Returns true if we were able to find single terminator operand values for
   /// each predecessor of this arguments basic block. The found values are
@@ -221,7 +253,8 @@ class SILPhiArgument : public SILArgument {
   /// terminator. e.g. the incoming value for a switch_enum payload argument is
   /// the enum itself (the operand of the switch_enum).
   bool getSingleTerminatorOperands(
-      llvm::SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>> &OutArray);
+      SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>>
+          &returnedSingleTermOperands) const;
 
   /// If this SILArgument's parent block has a single predecessor whose
   /// terminator has a single operand, return the incoming operand of the
@@ -236,30 +269,35 @@ class SILPhiArgument : public SILArgument {
   static bool classof(const SILNode *node) {
     return node->getKind() == SILNodeKind::SILPhiArgument;
   }
+};
 
-private:
-  friend SILBasicBlock;
-  SILPhiArgument(SILBasicBlock *ParentBB, SILType Ty, ValueOwnershipKind OwnershipKind,
-                 const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILPhiArgument, ParentBB, Ty, OwnershipKind, D) {}
-  SILPhiArgument(SILBasicBlock *ParentBB, SILBasicBlock::arg_iterator Pos,
-                 SILType Ty, ValueOwnershipKind OwnershipKind,
-                 const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILPhiArgument, ParentBB, Pos, Ty, OwnershipKind, D) {}
+class SILFunctionArgument : public SILArgument {
+  friend class SILBasicBlock;
+
+  SILFunctionArgument(SILBasicBlock *parentBlock, SILType type,
+                      ValueOwnershipKind ownershipKind,
+                      const ValueDecl *decl = nullptr)
+      : SILArgument(ValueKind::SILFunctionArgument, parentBlock, type,
+                    ownershipKind, decl) {}
+  SILFunctionArgument(SILBasicBlock *parentBlock,
+                      SILBasicBlock::arg_iterator argArrayInsertPt,
+                      SILType type, ValueOwnershipKind ownershipKind,
+                      const ValueDecl *decl = nullptr)
+      : SILArgument(ValueKind::SILFunctionArgument, parentBlock,
+                    argArrayInsertPt, type, ownershipKind, decl) {}
 
   // A special constructor, only intended for use in
-  // SILBasicBlock::replacePHIArg.
-  explicit SILPhiArgument(SILType Ty, ValueOwnershipKind OwnershipKind,
-                          const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILPhiArgument, Ty, OwnershipKind, D) {}
-};
+  // SILBasicBlock::replaceFunctionArg.
+  explicit SILFunctionArgument(SILType type, ValueOwnershipKind ownershipKind,
+                               const ValueDecl *decl = nullptr)
+      : SILArgument(ValueKind::SILFunctionArgument, type, ownershipKind, decl) {
+  }
 
-class SILFunctionArgument : public SILArgument {
 public:
   bool isIndirectResult() const {
     auto numIndirectResults =
         getFunction()->getConventions().getNumIndirectSILResults();
-    return (getIndex() < numIndirectResults);
+    return getIndex() < numIndirectResults;
   }
 
   SILArgumentConvention getArgumentConvention() const {
@@ -280,76 +318,66 @@ class SILFunctionArgument : public SILArgument {
   bool isSelf() const;
 
   /// Returns true if this SILArgument is passed via the given convention.
-  bool hasConvention(SILArgumentConvention P) const {
-    return getArgumentConvention() == P;
+  bool hasConvention(SILArgumentConvention convention) const {
+    return getArgumentConvention() == convention;
   }
 
   static bool classof(const SILInstruction *) = delete;
   static bool classof(const SILUndef *) = delete;
   static bool classof(const SILNode *node) {
     return node->getKind() == SILNodeKind::SILFunctionArgument;
   }
-
-private:
-  friend SILBasicBlock;
-
-  SILFunctionArgument(SILBasicBlock *ParentBB, SILType Ty, ValueOwnershipKind OwnershipKind,
-                      const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILFunctionArgument, ParentBB, Ty, OwnershipKind, D) {}
-  SILFunctionArgument(SILBasicBlock *ParentBB, SILBasicBlock::arg_iterator Pos,
-                      SILType Ty, ValueOwnershipKind OwnershipKind, const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILFunctionArgument, ParentBB, Pos, Ty, OwnershipKind, D) {}
-
-  // A special constructor, only intended for use in
-  // SILBasicBlock::replaceFunctionArg.
-  explicit SILFunctionArgument(SILType Ty, ValueOwnershipKind OwnershipKind,
-                               const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILFunctionArgument, Ty, OwnershipKind, D) {}
 };
 
 //===----------------------------------------------------------------------===//
 // Out of line Definitions for SILArgument to avoid Forward Decl issues
 //===----------------------------------------------------------------------===//
 
-inline bool SILArgument::isPhiArgument() {
+inline bool SILArgument::isPhiArgument() const {
   if (auto *phiArg = dyn_cast<SILPhiArgument>(this))
     return phiArg->isPhiArgument();
 
   return false;
 }
 
-inline SILValue SILArgument::getIncomingPhiValue(SILBasicBlock *BB) {
+inline SILValue
+SILArgument::getIncomingPhiValue(SILBasicBlock *predBlock) const {
   if (isa<SILFunctionArgument>(this))
     return SILValue();
-  return cast<SILPhiArgument>(this)->getIncomingPhiValue(BB);
+  return cast<SILPhiArgument>(this)->getIncomingPhiValue(predBlock);
 }
 
-inline bool
-SILArgument::getIncomingPhiValues(llvm::SmallVectorImpl<SILValue> &OutArray) {
+inline bool SILArgument::getIncomingPhiValues(
+    SmallVectorImpl<SILValue> &returnedPhiValues) const {
   if (isa<SILFunctionArgument>(this))
     return false;
-  return cast<SILPhiArgument>(this)->getIncomingPhiValues(OutArray);
+  return cast<SILPhiArgument>(this)->getIncomingPhiValues(returnedPhiValues);
 }
 
 inline bool SILArgument::getIncomingPhiValues(
-    llvm::SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>> &OutArray) {
+    SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>>
+        &returnedPredAndPhiValuePairs) const {
   if (isa<SILFunctionArgument>(this))
     return false;
-  return cast<SILPhiArgument>(this)->getIncomingPhiValues(OutArray);
+  return cast<SILPhiArgument>(this)->getIncomingPhiValues(
+      returnedPredAndPhiValuePairs);
 }
 
 inline bool SILArgument::getSingleTerminatorOperands(
-    llvm::SmallVectorImpl<SILValue> &OutArray) {
+    SmallVectorImpl<SILValue> &returnedSingleTermOperands) const {
   if (isa<SILFunctionArgument>(this))
     return false;
-  return cast<SILPhiArgument>(this)->getSingleTerminatorOperands(OutArray);
+  return cast<SILPhiArgument>(this)->getSingleTerminatorOperands(
+      returnedSingleTermOperands);
 }
 
 inline bool SILArgument::getSingleTerminatorOperands(
-    llvm::SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>> &OutArray) {
+    SmallVectorImpl<std::pair<SILBasicBlock *, SILValue>>
+        &returnedSingleTermOperands) const {
   if (isa<SILFunctionArgument>(this))
     return false;
-  return cast<SILPhiArgument>(this)->getSingleTerminatorOperands(OutArray);
+  return cast<SILPhiArgument>(this)->getSingleTerminatorOperands(
+      returnedSingleTermOperands);
 }
 
 } // end swift namespace