Mangling: handle inverse requirements

Author: kavon

docs/ABI/Mangling.rst

@@ -680,12 +680,14 @@ Types
   METATYPE-REPR ::= 'T'                      // Thick metatype representation
   METATYPE-REPR ::= 'o'                      // ObjC metatype representation
 
+  existential-layout ::= protocol-list 'p'                 // existential layout
+  existential-layout ::= protocol-list superclass 'Xc'     // existential layout with superclass
+  existential-layout ::= protocol-list 'Xl'                // existential layout with AnyObject
+
   type ::= associated-type
   type ::= any-generic-type
-  type ::= protocol-list 'p'                 // existential type
-  type ::= protocol-list superclass 'Xc'     // existential type with superclass
-  type ::= protocol-list 'Xl'                // existential type with AnyObject
-  type ::= protocol-list requirement* '_' 'XP'   // constrained existential type
+  type ::= existential-layout                         // existential type
+  type ::= existential-layout requirement '_' requirement* 'XP'   // constrained existential type
   type ::= type-list 't'                     // tuple
   type ::= type generic-signature 'u'        // generic type
   type ::= 'x'                               // generic param, depth=0, idx=0
@@ -925,13 +927,19 @@ now codified into the ABI; the index 0 is therefore reserved.
 
   generic-param-pack-marker ::= 'Rv' GENERIC_PARAM-INDEX   // generic parameter pack marker
 
+  INVERTIBLE-KIND ::= 'c'  // Copyable
+  INVERTIBLE-KIND ::= 'e'  // Escapable
+
   GENERIC-PARAM-COUNT ::= 'z'                // zero parameters
   GENERIC-PARAM-COUNT ::= INDEX              // N+1 parameters
 
   requirement ::= protocol 'R' GENERIC-PARAM-INDEX                  // protocol requirement
   requirement ::= protocol assoc-type-name 'Rp' GENERIC-PARAM-INDEX // protocol requirement on associated type
   requirement ::= protocol assoc-type-list 'RP' GENERIC-PARAM-INDEX // protocol requirement on associated type at depth
   requirement ::= protocol substitution 'RQ'                        // protocol requirement with substitution
+#if SWIFT_RUNTIME_VERSION >= 6.0
+  requirement ::= 'Ri' INVERTIBLE-KIND GENERIC-PARAM-INDEX          // inverse requirement
+#endif
   requirement ::= type 'Rb' GENERIC-PARAM-INDEX                     // base class requirement
   requirement ::= type assoc-type-name 'Rc' GENERIC-PARAM-INDEX     // base class requirement on associated type
   requirement ::= type assoc-type-list 'RC' GENERIC-PARAM-INDEX     // base class requirement on associated type at depth

include/swift/AST/ASTMangler.h

@@ -452,14 +452,16 @@ class ASTMangler : public Mangler {
 
   void appendContextOf(const ValueDecl *decl);
 
-  void appendContext(const DeclContext *ctx, StringRef useModuleName);
+  void appendContext(const DeclContext *ctx, StringRef useModuleName,
+                     bool shouldMangleInverseGenerics = false);
 
   void appendModule(const ModuleDecl *module, StringRef useModuleName);
 
   void appendProtocolName(const ProtocolDecl *protocol,
                           bool allowStandardSubstitution = true);
 
-  void appendAnyGenericType(const GenericTypeDecl *decl);
+  void appendAnyGenericType(const GenericTypeDecl *decl,
+                            bool shouldMangleInverseGenerics = false);
 
   enum FunctionManglingKind {
     NoFunctionMangling,
@@ -510,10 +512,22 @@ class ASTMangler : public Mangler {
   /// \param contextSig The signature of the known context. This function
   /// will only mangle the difference between \c sig and \c contextSig.
   ///
+  /// \param skipEquivalenceCheck Whether we should skip the sig == contextSig
+  /// check. Skipping this check means we will mangle the signature regardless
+  /// of if the surrounding context has the same signature. This should
+  /// generally always be false, but there are inverse generic mangling concerns
+  /// that need to force signature mangling.
+  ///
+  /// \param shouldMangleInverseGenerics Whether we should append inverse
+  /// generic requirements to the signature mangling. If @_preInverseGenerics is
+  /// present do not mangle them in addition to other requirements.
+  ///
   /// \returns \c true if a generic signature was appended, \c false
   /// if it was empty.
   bool appendGenericSignature(GenericSignature sig,
-                              GenericSignature contextSig = nullptr);
+                              GenericSignature contextSig = nullptr,
+                              bool skipEquivalenceCheck = false,
+                              bool shouldMangleInverseGenerics = true);
 
   /// Append a requirement to the mangling.
   ///
@@ -527,10 +541,21 @@ class ASTMangler : public Mangler {
   void appendRequirement(const Requirement &reqt, GenericSignature sig,
                          bool lhsBaseIsProtocolSelf = false);
 
+  /// Append an inverse requirement into the mangling.
+  ///
+  /// Instead of mangling the presence of an invertible protocol, we mangle
+  /// their absence, which is what an inverse represents.
+  ///
+  /// \param req The inverse requirement to mangle.
+  void appendInverseRequirement(const InverseRequirement &req,
+                                GenericSignature sig,
+                                bool lhsBaseIsProtocolSelf = false);
+
   void appendGenericSignatureParts(GenericSignature sig,
                                    ArrayRef<CanTypeWrapper<GenericTypeParamType>> params,
                                    unsigned initialParamDepth,
-                                   ArrayRef<Requirement> requirements);
+                                   ArrayRef<Requirement> requirements,
+                                   ArrayRef<InverseRequirement> inverseRequirements);
 
   DependentMemberType *dropProtocolFromAssociatedType(DependentMemberType *dmt,
                                                       GenericSignature sig);

include/swift/AST/Decl.h

@@ -1856,6 +1856,10 @@ class ExtensionDecl final : public GenericContext, public Decl,
   /// resiliently moved into the original protocol itself.
   bool isEquivalentToExtendedContext() const;
 
+  /// Determine whether this extension context is in the same defining module as
+  /// the original nominal type context.
+  bool isInSameDefiningModule() const;
+
   /// Returns the name of the category specified by the \c \@_objcImplementation
   /// attribute, or \c None if the name is invalid or
   /// \c isObjCImplementation() is false.

include/swift/AST/DeclAttr.def

@@ -488,7 +488,10 @@ SIMPLE_DECL_ATTR(_noObjCBridging, NoObjCBridging,
 DECL_ATTR(_distributedThunkTarget, DistributedThunkTarget,
   OnAbstractFunction | UserInaccessible | ABIStableToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   156)
-LAST_DECL_ATTR(DistributedThunkTarget)
+SIMPLE_DECL_ATTR(_preInverseGenerics, PreInverseGenerics,
+  OnAbstractFunction | OnSubscript | OnVar | UserInaccessible | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
+  157)
+LAST_DECL_ATTR(PreInverseGenerics)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/GenericSignature.h

@@ -479,6 +479,16 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Utility wrapper for use when this is an opened existential signature.
   Type getExistentialType(Type type) const;
 
+  /// Determines if this generic signature is the complete opposite of a generic
+  /// signature with inverse requirements.
+  ///
+  /// Given the following 'other' signature (this assumes Equatable: ~Copyable):
+  ///   <T: ~Copyable & Equatable, U: ~Copyable, V: Copyable>
+  /// returns true iff our generic signature is:
+  ///   <T: Copyable & Equatable, U: Copyable, V: Copyable>
+  bool areAllRequirementsPositiveInverseRequirementsSatisfying(
+                                                  GenericSignature other) const;
+
   static void Profile(llvm::FoldingSetNodeID &ID,
                       ArrayRef<GenericTypeParamType *> genericParams,
                       ArrayRef<Requirement> requirements);
@@ -560,11 +570,11 @@ void validateGenericSignaturesInModule(ModuleDecl *module);
 /// required to be minimal or canonical, and may contain unresolved
 /// DependentMemberTypes.
 ///
-/// If \p baseSignature is non-null, the new parameters and requirements
-/// are added on; existing requirements of the base signature might become
-/// redundant.
-///
-/// If \p baseSignature is null, build a new signature from scratch.
+/// \param baseSignature if non-null, the new parameters and requirements
+///// are added on; existing requirements of the base signature might become
+///// redundant. Otherwise if null, build a new signature from scratch.
+/// \param allowInverses if true, default requirements to Copyable/Escapable are
+/// expanded for generic parameters.
 GenericSignature buildGenericSignature(
     ASTContext &ctx,
     GenericSignature baseSignature,

include/swift/AST/Requirement.h

@@ -251,6 +251,9 @@ struct InverseRequirement {
 
   InvertibleProtocolKind getKind() const;
 
+  /// Linear order on inverse requirements in a generic signature.
+  int compare(const InverseRequirement &other) const;
+
   /// Appends additional requirements corresponding to defaults for the given
   /// generic parameters.
   static void expandDefaults(ASTContext &ctx,

include/swift/AST/Types.h

@@ -6007,6 +6007,7 @@ class ProtocolCompositionType final : public TypeBase,
   }
 
   InvertibleProtocolSet getInverses() const { return Inverses; }
+  bool hasInverse() const { return !Inverses.empty(); }
 
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getMembers(), getInverses(), hasExplicitAnyObject());

include/swift/Demangling/DemangleNodes.def

@@ -396,5 +396,7 @@ NODE(OutlinedAssignWithTakeNoValueWitness)
 NODE(OutlinedAssignWithCopyNoValueWitness)
 NODE(OutlinedDestroyNoValueWitness)
 
+NODE(DependentGenericInverseConformanceRequirement)
+
 #undef CONTEXT_NODE
 #undef NODE

include/swift/Demangling/TypeDecoder.h

@@ -448,8 +448,14 @@ void decodeRequirement(NodePointer node,
           child->getChild(1), /*forRequirement=*/false);
       if (!constraintType)
         return;
+    } else if (child->getKind() ==
+          Demangle::Node::Kind::DependentGenericInverseConformanceRequirement) {
+      // FIXME(kavon): this is unimplemented! We should build a PCT here with
+      //               the inverse in it.
+      return;
     }
 
+
     switch (child->getKind()) {
     case Demangle::Node::Kind::DependentGenericConformanceRequirement: {
       requirements.push_back(BuiltRequirement(