Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

include/swift/ABI/MetadataValues.h

@@ -1197,7 +1197,7 @@ class TargetExtendedFunctionTypeFlags {
     // Values for the enumerated isolation kinds
     IsolatedAny            = 0x00000002U,
 
-    // Values if we have a transferring result.
+    // Values if we have a sending result.
     HasSendingResult  = 0x00000010U,
 
     /// A InvertibleProtocolSet in the high bits.

include/swift/AST/ASTBridging.h

@@ -1550,7 +1550,6 @@ enum ENUM_EXTENSIBILITY_ATTR(open) BridgedAttributedTypeSpecifier : size_t {
   BridgedAttributedTypeSpecifierLegacyOwned,
   BridgedAttributedTypeSpecifierConst,
   BridgedAttributedTypeSpecifierIsolated,
-  BridgedAttributedTypeSpecifierTransferring,
   BridgedAttributedTypeSpecifierSending,
 };
 

include/swift/AST/DiagnosticsParse.def

@@ -2204,19 +2204,10 @@ ERROR(lifetime_dependence_invalid_init_return, PointsToFirstBadToken,
       "specifiers",
       ())
 
-ERROR(transferring_after_parameter_specifier,none,
-      "'transferring' must be placed before specifier '%0'", (StringRef))
-ERROR(transferring_repeated,none,
-      "parameter may have at most one 'transferring' specifier", ())
 ERROR(sending_before_parameter_specifier,none,
       "'sending' must be placed after specifier '%0'", (StringRef))
 ERROR(sending_repeated,none,
       "parameter may have at most one 'sending' specifier", ())
-ERROR(sending_and_transferring_used_together,none,
-      "'transferring' and 'sending' may not be used together", ())
-WARNING(transferring_is_now_sendable,none,
-        "'transferring' has been renamed to 'sending' and the 'transferring' spelling will be removed shortly",
-        ())
 ERROR(sending_cannot_be_used_with_borrowing,none,
       "'%0' cannot be used together with 'borrowing'", (StringRef))
 

include/swift/AST/DiagnosticsSema.def

@@ -7979,16 +7979,9 @@ ERROR(lifetime_dependence_immortal_conflict_name, none,
       "conflict between the parameter name and immortal keyword", ())
 
 //===----------------------------------------------------------------------===//
-//                             MARK: Transferring
+//                             MARK: Sending
 //===----------------------------------------------------------------------===//
 
-ERROR(transferring_unsupported_param_specifier, none,
-      "'%0' cannot be applied to a 'transferring' parameter", (StringRef))
-
-ERROR(transferring_only_on_parameters_and_results, none,
-      "'transferring' may only be used on parameters and results", ())
-ERROR(transferring_cannot_be_applied_to_tuple_elt, none,
-      "'transferring' cannot be applied to tuple elements", ())
 ERROR(sending_unsupported_param_specifier, none,
       "'%0' cannot be applied to a 'sending' parameter", (StringRef))
 ERROR(sending_only_on_parameters_and_results, none,

include/swift/AST/ExtInfo.h

@@ -486,15 +486,15 @@ class ASTExtInfoBuilder {
                           DifferentiabilityKind::NonDifferentiable, nullptr,
                           FunctionTypeIsolation::forNonIsolated(),
                           LifetimeDependenceInfo(),
-                          false /*transferringResult*/) {}
+                          false /*sendingResult*/) {}
 
   // Constructor for polymorphic type.
   ASTExtInfoBuilder(Representation rep, bool throws, Type thrownError)
       : ASTExtInfoBuilder(rep, false, throws, thrownError,
                           DifferentiabilityKind::NonDifferentiable, nullptr,
                           FunctionTypeIsolation::forNonIsolated(),
                           LifetimeDependenceInfo(),
-                          false /*transferringResult*/) {}
+                          false /*sendingResult*/) {}
 
   // Constructor with no defaults.
   ASTExtInfoBuilder(Representation rep, bool isNoEscape, bool throws,

include/swift/AST/TypeRepr.h

@@ -1119,7 +1119,6 @@ class SpecifierTypeRepr : public TypeRepr {
            T->getKind() == TypeReprKind::Isolated ||
            T->getKind() == TypeReprKind::CompileTimeConst ||
            T->getKind() == TypeReprKind::LifetimeDependentReturn ||
-           T->getKind() == TypeReprKind::Transferring ||
            T->getKind() == TypeReprKind::Sending;
   }
   static bool classof(const SpecifierTypeRepr *T) { return true; }
@@ -1191,21 +1190,6 @@ class CompileTimeConstTypeRepr : public SpecifierTypeRepr {
   static bool classof(const CompileTimeConstTypeRepr *T) { return true; }
 };
 
-/// A transferring type.
-/// \code
-///   x : transferring Int
-/// \endcode
-class TransferringTypeRepr : public SpecifierTypeRepr {
-public:
-  TransferringTypeRepr(TypeRepr *Base, SourceLoc InOutLoc)
-      : SpecifierTypeRepr(TypeReprKind::Transferring, Base, InOutLoc) {}
-
-  static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::Transferring;
-  }
-  static bool classof(const TransferringTypeRepr *T) { return true; }
-};
-
 /// A sending type.
 /// \code
 ///   x : sending Int
@@ -1621,7 +1605,6 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Array:
   case TypeReprKind::SILBox:
   case TypeReprKind::Isolated:
-  case TypeReprKind::Transferring:
   case TypeReprKind::Sending:
   case TypeReprKind::Placeholder:
   case TypeReprKind::CompileTimeConst:

include/swift/AST/TypeReprNodes.def

@@ -70,7 +70,6 @@ ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   SPECIFIER_TYPEREPR(Ownership, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(Isolated, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(CompileTimeConst, SpecifierTypeRepr)
-  SPECIFIER_TYPEREPR(Transferring, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(Sending, SpecifierTypeRepr)
 TYPEREPR(Fixed, TypeRepr)
 TYPEREPR(SILBox, TypeRepr)

include/swift/AST/Types.h

@@ -2429,7 +2429,7 @@ class YieldTypeFlags {
                               /*nonEphemeral*/ false, getOwnershipSpecifier(),
                               /*isolated*/ false, /*noDerivative*/ false,
                               /*compileTimeConst*/ false,
-                              /*is transferring*/ false);
+                              /*is sending*/ false);
   }
 
   bool operator ==(const YieldTypeFlags &other) const {

include/swift/Basic/Features.def

@@ -196,7 +196,6 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(NoncopyableGenerics, 427, "Noncopyable generics")
 SUPPRESSIBLE_LANGUAGE_FEATURE(ConformanceSuppression, 426, "Suppressible inferred conformances")
 SUPPRESSIBLE_LANGUAGE_FEATURE(BitwiseCopyable2, 426, "BitwiseCopyable feature")
 LANGUAGE_FEATURE(BodyMacros, 415, "Function body macros")
-LANGUAGE_FEATURE(TransferringArgsAndResults, 430, "Transferring args and results")
 SUPPRESSIBLE_LANGUAGE_FEATURE(SendingArgsAndResults, 430, "Sending arg and results")
 LANGUAGE_FEATURE(BorrowingSwitch, 432, "Noncopyable type pattern matching")
 CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE(IsolatedAny, 431, "@isolated(any) function types")

include/swift/Option/FrontendOptions.td

@@ -1377,11 +1377,6 @@ def disable_experimental_parser_round_trip : Flag<["-"],
   "disable-experimental-parser-round-trip">,
   HelpText<"Disable round trip through the new swift parser">;
 
-def disable_transferring_args_and_results_with_region_isolation : Flag<["-"],
-  "disable-transferring-args-and-results-with-region-based-isolation">,
-  HelpText<"Disable transferring args and results when region based isolation is enabled. Only enabled with asserts">,
-  Flags<[HelpHidden]>;
-
 def disable_sending_args_and_results_with_region_isolation : Flag<["-"],
   "disable-sending-args-and-results-with-region-based-isolation">,
   HelpText<"Disable sending args and results when region based isolation is enabled. Only enabled with asserts">,

include/swift/Parse/Parser.h

@@ -1211,9 +1211,6 @@ class Parser {
         Tok.isContextualKeyword("isolated") ||
         Tok.isContextualKeyword("_const"))
       return true;
-    if (Context.LangOpts.hasFeature(Feature::TransferringArgsAndResults) &&
-        Tok.isContextualKeyword("transferring"))
-      return true;
     if (Context.LangOpts.hasFeature(Feature::SendingArgsAndResults) &&
         Tok.isContextualKeyword("sending"))
       return true;
@@ -1264,7 +1261,6 @@ class Parser {
     SourceLoc SpecifierLoc;
     SourceLoc IsolatedLoc;
     SourceLoc ConstLoc;
-    SourceLoc TransferringLoc;
     SourceLoc SendingLoc;
     SmallVector<TypeOrCustomAttr> Attributes;
     SmallVector<LifetimeDependenceSpecifier> lifetimeDependenceSpecifiers;
@@ -1577,9 +1573,6 @@ class Parser {
     /// The location of the '_const' keyword, if present.
     SourceLoc CompileConstLoc;
 
-    /// The location of the 'transferring' keyword if present.
-    SourceLoc TransferringLoc;
-
     /// The location of the 'sending' keyword if present.
     SourceLoc SendingLoc;
 

lib/AST/ASTBridging.cpp

@@ -877,8 +877,6 @@ BridgedParamDecl BridgedParamDecl_createParsed(
           paramDecl->setIsolated(true);
         else if (isa<CompileTimeConstTypeRepr>(STR))
           paramDecl->setCompileTimeConst(true);
-        else if (isa<TransferringTypeRepr>(STR))
-          paramDecl->setSending(true);
         else if (isa<SendingTypeRepr>(STR))
           paramDecl->setSending(true);
 
@@ -2225,9 +2223,6 @@ BridgedSpecifierTypeRepr BridgedSpecifierTypeRepr_createParsed(
     return new (context)
         OwnershipTypeRepr(baseType, ParamSpecifier::LegacyOwned, loc);
   }
-  case BridgedAttributedTypeSpecifierTransferring: {
-    return new (context) TransferringTypeRepr(baseType, loc);
-  }
   case BridgedAttributedTypeSpecifierSending: {
     return new (context) SendingTypeRepr(baseType, loc);
   }

lib/AST/ASTDumper.cpp

@@ -3448,12 +3448,6 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,
     printFoot();
   }
 
-  void visitTransferringTypeRepr(TransferringTypeRepr *T, StringRef label) {
-    printCommon("transferring", label);
-    printRec(T->getBase());
-    printFoot();
-  }
-
   void visitSendingTypeRepr(SendingTypeRepr *T, StringRef label) {
     printCommon("sending", label);
     printRec(T->getBase());

lib/AST/ASTMangler.cpp

@@ -2166,7 +2166,7 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn,
     appendType(param.getInterfaceType(), sig, forDecl);
   }
 
-  // Mangle if we have a transferring result.
+  // Mangle if we have a sending result.
   if (isInRecursion && fn->hasSendingResult())
     OpArgs.push_back('T');
 

lib/AST/ASTWalker.cpp

@@ -2337,10 +2337,6 @@ bool Traversal::visitIsolatedTypeRepr(IsolatedTypeRepr *T) {
   return doIt(T->getBase());
 }
 
-bool Traversal::visitTransferringTypeRepr(TransferringTypeRepr *T) {
-  return doIt(T->getBase());
-}
-
 bool Traversal::visitSendingTypeRepr(SendingTypeRepr *T) {
   return doIt(T->getBase());
 }

lib/AST/Builtins.cpp

@@ -1686,7 +1686,7 @@ static ValueDecl *getStartAsyncLet(ASTContext &ctx, Identifier id) {
   bool hasSendingResult =
       ctx.LangOpts.hasFeature(Feature::RegionBasedIsolation);
 
-  // operation async function pointer: () async throws -> transferring T
+  // operation async function pointer: () async throws -> sending T
   auto extInfo = ASTExtInfoBuilder()
                      .withAsync()
                      .withThrows()

lib/AST/Decl.cpp

@@ -10371,8 +10371,7 @@ FuncDecl *FuncDecl::create(ASTContext &Context, SourceLoc StaticLoc,
       ClangNode());
   FD->setParameters(BodyParams);
   FD->FnRetType = TypeLoc(ResultTyR);
-  if (llvm::isa_and_nonnull<TransferringTypeRepr>(ResultTyR) ||
-      llvm::isa_and_nonnull<SendingTypeRepr>(ResultTyR))
+  if (llvm::isa_and_nonnull<SendingTypeRepr>(ResultTyR))
     FD->setSendingResult();
   return FD;
 }

lib/AST/FeatureSet.cpp

@@ -638,7 +638,6 @@ UNINTERESTING_FEATURE(BitwiseCopyable)
 UNINTERESTING_FEATURE(FixedArrays)
 UNINTERESTING_FEATURE(GroupActorErrors)
 
-UNINTERESTING_FEATURE(TransferringArgsAndResults)
 static bool usesFeatureSendingArgsAndResults(Decl *decl) {
   auto isFunctionTypeWithSending = [](Type type) {
       auto fnType = type->getAs<AnyFunctionType>();

lib/AST/NameLookup.cpp

@@ -3180,7 +3180,6 @@ directReferencesForTypeRepr(Evaluator &evaluator,
   case TypeReprKind::NamedOpaqueReturn:
   case TypeReprKind::Existential:
   case TypeReprKind::LifetimeDependentReturn:
-  case TypeReprKind::Transferring:
   case TypeReprKind::Sending:
     return result;
 

lib/AST/TypeRepr.cpp

@@ -852,9 +852,6 @@ void SpecifierTypeRepr::printImpl(ASTPrinter &Printer,
   case TypeReprKind::Isolated:
     Printer.printKeyword("isolated", Opts, " ");
     break;
-  case TypeReprKind::Transferring:
-    Printer.printKeyword("transferring", Opts, " ");
-    break;
   case TypeReprKind::Sending:
     Printer.printKeyword("sending", Opts, " ");
     break;

lib/ASTGen/Sources/ASTGen/SourceFile.swift

@@ -60,7 +60,6 @@ extension Parser.ExperimentalFeatures {
     mapFeature(.ThenStatements, to: .thenStatements)
     mapFeature(.DoExpressions, to: .doExpressions)
     mapFeature(.NonescapableTypes, to: .nonescapableTypes)
-    mapFeature(.TransferringArgsAndResults, to: .transferringArgsAndResults)
     mapFeature(.SendingArgsAndResults, to: .sendingArgsAndResults)
   }
 }

lib/ClangImporter/ClangImporter.cpp

@@ -676,10 +676,8 @@ void importer::getNormalInvocationArguments(
     }
   }
 
-  // If we support TransferringArgsAndResults, set the -D flag to signal that it
+  // If we support SendingArgsAndResults, set the -D flag to signal that it
   // is supported.
-  if (LangOpts.hasFeature(Feature::TransferringArgsAndResults))
-    invocationArgStrs.push_back("-D__SWIFT_ATTR_SUPPORTS_TRANSFERRING=1");
   if (LangOpts.hasFeature(Feature::SendingArgsAndResults))
     invocationArgStrs.push_back("-D__SWIFT_ATTR_SUPPORTS_SENDING=1");
 

lib/ClangImporter/ImportDecl.cpp

@@ -8061,18 +8061,6 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
         nominal->registerProtocolConformance(conformance, /*synthesized=*/true);
       }
 
-      if (swiftAttr->getAttribute() == "transferring") {
-        // Swallow this if the feature is not enabled.
-        if (!SwiftContext.LangOpts.hasFeature(
-                Feature::TransferringArgsAndResults))
-          continue;
-        auto *funcDecl = dyn_cast<FuncDecl>(MappedDecl);
-        if (!funcDecl)
-          continue;
-        funcDecl->setSendingResult();
-        continue;
-      }
-
       if (swiftAttr->getAttribute() == "sending") {
         // Swallow this if the feature is not enabled.
         if (!SwiftContext.LangOpts.hasFeature(Feature::SendingArgsAndResults))

lib/ClangImporter/ImportType.cpp

@@ -2649,19 +2649,8 @@ static ParamDecl *getParameterInfo(ClangImporter::Implementation *impl,
       impl->importSourceLoc(param->getLocation()), bodyName,
       impl->ImportedHeaderUnit);
 
-  // If TransferringArgsAndResults are enabled and we have a transferring
-  // argument, set that the param was transferring.
-  if (paramInfo->getASTContext().LangOpts.hasFeature(
-          Feature::TransferringArgsAndResults)) {
-    if (auto *attr = param->getAttr<clang::SwiftAttrAttr>()) {
-      if (attr->getAttribute() == "transferring") {
-        paramInfo->setSending();
-      }
-    }
-  }
-
-  // If TransferringArgsAndResults are enabled and we have a transferring
-  // argument, set that the param was transferring.
+  // If SendingArgsAndResults are enabled and we have a sending argument,
+  // set that the param was sending.
   if (paramInfo->getASTContext().LangOpts.hasFeature(
           Feature::SendingArgsAndResults)) {
     if (auto *attr = param->getAttr<clang::SwiftAttrAttr>()) {

lib/Migrator/APIDiffMigratorPass.cpp

@@ -157,10 +157,6 @@ class ChildIndexFinder : public TypeReprVisitor<ChildIndexFinder, FoundResult> {
     return visit(T->getBase());
   }
 
-  FoundResult visitTransferringTypeRepr(TransferringTypeRepr *T) {
-    return visit(T->getBase());
-  }
-
   FoundResult visitSendingTypeRepr(SendingTypeRepr *T) {
     return visit(T->getBase());
   }