Merge pull request #70278 from kavon/refactor-InverseType

[NCGenerics] fold InverseType into PCT

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -3158,11 +3158,11 @@ 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' "
+      "cannot add inverse constraint '%0: ~%1' "
       "on generic parameter '%0' defined in outer scope",
       (StringRef, StringRef))
 
@@ -7558,6 +7558,11 @@ ERROR(accessor_macro_not_single_var, none,
 ERROR(noncopyable_but_copyable, none,
       "%kind0 required to be 'Copyable' but is marked with '~Copyable'",
       (const ValueDecl *))
+ERROR(noncopyable_generic_but_copyable, none,
+      "%0 required to be '%1' but is marked with '~%1'",
+      (Type, StringRef))
+WARNING(redundant_inverse_constraint,none,
+        "redundant constraint %0 : '~%1'", (Type, StringRef))
 ERROR(noncopyable_class, none,
       "classes cannot be noncopyable",
       ())

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

@@ -171,10 +171,10 @@ 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;
 
   /// 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);
 

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/Requirement.h

@@ -27,6 +27,8 @@
 
 namespace swift {
 
+enum class InvertibleProtocolKind : uint8_t;
+
 /// Return type of Requirement::checkRequirement().
 enum class CheckRequirementResult : uint8_t {
   /// The requirement was fully satisfied.
@@ -222,6 +224,31 @@ struct StructuralRequirement {
   /// diagnosed as redundant, since we want to give users the option of
   /// spelling out these requirements explicitly.
   bool inferred = false;
+
+  /// A flag indicating whether this requirement was produced via the expansion
+  /// of default conformances to invertible protocols.
+  bool fromDefault = false;
+};
+
+struct InverseRequirement {
+  Type subject;
+  ProtocolDecl *protocol;
+  SourceLoc loc;
+
+  InverseRequirement(Type subject, ProtocolDecl *protocol, SourceLoc loc);
+
+  InvertibleProtocolKind getKind() const;
+
+  static void enumerateDefaultedParams(TypeDecl *decl,
+                                       SmallVectorImpl<Type> &result);
+
+  static void expandDefault(Type gp,
+                            SourceLoc loc,
+                            SmallVectorImpl<StructuralRequirement> &result);
+
+  static void expandDefaults(ASTContext &ctx,
+                             ArrayRef<Type> gps,
+                             SmallVectorImpl<StructuralRequirement> &result);
 };
 
 } // end namespace swift

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
@@ -5813,6 +5771,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 getInverseOf(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).
@@ -7296,8 +7257,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() {
@@ -7313,7 +7273,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;
@@ -3842,28 +3841,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();
 

lib/AST/ASTDumper.cpp

@@ -4375,12 +4375,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());