[NCGenerics] fold InverseType into PCT

We already need to track the inverses separate from the members in a
ProtocolCompositionType, since inverses aren't real types. Thus, the
only purpose being served by InverseType is to be eliminated by
RequirementLowering when it appears in a conformance requirement.

We already have another RequirementKind that normally does not
correspond to a Constrant that we can use for the purpose of carrying
inverses in StructuralRequirements prior to lowering. That is the
LayoutConstraint.

In summary: InverseType here got replaced by ProtocolCompositionType
when used as a type. When desugaring a requirement to conform to a PCT
that contains an inverse, we add a LayoutConstraint::Noncopyable
requirement so that RequirementLowering is aware that there was a
`~Copyable` requirement.

Author: kavon

include/swift/AST/ASTContext.h

@@ -1023,6 +1023,7 @@ class ASTContext final {
   const CanType TheEmptyTupleType;        /// This is '()', aka Void
   const CanType TheEmptyPackType;
   const CanType TheAnyType;               /// This is 'Any', the empty protocol composition
+  const CanType InverseCopyable;          /// This is '~Copyable', the inverse of Copyable.
 #define SINGLETON_TYPE(SHORT_ID, ID) \
   const CanType The##SHORT_ID##Type;
 #include "swift/AST/TypeNodes.def"

include/swift/AST/DiagnosticsSema.def

@@ -3158,8 +3158,8 @@ ERROR(requires_not_suitable_archetype,none,
       (Type))
 
 ERROR(requires_not_suitable_inverse_subject,none,
-      "cannot apply inverse %1 to type %0 in conformance requirement",
-      (Type, Type))
+      "cannot apply inverse '~%1' to type %0 in conformance requirement",
+      (Type, StringRef))
 
 ERROR(requires_not_suitable_inverse_outer_subject,none,
       "cannot add inverse constraint '%0: %1' "

include/swift/AST/ExistentialLayout.h

@@ -37,7 +37,6 @@ struct ExistentialLayout {
   }
 
   ExistentialLayout(CanProtocolType type);
-  ExistentialLayout(CanInverseType type);
   ExistentialLayout(CanProtocolCompositionType type);
   ExistentialLayout(CanParameterizedProtocolType type);
 

include/swift/AST/LayoutConstraint.h

@@ -31,6 +31,7 @@
 namespace swift {
 
 class ASTPrinter;
+enum class InvertibleProtocolKind : uint8_t;
 
 /// This is a class representing the layout constraint.
 class LayoutConstraintInfo
@@ -171,10 +172,14 @@ class LayoutConstraintInfo
   std::string getString(const PrintOptions &PO = PrintOptions()) const;
 
   /// Return the name of this layout constraint.
-  StringRef getName(bool useClassLayoutName = false) const;
+  StringRef getName(bool internalName = false) const;
+
+  /// If this layout constraint represents an inverse of an invertible protocol,
+  /// returns the kind of protocol.
+  llvm::Optional<InvertibleProtocolKind> getInverseKind() const;
 
   /// Return the name of a layout constraint with a given kind.
-  static StringRef getName(LayoutConstraintKind Kind, bool useClassLayoutName = false);
+  static StringRef getName(LayoutConstraintKind Kind, bool internalName = false);
 
   static bool isKnownLayout(LayoutConstraintKind Kind);
 
@@ -217,6 +222,7 @@ class LayoutConstraintInfo
   static LayoutConstraintInfo ClassConstraintInfo;
   static LayoutConstraintInfo NativeClassConstraintInfo;
   static LayoutConstraintInfo TrivialConstraintInfo;
+  static LayoutConstraintInfo NoncopyableConstraintInfo;
 };
 
 /// A wrapper class containing a reference to the actual LayoutConstraintInfo
@@ -232,6 +238,8 @@ class LayoutConstraint {
   static LayoutConstraint getLayoutConstraint(LayoutConstraintKind Kind,
                                               ASTContext &C);
 
+  static LayoutConstraint getInverseConstraint(InvertibleProtocolKind Kind);
+
   static LayoutConstraint getLayoutConstraint(LayoutConstraintKind Kind);
 
   static LayoutConstraint getLayoutConstraint(LayoutConstraintKind Kind,

include/swift/AST/LayoutConstraintKind.h

@@ -39,7 +39,9 @@ enum class LayoutConstraintKind : uint8_t {
   RefCountedObject,
   // It is a layout constraint representing a native reference counted object.
   NativeRefCountedObject,
-  LastLayout = NativeRefCountedObject,
+  // It is a layout constraint representing a noncopyable value.
+  Noncopyable,
+  LastLayout = Noncopyable,
 };
 
 #endif

include/swift/AST/PrintOptions.h

@@ -328,9 +328,8 @@ struct PrintOptions {
   /// Whether to print generic requirements in a where clause.
   bool PrintGenericRequirements = true;
 
-  /// Whether to print the real layout name instead of AnyObject
-  /// for class layout
-  bool PrintClassLayoutName = false;
+  /// Whether to print the internal layout name instead of AnyObject, etc.
+  bool PrintInternalLayoutName = false;
 
   /// Suppress emitting @available(*, noasync)
   bool SuppressNoAsyncAvailabilityAttr = false;

include/swift/AST/TypeMatcher.h

@@ -495,14 +495,6 @@ 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,7 +180,6 @@ 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

@@ -1532,48 +1532,6 @@ 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
@@ -5811,6 +5769,9 @@ class ProtocolCompositionType final : public TypeBase,
   /// Constructs a protocol composition corresponding to the `AnyObject` type.
   static Type theAnyObjectType(const ASTContext &C);
 
+  /// Constructs a protocol composition corresponding to the `~IP` type.
+  static Type theInverseOf(const ASTContext &C, InvertibleProtocolKind IP);
+
   /// 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).
@@ -7294,8 +7255,7 @@ inline bool TypeBase::isConstraintType() const {
 inline bool CanType::isConstraintTypeImpl(CanType type) {
   return (isa<ProtocolType>(type) ||
           isa<ProtocolCompositionType>(type) ||
-          isa<ParameterizedProtocolType>(type) ||
-          isa<InverseType>(type));
+          isa<ParameterizedProtocolType>(type));
 }
 
 inline bool TypeBase::isExistentialType() {
@@ -7311,7 +7271,6 @@ 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) {

lib/AST/ASTContext.cpp

@@ -460,7 +460,6 @@ struct ASTContext::Implementation {
     llvm::DenseMap<std::pair<ClassDecl*, Type>, ClassType*> ClassTypes;
     llvm::DenseMap<std::pair<ProtocolDecl*, Type>, ProtocolType*> ProtocolTypes;
     llvm::DenseMap<Type, ExistentialType *> ExistentialTypes;
-    llvm::DenseMap<Type, InverseType *> InverseTypes;
     llvm::FoldingSet<UnboundGenericType> UnboundGenericTypes;
     llvm::FoldingSet<BoundGenericType> BoundGenericTypes;
     llvm::FoldingSet<ProtocolCompositionType> ProtocolCompositionTypes;
@@ -685,6 +684,8 @@ ASTContext::ASTContext(
       TheEmptyTupleType(TupleType::get(ArrayRef<TupleTypeElt>(), *this)),
       TheEmptyPackType(PackType::get(*this, {})),
       TheAnyType(ProtocolCompositionType::theAnyType(*this)),
+      InverseCopyable(ProtocolCompositionType::theInverseOf(*this,
+                      InvertibleProtocolKind::Copyable)),
 #define SINGLETON_TYPE(SHORT_ID, ID) \
     The##SHORT_ID##Type(new (*this, AllocationArena::Permanent) \
                           ID##Type(*this)),
@@ -3844,28 +3845,6 @@ Type ExistentialMetatypeType::getExistentialInstanceType() {
   return ExistentialType::get(getInstanceType());
 }
 
-InvertibleProtocolKind InverseType::getInverseKind() const {
-  return *getInvertibleProtocolKind(*protocol->getKnownProtocol());
-}
-
-Type InverseType::get(Type invertedProto) {
-  auto &C = invertedProto->getASTContext();
-
-  auto properties = invertedProto->getRecursiveProperties();
-  auto arena = getArena(properties);
-
-  auto &entry = C.getImpl().getArena(arena).InverseTypes[invertedProto];
-  if (entry)
-    return entry;
-
-  const ASTContext *canonicalContext =
-      invertedProto->isCanonical() ? &C : nullptr;
-
-  return entry = new (C, arena) InverseType(invertedProto,
-                                            canonicalContext,
-                                            properties);
-}
-
 ModuleType *ModuleType::get(ModuleDecl *M) {
   ASTContext &C = M->getASTContext();
 
@@ -6039,6 +6018,14 @@ CanSILBoxType SILBoxType::get(CanType boxedType) {
   return get(boxedType->getASTContext(), layout, subMap);
 }
 
+LayoutConstraint
+LayoutConstraint::getInverseConstraint(InvertibleProtocolKind Kind) {
+  switch (Kind) {
+  case InvertibleProtocolKind::Copyable:
+    return getLayoutConstraint(LayoutConstraintKind::Noncopyable);
+  }
+}
+
 LayoutConstraint
 LayoutConstraint::getLayoutConstraint(LayoutConstraintKind Kind,
                                       ASTContext &C) {

lib/AST/ASTDumper.cpp

@@ -4368,12 +4368,6 @@ namespace {
       printFoot();
     }
 
-    void visitInverseType(InverseType *T, StringRef label) {
-      printCommon("inverse_type", label);
-      printRec(T->getInvertedProtocol());
-      printFoot();
-    }
-
     void visitLValueType(LValueType *T, StringRef label) {
       printCommon("lvalue_type", label);
       printRec(T->getObjectType());

lib/AST/ASTMangler.cpp

@@ -1401,9 +1401,6 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
     case TypeKind::LValue:
       llvm_unreachable("@lvalue types should not occur in function interfaces");
 
-    case TypeKind::Inverse:
-      llvm_unreachable("inverse types should not appear in interfaces");
-
     case TypeKind::InOut:
       appendType(cast<InOutType>(tybase)->getObjectType(), sig, forDecl);
       return appendOperator("z");
@@ -3804,6 +3801,9 @@ void ASTMangler::appendOpParamForLayoutConstraint(LayoutConstraint layout) {
       appendOperatorParam("M", Index(layout->getTrivialSizeInBits()),
                           Index(layout->getAlignmentInBits()));
     break;
+  case LayoutConstraintKind::Noncopyable:
+    appendOperatorParam("nc");
+    break;
   }
 }
 

lib/AST/ASTPrinter.cpp

@@ -6314,11 +6314,6 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       Printer << "_";
   }
 
-  void visitInverseType(InverseType *T) {
-    Printer << "~";
-    visit(T->getInvertedProtocol());
-  }
-
   void visitPlaceholderType(PlaceholderType *T) {
     if (Options.PrintTypesForDebugging) {
       Printer << "<<placeholder for ";
@@ -7667,15 +7662,16 @@ void LayoutConstraint::print(raw_ostream &OS,
 
 void LayoutConstraintInfo::print(ASTPrinter &Printer,
                                  const PrintOptions &PO) const {
-  Printer << getName(PO.PrintClassLayoutName);
+  Printer << getName(PO.PrintInternalLayoutName);
   switch (getKind()) {
   case LayoutConstraintKind::UnknownLayout:
   case LayoutConstraintKind::RefCountedObject:
   case LayoutConstraintKind::NativeRefCountedObject:
   case LayoutConstraintKind::Class:
   case LayoutConstraintKind::NativeClass:
   case LayoutConstraintKind::Trivial:
-    return;
+  case LayoutConstraintKind::Noncopyable:
+    return; // non-parameterized cases
   case LayoutConstraintKind::TrivialOfAtMostSize:
   case LayoutConstraintKind::TrivialOfExactSize:
     Printer << "(";

lib/AST/Attr.cpp

@@ -1261,7 +1261,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
                       Printer << "@_noMetadata ";
                   }
                   auto OptionsCopy = Options;
-                  OptionsCopy.PrintClassLayoutName = typeErased;
+                  OptionsCopy.PrintInternalLayoutName = typeErased;
                   req.print(Printer, OptionsCopy);
                 },
                 [&] { Printer << ", "; });

lib/AST/ExistentialGeneralization.cpp

@@ -110,11 +110,6 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
                                         origType->hasExplicitAnyObject());
   }
 
-  Type visitInverseType(CanInverseType type) {
-    // TODO(kavon): determine how to handle inverses for ExistentialGeneralization
-    llvm_unreachable("unimplemented");
-  }
-
   // Generalize the type arguments of nominal types.
   Type visitBoundGenericType(CanBoundGenericType origType) {
     return generalizeGenericArguments(origType->getDecl(), origType);