Add ParamSpecifier cases for Borrowing and Consuming.

And do a first pass of auditing existing uses of the parameter specifiers to
make sure that we look at the ValueOwnership mapping in most cases instead of
individual modifiers.

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
@@ -5993,10 +5991,17 @@ enum class ParamSpecifier : uint8_t {
   /// duration of a call.
   InOut = 1,
 
+  /// `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`.
-  Shared = 2,
-    /// `__owned`, a legacy spelling of `consuming`.
-  Owned = 3,
+  LegacyShared = 4,
+  /// `__owned`, a legacy spelling of `consuming`.
+  LegacyOwned = 5,
 };
 
 /// A function parameter declaration.
@@ -6285,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;
   }
@@ -6297,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;
     }
@@ -6323,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) {
+  #warning "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");
   }
@@ -6358,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/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

@@ -1099,16 +1099,12 @@ class OwnershipTypeRepr : public SpecifierTypeRepr {
   ValueOwnership getValueOwnership() const;
 
   /// Return the spelling of the ownership specifier as a string.
-  StringRef getSpecifierSpelling() const {
-    return getSpecifierSpelling(getSpecifier());
-  }
+  StringRef getSpecifierSpelling() const;
 
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Ownership;
   }
   static bool classof(const OwnershipTypeRepr *T) { return true; }
-
-  static StringRef getSpecifierSpelling(ParamSpecifier spell);
 };
 
 /// An 'isolated' type.

include/swift/Parse/Token.h

@@ -176,10 +176,6 @@ class Token {
       if (getRawText().equals("__shared") ||
           getRawText().equals("__owned"))
         return false;
-      
-/*      // ...or some
-      if (getRawText().equals("some"))
-        return false;*/
 
       return true;
     }

lib/AST/ASTDumper.cpp

@@ -1015,19 +1015,8 @@ namespace {
       }
 
       if (auto specifier = P->getCachedSpecifier()) {
-        switch (*specifier) {
-        case ParamDecl::Specifier::Default:
-          /* nothing */
-          break;
-        case ParamDecl::Specifier::InOut:
-          OS << " inout";
-          break;
-        case ParamDecl::Specifier::Shared:
-          OS << " shared";
-          break;
-        case ParamDecl::Specifier::Owned:
-          OS << " owned";
-          break;
+        if (*specifier != ParamDecl::Specifier::Default) {
+          OS << ' ' << ParamDecl::getSpecifierSpelling(*specifier);
         }
       }
 

lib/AST/Decl.cpp

@@ -6825,7 +6825,7 @@ bool VarDecl::isLet() const {
   // a high-level request. Once this is done, all callers of the introducer and
   // specifier setters can be removed.
   if (auto *PD = dyn_cast<ParamDecl>(this)) {
-    return PD->isImmutable();
+    return PD->isImmutableInFunctionBody();
   }
   return getIntroducer() == Introducer::Let;
 }
@@ -6849,13 +6849,28 @@ bool VarDecl::isOrdinaryStoredProperty() const {
 }
 
 void ParamDecl::setSpecifier(Specifier specifier) {
-  // FIXME: Revisit this; in particular shouldn't __owned parameters be
-  // ::Let also?
-  setIntroducer(specifier == ParamSpecifier::Default
-                ? VarDecl::Introducer::Let
-                : VarDecl::Introducer::Var);
-  Bits.ParamDecl.Specifier = static_cast<unsigned>(specifier);
-  Bits.ParamDecl.SpecifierComputed = true;
+  VarDecl::Introducer introducer;
+  switch (specifier) {
+  // Unannotated or `borrowing` parameters are locally immutable.
+  // So are parameters using the legacy `__shared` or `__owned` modifiers.
+  case ParamSpecifier::Default:
+  case ParamSpecifier::Borrowing:
+  case ParamSpecifier::LegacyShared:
+  case ParamSpecifier::LegacyOwned:
+    introducer = VarDecl::Introducer::Let;
+    break;
+  
+  // `inout` and `consuming` parameters are locally mutable.
+  case ParamSpecifier::InOut:
+  case ParamSpecifier::Consuming:
+    introducer = VarDecl::Introducer::Var;
+    break;
+  }
+  
+  setIntroducer(introducer);
+  Bits.ParamDecl.OwnershipSpecifier = static_cast<unsigned>(specifier) + 1;
+  assert(getCachedSpecifier() == specifier
+         && "not enough bits in ParamDecl flags for specifier anymore!");
 }
 
 bool ParamDecl::isAnonClosureParam() const {
@@ -6885,6 +6900,24 @@ ParamDecl::Specifier ParamDecl::getSpecifier() const {
                            ParamDecl::Specifier::Default);
 }
 
+StringRef ParamDecl::getSpecifierSpelling(ParamSpecifier specifier) {
+  switch (specifier) {
+  case ParamSpecifier::Default:
+    return "";
+  case ParamSpecifier::Borrowing:
+    return "borrowing";
+  case ParamSpecifier::Consuming:
+    return "consuming";
+  case ParamSpecifier::InOut:
+    return "inout";
+  case ParamSpecifier::LegacyShared:
+    return "__shared";
+  case ParamSpecifier::LegacyOwned:
+    return "__owned";
+  }
+  llvm_unreachable("invalid ParamSpecifier");
+}
+
 StaticSpellingKind AbstractStorageDecl::getCorrectStaticSpelling() const {
   if (!isStatic())
     return StaticSpellingKind::None;
@@ -7254,7 +7287,7 @@ ParamDecl::ParamDecl(SourceLoc specifierLoc,
       ArgumentNameAndFlags(argumentName, None),
       ParameterNameLoc(parameterNameLoc),
       ArgumentNameLoc(argumentNameLoc), SpecifierLoc(specifierLoc) {
-  Bits.ParamDecl.SpecifierComputed = false;
+  Bits.ParamDecl.OwnershipSpecifier = 0;
   Bits.ParamDecl.defaultArgumentKind =
     static_cast<unsigned>(DefaultArgumentKind::None);
 }

lib/AST/TypeRepr.cpp

@@ -606,32 +606,12 @@ void SpecifierTypeRepr::printImpl(ASTPrinter &Printer,
   printTypeRepr(Base, Printer, Opts);
 }
 
-StringRef OwnershipTypeRepr::getSpecifierSpelling(ParamSpecifier specifier) {
-  switch (specifier) {
-  case ParamSpecifier::InOut:
-    return "inout";
-  case ParamSpecifier::Shared:
-    return "__shared";
-  case ParamSpecifier::Owned:
-    return "__owned";
-  case ParamSpecifier::Default:
-    return "";
-  }
-  llvm_unreachable("invalid ParamSpecifier");
+StringRef OwnershipTypeRepr::getSpecifierSpelling() const {
+  return ParamDecl::getSpecifierSpelling(getSpecifier());
 }
 
 ValueOwnership OwnershipTypeRepr::getValueOwnership() const {
-  switch (getSpecifier()) {
-  case ParamSpecifier::InOut:
-    return ValueOwnership::InOut;
-    
-  case ParamSpecifier::Shared:
-    return ValueOwnership::Shared;
-  case ParamSpecifier::Owned:
-    return ValueOwnership::Owned;
-  case ParamSpecifier::Default:
-    return ValueOwnership::Default;
-  }
+  return ParamDecl::getValueOwnershipForSpecifier(getSpecifier());
 }
 
 void PlaceholderTypeRepr::printImpl(ASTPrinter &Printer,

lib/Parse/ParseDecl.cpp

@@ -4496,6 +4496,8 @@ Parser::parseTypeAttributeListPresent(ParamDecl::Specifier &Specifier,
          Tok.isContextualKeyword("__shared") ||
          Tok.isContextualKeyword("__owned") ||
          Tok.isContextualKeyword("isolated") ||
+         Tok.isContextualKeyword("consuming") ||
+         Tok.isContextualKeyword("borrowing") ||
          Tok.isContextualKeyword("_const")) {
 
     if (Tok.isContextualKeyword("isolated")) {
@@ -4520,9 +4522,13 @@ Parser::parseTypeAttributeListPresent(ParamDecl::Specifier &Specifier,
         Specifier = ParamDecl::Specifier::InOut;
       } else if (Tok.is(tok::identifier)) {
         if (Tok.getRawText().equals("__shared")) {
-          Specifier = ParamDecl::Specifier::Shared;
+          Specifier = ParamDecl::Specifier::LegacyShared;
         } else if (Tok.getRawText().equals("__owned")) {
-          Specifier = ParamDecl::Specifier::Owned;
+          Specifier = ParamDecl::Specifier::LegacyOwned;
+        } else if (Tok.getRawText().equals("borrowing")) {
+          Specifier = ParamDecl::Specifier::Borrowing;
+        } else if (Tok.getRawText().equals("consuming")) {
+          Specifier = ParamDecl::Specifier::Consuming;
         }
       }
     }