Merge pull request swiftlang#67930 from kavon/copyable-requirement

Copyable as a Requirement Against the Machine

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -2346,6 +2346,10 @@ ERROR(inferred_opaque_type,none,
       "property definition has inferred type %0, involving the 'some' "
       "return type of another declaration", (Type))
 
+// Inverse Constraints
+ERROR(inverse_type_not_invertable,none,
+      "type %0 is not invertable", (Type))
+
 // Extensions
 ERROR(non_nominal_extension,none,
       "non-nominal type %0 cannot be extended", (Type))

include/swift/AST/KnownProtocols.def

@@ -126,7 +126,7 @@ PROTOCOL(AsyncIteratorProtocol)
 
 PROTOCOL(FloatingPoint)
 
-PROTOCOL_(Copyable)
+PROTOCOL(Copyable)
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByBooleanLiteral, "BooleanLiteralType", true)

include/swift/AST/KnownProtocols.h

@@ -14,6 +14,7 @@
 #define SWIFT_AST_KNOWNPROTOCOLS_H
 
 #include "swift/Basic/InlineBitfield.h"
+#include "swift/Basic/FixedBitSet.h"
 #include "swift/Config.h"
 
 namespace llvm {
@@ -41,6 +42,12 @@ enum : uint8_t {
 enum : unsigned { NumKnownProtocolKindBits =
   countBitsUsed(static_cast<unsigned>(NumKnownProtocols - 1)) };
 
+using KnownProtocolSet = FixedBitSet<NumKnownProtocols, KnownProtocolKind>;
+
+/// Produces a set of all protocols that have an inverse, i.e., for every
+/// known protocol KP in the set, ~KP exists.
+KnownProtocolSet getInvertableProtocols();
+
 /// Retrieve the name of the given known protocol.
 llvm::StringRef getProtocolName(KnownProtocolKind kind);
 

include/swift/AST/TypeRepr.h

@@ -1321,6 +1321,34 @@ class ExistentialTypeRepr: public TypeRepr {
   friend class TypeRepr;
 };
 
+/// A type repr represeting the inverse of some constraint. For example,
+///    ~Copyable
+/// where `Copyable` is the constraint type.
+class InverseTypeRepr : public TypeRepr {
+  TypeRepr *Constraint;
+  SourceLoc TildeLoc;
+
+public:
+  InverseTypeRepr(SourceLoc tildeLoc, TypeRepr *constraint)
+      : TypeRepr(TypeReprKind::Inverse), Constraint(constraint),
+        TildeLoc(tildeLoc) {}
+
+  TypeRepr *getConstraint() const { return Constraint; }
+  SourceLoc getTildeLoc() const { return TildeLoc; }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::Inverse;
+  }
+  static bool classof(const InverseTypeRepr *T) { return true; }
+
+private:
+  SourceLoc getStartLocImpl() const { return TildeLoc; }
+  SourceLoc getEndLocImpl() const { return Constraint->getEndLoc(); }
+  SourceLoc getLocImpl() const { return TildeLoc; }
+  void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
+  friend class TypeRepr;
+};
+
 /// TypeRepr for a user-specified placeholder (essentially, a user-facing
 /// representation of an anonymous type variable.
 ///
@@ -1459,6 +1487,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Dictionary:
   case TypeReprKind::Optional:
   case TypeReprKind::ImplicitlyUnwrappedOptional:
+  case TypeReprKind::Inverse:
   case TypeReprKind::Vararg:
   case TypeReprKind::PackExpansion:
   case TypeReprKind::Pack:

include/swift/AST/TypeReprNodes.def

@@ -65,6 +65,7 @@ TYPEREPR(Protocol, TypeRepr)
 TYPEREPR(OpaqueReturn, TypeRepr)
 TYPEREPR(NamedOpaqueReturn, TypeRepr)
 TYPEREPR(Existential, TypeRepr)
+TYPEREPR(Inverse, TypeRepr)
 TYPEREPR(Pack, TypeRepr)
 TYPEREPR(PackElement, TypeRepr)
 TYPEREPR(Placeholder, TypeRepr)

include/swift/AST/Types.h

@@ -634,8 +634,8 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   bool isPlaceholder();
 
-  /// Returns true if this is a move-only type.
-  bool isPureMoveOnly();
+  /// Returns true if this is a noncopyable type.
+  bool isNoncopyable();
 
   /// Does the type have outer parenthesis?
   bool hasParenSugar() const { return getKind() == TypeKind::Paren; }
@@ -5351,7 +5351,7 @@ class SILMoveOnlyWrappedType final : public TypeBase,
       : TypeBase(TypeKind::SILMoveOnlyWrapped, &innerType->getASTContext(),
                  innerType->getRecursiveProperties()),
         innerType(innerType) {
-    assert(!innerType->isPureMoveOnly() && "Inner type must be copyable");
+    assert(!innerType->isNoncopyable() && "Inner type must be copyable");
   }
 
 public:

include/swift/Basic/Features.def

@@ -235,6 +235,9 @@ EXPERIMENTAL_FEATURE(RawLayout, true)
 /// Enables the "embedded" swift mode (no runtime).
 EXPERIMENTAL_FEATURE(Embedded, true)
 
+/// Enables noncopyable generics
+EXPERIMENTAL_FEATURE(NoncopyableGenerics, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/Parse/Parser.h

@@ -158,6 +158,11 @@ class Parser {
   bool InSwiftKeyPath = false;
   bool InFreestandingMacroArgument = false;
 
+  // A cached answer to
+  //     Context.LangOpts.hasFeature(Feature::NoncopyableGenerics)
+  // to ensure there's no parsing performance regression.
+  bool EnabledNoncopyableGenerics;
+
   /// Whether we should delay parsing nominal type, extension, and function
   /// bodies.
   bool isDelayedParsingEnabled() const;
@@ -2058,6 +2063,11 @@ class Parser {
 
   void performIDEInspectionSecondPassImpl(
       IDEInspectionDelayedDeclState &info);
+
+  /// Returns true if the caller should skip calling `parseType` afterwards.
+  bool parseLegacyTildeCopyable(SourceLoc *parseTildeCopyable,
+                                ParserStatus &Status,
+                                SourceLoc &TildeCopyableLoc);
 };
 
 /// Describes a parsed declaration name.

include/swift/SIL/SILType.h

@@ -748,10 +748,6 @@ class SILType {
   /// wrapped type.
   bool isMoveOnly() const;
 
-  /// Is this a type that is a first class move only type. This returns false
-  /// for a move only wrapped type.
-  bool isPureMoveOnly() const;
-
   /// Return true if this is a value type (struct/enum) that requires
   /// deinitialization beyond destruction of its members.
   bool isValueTypeWithDeinit() const;

lib/AST/ASTContext.cpp

@@ -102,6 +102,10 @@ llvm::StringRef swift::getProtocolName(KnownProtocolKind kind) {
   llvm_unreachable("bad KnownProtocolKind");
 }
 
+KnownProtocolSet swift::getInvertableProtocols() {
+  return { KnownProtocolKind::Copyable };
+}
+
 namespace {
 enum class SearchPathKind : uint8_t {
   Import = 1 << 0,