[transferring] Change transferring to no longer be a ParamSpecifier.

Instead it is a bit on ParamDecl and SILParameterInfo. I preserve the consuming
behavior by making it so that the type checker changes the ParamSpecifier to
ImplicitlyCopyableConsuming if we have a default param specifier and
transferring is set. NOTE: The user can never write ImplicitlyCopyableConsuming.

NOTE: I had to expand the amount of flags that can be stored in ParamDecl so I
stole bits from TypeRepr and added some logic for packing option bits into
TyRepr and DefaultValue.

rdar://121324715

Author: gottesmm

include/swift/AST/Decl.h

@@ -6468,8 +6468,6 @@ class ParamDecl : public VarDecl {
   SourceLoc ArgumentNameLoc;
   SourceLoc SpecifierLoc;
 
-  TypeRepr *TyRepr = nullptr;
-
   struct alignas(1 << StoredDefaultArgumentAlignInBits) StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
 
@@ -6488,7 +6486,9 @@ class ParamDecl : public VarDecl {
   /// argument without triggering a request.
   llvm::Optional<Initializer *> getCachedDefaultArgumentInitContext() const;
 
-  enum class Flags : uint8_t {
+  /// NOTE: This is stored using bits from TyReprAndFlags and
+  /// DefaultValueAndFlags.
+  enum class Flag : uint8_t {
     /// Whether or not this parameter is vargs.
     IsVariadic = 1 << 0,
 
@@ -6500,12 +6500,66 @@ class ParamDecl : public VarDecl {
 
     /// Whether or not this paramater is '_resultDependsOn'
     IsResultDependsOn = 1 << 3,
+
+    /// Whether or not this parameter is 'transferring'.
+    IsTransferring = 1 << 4,
   };
 
-  /// The default value, if any, along with flags.
-  llvm::PointerIntPair<StoredDefaultArgument *, 3, OptionSet<Flags>>
+  /// The type repr and 3 bits used for flags.
+  llvm::PointerIntPair<TypeRepr *, 3, std::underlying_type<Flag>::type>
+      TyReprAndFlags;
+
+  /// The default value, if any, along with 3 bits for flags.
+  llvm::PointerIntPair<StoredDefaultArgument *, 3,
+                       std::underlying_type<Flag>::type>
       DefaultValueAndFlags;
 
+  OptionSet<Flag> getOptions() const {
+    uint8_t result = 0;
+    result |= TyReprAndFlags.getInt();
+    result |= DefaultValueAndFlags.getInt() << 3;
+    return OptionSet<Flag>(result);
+  }
+
+  /// Set the current set of options to \p newFlags.
+  void setOptions(OptionSet<Flag> newFlags) {
+    uint8_t bits = newFlags.toRaw();
+    TyReprAndFlags.setInt(bits & 0x7);
+    DefaultValueAndFlags.setInt(bits >> 3);
+  }
+
+  void setOptionsAndPointers(TypeRepr *tyRepr,
+                             StoredDefaultArgument *storedArgs,
+                             OptionSet<Flag> newFlags) {
+    uint8_t bits = newFlags.toRaw();
+    TyReprAndFlags.setPointerAndInt(tyRepr, bits & 0x7);
+    DefaultValueAndFlags.setPointerAndInt(storedArgs, bits >> 3);
+  }
+
+  void addFlag(Flag newFlag) {
+    auto flagBits = uint8_t(newFlag);
+    if (uint8_t(newFlag) < (1 << 3)) {
+      flagBits &= 0x7;
+      TyReprAndFlags.setInt(TyReprAndFlags.getInt() | flagBits);
+      return;
+    }
+
+    flagBits >>= 3;
+    DefaultValueAndFlags.setInt(DefaultValueAndFlags.getInt() | flagBits);
+  }
+
+  void removeFlag(Flag newFlag) {
+    auto flagBits = uint8_t(newFlag);
+    if (uint8_t(newFlag) < (1 << 3)) {
+      flagBits &= 0x7;
+      TyReprAndFlags.setInt(TyReprAndFlags.getInt() & ~flagBits);
+      return;
+    }
+
+    flagBits >>= 3;
+    DefaultValueAndFlags.setInt(DefaultValueAndFlags.getInt() & ~flagBits);
+  }
+
   friend class ParamSpecifierRequest;
 
 public:
@@ -6551,8 +6605,8 @@ class ParamDecl : public VarDecl {
   SourceLoc getSpecifierLoc() const { return SpecifierLoc; }
 
   /// Retrieve the TypeRepr corresponding to the parsed type of the parameter, if it exists.
-  TypeRepr *getTypeRepr() const { return TyRepr; }
-  void setTypeRepr(TypeRepr *repr) { TyRepr = repr; }
+  TypeRepr *getTypeRepr() const { return TyReprAndFlags.getPointer(); }
+  void setTypeRepr(TypeRepr *repr) { TyReprAndFlags.setPointer(repr); }
 
   bool isDestructured() const {
     auto flags = ArgumentNameAndFlags.getInt();
@@ -6674,30 +6728,44 @@ class ParamDecl : public VarDecl {
   /// Whether or not this parameter is old-style variadic.
   bool isVariadic() const;
   void setVariadic(bool value = true) {
-    auto flags = DefaultValueAndFlags.getInt();
-    DefaultValueAndFlags.setInt(value ? flags | Flags::IsVariadic
-                                      : flags - Flags::IsVariadic);
+    if (value)
+      addFlag(Flag::IsVariadic);
+    else
+      removeFlag(Flag::IsVariadic);
   }
 
   /// Whether or not this parameter is marked with `@autoclosure`.
   bool isAutoClosure() const {
-    return DefaultValueAndFlags.getInt().contains(Flags::IsAutoClosure);
+    return getOptions().contains(Flag::IsAutoClosure);
   }
+
   void setAutoClosure(bool value = true) {
-    auto flags = DefaultValueAndFlags.getInt();
-    DefaultValueAndFlags.setInt(value ? flags | Flags::IsAutoClosure
-                                      : flags - Flags::IsAutoClosure);
+    if (value)
+      addFlag(Flag::IsAutoClosure);
+    else
+      removeFlag(Flag::IsAutoClosure);
   }
 
   /// Whether or not this parameter is marked with 'isolated'.
-  bool isIsolated() const {
-    return DefaultValueAndFlags.getInt().contains(Flags::IsIsolated);
-  }
+  bool isIsolated() const { return getOptions().contains(Flag::IsIsolated); }
 
   void setIsolated(bool value = true) {
-    auto flags = DefaultValueAndFlags.getInt();
-    DefaultValueAndFlags.setInt(value ? flags | Flags::IsIsolated
-                                      : flags - Flags::IsIsolated);
+    if (value)
+      addFlag(Flag::IsIsolated);
+    else
+      removeFlag(Flag::IsIsolated);
+  }
+
+  /// Whether or not this parameter is marked with 'transferring'.
+  bool isTransferring() const {
+    return getOptions().contains(Flag::IsTransferring);
+  }
+
+  void setTransferring(bool value = true) {
+    if (value)
+      addFlag(Flag::IsTransferring);
+    else
+      removeFlag(Flag::IsTransferring);
   }
 
   /// Whether or not this parameter is marked with '_const'.

include/swift/AST/DiagnosticsParse.def

@@ -2209,5 +2209,11 @@ ERROR(lifetime_dependence_invalid_init_return, PointsToFirstBadToken,
       "expected Self return type for initializers with lifetime dependence "
       "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", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsSema.def

@@ -7795,47 +7795,55 @@ ERROR(pack_iteration_where_clause_not_supported, none,
       "'where' clause in pack iteration is not supported", ())
 
 
- //------------------------------------------------------------------------------
- // MARK: Lifetime Dependence Diagnostics
- //------------------------------------------------------------------------------
-
- ERROR(lifetime_dependence_invalid_param_name, none,
-       "invalid parameter name specified %0", (Identifier))
- ERROR(lifetime_dependence_invalid_param_index, none,
-       "invalid parameter index specified %0", (unsigned))
- ERROR(lifetime_dependence_invalid_self, none,
-       "invalid lifetime dependence specifier, self is valid in non-static "
-       "methods only", ())
- ERROR(lifetime_dependence_duplicate_param_id, none,
-       "duplicate lifetime dependence specifier", ())
- ERROR(lifetime_dependence_cannot_use_kind, none,
-       "invalid use of %0 lifetime dependence for %1 ownership",
-       (StringRef, StringRef))
- ERROR(lifetime_dependence_only_on_function_method_init_result, none,
-       "lifetime dependence specifiers may only be used on result of "
-       "functions, methods, initializers",
-       ())
- ERROR(lifetime_dependence_invalid_return_type, none,
-       "lifetime dependence can only be specified on ~Escapable results", ())
- ERROR(lifetime_dependence_missing_ownership_modifier, none,
-       "lifetime dependence can only be specified on parameters with ownership "
-       "modifiers (borrowing, consuming, inout)", ())
- ERROR(lifetime_dependence_cannot_infer_wo_ownership_modifier_on_method, none,
-       "cannot infer lifetime dependence, specify ownership modifier for the "
-       "method",
-       ())
- ERROR(lifetime_dependence_cannot_infer_wo_ambiguous_candidate, none,
-       "cannot infer lifetime dependence, multiple ~Escapable or ~Copyable "
-       "parameters with ownership modifiers, specify explicit lifetime "
-       "dependence",
-       ())
- ERROR(lifetime_dependence_cannot_infer_no_candidates, none,
-       "cannot infer lifetime dependence, no ~Escapable or ~Copyable "
-       "parameters with ownership modifiers present",
-       ())
- ERROR(lifetime_dependence_ctor_non_self_or_nil_return, none,
-       "expected nil or self as return values in an initializer with "
-       "lifetime dependent specifiers",
-       ())
+//------------------------------------------------------------------------------
+// MARK: Lifetime Dependence Diagnostics
+//------------------------------------------------------------------------------
+
+ERROR(lifetime_dependence_invalid_param_name, none,
+      "invalid parameter name specified %0", (Identifier))
+ERROR(lifetime_dependence_invalid_param_index, none,
+      "invalid parameter index specified %0", (unsigned))
+ERROR(lifetime_dependence_invalid_self, none,
+      "invalid lifetime dependence specifier, self is valid in non-static "
+      "methods only", ())
+ERROR(lifetime_dependence_duplicate_param_id, none,
+      "duplicate lifetime dependence specifier", ())
+ERROR(lifetime_dependence_cannot_use_kind, none,
+      "invalid use of %0 lifetime dependence for %1 ownership",
+      (StringRef, StringRef))
+ERROR(lifetime_dependence_only_on_function_method_init_result, none,
+      "lifetime dependence specifiers may only be used on result of "
+      "functions, methods, initializers",
+      ())
+ERROR(lifetime_dependence_invalid_return_type, none,
+      "lifetime dependence can only be specified on ~Escapable results", ())
+ERROR(lifetime_dependence_missing_ownership_modifier, none,
+      "lifetime dependence can only be specified on parameters with ownership "
+      "modifiers (borrowing, consuming, inout)", ())
+ERROR(lifetime_dependence_cannot_infer_wo_ownership_modifier_on_method, none,
+      "cannot infer lifetime dependence, specify ownership modifier for the "
+      "method",
+      ())
+ERROR(lifetime_dependence_cannot_infer_wo_ambiguous_candidate, none,
+      "cannot infer lifetime dependence, multiple ~Escapable or ~Copyable "
+      "parameters with ownership modifiers, specify explicit lifetime "
+      "dependence",
+      ())
+ERROR(lifetime_dependence_cannot_infer_no_candidates, none,
+      "cannot infer lifetime dependence, no ~Escapable or ~Copyable "
+      "parameters with ownership modifiers present",
+      ())
+ERROR(lifetime_dependence_ctor_non_self_or_nil_return, none,
+      "expected nil or self as return values in an initializer with "
+      "lifetime dependent specifiers",
+      ())
+
+//===----------------------------------------------------------------------===//
+//                             MARK: Transferring
+//===----------------------------------------------------------------------===//
+
+ERROR(transferring_unsupported_param_specifier, none,
+      "'%0' cannot be applied to a 'transferring' parameter", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/TypeAttr.def

@@ -105,6 +105,7 @@ SIMPLE_SIL_TYPE_ATTR(captures_generics, CapturesGenerics)
 // Used at the SIL level to mark a type as moveOnly.
 SIMPLE_SIL_TYPE_ATTR(moveOnly, MoveOnly)
 SIMPLE_SIL_TYPE_ATTR(sil_isolated, SILIsolated)
+SIMPLE_SIL_TYPE_ATTR(sil_transferring, SILTransferring)
 
 // SIL metatype attributes.
 SIMPLE_SIL_TYPE_ATTR(thin, Thin)

include/swift/AST/TypeRepr.h

@@ -1139,7 +1139,8 @@ class SpecifierTypeRepr : public TypeRepr {
            T->getKind() == TypeReprKind::Isolated ||
            T->getKind() == TypeReprKind::CompileTimeConst ||
            T->getKind() == TypeReprKind::ResultDependsOn ||
-           T->getKind() == TypeReprKind::LifetimeDependentReturn;
+           T->getKind() == TypeReprKind::LifetimeDependentReturn ||
+           T->getKind() == TypeReprKind::Transferring;
   }
   static bool classof(const SpecifierTypeRepr *T) { return true; }
 
@@ -1225,6 +1226,21 @@ class ResultDependsOnTypeRepr : public SpecifierTypeRepr {
   static bool classof(const ResultDependsOnTypeRepr *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 TypeRepr for a known, fixed type.
 ///
 /// Fixed type representations should be used sparingly, in places
@@ -1626,6 +1642,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Array:
   case TypeReprKind::SILBox:
   case TypeReprKind::Isolated:
+  case TypeReprKind::Transferring:
   case TypeReprKind::Placeholder:
   case TypeReprKind::CompileTimeConst:
   case TypeReprKind::ResultDependsOn:

include/swift/AST/TypeReprNodes.def

@@ -74,6 +74,7 @@ ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   SPECIFIER_TYPEREPR(Isolated, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(CompileTimeConst, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(ResultDependsOn, SpecifierTypeRepr)
+  SPECIFIER_TYPEREPR(Transferring, SpecifierTypeRepr)
 TYPEREPR(Fixed, TypeRepr)
 TYPEREPR(SILBox, TypeRepr)
 TYPEREPR(Self, TypeRepr)

include/swift/AST/Types.h

@@ -2212,6 +2212,8 @@ enum class ParamSpecifier : uint8_t {
   ImplicitlyCopyableConsuming = 6,
 };
 
+StringRef getNameForParamSpecifier(ParamSpecifier name);
+
 /// Provide parameter type relevant flags, i.e. variadic, autoclosure, and
 /// escaping.
 class ParameterTypeFlags {

include/swift/Parse/Parser.h

@@ -1244,6 +1244,7 @@ class Parser {
     SourceLoc IsolatedLoc;
     SourceLoc ConstLoc;
     SourceLoc ResultDependsOnLoc;
+    SourceLoc TransferringLoc;
     SmallVector<TypeOrCustomAttr> Attributes;
     SmallVector<LifetimeDependenceSpecifier> lifetimeDependenceSpecifiers;
 
@@ -1561,6 +1562,9 @@ class Parser {
     /// The location of the '_resultDependsOn' keyword, if present.
     SourceLoc ResultDependsOnLoc;
 
+    /// The location of the 'transferring' keyword if present.
+    SourceLoc TransferringLoc;
+
     /// The type following the ':'.
     TypeRepr *Type = nullptr;
 

lib/AST/ASTBridging.cpp

@@ -869,6 +869,8 @@ BridgedParamDecl BridgedParamDecl_createParsed(
           paramDecl->setIsolated(true);
         else if (isa<CompileTimeConstTypeRepr>(STR))
           paramDecl->setCompileTimeConst(true);
+        else if (isa<TransferringTypeRepr>(STR))
+          paramDecl->setTransferring(true);
 
         unwrappedType = STR->getBase();
         continue;
@@ -2175,8 +2177,7 @@ BridgedSpecifierTypeRepr BridgedSpecifierTypeRepr_createParsed(
         OwnershipTypeRepr(baseType, ParamSpecifier::LegacyOwned, loc);
   }
   case BridgedAttributedTypeSpecifierTransferring: {
-    return new (context)
-        OwnershipTypeRepr(baseType, ParamSpecifier::ImplicitlyCopyableConsuming, loc);
+    return new (context) TransferringTypeRepr(baseType, loc);
   }
   case BridgedAttributedTypeSpecifierConst: {
     return new (context) CompileTimeConstTypeRepr(baseType, loc);

lib/AST/ASTDumper.cpp

@@ -3435,6 +3435,12 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,
     printFoot();
   }
 
+  void visitTransferringTypeRepr(TransferringTypeRepr *T, StringRef label) {
+    printCommon("transferring", label);
+    printRec(T->getBase());
+    printFoot();
+  }
+
   void visitCompileTimeConstTypeRepr(CompileTimeConstTypeRepr *T, StringRef label) {
     printCommon("_const", label);
     printRec(T->getBase());