[sending] Rename Sema level APIs from isSendingParameter -> isPassedToSendingParameter.

This came up while I was talking with @xedin. This name makes
it really clear what we are trying to communicate to the author.

Author: gottesmm

Diff for: include/swift/AST/Expr.h

@@ -283,8 +283,8 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     /// \c \@preconcurrency declaration.
     IsolatedByPreconcurrency : 1,
 
-    /// True if this is a closure literal that is passed as a sending parameter.
-    IsSendingParameter : 1
+    /// True if this is a closure literal that is passed to a sending parameter.
+    IsPassedToSendingParameter : 1
   );
 
   SWIFT_INLINE_BITFIELD_FULL(BindOptionalExpr, Expr, 16,
@@ -4142,7 +4142,7 @@ class ClosureExpr : public AbstractClosureExpr {
     Bits.ClosureExpr.HasAnonymousClosureVars = false;
     Bits.ClosureExpr.ImplicitSelfCapture = false;
     Bits.ClosureExpr.InheritActorContext = false;
-    Bits.ClosureExpr.IsSendingParameter = false;
+    Bits.ClosureExpr.IsPassedToSendingParameter = false;
   }
 
   SourceRange getSourceRange() const;
@@ -4198,14 +4198,14 @@ class ClosureExpr : public AbstractClosureExpr {
     Bits.ClosureExpr.IsolatedByPreconcurrency = value;
   }
 
-  /// Whether the closure is a closure literal that is passed as a sending
+  /// Whether the closure is a closure literal that is passed to a sending
   /// parameter.
-  bool isSendingParameter() const {
-    return Bits.ClosureExpr.IsSendingParameter;
+  bool isPassedToSendingParameter() const {
+    return Bits.ClosureExpr.IsPassedToSendingParameter;
   }
 
-  void setSendingParameter(bool value = true) {
-    Bits.ClosureExpr.IsSendingParameter = value;
+  void setIsPassedToSendingParameter(bool value = true) {
+    Bits.ClosureExpr.IsPassedToSendingParameter = value;
   }
 
   /// Determine whether this closure expression has an

Diff for: include/swift/AST/Types.h

@@ -3832,7 +3832,7 @@ struct ParameterListInfo {
   SmallBitVector implicitSelfCapture;
   SmallBitVector inheritActorContext;
   SmallBitVector variadicGenerics;
-  SmallBitVector isSending;
+  SmallBitVector isPassedToSending;
 
 public:
   ParameterListInfo() { }
@@ -3865,7 +3865,7 @@ struct ParameterListInfo {
   bool isVariadicGenericParameter(unsigned paramIdx) const;
 
   /// Returns true if this is a sending parameter.
-  bool isSendingParameter(unsigned paramIdx) const;
+  bool isPassedToSendingParameter(unsigned paramIdx) const;
 
   /// Retrieve the number of non-defaulted parameters.
   unsigned numNonDefaultedParameters() const {

Diff for: lib/AST/Type.cpp

@@ -1302,7 +1302,7 @@ ParameterListInfo::ParameterListInfo(
   implicitSelfCapture.resize(params.size());
   inheritActorContext.resize(params.size());
   variadicGenerics.resize(params.size());
-  isSending.resize(params.size());
+  isPassedToSending.resize(params.size());
 
   // No parameter owner means no parameter list means no default arguments
   // - hand back the zeroed bitvector.
@@ -1368,7 +1368,7 @@ ParameterListInfo::ParameterListInfo(
     }
 
     if (param->isSending()) {
-      isSending.set(i);
+      isPassedToSending.set(i);
     }
   }
 }
@@ -1410,8 +1410,9 @@ bool ParameterListInfo::isVariadicGenericParameter(unsigned paramIdx) const {
       : false;
 }
 
-bool ParameterListInfo::isSendingParameter(unsigned paramIdx) const {
-  return paramIdx < isSending.size() ? isSending[paramIdx] : false;
+bool ParameterListInfo::isPassedToSendingParameter(unsigned paramIdx) const {
+  return paramIdx < isPassedToSending.size() ? isPassedToSending[paramIdx]
+                                             : false;
 }
 
 /// Turn a param list into a symbolic and printable representation that does not

Diff for: lib/Sema/CSApply.cpp

@@ -5965,23 +5965,24 @@ static bool hasCurriedSelf(ConstraintSystem &cs, ConcreteDeclRef callee,
 /// Apply the contextually Sendable flag to the given expression,
 static void applyContextualClosureFlags(Expr *expr, bool implicitSelfCapture,
                                         bool inheritActorContext,
-                                        bool isSendingParameter) {
+                                        bool isPassedToSendingParameter) {
   if (auto closure = dyn_cast<ClosureExpr>(expr)) {
     closure->setAllowsImplicitSelfCapture(implicitSelfCapture);
     closure->setInheritsActorContext(inheritActorContext);
-    closure->setSendingParameter(isSendingParameter);
+    closure->setIsPassedToSendingParameter(isPassedToSendingParameter);
     return;
   }
 
   if (auto captureList = dyn_cast<CaptureListExpr>(expr)) {
     applyContextualClosureFlags(captureList->getClosureBody(),
                                 implicitSelfCapture, inheritActorContext,
-                                isSendingParameter);
+                                isPassedToSendingParameter);
   }
 
   if (auto identity = dyn_cast<IdentityExpr>(expr)) {
     applyContextualClosureFlags(identity->getSubExpr(), implicitSelfCapture,
-                                inheritActorContext, isSendingParameter);
+                                inheritActorContext,
+                                isPassedToSendingParameter);
   }
 }
 
@@ -6209,10 +6210,12 @@ ArgumentList *ExprRewriter::coerceCallArguments(
     // implicit self capture or inheriting actor context.
     bool isImplicitSelfCapture = paramInfo.isImplicitSelfCapture(paramIdx);
     bool inheritsActorContext = paramInfo.inheritsActorContext(paramIdx);
-    bool isSendingParameter = paramInfo.isSendingParameter(paramIdx);
+    bool isPassedToSendingParameter =
+        paramInfo.isPassedToSendingParameter(paramIdx);
 
     applyContextualClosureFlags(argExpr, isImplicitSelfCapture,
-                                inheritsActorContext, isSendingParameter);
+                                inheritsActorContext,
+                                isPassedToSendingParameter);
 
     // If the types exactly match, this is easy.
     auto paramType = param.getOldType();

Diff for: lib/Sema/TypeCheckConcurrency.cpp

@@ -4188,7 +4188,7 @@ namespace {
       // the context.
       if (auto *explicitClosure = dyn_cast<ClosureExpr>(closure)) {
         if (!explicitClosure->inheritsActorContext() &&
-            explicitClosure->isSendingParameter())
+            explicitClosure->isPassedToSendingParameter())
           return ActorIsolation::forNonisolated(/*unsafe=*/false)
               .withPreconcurrency(preconcurrency);
       }