Rename getArgumentOperandConvention to getCaptureConvention

The name was misleading and problematic. There is already a
getArgumentConvention which is completely different.

Author: atrick

include/swift/SIL/ApplySite.h

@@ -375,9 +375,11 @@ class ApplySite {
   ///
   /// For full applies, this is equivalent to `getArgumentConvention`. But for
   /// a partial_apply, the argument ownership convention at the partial_apply
-  /// instruction itself is different from the argument convention of the callee.
+  /// instruction itself is different from the argument convention of the
+  /// callee.
+  /// 
   /// For details see the partial_apply documentation in SIL.rst.
-  SILArgumentConvention getArgumentOperandConvention(const Operand &oper) const {
+  SILArgumentConvention getCaptureConvention(const Operand &oper) const {
     SILArgumentConvention conv = getArgumentConvention(oper);
     auto *pai = dyn_cast<PartialApplyInst>(Inst);
     if (!pai)

lib/SIL/Verifier/MemoryLifetimeVerifier.cpp

@@ -434,7 +434,7 @@ void MemoryLifetimeVerifier::initDataflowInBlock(SILBasicBlock *block,
         ApplySite AS(&I);
         for (Operand &op : I.getAllOperands()) {
           if (AS.isArgumentOperand(op)) {
-            setFuncOperandBits(state, op, AS.getArgumentOperandConvention(op),
+            setFuncOperandBits(state, op, AS.getCaptureConvention(op),
                               isa<TryApplyInst>(&I));
           }
         }
@@ -771,7 +771,7 @@ void MemoryLifetimeVerifier::checkBlock(SILBasicBlock *block, Bits &bits) {
         ApplySite AS(&I);
         for (Operand &op : I.getAllOperands()) {
           if (AS.isArgumentOperand(op))
-            checkFuncArgument(bits, op, AS.getArgumentOperandConvention(op), &I);
+            checkFuncArgument(bits, op, AS.getCaptureConvention(op), &I);
         }
         break;
       }

lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableAddressesChecker.cpp

@@ -1332,7 +1332,7 @@ bool GatherLexicalLifetimeUseVisitor::visitUse(Operand *op,
       return false;
     }
 
-    if (fas.getArgumentOperandConvention(*op) ==
+    if (fas.getCaptureConvention(*op) ==
         SILArgumentConvention::Indirect_InoutAliasable) {
       // If we don't find the function, we can't handle this, so bail.
       auto *func = fas.getCalleeFunction();

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -2378,7 +2378,7 @@ bool GatherUsesVisitor::visitUse(Operand *op) {
     // either.
     if (auto *f = pas->getCalleeFunction()) {
       if (f->hasSemanticsAttr(semantics::NO_MOVEONLY_DIAGNOSTICS)) {
-        if (ApplySite(pas).getArgumentOperandConvention(*op).isInoutConvention()) {
+        if (ApplySite(pas).getCaptureConvention(*op).isInoutConvention()) {
           diagnosticEmitter.emitEarlierPassEmittedDiagnostic(markedValue);
           return false;
         }

lib/SILOptimizer/Mandatory/MoveOnlyUtils.cpp

@@ -258,7 +258,7 @@ bool noncopyable::memInstMustReinitialize(Operand *memOper) {
   case SILInstructionKind::TryApplyInst:
   case SILInstructionKind::ApplyInst: {
     FullApplySite applySite(memInst);
-    return applySite.getArgumentOperandConvention(*memOper).isInoutConvention();
+    return applySite.getCaptureConvention(*memOper).isInoutConvention();
   }
   case SILInstructionKind::StoreInst:
     return cast<StoreInst>(memInst)->getOwnershipQualifier() ==
@@ -295,7 +295,7 @@ bool noncopyable::memInstMustConsume(Operand *memOper) {
   case SILInstructionKind::TryApplyInst:
   case SILInstructionKind::ApplyInst: {
     FullApplySite applySite(memInst);
-    return applySite.getArgumentOperandConvention(*memOper).isOwnedConvention();
+    return applySite.getCaptureConvention(*memOper).isOwnedConvention();
   }
   case SILInstructionKind::PartialApplyInst: {
     // If we are on the stack or have an inout convention, we do not