Merge pull request #63073 from jckarter/se-0377-finalize

Changes to implement the final approved SE-0377 behavior

Author: jckarter

include/swift/AST/ASTSynthesis.h

@@ -239,7 +239,9 @@ template <class S>
 struct SpecifiedParamSynthesizer { ParamSpecifier specifier; S sub; };
 template <class G>
 constexpr SpecifiedParamSynthesizer<G> _owned(G sub) {
-  return {ParamSpecifier::Owned, sub};
+  // TODO: We should probably synthesize decls to use the standard `consuming`
+  // modifier, once we're certain doing so won't break anything.
+  return {ParamSpecifier::LegacyOwned, sub};
 }
 template <class G>
 constexpr SpecifiedParamSynthesizer<G> _inout(G sub) {
@@ -257,10 +259,8 @@ FunctionType::Param synthesizeParamType(SynthesisContext &SC,
                                         const SpecifiedParamSynthesizer<S> &s) {
   auto param = synthesizeParamType(SC, s.sub);
   auto flags = param.getParameterFlags();
-  if (s.specifier == ParamSpecifier::Owned)
-    flags = flags.withOwned(true);
-  if (s.specifier == ParamSpecifier::InOut)
-    flags = flags.withInOut(true);
+  if (s.specifier != ParamSpecifier::Default)
+    flags = flags.withValueOwnership(s.specifier);
   return param.withFlags(flags);
 }
 

include/swift/AST/Decl.h

@@ -410,12 +410,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   );
 
   SWIFT_INLINE_BITFIELD(ParamDecl, VarDecl, 1+2+NumDefaultArgumentKindBits,
-    /// Whether we've computed the specifier yet.
-    SpecifierComputed : 1,
-
-    /// The specifier associated with this parameter.  This determines
-    /// the storage semantics of the value e.g. mutability.
-    Specifier : 2,
+    /// The specifier associated with this parameter + 1, or zero if the
+    /// specifier has not been computed yet.  This determines
+    /// the ownership semantics of the parameter.
+    OwnershipSpecifier : 3,
 
     /// Information about a symbolic default argument, like #file.
     defaultArgumentKind : NumDefaultArgumentKindBits
@@ -5983,11 +5981,27 @@ class VarDecl : public AbstractStorageDecl {
   }
 };
 
+/// The various spellings of ownership modifier that can be used in source.
 enum class ParamSpecifier : uint8_t {
+  /// No explicit ownership specifier was provided. The parameter will use the
+  /// default ownership convention for the declaration.
   Default = 0,
+
+  /// `inout`, indicating exclusive mutable access to the argument for the
+  /// duration of a call.
   InOut = 1,
-  Shared = 2,
-  Owned = 3,
+
+  /// `borrowing`, indicating nonexclusive access to the argument for the
+  /// duration of a call.
+  Borrowing = 2,
+  /// `consuming`, indicating ownership transfer of the argument from caller
+  /// to callee.
+  Consuming = 3,
+
+  /// `__shared`, a legacy spelling of `borrowing`.
+  LegacyShared = 4,
+  /// `__owned`, a legacy spelling of `consuming`.
+  LegacyOwned = 5,
 };
 
 /// A function parameter declaration.
@@ -6276,8 +6290,8 @@ class ParamDecl : public VarDecl {
   using Specifier = ParamSpecifier;
 
   Optional<Specifier> getCachedSpecifier() const {
-    if (Bits.ParamDecl.SpecifierComputed)
-      return Specifier(Bits.ParamDecl.Specifier);
+    if (Bits.ParamDecl.OwnershipSpecifier != 0)
+      return Specifier(Bits.ParamDecl.OwnershipSpecifier - 1);
 
     return None;
   }
@@ -6288,20 +6302,18 @@ class ParamDecl : public VarDecl {
 
   /// Is the type of this parameter 'inout'?
   bool isInOut() const { return getSpecifier() == Specifier::InOut; }
-  /// Is this an immutable 'shared' property?
-  bool isShared() const { return getSpecifier() == Specifier::Shared; }
-  /// Is this an immutable 'owned' property?
-  bool isOwned() const { return getSpecifier() == Specifier::Owned; }
 
-  bool isImmutable() const {
-    return isImmutableSpecifier(getSpecifier());
+  bool isImmutableInFunctionBody() const {
+    return isSpecifierImmutableInFunctionBody(getSpecifier());
   }
-  static bool isImmutableSpecifier(Specifier sp) {
+  static bool isSpecifierImmutableInFunctionBody(Specifier sp) {
     switch (sp) {
     case Specifier::Default:
-    case Specifier::Shared:
-    case Specifier::Owned:
+    case Specifier::Borrowing:
+    case Specifier::LegacyShared:
+    case Specifier::LegacyOwned:
       return true;
+    case Specifier::Consuming:
     case Specifier::InOut:
       return false;
     }
@@ -6314,29 +6326,32 @@ class ParamDecl : public VarDecl {
 
   static ValueOwnership getValueOwnershipForSpecifier(Specifier specifier) {
     switch (specifier) {
-    case Specifier::Default:
-      return ValueOwnership::Default;
-    case Specifier::InOut:
+    case ParamSpecifier::InOut:
       return ValueOwnership::InOut;
-    case Specifier::Shared:
+    case ParamSpecifier::Borrowing:
+    case ParamSpecifier::LegacyShared:
       return ValueOwnership::Shared;
-    case Specifier::Owned:
+    case ParamSpecifier::Consuming:
+    case ParamSpecifier::LegacyOwned:
       return ValueOwnership::Owned;
+    case ParamSpecifier::Default:
+      return ValueOwnership::Default;
     }
-    llvm_unreachable("unhandled specifier");
+    llvm_unreachable("invalid ParamSpecifier");
   }
 
   static Specifier
   getParameterSpecifierForValueOwnership(ValueOwnership ownership) {
+    // TODO: switch over to consuming/borrowing once they're fully supported
     switch (ownership) {
     case ValueOwnership::Default:
       return Specifier::Default;
     case ValueOwnership::Shared:
-      return Specifier::Shared;
+      return Specifier::LegacyShared; // should become Borrowing
     case ValueOwnership::InOut:
       return Specifier::InOut;
     case ValueOwnership::Owned:
-      return Specifier::Owned;
+      return Specifier::LegacyOwned; // should become Consuming
     }
     llvm_unreachable("unhandled ownership");
   }
@@ -6349,6 +6364,9 @@ class ParamDecl : public VarDecl {
   static bool classof(const Decl *D) { 
     return D->getKind() == DeclKind::Param;
   }
+  
+  /// Get the source code spelling of a parameter specifier value as a string.
+  static StringRef getSpecifierSpelling(Specifier spec);
 };
 
 /// Describes the kind of subscripting used in Objective-C.

include/swift/AST/DiagnosticsParse.def

@@ -986,7 +986,7 @@ ERROR(parameter_specifier_as_attr_disallowed,none,
       "'%0' before a parameter name is not allowed, place it before the parameter type instead",
       (StringRef))
 ERROR(parameter_specifier_repeated,none,
-      "parameter must not have multiple '__owned', 'inout', or '__shared' specifiers", ())
+      "parameter may have at most one of the 'inout', 'borrowing', or 'consuming' specifiers", ())
 WARNING(parameter_let_var_as_attr,none,
       "'%0' in this position is interpreted as an argument label",
       (StringRef))

include/swift/AST/Ownership.h

@@ -122,11 +122,11 @@ enum class ValueOwnership : uint8_t {
   /// the context-dependent default ownership (sometimes shared,
   /// sometimes owned)
   Default,
-  /// an 'inout' mutating pointer-like value
+  /// an 'inout' exclusive, mutating borrow
   InOut,
-  /// a '__shared' non-mutating pointer-like value
+  /// a 'borrowing' nonexclusive, usually nonmutating borrow
   Shared,
-  /// an '__owned' value
+  /// a 'consuming' ownership transfer
   Owned,
 
   Last_Kind = Owned

include/swift/AST/TypeCheckRequests.h

@@ -2133,7 +2133,8 @@ class NeedsNewVTableEntryRequest
   void cacheResult(bool value) const;
 };
 
-/// Determines the specifier for a parameter (inout, __owned, etc).
+/// Determines the ownership specifier for a parameter
+/// (inout/consuming/borrowing)
 class ParamSpecifierRequest
     : public SimpleRequest<ParamSpecifierRequest,
                            ParamSpecifier(ParamDecl *),

include/swift/AST/TypeRepr.h

@@ -40,6 +40,8 @@ namespace swift {
   class TupleTypeRepr;
   class TypeDecl;
 
+enum class ParamSpecifier : uint8_t;
+
 enum class TypeReprKind : uint8_t {
 #define TYPEREPR(ID, PARENT) ID,
 #define LAST_TYPEREPR(ID) Last_TypeRepr = ID,
@@ -1062,9 +1064,7 @@ class SpecifierTypeRepr : public TypeRepr {
   SourceLoc getSpecifierLoc() const { return SpecifierLoc; }
 
   static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::InOut ||
-           T->getKind() == TypeReprKind::Shared ||
-           T->getKind() == TypeReprKind::Owned ||
+    return T->getKind() == TypeReprKind::Ownership ||
            T->getKind() == TypeReprKind::Isolated ||
            T->getKind() == TypeReprKind::CompileTimeConst;
   }
@@ -1077,71 +1077,36 @@ class SpecifierTypeRepr : public TypeRepr {
   friend class TypeRepr;
 };
 
-// This repr holds types that are associated with some ownership specifier
-// like 'inout', '__shared', etc. It's a simple grouping of those specifiers.
-class OwnershipTypeRepr : public SpecifierTypeRepr {
-public:
-  OwnershipTypeRepr(TypeReprKind Kind, TypeRepr *Base, SourceLoc OwnershipLoc)
-      : SpecifierTypeRepr(Kind, Base, OwnershipLoc) {
-    assert(OwnershipTypeRepr::classof(cast<TypeRepr>(this)));
-  }
-
-  static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::InOut ||
-           T->getKind() == TypeReprKind::Shared ||
-           T->getKind() == TypeReprKind::Owned;
-  }
-  static bool classof(const OwnershipTypeRepr *T) { return true; }
-  friend class SpecifierTypeRepr;
-};
-  
-/// An 'inout' type.
+/// A parameter type with an ownership specifier, such as `inout`, `borrowing`,
+/// or `consuming`.
 /// \code
 ///   x : inout Int
+///   y : consuming Int
+///   z : borrowing Int
 /// \endcode
-class InOutTypeRepr : public OwnershipTypeRepr {
+
+class OwnershipTypeRepr : public SpecifierTypeRepr {
+  ParamSpecifier Specifier;
 public:
-  InOutTypeRepr(TypeRepr *Base, SourceLoc InOutLoc)
-    : OwnershipTypeRepr(TypeReprKind::InOut, Base, InOutLoc) {}
+  OwnershipTypeRepr(TypeRepr *Base, ParamSpecifier Specifier,
+                    SourceLoc ModifierLoc)
+    : SpecifierTypeRepr(TypeReprKind::Ownership, Base, ModifierLoc),
+      Specifier(Specifier) {}
 
-  static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::InOut;
-  }
-  static bool classof(const InOutTypeRepr *T) { return true; }
-};
+  ParamSpecifier getSpecifier() const { return Specifier; }
 
-/// A 'borrowing' parameter type.
-/// \code
-///   x : borrowing Int
-/// \endcode
-/// Historically, this attribute was spelled '__shared'.
-class SharedTypeRepr : public OwnershipTypeRepr {
-public:
-  SharedTypeRepr(TypeRepr *Base, SourceLoc SharedLoc)
-    : OwnershipTypeRepr(TypeReprKind::Shared, Base, SharedLoc) {}
-
-  static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::Shared;
-  }
-  static bool classof(const SharedTypeRepr *T) { return true; }
-};
-
-/// A 'consuming' parameter type.
-/// \code
-///   x : consuming Int
-/// \endcode
-/// Historically, this attribute was spelled '__owned'.
-class OwnedTypeRepr : public OwnershipTypeRepr {
-public:
-  OwnedTypeRepr(TypeRepr *Base, SourceLoc OwnedLoc)
-      : OwnershipTypeRepr(TypeReprKind::Owned, Base, OwnedLoc) {}
+  /// Return the \c ValueOwnership kind that corresponds to the specifier.
+  ValueOwnership getValueOwnership() const;
+  
+  /// Return the spelling of the ownership specifier as a string.
+  StringRef getSpecifierSpelling() const;
 
   static bool classof(const TypeRepr *T) {
-    return T->getKind() == TypeReprKind::Owned;
+    return T->getKind() == TypeReprKind::Ownership;
   }
-  static bool classof(const OwnedTypeRepr *T) { return true; }
+  static bool classof(const OwnershipTypeRepr *T) { return true; }
 };
-
+  
 /// An 'isolated' type.
 /// \code
 ///   x : isolated Actor
@@ -1449,7 +1414,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Attributed:
   case TypeReprKind::Error:
   case TypeReprKind::Function:
-  case TypeReprKind::InOut:
+  case TypeReprKind::Ownership:
   case TypeReprKind::Composition:
   case TypeReprKind::OpaqueReturn:
   case TypeReprKind::NamedOpaqueReturn:
@@ -1471,8 +1436,6 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Fixed:
   case TypeReprKind::Array:
   case TypeReprKind::SILBox:
-  case TypeReprKind::Shared:
-  case TypeReprKind::Owned:
   case TypeReprKind::Isolated:
   case TypeReprKind::Placeholder:
   case TypeReprKind::CompileTimeConst:

include/swift/AST/TypeReprNodes.def

@@ -69,9 +69,7 @@ TYPEREPR(Pack, TypeRepr)
 TYPEREPR(PackElement, TypeRepr)
 TYPEREPR(Placeholder, TypeRepr)
 ABSTRACT_TYPEREPR(Specifier, TypeRepr)
-  SPECIFIER_TYPEREPR(InOut, SpecifierTypeRepr)
-  SPECIFIER_TYPEREPR(Shared, SpecifierTypeRepr)
-  SPECIFIER_TYPEREPR(Owned, SpecifierTypeRepr)
+  SPECIFIER_TYPEREPR(Ownership, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(Isolated, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(CompileTimeConst, SpecifierTypeRepr)
 TYPEREPR(Fixed, TypeRepr)

include/swift/Parse/Parser.h

@@ -1144,15 +1144,36 @@ class Parser {
   bool parseVersionTuple(llvm::VersionTuple &Version, SourceRange &Range,
                          const Diagnostic &D);
 
+  bool canHaveParameterSpecifierContextualKeyword() {
+    // The parameter specifiers like `isolated`, `consuming`, `borrowing` are
+    // also valid identifiers and could be the name of a type. Check whether
+    // the following token is something that can introduce a type. Thankfully
+    // none of these tokens overlap with the set of tokens that can follow an
+    // identifier in a type production.
+    return Tok.is(tok::identifier)
+      && peekToken().isAny(tok::at_sign,
+                           tok::kw_inout,
+                           tok::l_paren,
+                           tok::identifier,
+                           tok::l_square,
+                           tok::kw_Any,
+                           tok::kw_Self,
+                           tok::kw__,
+                           tok::kw_var,
+                           tok::kw_let);
+  }
+
   ParserStatus parseTypeAttributeList(ParamDecl::Specifier &Specifier,
                                       SourceLoc &SpecifierLoc,
                                       SourceLoc &IsolatedLoc,
                                       SourceLoc &ConstLoc,
                                       TypeAttributes &Attributes) {
     if (Tok.isAny(tok::at_sign, tok::kw_inout) ||
-        (Tok.is(tok::identifier) &&
+        (canHaveParameterSpecifierContextualKeyword() &&
          (Tok.getRawText().equals("__shared") ||
           Tok.getRawText().equals("__owned") ||
+          Tok.getRawText().equals("consuming") ||
+          Tok.getRawText().equals("borrowing") ||
           Tok.isContextualKeyword("isolated") ||
           Tok.isContextualKeyword("_const"))))
       return parseTypeAttributeListPresent(

include/swift/Parse/Token.h

@@ -172,15 +172,6 @@ class Token {
   bool canBeArgumentLabel() const {
     // Identifiers, escaped identifiers, and '_' can be argument labels.
     if (is(tok::identifier) || isEscapedIdentifier() || is(tok::kw__)) {
-      // ... except for '__shared' and '__owned'.
-      if (getRawText().equals("__shared") ||
-          getRawText().equals("__owned"))
-        return false;
-      
-/*      // ...or some
-      if (getRawText().equals("some"))
-        return false;*/
-
       return true;
     }