AST: Combine various ownership TypeReprs into one OwnershipTypeRepr.

jckarter · jckarter · commit 1311df6544d0 · 2023-02-28T09:15:43.000-08:00
This lets us consolidate code paths that mostly run in parallel over the existing InOutTypeRepr/SharedTypeRepr/OwnedTypeRepr family of types. This patch by itself is NFC but makes it easier to introduce new spellings, particularly the newly-official `borrowing` and `consuming` modifiers that were approved in SE-0377.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -5983,10 +5983,19 @@ 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`, a legacy spelling of `borrowing`.
   Shared = 2,
+    /// `__owned`, a legacy spelling of `consuming`.
   Owned = 3,
 };
 
diff --git a/include/swift/AST/TypeRepr.h b/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,40 @@ 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;
+  /// 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 {
+    return getSpecifierSpelling(getSpecifier());
   }
-  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) {}
 
   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; }
 
+  static StringRef getSpecifierSpelling(ParamSpecifier spell);
+};
+  
 /// An 'isolated' type.
 /// \code
 ///   x : isolated Actor
@@ -1449,7 +1418,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 +1440,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:
diff --git a/include/swift/AST/TypeReprNodes.def b/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)
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -3260,24 +3260,15 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
-  void visitInOutTypeRepr(InOutTypeRepr *T) {
-    printCommon("type_inout") << '\n';
+  void visitOwnershipTypeRepr(OwnershipTypeRepr *T) {
+    printCommon("type_ownership")
+      << ' '
+      << T->getSpecifierSpelling()
+      << '\n';
     printRec(T->getBase());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
   
-  void visitSharedTypeRepr(SharedTypeRepr *T) {
-    printCommon("type_shared") << '\n';
-    printRec(T->getBase());
-    PrintWithColorRAII(OS, ParenthesisColor) << ')';
-  }
-
-  void visitOwnedTypeRepr(OwnedTypeRepr *T) {
-    printCommon("type_owned") << '\n';
-    printRec(T->getBase());
-    PrintWithColorRAII(OS, ParenthesisColor) << ')';
-  }
-
   void visitIsolatedTypeRepr(IsolatedTypeRepr *T) {
     printCommon("isolated") << '\n';
     printRec(T->getBase());
diff --git a/lib/AST/ASTWalker.cpp b/lib/AST/ASTWalker.cpp
@@ -2069,15 +2069,7 @@ bool Traversal::visitProtocolTypeRepr(ProtocolTypeRepr *T) {
   return doIt(T->getBase());
 }
 
-bool Traversal::visitInOutTypeRepr(InOutTypeRepr *T) {
-  return doIt(T->getBase());
-}
-
-bool Traversal::visitSharedTypeRepr(SharedTypeRepr *T) {
-  return doIt(T->getBase());
-}
-
-bool Traversal::visitOwnedTypeRepr(OwnedTypeRepr *T) {
+bool Traversal::visitOwnershipTypeRepr(OwnershipTypeRepr *T) {
   return doIt(T->getBase());
 }
 
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -2628,13 +2628,11 @@ directReferencesForTypeRepr(Evaluator &evaluator,
 
   case TypeReprKind::Error:
   case TypeReprKind::Function:
-  case TypeReprKind::InOut:
+  case TypeReprKind::Ownership:
   case TypeReprKind::Isolated:
   case TypeReprKind::CompileTimeConst:
   case TypeReprKind::Metatype:
-  case TypeReprKind::Owned:
   case TypeReprKind::Protocol:
-  case TypeReprKind::Shared:
   case TypeReprKind::SILBox:
   case TypeReprKind::Placeholder:
   case TypeReprKind::Pack:
diff --git a/lib/AST/TypeRepr.cpp b/lib/AST/TypeRepr.cpp
@@ -591,15 +591,11 @@ void SpecifierTypeRepr::printImpl(ASTPrinter &Printer,
 #include "swift/AST/TypeReprNodes.def"
     llvm_unreachable("invalid repr kind");
     break;
-  case TypeReprKind::InOut:
-    Printer.printKeyword("inout", Opts, " ");
-    break;
-  case TypeReprKind::Shared:
-    Printer.printKeyword("__shared", Opts, " ");
-    break;
-  case TypeReprKind::Owned:
-    Printer.printKeyword("__owned", Opts, " ");
+  case TypeReprKind::Ownership: {
+    auto ownershipRepr = cast<OwnershipTypeRepr>(this);
+    Printer.printKeyword(ownershipRepr->getSpecifierSpelling(), Opts, " ");
     break;
+  }
   case TypeReprKind::Isolated:
     Printer.printKeyword("isolated", Opts, " ");
     break;
@@ -610,6 +606,34 @@ 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");
+}
+
+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;
+  }
+}
+
 void PlaceholderTypeRepr::printImpl(ASTPrinter &Printer,
                                     const PrintOptions &Opts) const {
   Printer.printText("_");
diff --git a/lib/Migrator/APIDiffMigratorPass.cpp b/lib/Migrator/APIDiffMigratorPass.cpp
@@ -149,15 +149,7 @@ class ChildIndexFinder : public TypeReprVisitor<ChildIndexFinder, FoundResult> {
     return visit(T->getTypeRepr());
   }
 
-  FoundResult visitInOutTypeRepr(InOutTypeRepr *T) {
-    return visit(T->getBase());
-  }
-
-  FoundResult visitSharedTypeRepr(SharedTypeRepr *T) {
-    return visit(T->getBase());
-  }
-
-  FoundResult visitOwnedTypeRepr(OwnedTypeRepr *T) {
+  FoundResult visitOwnershipTypeRepr(OwnershipTypeRepr *T) {
     return visit(T->getBase());
   }
 
diff --git a/lib/Parse/ParsePattern.cpp b/lib/Parse/ParsePattern.cpp
@@ -486,32 +486,33 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
     return status;
   });
 }
-template <typename T>
+
 static TypeRepr *
-validateParameterWithSpecifier(Parser &parser,
+validateParameterWithOwnership(Parser &parser,
                                Parser::ParsedParameter &paramInfo,
-                               StringRef specifierName,
+                               ParamSpecifier specifier,
                                bool parsingEnumElt) {
   auto type = paramInfo.Type;
   auto loc = paramInfo.SpecifierLoc;
   // If we're validating an enum element, 'inout' is not allowed
   // at all - Sema will catch this for us.  In all other contexts, we
   // assume the user put 'inout' in the wrong place and offer a fixit.
   if (parsingEnumElt) {
-    return new (parser.Context) T(type, loc);
+    return new (parser.Context) OwnershipTypeRepr(type, specifier, loc);
   }
   
   if (isa<SpecifierTypeRepr>(type)) {
     parser.diagnose(loc, diag::parameter_specifier_repeated).fixItRemove(loc);
   } else {
+    auto specifierName = OwnershipTypeRepr::getSpecifierSpelling(specifier);
     llvm::SmallString<128> replacement(specifierName);
     replacement += " ";
     parser
         .diagnose(loc, diag::parameter_specifier_as_attr_disallowed,
                   specifierName)
         .fixItRemove(loc)
         .fixItInsert(type->getStartLoc(), replacement);
-    type = new (parser.Context) T(type, loc);
+    type = new (parser.Context) OwnershipTypeRepr(type, specifier, loc);
   }
 
   return type;
@@ -559,17 +560,17 @@ mapParsedParameters(Parser &parser,
     if (auto type = paramInfo.Type) {
       // If 'inout' was specified, turn the type into an in-out type.
       if (paramInfo.SpecifierKind == ParamDecl::Specifier::InOut) {
-        type = validateParameterWithSpecifier<InOutTypeRepr>(parser, paramInfo,
-                                                             "inout",
-                                                             parsingEnumElt);
+        type = validateParameterWithOwnership(parser, paramInfo,
+                                              ParamSpecifier::InOut,
+                                              parsingEnumElt);
       } else if (paramInfo.SpecifierKind == ParamDecl::Specifier::Shared) {
-        type = validateParameterWithSpecifier<SharedTypeRepr>(parser, paramInfo,
-                                                              "__shared",
-                                                              parsingEnumElt);
+        type = validateParameterWithOwnership(parser, paramInfo,
+                                              ParamSpecifier::Shared,
+                                              parsingEnumElt);
       } else if (paramInfo.SpecifierKind == ParamDecl::Specifier::Owned) {
-        type = validateParameterWithSpecifier<OwnedTypeRepr>(parser, paramInfo,
-                                                             "__owned",
-                                                             parsingEnumElt);
+        type = validateParameterWithOwnership(parser, paramInfo,
+                                              ParamSpecifier::Owned,
+                                              parsingEnumElt);
       }
 
       if (paramInfo.IsolatedLoc.isValid()) {
diff --git a/lib/Parse/ParseType.cpp b/lib/Parse/ParseType.cpp
@@ -45,13 +45,9 @@ TypeRepr *Parser::applyAttributeToType(TypeRepr *ty,
   if (specifierLoc.isValid()) {
     switch (specifier) {
     case ParamDecl::Specifier::Owned:
-      ty = new (Context) OwnedTypeRepr(ty, specifierLoc);
-      break;
     case ParamDecl::Specifier::InOut:
-      ty = new (Context) InOutTypeRepr(ty, specifierLoc);
-      break;
     case ParamDecl::Specifier::Shared:
-      ty = new (Context) SharedTypeRepr(ty, specifierLoc);
+      ty = new (Context) OwnershipTypeRepr(ty, specifier, specifierLoc);
       break;
     case ParamDecl::Specifier::Default:
       break;
@@ -1190,7 +1186,9 @@ ParserResult<TypeRepr> Parser::parseTypeTupleBody() {
         // Build inout type. Note that we bury the inout locator within the
         // named locator. This is weird but required by Sema apparently.
         element.Type =
-            new (Context) InOutTypeRepr(element.Type, ObsoletedInOutLoc);
+            new (Context) OwnershipTypeRepr(element.Type,
+                                            ParamSpecifier::InOut,
+                                            ObsoletedInOutLoc);
       }
     }
 
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp b/tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp
