Merge pull request #69406 from kavon/noncopyable-generics-pt2

[NoncopyableGenerics] handle `~Copyable` in `where`, `some`, and compositions.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -2447,10 +2447,6 @@ ERROR(inferred_opaque_type,none,
 // Inverse Constraints
 ERROR(inverse_type_not_invertible,none,
       "type %0 is not invertible", (Type))
-ERROR(inverse_duplicate,none,
-      "duplicate inverse constraint", ())
-NOTE(inverse_duplicate_previous,none,
-      "previous inverse constraint here", ())
 
 // Extensions
 ERROR(non_nominal_extension,none,
@@ -3132,6 +3128,15 @@ ERROR(requires_not_suitable_archetype,none,
       "generic parameter or associated type",
       (Type))
 
+ERROR(requires_not_suitable_inverse_subject,none,
+      "cannot apply inverse %1 to type %0 in conformance requirement",
+      (Type, Type))
+
+ERROR(requires_not_suitable_inverse_outer_subject,none,
+      "cannot add inverse constraint '%0: %1' "
+      "on generic parameter '%0' defined in outer scope",
+      (StringRef, StringRef))
+
 ERROR(invalid_shape_requirement,none,
       "invalid same-shape requirement between %0 and %1",
       (Type, Type))
@@ -7558,7 +7563,7 @@ ERROR(noncopyable_cannot_conform_to_type, none,
      "noncopyable %kind0 cannot conform to %1",
      (const ValueDecl *, Type))
 ERROR(noncopyable_parameter_requires_ownership, none,
-      "noncopyable parameter must specify its ownership", ())
+      "parameter of noncopyable type %0 must specify ownership", (Type))
 ERROR(noncopyable_parameter_subscript_unsupported, none,
       "subscripts cannot have noncopyable parameters yet", ())
 NOTE(noncopyable_parameter_ownership_suggestion, none,

include/swift/AST/ExistentialLayout.h

@@ -31,11 +31,13 @@ struct ExistentialLayout {
 
   ExistentialLayout() {
     hasExplicitAnyObject = false;
+    hasInverseCopyable = false;
     containsNonObjCProtocol = false;
     containsParameterized = false;
   }
 
   ExistentialLayout(CanProtocolType type);
+  ExistentialLayout(CanInverseType type);
   ExistentialLayout(CanProtocolCompositionType type);
   ExistentialLayout(CanParameterizedProtocolType type);
 
@@ -45,6 +47,9 @@ struct ExistentialLayout {
   /// Whether the existential contains an explicit '& AnyObject' constraint.
   bool hasExplicitAnyObject : 1;
 
+  /// Whether the existential contains an explicit '& ~Copyable' constraint.
+  bool hasInverseCopyable : 1;
+
   /// Whether any protocol members are non-@objc.
   bool containsNonObjCProtocol : 1;
 

include/swift/AST/KnownProtocols.def

@@ -41,6 +41,14 @@
     PROTOCOL_WITH_NAME(Id, Name)
 #endif
 
+/// \def INVERTIBLE_PROTOCOL_WITH_NAME(id, name)
+/// \param Name a string literal with the external name of this protocol
+/// \param Id the internal "enum name" of this protocol.
+#ifndef INVERTIBLE_PROTOCOL_WITH_NAME
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) \
+    PROTOCOL_WITH_NAME(Id, Name)
+#endif
+
 
 #define PROTOCOL(name) PROTOCOL_WITH_NAME(name, #name)
 #define PROTOCOL_(name) PROTOCOL_WITH_NAME(name, "_" #name)
@@ -127,7 +135,7 @@ PROTOCOL(AsyncIteratorProtocol)
 
 PROTOCOL(FloatingPoint)
 
-PROTOCOL(Copyable)
+INVERTIBLE_PROTOCOL_WITH_NAME(Copyable, "Copyable")
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByBooleanLiteral, "BooleanLiteralType", true)
@@ -156,6 +164,7 @@ BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_(ExpressibleByBuiltinUnicodeScalarLitera
 #undef EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
 #undef BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_
 #undef BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
+#undef INVERTIBLE_PROTOCOL_WITH_NAME
 #undef PROTOCOL
 #undef PROTOCOL_
 #undef PROTOCOL_WITH_NAME

include/swift/AST/KnownProtocols.h

@@ -42,15 +42,37 @@ 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 getInvertibleProtocols();
-
 /// Retrieve the name of the given known protocol.
 llvm::StringRef getProtocolName(KnownProtocolKind kind);
 
+/// MARK: Invertible protocols
+///
+/// The invertible protocols are a subset of the known protocols.
+
+enum : uint8_t {
+  // Use preprocessor trick to count all the invertible protocols.
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) +1
+  /// The number of invertible protocols.
+  NumInvertibleProtocols =
+#include "swift/AST/KnownProtocols.def"
+};
+
+enum class InvertibleProtocolKind : uint8_t {
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) Id,
+#include "swift/AST/KnownProtocols.def"
+};
+
+using InvertibleProtocolSet = FixedBitSet<NumInvertibleProtocols,
+                                          InvertibleProtocolKind>;
+
+/// Maps a KnownProtocol to the set of InvertibleProtocols, if a mapping exists.
+/// \returns None if the known protocol is not invertible.
+llvm::Optional<InvertibleProtocolKind>
+    getInvertibleProtocolKind(KnownProtocolKind kp);
+
+/// Returns the KnownProtocolKind corresponding to an InvertibleProtocolKind.
+KnownProtocolKind getKnownProtocolKind(InvertibleProtocolKind ip);
+
 } // end namespace swift
 
 #endif

include/swift/AST/TypeMatcher.h

@@ -495,6 +495,14 @@ class TypeMatcher {
                       sugaredFirstType);
     }
 
+    bool visitInverseType(CanInverseType firstInverse,
+                          Type secondType,
+                          Type sugaredFirstType) {
+      // NOTE: If this visitor is reached, determine whether it should've been
+      // before implementing this.
+      llvm_unreachable("Yahaha! You found me!");
+    }
+
     bool visitLValueType(CanLValueType firstLValue, Type secondType,
                          Type sugaredFirstType) {
       if (auto secondLValue = secondType->getAs<LValueType>()) {

include/swift/AST/TypeNodes.def

@@ -180,6 +180,7 @@ ARTIFICIAL_TYPE(SILMoveOnlyWrapped, Type)
 ALWAYS_CANONICAL_ARTIFICIAL_TYPE(SILPack, Type)
 ARTIFICIAL_TYPE(SILToken, Type)
 TYPE(ProtocolComposition, Type)
+UNCHECKED_TYPE(Inverse, Type)
 TYPE(ParameterizedProtocol, Type)
 TYPE(Existential, Type)
 TYPE(LValue, Type)

include/swift/AST/Types.h

@@ -24,6 +24,7 @@
 #include "swift/AST/ExtInfo.h"
 #include "swift/AST/GenericParamKey.h"
 #include "swift/AST/Identifier.h"
+#include "swift/AST/KnownProtocols.h"
 #include "swift/AST/Ownership.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/Requirement.h"
@@ -100,7 +101,6 @@ class ProtocolConformance;
 enum PointerTypeKind : unsigned;
 struct ValueOwnershipKind;
 class ErrorExpr;
-enum class KnownProtocolKind : uint8_t;
 
 typedef CanTypeWrapper<SILFunctionType> CanSILFunctionType;
 
@@ -1534,6 +1534,48 @@ class NominalOrBoundGenericNominalType : public AnyGenericType {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(NominalOrBoundGenericNominalType, AnyGenericType)
 
+/// InverseType represents the "inverse" of a ProtocolType as a constraint.
+/// An inverse represents the _absence_ of an implicit constraint to the given
+/// protocol.
+///
+/// Otherwise, an inverse is not a real type! It's an annotation for other types
+/// to signal whether an implicit requirement on that type should be omitted.
+/// Because that annotation is expressed in the surface language as if it _were_
+/// a type (that is, as a type constraint) we still model it as a Type through
+/// typechecking.
+class InverseType final : public TypeBase {
+  Type protocol;
+
+  InverseType(Type type,
+              const ASTContext *canonicalContext,
+              RecursiveTypeProperties properties)
+      : TypeBase(TypeKind::Inverse, canonicalContext, properties),
+        protocol(type) {
+    assert(protocol->is<ProtocolType>());
+  }
+
+public:
+  /// Produce an inverse constraint type for the given protocol type.
+  static Type get(Type protocolType);
+
+
+  /// Obtain the underlying \c ProtocolType that was inverted.
+  Type getInvertedProtocol() const {
+    return protocol;
+  }
+
+  /// Get known kind of inverse this type represents.
+  InvertibleProtocolKind getInverseKind() const;
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::Inverse;
+  }
+};
+BEGIN_CAN_TYPE_WRAPPER(InverseType, Type)
+  PROXY_CAN_TYPE_SIMPLE_GETTER(getInvertedProtocol)
+END_CAN_TYPE_WRAPPER(InverseType, Type)
+
 /// ErrorType - Represents the type of an erroneously constructed declaration,
 /// expression, or type. When creating ErrorTypes, an associated error
 /// diagnostic should always be emitted. That way when later stages of
@@ -5739,13 +5781,37 @@ class ProtocolCompositionType final : public TypeBase,
     public llvm::FoldingSetNode,
     private llvm::TrailingObjects<ProtocolCompositionType, Type> {
   friend TrailingObjects;
+
+  // TODO(kavon): this could probably be folded into the existing Bits field
+  // or we could just store the InverseType's in the Members array.
+  InvertibleProtocolSet Inverses;
 
 public:
   /// Retrieve an instance of a protocol composition type with the
-  /// given set of members.
+  /// given set of members. A "hidden member" is an implicit constraint that
+  /// is present for all protocol compositions.
+  ///
+  /// \param Members the regular members of this composition.
+  /// \param Inverses the set of inverses that are a member of the composition,
+  ///                 i.e., if \c IP is in this set, then \c ~IP is a member of
+  ///                 this composition.
+  /// \param HasExplicitAnyObject indicates whether this composition should be
+  /// treated as if \c AnyObject was a member.
   static Type get(const ASTContext &C, ArrayRef<Type> Members,
+                  InvertibleProtocolSet Inverses,
                   bool HasExplicitAnyObject);
 
+  /// Retrieve an instance of a protocol composition type with the
+  /// given set of members. Assumes no inverses are present in \c Members.
+  static Type get(const ASTContext &C, ArrayRef<Type> Members,
+                  bool HasExplicitAnyObject);
+
+  /// Constructs a protocol composition corresponding to the `Any` type.
+  static Type theAnyType(const ASTContext &C);
+
+  /// Constructs a protocol composition corresponding to the `AnyObject` type.
+  static Type theAnyObjectType(const ASTContext &C);
+
   /// Canonical protocol composition types are minimized only to a certain
   /// degree to preserve ABI compatibility. This routine enables performing
   /// slower, but stricter minimization at need (e.g. redeclaration checking).
@@ -5768,11 +5834,14 @@ class ProtocolCompositionType final : public TypeBase,
     return {getTrailingObjects<Type>(), Bits.ProtocolCompositionType.Count};
   }
 
+  InvertibleProtocolSet getInverses() const { return Inverses; }
+
   void Profile(llvm::FoldingSetNodeID &ID) {
-    Profile(ID, getMembers(), hasExplicitAnyObject());
+    Profile(ID, getMembers(), getInverses(), hasExplicitAnyObject());
   }
   static void Profile(llvm::FoldingSetNodeID &ID,
                       ArrayRef<Type> Members,
+                      InvertibleProtocolSet Inverses,
                       bool HasExplicitAnyObject);
 
   /// True if the composition requires the concrete conforming type to
@@ -5793,12 +5862,15 @@ class ProtocolCompositionType final : public TypeBase,
 private:
   static ProtocolCompositionType *build(const ASTContext &C,
                                         ArrayRef<Type> Members,
+                                        InvertibleProtocolSet Inverses,
                                         bool HasExplicitAnyObject);
 
   ProtocolCompositionType(const ASTContext *ctx, ArrayRef<Type> members,
+                          InvertibleProtocolSet inverses,
                           bool hasExplicitAnyObject,
                           RecursiveTypeProperties properties)
-    : TypeBase(TypeKind::ProtocolComposition, /*Context=*/ctx, properties) {
+    : TypeBase(TypeKind::ProtocolComposition, /*Context=*/ctx, properties),
+      Inverses(inverses) {
     Bits.ProtocolCompositionType.HasExplicitAnyObject = hasExplicitAnyObject;
     Bits.ProtocolCompositionType.Count = members.size();
     std::uninitialized_copy(members.begin(), members.end(),
@@ -7223,7 +7295,8 @@ inline bool TypeBase::isConstraintType() const {
 inline bool CanType::isConstraintTypeImpl(CanType type) {
   return (isa<ProtocolType>(type) ||
           isa<ProtocolCompositionType>(type) ||
-          isa<ParameterizedProtocolType>(type));
+          isa<ParameterizedProtocolType>(type) ||
+          isa<InverseType>(type));
 }
 
 inline bool TypeBase::isExistentialType() {
@@ -7239,6 +7312,7 @@ inline bool CanType::isExistentialTypeImpl(CanType type) {
          isa<ProtocolCompositionType>(type) ||
          isa<ExistentialType>(type) ||
          isa<ParameterizedProtocolType>(type);
+  // TODO(kavon): treat InverseType as an existential, etc?
 }
 
 inline bool CanType::isAnyExistentialTypeImpl(CanType type) {

include/swift/Basic/FixedBitSet.h

@@ -84,14 +84,21 @@ class FixedBitSet {
 
 public:
   /// Build an empty set.
-  FixedBitSet() {}
+  constexpr FixedBitSet() {}
 
   /// Build a set containing the given elements.
   FixedBitSet(std::initializer_list<ValueType> elements) {
     for (const auto &elt : elements)
       insert(elt);
   }
 
+  /// Build a set filled with all possible elements, i.e., a "full" set.
+  static FixedBitSet full() {
+    FixedBitSet set;
+    set.insertAll();
+    return set;
+  }
+
   /// Return true if the set is empty.
   bool empty() const {
     for (auto chunk : chunks)