implement ~Copyable to suppress implicit conformance to Copyable

Also has been referred to as "without Copyable"

See SE-390 for details, or read the discussion here:

https://forums.swift.org/t/second-review-se-0390-noncopyable-structs-and-enums/63866

Author: kavon

docs/Generics/generics.tex

@@ -3107,7 +3107,7 @@ \section{Source Code Reference}\label{genericdeclsourceref}
 An associated type declaration.
 \begin{itemize}
 \item \texttt{getTrailingWhereClause()} returns the associated type's trailing \texttt{where} clause, or \texttt{nullptr}.
-\item \texttt{getInherited()} returns the associated type's inheritance clause.
+\item \texttt{getAllInheritedEntries()} returns the associated type's inheritance clause.
 \end{itemize}
 
 Trailing \texttt{where} clauses and inheritance clauses are not preserved in serialized associated type declarations. Requirements on associated types are part of a protocol's requirement signature, so except when actually building the requirement signature, most code uses \texttt{getRequirementSignature()} from Section~\ref{genericsigsourceref} instead.

include/swift/AST/Decl.h

@@ -1471,13 +1471,33 @@ class ImportDecl final : public Decl,
 /// An entry in the "inherited" list of a type or extension.
 struct InheritedEntry : public TypeLoc {
   /// Whether there was an @unchecked attribute.
-  bool isUnchecked = false;
+  bool isUnchecked;
 
+  /// Whether this entry represents the suppression of implicit conformance to
+  /// the type in this entry.
+  bool isSuppressed;
+
+  /// This constructor will automatically try to determine the "isUnchecked"
+  /// and "isSuppressed" statuses based on the \c typeLoc.
   InheritedEntry(const TypeLoc &typeLoc);
 
-  InheritedEntry(const TypeLoc &typeLoc, bool isUnchecked)
-    : TypeLoc(typeLoc), isUnchecked(isUnchecked) { }
+  InheritedEntry(const TypeLoc &typeLoc, bool isUnchecked, bool isSuppressed)
+      : TypeLoc(typeLoc), isUnchecked(isUnchecked), isSuppressed(isSuppressed)
+      {}
+};
+
+// A predicate Callable used to filter a collection of InheritedEntry
+struct InheritedEntryFilter {
+  bool WantSuppressed;
+  InheritedEntryFilter(bool wantSuppressed)
+      : WantSuppressed(wantSuppressed) {}
+  bool operator()(InheritedEntry result) const {
+    return result.isSuppressed == WantSuppressed;
+  }
 };
+using InheritedEntryIter =
+    llvm::filter_iterator<const InheritedEntry *, InheritedEntryFilter>;
+using InheritedEntryRange = iterator_range<InheritedEntryIter>;
 
 /// ExtensionDecl - This represents a type extension containing methods
 /// associated with the type.  This is not a ValueDecl and has no Type because
@@ -1591,12 +1611,26 @@ class ExtensionDecl final : public GenericContext, public Decl,
   /// Repr would not be available if the extension was been loaded
   /// from a serialized module.
   TypeRepr *getExtendedTypeRepr() const { return ExtendedTypeRepr; }
-                              
-  /// Retrieve the set of protocols that this type inherits (i.e,
-  /// explicitly conforms to).
-  ArrayRef<InheritedEntry> getInherited() const { return Inherited; }
 
-  void setInherited(ArrayRef<InheritedEntry> i) { Inherited = i; }
+  /// Retrieve the list of all protocols that this type either inherits from
+  /// (i.e, explicitly conforms to) or is suppressing implicit conformance to.
+  ArrayRef<InheritedEntry> getAllInheritedEntries() const { return Inherited; }
+
+  void setAllInheritedEntries(ArrayRef<InheritedEntry> i) { Inherited = i; }
+
+  /// Retrieve an iterator range of protocols that this type is suppressing
+  /// implicit conformances to.
+  InheritedEntryRange getSuppressed() const {
+    return llvm::make_filter_range(getAllInheritedEntries(),
+                                   InheritedEntryFilter(/*wantSuppressed*/true));
+  }
+
+  /// Retrieve an iterator range of protocols that this type inherits (i.e,
+  /// explicitly conforms to).
+  InheritedEntryRange getInherited() const {
+    return llvm::make_filter_range(getAllInheritedEntries(),
+                                   InheritedEntryFilter(/*wantSuppressed*/false));
+  }
 
   bool hasDefaultAccessLevel() const {
     return Bits.ExtensionDecl.DefaultAndMaxAccessLevel != 0;
@@ -2451,18 +2485,18 @@ class ValueDecl : public Decl {
     /// optional result.
     unsigned isIUO : 1;
 
-    /// Whether the "isMoveOnly" bit has been computed yet.
-    unsigned isMoveOnlyComputed : 1;
+    /// Whether the "isNoncopyable" bit has been computed yet.
+    unsigned isNoncopyableComputed : 1;
 
-    /// Whether this declaration can not be copied and thus is move only.
-    unsigned isMoveOnly : 1;
+    /// Whether this declaration is noncopyable.
+    unsigned isNoncopyable : 1;
   } LazySemanticInfo = { };
 
   friend class DynamicallyReplacedDeclRequest;
   friend class OverriddenDeclsRequest;
   friend class IsObjCRequest;
   friend class IsFinalRequest;
-  friend class IsMoveOnlyRequest;
+  friend class IsNoncopyableRequest;
   friend class IsDynamicRequest;
   friend class IsImplicitlyUnwrappedOptionalRequest;
   friend class InterfaceTypeRequest;
@@ -2952,11 +2986,29 @@ class TypeDecl : public ValueDecl {
   /// metatype.
   Type getDeclaredInterfaceType() const;
 
-  /// Retrieve the set of protocols that this type inherits (i.e,
+  /// Retrieve the list of all protocols that this type either inherits from
+  /// (i.e, explicitly conforms to) or is suppressing implicit conformance to.
+  ArrayRef<InheritedEntry> getAllInheritedEntries() const { return Inherited; }
+
+  void setAllInheritedEntries(ArrayRef<InheritedEntry> i) { Inherited = i; }
+
+  /// Retrieve an iterator range of protocols that this type is suppressing
+  /// implicit conformances to.
+  InheritedEntryRange getSuppressed() const {
+    return llvm::make_filter_range(getAllInheritedEntries(),
+                                   InheritedEntryFilter(/*wantSuppressed*/true));
+  }
+
+  /// Retrieve an iterator range of protocols that this type inherits (i.e,
   /// explicitly conforms to).
-  ArrayRef<InheritedEntry> getInherited() const { return Inherited; }
+  InheritedEntryRange getInherited() const {
+    return llvm::make_filter_range(getAllInheritedEntries(),
+                                   InheritedEntryFilter(/*wantSuppressed*/false));
+  }
 
-  void setInherited(ArrayRef<InheritedEntry> i) { Inherited = i; }
+  /// Does this decl suppress implicit conformance to the given protocol?
+  /// That is, it is "without KP"
+  bool isSuppressingConformance(KnownProtocolKind kp) const;
 
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&

include/swift/AST/DiagnosticsSema.def

@@ -6888,8 +6888,26 @@ ERROR(moveonly_cast,none,
       "move-only types cannot be conditionally cast", ())
 ERROR(moveonly_failable_init,none,
       "move-only types cannot have failable initializers yet", ())
-ERROR(moveonly_objc_enum_banned, none,
-      "@objc enums cannot be marked as move-only", ())
+ERROR(noncopyable_objc_enum, none,
+      "@objc enums cannot be noncopyable", ())
+
+//------------------------------------------------------------------------------
+// MARK: Conformance suppression diagnostics
+//------------------------------------------------------------------------------
+
+ERROR(suppress_cannot_suppress,none,
+      "cannot suppress implicit conformance to %0", (Type))
+
+ERROR(suppress_on_wrong_decl,none,
+      "cannot suppress conformance on %0", (DescriptiveDeclKind))
+
+ERROR(suppress_duplicate,none,
+      "implicit conformance to %0 already suppressed", (Type))
+NOTE(suppress_previously_here,none,
+      "%0 previously suppressed here", (Type))
+
+ERROR(suppress_not_protocol,none,
+      "suppression of non-protocol type %0", (Type))
 
 //------------------------------------------------------------------------------
 // MARK: Type inference from default expressions
@@ -6948,17 +6966,21 @@ ERROR(concurrency_task_to_thread_model_global_actor_annotation,none,
       "annotating a type with a global actor %0 is not permitted within %1",
       (TypeRepr*, StringRef))
 
-ERROR(moveOnly_not_allowed_here,none,
-      "'moveOnly' only applies to structs or enums", ())
+ERROR(noncopyable_only_struct_enum,none,
+      "only structs or enums can be noncopyable", ())
 ERROR(move_expression_not_passed_lvalue,none,
       "'consume' can only be applied to lvalues", ())
 ERROR(borrow_expression_not_passed_lvalue,none,
       "'borrow' can only be applied to lvalues", ())
 
-ERROR(moveOnly_requires_lexical_lifetimes,none,
+ERROR(noncopyable_requires_sil_option,none,
       "noncopyable types require lexical borrow scopes "
       "(add -enable-lexical-borrow-scopes=true)", ())
 
+ERROR(moveOnly_attr_deprecated,none,
+      "'@_moveOnly' attribute is deprecated; "
+      "use the ~Copyable constraint suppression instead", ())
+
 //------------------------------------------------------------------------------
 // MARK: #_hasSymbol
 //------------------------------------------------------------------------------

include/swift/AST/NameLookup.h

@@ -602,15 +602,41 @@ SelfBounds getSelfBoundsFromWhereClause(
 /// given protocol or protocol extension.
 SelfBounds getSelfBoundsFromGenericSignature(const ExtensionDecl *extDecl);
 
+/// Retrieve the InheritedEntry at the given \c index from among the list of
+/// all inherited entries.
+inline const InheritedEntry &getInheritedEntryAtIndex(
+    llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
+    unsigned index) {
+  llvm::ArrayRef<InheritedEntry> allEntries;
+
+  if (auto typeDecl = decl.dyn_cast<const TypeDecl *>())
+    allEntries = typeDecl->getAllInheritedEntries();
+  else
+    allEntries = decl.get<const ExtensionDecl *>()->getAllInheritedEntries();
+
+  return allEntries[index];
+}
+
 /// Retrieve the TypeLoc at the given \c index from among the set of
 /// type declarations that are directly "inherited" by the given declaration.
 inline const TypeLoc &getInheritedTypeLocAtIndex(
     llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
     unsigned index) {
-  if (auto typeDecl = decl.dyn_cast<const TypeDecl *>())
-    return typeDecl->getInherited()[index];
+  InheritedEntry const& entry = getInheritedEntryAtIndex(decl, index);
+
+  if (entry.isSuppressed) {
+#ifndef NDEBUG
+    llvm::dbgs() << "index " << index << " of inherited entries of \n";
+    if (auto td = decl.dyn_cast<const TypeDecl *>())
+      td->dump(llvm::dbgs(), 1);
+    else
+      decl.dyn_cast<const ExtensionDecl *>()->dump(llvm::dbgs(), 1);
+    llvm::dbgs() << "\n";
+#endif
+    llvm_unreachable("index unexpectedly refers to a suppressed entry");
+  }
 
-  return decl.get<const ExtensionDecl *>()->getInherited()[index];
+  return entry;
 }
 
 namespace namelookup {

include/swift/AST/TypeCheckRequests.h

@@ -404,9 +404,10 @@ class IsFinalRequest :
   void cacheResult(bool value) const;
 };
 
-/// Determine whether the given declaration is 'moveOnly'.
-class IsMoveOnlyRequest
-    : public SimpleRequest<IsMoveOnlyRequest, bool(ValueDecl *),
+/// Determine whether the given declaration is noncopyable (i.e., does not
+/// offer the ability to copy values of that type.)
+class IsNoncopyableRequest
+    : public SimpleRequest<IsNoncopyableRequest, bool(ValueDecl *),
                            RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -207,7 +207,7 @@ SWIFT_REQUEST(TypeChecker, IsDynamicRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, IsMoveOnlyRequest, bool(ValueDecl *), SeparatelyCached,
+SWIFT_REQUEST(TypeChecker, IsNoncopyableRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsGetterMutatingRequest, bool(AbstractStorageDecl *),
               SeparatelyCached, NoLocationInfo)

include/swift/AST/TypeRepr.h

@@ -1066,7 +1066,8 @@ class SpecifierTypeRepr : public TypeRepr {
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Ownership ||
            T->getKind() == TypeReprKind::Isolated ||
-           T->getKind() == TypeReprKind::CompileTimeConst;
+           T->getKind() == TypeReprKind::CompileTimeConst ||
+           T->getKind() == TypeReprKind::Suppressed;
   }
   static bool classof(const SpecifierTypeRepr *T) { return true; }
 
@@ -1106,6 +1107,22 @@ class OwnershipTypeRepr : public SpecifierTypeRepr {
   }
   static bool classof(const OwnershipTypeRepr *T) { return true; }
 };
+
+/// A representation of a suppressed conformance to a type. That is, "without T"
+/// means "implicit conformance to T is suppressed".
+/// \code
+///   x : ~Copyable
+/// \endcode
+class SuppressedTypeRepr : public SpecifierTypeRepr {
+public:
+  SuppressedTypeRepr(TypeRepr *Base, SourceLoc WithoutLoc)
+      : SpecifierTypeRepr(TypeReprKind::Suppressed, Base, WithoutLoc) {}
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::Suppressed;
+  }
+  static bool classof(const SuppressedTypeRepr *T) { return true; }
+};
 
 /// An 'isolated' type.
 /// \code
@@ -1420,6 +1437,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::NamedOpaqueReturn:
   case TypeReprKind::Existential:
   case TypeReprKind::PackElement:
+  case TypeReprKind::Suppressed:
     return false;
   case TypeReprKind::SimpleIdent:
   case TypeReprKind::GenericIdent:

include/swift/AST/TypeReprNodes.def

@@ -72,6 +72,7 @@ ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   SPECIFIER_TYPEREPR(Ownership, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(Isolated, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(CompileTimeConst, SpecifierTypeRepr)
+  SPECIFIER_TYPEREPR(Suppressed, SpecifierTypeRepr)
 TYPEREPR(Fixed, TypeRepr)
 TYPEREPR(SILBox, TypeRepr)
 LAST_TYPEREPR(SILBox)

include/swift/Parse/Parser.h

@@ -1194,9 +1194,20 @@ class Parser {
 
   ParserResult<ImportDecl> parseDeclImport(ParseDeclOptions Flags,
                                            DeclAttributes &Attributes);
+
+  /// Flags that control the parsing of inheritance clauses.
+  enum ParseInheritanceFlags {
+    PI_Default               = 0,
+    PI_AllowClassRequirement = 1 << 1,
+    PI_AllowAnyObject        = 1 << 2,
+    PI_AllowSuppression      = 1 << 3,
+  };
+
+  using ParseInheritanceOptions = OptionSet<ParseInheritanceFlags>;
+
   ParserStatus parseInheritance(SmallVectorImpl<InheritedEntry> &Inherited,
-                                bool allowClassRequirement,
-                                bool allowAnyObject);
+                                ParseInheritanceOptions options);
+
   ParserStatus parseDeclItem(bool &PreviousHadSemi,
                              ParseDeclOptions Options,
                              llvm::function_ref<void(Decl*)> handler);

include/swift/Parse/Token.h

@@ -124,6 +124,10 @@ class Token {
     return !isEllipsis();
   }
 
+  bool isTilde() const {
+    return isAnyOperator() && Text == "~";
+  }
+
   /// Determine whether this token occurred at the start of a line.
   bool isAtStartOfLine() const { return AtStartOfLine; }
 

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -1813,7 +1813,7 @@ SwiftDeclCollector::constructExternalExtensionNode(NominalTypeDecl *NTD,
     //        inherit from other internal protocols. It should also consider
     //        conditional conformances with internal requirements that are still
     //        part of the ABI.
-    if (!Ext->getInherited().empty())
+    if (!Ext->getAllInheritedEntries().empty())
       anyConformancesAdded = true;
   }
 

lib/AST/ASTDumper.cpp

@@ -574,7 +574,11 @@ namespace {
         return;
       OS << " inherits: ";
       interleave(Inherited,
-                 [&](InheritedEntry Super) { Super.getType().print(OS); },
+                 [&](InheritedEntry Super) {
+                   if (Super.isSuppressed)
+                     OS << "~";
+                   Super.getType().print(OS);
+                 },
                  [&] { OS << ", "; });
     }
 
@@ -777,13 +781,13 @@ namespace {
       switch (IDC->getIterableContextKind()) {
       case IterableDeclContextKind::NominalTypeDecl: {
         const auto NTD = cast<NominalTypeDecl>(IDC);
-        printInherited(NTD->getInherited());
+        printInherited(NTD->getAllInheritedEntries());
         printWhereRequirements(NTD);
         break;
       }
       case IterableDeclContextKind::ExtensionDecl:
         const auto ED = cast<ExtensionDecl>(IDC);
-        printInherited(ED->getInherited());
+        printInherited(ED->getAllInheritedEntries());
         printWhereRequirements(ED);
         break;
       }
@@ -3270,6 +3274,12 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     printRec(T->getBase());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
+
+  void visitSuppressedTypeRepr(SuppressedTypeRepr *T) {
+    printCommon("suppressing") << '\n';
+    printRec(T->getBase());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
 
   void visitIsolatedTypeRepr(IsolatedTypeRepr *T) {
     printCommon("isolated") << '\n';