[ast] Rename ParamSpecifier::{Transferring,ImplicitlyCopyableConsuming}.

The reason why I am doing this is that I am going to be changing transferring to
not be a true ParamSpecifier. Instead, it is going to be a bit on Param that
changes the default ParamSpecifier used. That being said, I cannot use consuming
for this purpose since consuming today implies no implicit copy semantics, which
we do not want unless the user specifically asks for it by writing consuming.

Author: gottesmm

include/swift/AST/Decl.h

@@ -6776,7 +6776,7 @@ class ParamDecl : public VarDecl {
       return true;
     case Specifier::Consuming:
     case Specifier::InOut:
-    case Specifier::Transferring:
+    case Specifier::ImplicitlyCopyableConsuming:
       return false;
     }
     llvm_unreachable("unhandled specifier");
@@ -6794,7 +6794,7 @@ class ParamDecl : public VarDecl {
     case ParamSpecifier::LegacyShared:
       return ValueOwnership::Shared;
     case ParamSpecifier::Consuming:
-    case ParamSpecifier::Transferring:
+    case ParamSpecifier::ImplicitlyCopyableConsuming:
     case ParamSpecifier::LegacyOwned:
       return ValueOwnership::Owned;
     case ParamSpecifier::Default:

include/swift/AST/Types.h

@@ -2207,9 +2207,9 @@ enum class ParamSpecifier : uint8_t {
   /// `__owned`, a legacy spelling of `consuming`.
   LegacyOwned = 5,
 
-  /// `transferring`. Indicating the transfer of a value from one isolation
-  /// domain to another.
-  Transferring = 6,
+  /// A convention that is similar to consuming a parameter that is mutable and
+  /// var like, but for which no implicit copy semantics are not implemented.
+  ImplicitlyCopyableConsuming = 6,
 };
 
 /// Provide parameter type relevant flags, i.e. variadic, autoclosure, and

lib/AST/ASTBridging.cpp

@@ -2176,7 +2176,7 @@ BridgedSpecifierTypeRepr BridgedSpecifierTypeRepr_createParsed(
   }
   case BridgedAttributedTypeSpecifierTransferring: {
     return new (context)
-        OwnershipTypeRepr(baseType, ParamSpecifier::Transferring, loc);
+        OwnershipTypeRepr(baseType, ParamSpecifier::ImplicitlyCopyableConsuming, loc);
   }
   case BridgedAttributedTypeSpecifierConst: {
     return new (context) CompileTimeConstTypeRepr(baseType, loc);

lib/AST/ASTMangler.cpp

@@ -2887,7 +2887,7 @@ getParameterFlagsForMangling(ParameterTypeFlags flags,
   case ParamSpecifier::InOut:
     return flags;
 
-  case ParamSpecifier::Transferring:
+  case ParamSpecifier::ImplicitlyCopyableConsuming:
   case ParamSpecifier::Consuming:
   case ParamSpecifier::Borrowing:
     // Only mangle the ownership if it diverges from the default.

lib/AST/ASTPrinter.cpp

@@ -3890,7 +3890,7 @@ static bool usesFeatureBitwiseCopyable(Decl *decl) { return false; }
 
 static bool usesFeatureTransferringArgsAndResults(Decl *decl) {
   if (auto *pd = dyn_cast<ParamDecl>(decl))
-    if (pd->getSpecifier() == ParamSpecifier::Transferring)
+    if (pd->getSpecifier() == ParamSpecifier::ImplicitlyCopyableConsuming)
       return true;
 
   // TODO: Results.
@@ -4592,8 +4592,8 @@ static void printParameterFlags(ASTPrinter &printer,
   case ParamSpecifier::LegacyOwned:
     printer.printKeyword("__owned", options, " ");
     break;
-  case ParamSpecifier::Transferring:
-    printer.printKeyword("transferring", options, " ");
+  case ParamSpecifier::ImplicitlyCopyableConsuming:
+    printer.printKeyword("implicitly_copyable_consuming", options, " ");
     break;
   }
 

lib/AST/Decl.cpp

@@ -7774,7 +7774,7 @@ void ParamDecl::setSpecifier(Specifier specifier) {
   // `inout` and `consuming` parameters are locally mutable.
   case ParamSpecifier::InOut:
   case ParamSpecifier::Consuming:
-  case ParamSpecifier::Transferring:
+  case ParamSpecifier::ImplicitlyCopyableConsuming:
     introducer = VarDecl::Introducer::Var;
     break;
   }
@@ -7838,8 +7838,8 @@ StringRef ParamDecl::getSpecifierSpelling(ParamSpecifier specifier) {
     return "__shared";
   case ParamSpecifier::LegacyOwned:
     return "__owned";
-  case ParamSpecifier::Transferring:
-    return "transferring";
+  case ParamSpecifier::ImplicitlyCopyableConsuming:
+    return "implicitly_copyable_consuming";
   }
   llvm_unreachable("invalid ParamSpecifier");
 }
@@ -8442,7 +8442,7 @@ AnyFunctionType::Param ParamDecl::toFunctionParam(Type type) const {
       type, isVariadic(), isAutoClosure(), isNonEphemeral(), getSpecifier(),
       isIsolated(), /*isNoDerivative*/ false, isCompileTimeConst(),
       hasResultDependsOn(),
-      getSpecifier() == ParamDecl::Specifier::Transferring /*is transferring*/);
+      getSpecifier() == ParamDecl::Specifier::ImplicitlyCopyableConsuming /*is transferring*/);
   return AnyFunctionType::Param(type, label, flags, internalLabel);
 }
 

lib/Parse/ParseDecl.cpp

@@ -5399,7 +5399,7 @@ ParserStatus Parser::ParsedTypeAttributeList::slowParse(Parser &P) {
         } else if (Tok.getRawText().equals("borrowing")) {
           Specifier = ParamDecl::Specifier::Borrowing;
         } else if (Tok.getRawText().equals("transferring")) {
-          Specifier = ParamDecl::Specifier::Transferring;
+          Specifier = ParamDecl::Specifier::ImplicitlyCopyableConsuming;
         } else if (Tok.getRawText().equals("consuming")) {
           Specifier = ParamDecl::Specifier::Consuming;
         }

lib/Parse/ParsePattern.cpp

@@ -286,7 +286,7 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
           } else if (Context.LangOpts.hasFeature(
                          Feature::TransferringArgsAndResults) &&
                      Tok.isContextualKeyword("transferring")) {
-            param.SpecifierKind = ParamDecl::Specifier::Transferring;
+            param.SpecifierKind = ParamDecl::Specifier::ImplicitlyCopyableConsuming;
             param.SpecifierLoc = consumeToken();
           }
 

lib/SILGen/SILGenLValue.cpp

@@ -3016,8 +3016,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenBorrowedBaseVisitor
         case ParamSpecifier::InOut:
         case ParamSpecifier::LegacyShared:
         case ParamSpecifier::LegacyOwned:
-        // For now, transferring isn't implicitly copyable.
-        case ParamSpecifier::Transferring:
+        case ParamSpecifier::ImplicitlyCopyableConsuming:
           return false;
         }
         if (pd->hasResultDependsOn()) {

lib/SILGen/SILGenProlog.cpp

@@ -860,7 +860,7 @@ class ArgumentInitHelper {
           argrv = ManagedValue::forBorrowedAddressRValue(
               SGF.B.createCopyableToMoveOnlyWrapperAddr(pd, argrv.getValue()));
           break;
-        case swift::ParamSpecifier::Transferring:
+        case swift::ParamSpecifier::ImplicitlyCopyableConsuming:
         case swift::ParamSpecifier::Consuming:
         case swift::ParamSpecifier::Default:
         case swift::ParamSpecifier::InOut:

lib/Sema/TypeCheckType.cpp

@@ -3683,7 +3683,7 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
         case TypeReprKind::Ownership:
           ownership = cast<OwnershipTypeRepr>(specifierRepr)->getSpecifier();
           nestedRepr = specifierRepr->getBase();
-          isTransferring = ownership == ParamSpecifier::Transferring;
+          isTransferring = ownership == ParamSpecifier::ImplicitlyCopyableConsuming;
           continue;
         case TypeReprKind::Isolated:
           isolated = true;
@@ -4878,7 +4878,7 @@ TypeResolver::resolveOwnershipTypeRepr(OwnershipTypeRepr *repr,
   case ParamSpecifier::LegacyOwned:
   case ParamSpecifier::Borrowing:
     break;
-  case ParamSpecifier::Transferring:
+  case ParamSpecifier::ImplicitlyCopyableConsuming:
   case ParamSpecifier::Consuming:
     if (auto *fnTy = result->getAs<FunctionType>()) {
       if (fnTy->isNoEscape()) {

lib/Serialization/Deserialization.cpp

@@ -2884,7 +2884,7 @@ getActualParamDeclSpecifier(serialization::ParamDeclSpecifier raw) {
   CASE(Consuming)
   CASE(LegacyShared)
   CASE(LegacyOwned)
-  CASE(Transferring)
+  CASE(ImplicitlyCopyableConsuming)
   }
 #undef CASE
   return llvm::None;

lib/Serialization/Serialization.cpp

@@ -2547,7 +2547,7 @@ static uint8_t getRawStableParamDeclSpecifier(swift::ParamDecl::Specifier sf) {
     return uint8_t(serialization::ParamDeclSpecifier::LegacyShared);
   case swift::ParamDecl::Specifier::LegacyOwned:
     return uint8_t(serialization::ParamDeclSpecifier::LegacyOwned);
-  case swift::ParamDecl::Specifier::Transferring:
+  case swift::ParamDecl::Specifier::ImplicitlyCopyableConsuming:
     return uint8_t(serialization::ParamDeclSpecifier::Transferring);
   }
   llvm_unreachable("bad param decl specifier kind");