Merge pull request #74998 from slavapestov/global-conformance-lookup

AST: Stop pretending that conformance lookup takes the module into account

Author: slavapestov

include/swift/AST/DistributedDecl.h

@@ -118,7 +118,7 @@ getDistributedActorAsActorConformanceRef(ASTContext &C);
 /// the DistributedActor-as-Actor conformance.
 ExtensionDecl *
 findDistributedActorAsActorExtension(
-    ProtocolDecl *distributedActorProto, ModuleDecl *module);
+    ProtocolDecl *distributedActorProto);
 
 bool isDistributedActorAsLocalActorComputedProperty(VarDecl *var);
 

include/swift/AST/GenericSignature.h

@@ -322,12 +322,6 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
       SmallVector<Requirement, 2> &reqs,
       SmallVector<InverseRequirement, 2> &inverses) const;
 
-  /// Look up a stored conformance in the generic signature. These are formed
-  /// from same-type constraints placed on associated types of generic
-  /// parameters which have conformance constraints on them.
-  ProtocolConformanceRef lookupConformance(CanType depTy,
-                                           ProtocolDecl *proto) const;
-
   /// Iterate over all generic parameters, passing a flag to the callback
   /// indicating if the generic parameter is canonical or not.
   void forEachParam(

include/swift/AST/Module.h

@@ -886,8 +886,8 @@ class ModuleDecl
   ///
   /// \returns An invalid conformance if the search failed, otherwise an
   /// abstract, concrete or pack conformance, depending on the lookup type.
-  ProtocolConformanceRef lookupConformance(Type type, ProtocolDecl *protocol,
-                                           bool allowMissing = false);
+  static ProtocolConformanceRef lookupConformance(Type type, ProtocolDecl *protocol,
+                                                  bool allowMissing = false);
 
   /// Global conformance lookup, checks conditional requirements.
   /// Requires a contextualized type.
@@ -903,9 +903,10 @@ class ModuleDecl
   ///
   /// \returns An invalid conformance if the search failed, otherwise an
   /// abstract, concrete or pack conformance, depending on the lookup type.
-  ProtocolConformanceRef checkConformance(Type type, ProtocolDecl *protocol,
-                              // Note: different default from lookupConformance
-                              bool allowMissing = true);
+  static ProtocolConformanceRef checkConformance(Type type, ProtocolDecl *protocol,
+                                                 // Note: different default from
+                                                 // lookupConformance
+                                                 bool allowMissing = true);
 
   /// Global conformance lookup, checks conditional requirements.
   /// Accepts interface types without context. If the conformance cannot be
@@ -925,22 +926,23 @@ class ModuleDecl
   /// if the search succeeded. `std::nullopt` if the type could have
   /// conditionally conformed depending on the context of the interface types.
   std::optional<ProtocolConformanceRef>
-  checkConformanceWithoutContext(Type type,
-                                 ProtocolDecl *protocol,
-                                 // Note: different default from lookupConformance
-                                 bool allowMissing = true);
+  static checkConformanceWithoutContext(Type type,
+                                        ProtocolDecl *protocol,
+                                        // Note: different default from
+                                        // lookupConformance
+                                        bool allowMissing = true);
 
 
   /// Look for the conformance of the given existential type to the given
   /// protocol.
-  ProtocolConformanceRef lookupExistentialConformance(Type type,
-                                                      ProtocolDecl *protocol);
+  static ProtocolConformanceRef lookupExistentialConformance(Type type,
+                                                             ProtocolDecl *protocol);
 
   /// Collect the conformances of \c fromType to each of the protocols of an
   /// existential type's layout.
   ArrayRef<ProtocolConformanceRef>
-  collectExistentialConformances(CanType fromType, CanType existential,
-                                 bool allowMissing = false);
+  static collectExistentialConformances(CanType fromType, CanType existential,
+                                        bool allowMissing = false);
 
   /// Find a member named \p name in \p container that was declared in this
   /// module.

include/swift/AST/NameLookupRequests.h

@@ -732,21 +732,18 @@ class DirectPrecedenceGroupLookupRequest
 
 class LookupConformanceDescriptor final {
 public:
-  ModuleDecl *Mod;
   Type Ty;
   ProtocolDecl *PD;
 
-  LookupConformanceDescriptor(ModuleDecl *Mod, Type Ty, ProtocolDecl *PD)
-      : Mod(Mod), Ty(Ty), PD(PD) {}
+  LookupConformanceDescriptor(Type Ty, ProtocolDecl *PD) : Ty(Ty), PD(PD) {}
 
   friend llvm::hash_code hash_value(const LookupConformanceDescriptor &desc) {
-    return llvm::hash_combine(desc.Mod, desc.Ty.getPointer(), desc.PD);
+    return llvm::hash_combine(desc.Ty.getPointer(), desc.PD);
   }
 
   friend bool operator==(const LookupConformanceDescriptor &lhs,
                          const LookupConformanceDescriptor &rhs) {
-    return lhs.Mod == rhs.Mod && lhs.Ty.getPointer() == rhs.Ty.getPointer() &&
-           lhs.PD == rhs.PD;
+    return lhs.Ty.getPointer() == rhs.Ty.getPointer() && lhs.PD == rhs.PD;
   }
 
   friend bool operator!=(const LookupConformanceDescriptor &lhs,

include/swift/AST/Requirement.h

@@ -241,8 +241,7 @@ checkRequirementsWithoutContext(ArrayRef<Requirement> requirements);
 /// Check if each requirement is satisfied after applying the given
 /// substitutions. The substitutions must replace all type parameters that
 /// appear in the requirement with concrete types or archetypes.
-CheckRequirementsResult checkRequirements(ModuleDecl *module,
-                                          ArrayRef<Requirement> requirements,
+CheckRequirementsResult checkRequirements(ArrayRef<Requirement> requirements,
                                           TypeSubstitutionFn substitutions,
                                           SubstOptions options = std::nullopt);
 

include/swift/AST/Type.h

@@ -97,10 +97,8 @@ using LookupConformanceFn = llvm::function_ref<GenericFunction>;
 /// Functor class suitable for use as a \c LookupConformanceFn to look up a
 /// conformance through a module.
 class LookUpConformanceInModule {
-  ModuleDecl *M;
 public:
-  explicit LookUpConformanceInModule(ModuleDecl *M)
-    : M(M) {}
+  explicit LookUpConformanceInModule() {}
 
   ProtocolConformanceRef operator()(CanType dependentType,
                                     Type conformingReplacementType,
@@ -116,21 +114,6 @@ class MakeAbstractConformanceForGenericType {
                                     Type conformingReplacementType,
                                     ProtocolDecl *conformedProtocol) const;
 };
-
-/// Functor class suitable for use as a \c LookupConformanceFn that fetches
-/// conformances from a generic signature.
-class LookUpConformanceInSignature {
-  const GenericSignatureImpl *Sig;
-public:
-  LookUpConformanceInSignature(const GenericSignatureImpl *Sig)
-    : Sig(Sig) {
-      assert(Sig && "Cannot lookup conformance in null signature!");
-    }
-
-    ProtocolConformanceRef operator()(CanType dependentType,
-                                      Type conformingReplacementType,
-                                      ProtocolDecl *conformedProtocol) const;
-};
 
 /// Flags that can be passed when substituting into a type.
 enum class SubstFlags {

include/swift/AST/Types.h

@@ -1309,8 +1309,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// \param genericEnv If non-null and the type is nested inside of a
   /// generic function, generic parameters of the outer context are
   /// mapped to context archetypes of this generic environment.
-  SubstitutionMap getContextSubstitutionMap(ModuleDecl *module,
-                                            const DeclContext *dc,
+  SubstitutionMap getContextSubstitutionMap(const DeclContext *dc,
                                             GenericEnvironment *genericEnv=nullptr);
 
   /// Deprecated version of the above.
@@ -1322,8 +1321,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
   ///
   /// \param genericEnv If non-null, generic parameters of the member are
   /// mapped to context archetypes of this generic environment.
-  SubstitutionMap getMemberSubstitutionMap(ModuleDecl *module,
-                                           const ValueDecl *member,
+  SubstitutionMap getMemberSubstitutionMap(const ValueDecl *member,
                                            GenericEnvironment *genericEnv=nullptr);
 
   /// Deprecated version of the above.
@@ -1340,7 +1338,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// \param member The property whose type we are substituting.
   ///
   /// \returns The resulting property type.
-  Type getTypeOfMember(ModuleDecl *module, const VarDecl *member);
+  Type getTypeOfMember(const VarDecl *member);
 
   /// Retrieve the type of the given member as seen through the given base
   /// type, substituting generic arguments where necessary.
@@ -1371,8 +1369,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// method's generic parameters.
   ///
   /// \returns The resulting member type.
-  Type getTypeOfMember(ModuleDecl *module, const ValueDecl *member,
-                       Type memberType);
+  Type getTypeOfMember(const ValueDecl *member, Type memberType);
 
   /// Get the type of a superclass member as seen from the subclass,
   /// substituting generic parameters, dynamic Self return, and the
@@ -7075,7 +7072,7 @@ class DependentMemberType : public TypeBase {
   /// Substitute the base type, looking up our associated type in it if it is
   /// non-dependent. Returns null if the member could not be found in the new
   /// base.
-  Type substBaseType(ModuleDecl *M, Type base);
+  Type substBaseType(Type base);
 
   /// Substitute the base type, looking up our associated type in it if it is
   /// non-dependent. Returns null if the member could not be found in the new

include/swift/SIL/DynamicCasts.h

@@ -109,14 +109,14 @@ void emitIndirectConditionalCastWithScalar(
     ProfileCounter FalseCount = ProfileCounter());
 
 /// Does the type conform to the _ObjectiveCBridgeable protocol.
-bool isObjectiveCBridgeable(ModuleDecl *M, CanType Ty);
+bool isObjectiveCBridgeable(CanType Ty);
 
 /// Get the bridged NS class of a CF class if it exists. Returns
 /// an empty CanType if such class does not exist.
-CanType getNSBridgedClassOfCFClass(ModuleDecl *M, CanType type);
+CanType getNSBridgedClassOfCFClass(CanType type);
 
 /// Does the type conform to Error.
-bool isError(ModuleDecl *M, CanType Ty);
+bool isError(CanType Ty);
 
 struct SILDynamicCastKind {
   enum innerty : std::underlying_type<SILInstructionKind>::type {

include/swift/SIL/SILCloner.h

@@ -50,7 +50,7 @@ struct SubstitutionMapWithLocalArchetypes {
                                     Type substType,
                                     ProtocolDecl *proto) {
     if (isa<LocalArchetypeType>(origType))
-      return proto->getParentModule()->lookupConformance(substType, proto);
+      return ModuleDecl::lookupConformance(substType, proto);
     if (SubsMap)
       return SubsMap->lookupConformance(origType, proto);
 

include/swift/SIL/TypeSubstCloner.h

@@ -331,7 +331,7 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
                 remappedOrigFnType->getDifferentiabilityResultIndices(),
                 dfei->getDerivativeFunctionKind(),
                 getBuilder().getModule().Types,
-                LookUpConformanceInModule(SwiftMod))
+                LookUpConformanceInModule())
             ->getWithoutDifferentiability();
     SILType remappedDerivativeFnType = getOpType(dfei->getType());
     // If remapped derivative type and derivative remapped type are equal, do