Merge pull request #71567 from gottesmm/transferring-param

[transferring] Implement transferring result and clean up transferring param support by making transferring a bit on param instead of a ParamSpecifier.

Author: gottesmm

include/swift/AST/Decl.h

@@ -507,7 +507,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   );
 
   SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl,
-                        1+1+2+1+1+NumSelfAccessKindBits+1,
+                        1+1+2+1+1+NumSelfAccessKindBits+1+1,
     /// Whether we've computed the 'static' flag yet.
     IsStaticComputed : 1,
 
@@ -529,7 +529,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     /// Whether this is a top-level function which should be treated
     /// as if it were in local context for the purposes of capture
     /// analysis.
-    HasTopLevelLocalContextCaptures : 1
+    HasTopLevelLocalContextCaptures : 1,
+
+    /// Set to true if this FuncDecl has a transferring result.
+    HasTransferringResult : 1
   );
 
   SWIFT_INLINE_BITFIELD(AccessorDecl, FuncDecl, 4 + 1 + 1,
@@ -6457,8 +6460,6 @@ class ParamDecl : public VarDecl {
   SourceLoc ArgumentNameLoc;
   SourceLoc SpecifierLoc;
 
-  TypeRepr *TyRepr = nullptr;
-
   struct alignas(1 << StoredDefaultArgumentAlignInBits) StoredDefaultArgument {
     PointerUnion<Expr *, VarDecl *> DefaultArg;
 
@@ -6477,7 +6478,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,
 
@@ -6489,12 +6492,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:
@@ -6540,8 +6597,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();
@@ -6663,30 +6720,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'.
@@ -6765,7 +6836,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");
@@ -6783,7 +6854,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:
@@ -7708,6 +7779,7 @@ class FuncDecl : public AbstractFunctionDecl {
     Bits.FuncDecl.IsStaticComputed = false;
     Bits.FuncDecl.IsStatic = false;
     Bits.FuncDecl.HasTopLevelLocalContextCaptures = false;
+    Bits.FuncDecl.HasTransferringResult = false;
   }
 
   void setResultInterfaceType(Type type);
@@ -7864,6 +7936,16 @@ class FuncDecl : public AbstractFunctionDecl {
     Bits.FuncDecl.ForcedStaticDispatch = flag;
   }
 
+  /// Returns true if this FuncDecl has a transferring result... returns false
+  /// otherwise.
+  bool hasTransferringResult() const {
+    return Bits.FuncDecl.HasTransferringResult;
+  }
+
+  void setTransferringResult(bool newValue = true) {
+    Bits.FuncDecl.HasTransferringResult = newValue;
+  }
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Func ||
            D->getKind() == DeclKind::Accessor;

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,61 @@ 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))
+
+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", ())
+
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"