Sema: Remove TypeChecker::LookUpConformance in favor of LookUpConformanceInModule

Calling TypeChecker::conformsToProtocol() with SkipConditionalRequirements
and an invalid SourceLoc() is now the same as calling
ModuleDecl::lookupConformance(), so we can replace all usages of
TypeChecker::LookUpConformance with LookUpConformanceInModule.

Author: slavapestov

lib/Sema/CSApply.cpp

@@ -414,7 +414,7 @@ namespace {
 
       return SubstitutionMap::get(sig,
                                   QueryTypeSubstitutionMap{subs},
-                                  TypeChecker::LookUpConformance(cs.DC));
+                                  LookUpConformanceInModule(cs.DC->getParentModule()));
     }
 
   public:

lib/Sema/TypeCheckAttr.cpp

@@ -2687,15 +2687,15 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
 
           return getSubstitution(type);
         },
-        TypeChecker::LookUpConformance(dc));
+        LookUpConformanceInModule(dc->getParentModule()));
 
     // Use invalid 'SourceLoc's to suppress diagnostics.
     auto result = TypeChecker::checkGenericArguments(
           protocol, SourceLoc(), SourceLoc(), typeEraser,
           genericSignature->getGenericParams(),
           genericSignature->getRequirements(),
           QuerySubstitutionMap{subMap},
-          TypeChecker::LookUpConformance(dc));
+          LookUpConformanceInModule(dc->getParentModule()));
 
     if (result != RequirementCheckResult::Success) {
       unviable.push_back(

lib/Sema/TypeCheckProtocol.cpp

@@ -3956,7 +3956,7 @@ void ConformanceChecker::ensureRequirementsAreSatisfied() {
       { proto->getSelfInterfaceType() },
       proto->getRequirementSignature(),
       QuerySubstitutionMap{substitutions},
-      TypeChecker::LookUpConformance(DC),
+      LookUpConformanceInModule(DC->getParentModule()),
       &listener);
 
   switch (result) {
@@ -4435,7 +4435,7 @@ TypeChecker::conformsToProtocol(Type T, ProtocolDecl *Proto, DeclContext *DC,
         DC, ComplainLoc, noteLoc, T,
         {lookupResult.getRequirement()->getSelfInterfaceType()}, *condReqs,
         [](SubstitutableType *dependentType) { return Type(dependentType); },
-        LookUpConformance(DC));
+        LookUpConformanceInModule(M));
     switch (conditionalCheckResult) {
     case RequirementCheckResult::Success:
       break;
@@ -4449,38 +4449,14 @@ TypeChecker::conformsToProtocol(Type T, ProtocolDecl *Proto, DeclContext *DC,
   return lookupResult;
 }
 
-// Exposes TypeChecker functionality for querying protocol conformance.
-//
-// Invoking TypeChecker::conformsToProtocol from the ModuleDecl bypasses
-// certain functionality that only applies to the diagnostic type checker:
-//
-// - ConformanceCheckFlags skips dependence checking.
-//
-// - Passing an invalid SourceLoc skips diagnostics.
-//
-// - Type::subst will be a nop, because 'source' type is already fully
-// substituted in SIL. Consequently, TypeChecker::LookUpConformance, which
-// is only valid during type checking, will never be invoked.
-//
-// - mapTypeIntoContext will be a nop.
+/// Exposes TypeChecker functionality for querying protocol conformance.
+/// Returns a valid ProtocolConformanceRef only if all conditional
+/// requirements are successfully resolved.
 ProtocolConformanceRef
 ModuleDecl::conformsToProtocol(Type sourceTy, ProtocolDecl *targetProtocol) {
   return TypeChecker::conformsToProtocol(sourceTy, targetProtocol, this, None);
 }
 
-ProtocolConformanceRef TypeChecker::LookUpConformance::
-operator()(CanType dependentType, Type conformingReplacementType,
-           ProtocolDecl *conformedProtocol) const {
-  if (conformingReplacementType->isTypeParameter())
-    return ProtocolConformanceRef(conformedProtocol);
-
-  return TypeChecker::conformsToProtocol(
-                         conformingReplacementType,
-                         conformedProtocol,
-                         dc,
-                         ConformanceCheckFlags::SkipConditionalRequirements);
-}
-
 void TypeChecker::checkConformance(NormalProtocolConformance *conformance) {
   MultiConformanceChecker checker(conformance->getProtocol()->getASTContext());
   checker.addConformance(conformance);

lib/Sema/TypeCheckProtocolInference.cpp

@@ -1097,7 +1097,7 @@ bool AssociatedTypeInference::checkCurrentTypeWitnesses(
                                        { proto->getSelfInterfaceType() },
                                        sanitizedRequirements,
                                        QuerySubstitutionMap{substitutions},
-                                       TypeChecker::LookUpConformance(dc),
+                                       LookUpConformanceInModule(dc->getParentModule()),
                                        nullptr, options);
   switch (result) {
   case RequirementCheckResult::Failure:

lib/Sema/TypeCheckType.cpp

@@ -675,7 +675,7 @@ static Type checkContextualRequirements(Type type,
         genericSig->getGenericParams(),
         genericSig->getRequirements(),
         QueryTypeSubstitutionMap{subMap},
-        TypeChecker::LookUpConformance(dc));
+        LookUpConformanceInModule(dc->getParentModule()));
 
   switch (result) {
   case RequirementCheckResult::Failure:
@@ -906,14 +906,16 @@ Type TypeChecker::applyUnboundGenericArguments(
   // Check the generic arguments against the requirements of the declaration's
   // generic signature.
   auto dc = resolution.getDeclContext();
+  auto *module = dc->getParentModule();
+
   if (!skipRequirementsCheck &&
       resolution.getStage() > TypeResolutionStage::Structural) {
     auto result =
       checkGenericArguments(dc, loc, noteLoc, unboundType,
                             genericSig->getGenericParams(),
                             genericSig->getRequirements(),
                             QueryTypeSubstitutionMap{subs},
-                            LookUpConformance(dc));
+                            LookUpConformanceInModule(module));
 
     switch (result) {
     case RequirementCheckResult::Failure:
@@ -933,15 +935,15 @@ Type TypeChecker::applyUnboundGenericArguments(
 
   // Apply the substitution map to the interface type of the declaration.
   resultType = resultType.subst(QueryTypeSubstitutionMap{subs},
-                                LookUpConformance(dc));
+                                LookUpConformanceInModule(module));
 
   // Form a sugared typealias reference.
   Type parentType = unboundType->getParent();
   if (typealias && (!parentType || !parentType->isAnyExistentialType())) {
     auto genericSig = typealias->getGenericSignature();
     auto subMap = SubstitutionMap::get(genericSig,
                                        QueryTypeSubstitutionMap{subs},
-                                       LookUpConformance(dc));
+                                       LookUpConformanceInModule(module));
     resultType = TypeAliasType::get(typealias, parentType,
                                     subMap, resultType);
   }
@@ -2858,7 +2860,7 @@ Type TypeResolver::resolveSILBoxType(SILBoxTypeRepr *repr,
     subMap = SubstitutionMap::get(
       genericSig,
       QueryTypeSubstitutionMap{genericArgMap},
-      TypeChecker::LookUpConformance(DC));
+      LookUpConformanceInModule(DC->getParentModule()));
   }
 
   auto layout = SILLayout::get(Context, genericSig, fields);
@@ -2949,7 +2951,7 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
       subsMap.insert({params[i], resolved->getCanonicalType()});
     }
     return SubstitutionMap::get(sig, QueryTypeSubstitutionMap{subsMap},
-                                TypeChecker::LookUpConformance(DC))
+                                LookUpConformanceInModule(DC->getParentModule()))
       .getCanonical();
   };
 

lib/Sema/TypeChecker.h

@@ -954,19 +954,6 @@ ProtocolConformanceRef conformsToProtocol(Type T, ProtocolDecl *Proto,
                                           ConformanceCheckOptions options,
                                           SourceLoc ComplainLoc = SourceLoc());
 
-/// Functor class suitable for use as a \c LookupConformanceFn to look up a
-/// conformance through a particular declaration context.
-class LookUpConformance {
-  DeclContext *dc;
-
-public:
-  explicit LookUpConformance(DeclContext *dc) : dc(dc) {}
-
-  ProtocolConformanceRef operator()(CanType dependentType,
-                                    Type conformingReplacementType,
-                                    ProtocolDecl *conformedProtocol) const;
-  };
-
   /// Completely check the given conformance.
   void checkConformance(NormalProtocolConformance *conformance);