[GSB] Teach requirement inference to use SubstitutionMaps.

The ad hoc substitution functions here were really odd; use
SubstitutionMap directly, and pass it through to
GenericSignatureBuilder::addRequirement().

Author: DougGregor

include/swift/AST/GenericSignatureBuilder.h

@@ -373,7 +373,7 @@ class GenericSignatureBuilder {
   /// where \c Dictionary requires that its key type be \c Hashable,
   /// the requirement \c K : Hashable is inferred from the parameter type,
   /// because the type \c Dictionary<K,V> cannot be formed without it.
-  void inferRequirements(TypeLoc type);
+  void inferRequirements(ModuleDecl &module, TypeLoc type);
 
   /// Infer requirements from the given pattern, recursively.
   ///
@@ -387,7 +387,8 @@ class GenericSignatureBuilder {
   /// where \c Dictionary requires that its key type be \c Hashable,
   /// the requirement \c K : Hashable is inferred from the parameter type,
   /// because the type \c Dictionary<K,V> cannot be formed without it.
-  void inferRequirements(ParameterList *params,GenericParamList *genericParams);
+  void inferRequirements(ModuleDecl &module, ParameterList *params,
+                         GenericParamList *genericParams);
 
   /// Finalize the set of requirements, performing any remaining checking
   /// required before generating archetypes.

lib/AST/GenericSignatureBuilder.cpp

@@ -2586,13 +2586,15 @@ bool GenericSignatureBuilder::addRequirement(
 
 /// AST walker that infers requirements from type representations.
 class GenericSignatureBuilder::InferRequirementsWalker : public TypeWalker {
+  ModuleDecl &module;
   GenericSignatureBuilder &Builder;
   TypeRepr *typeRepr;
 
 public:
-  InferRequirementsWalker(GenericSignatureBuilder &builder,
+  InferRequirementsWalker(ModuleDecl &module,
+                          GenericSignatureBuilder &builder,
                           TypeRepr *typeRepr)
-    : Builder(builder), typeRepr(typeRepr) { }
+    : module(module), Builder(builder), typeRepr(typeRepr) { }
 
   Action walkToTypePost(Type ty) override {
     auto boundGeneric = ty->getAs<BoundGenericType>();
@@ -2603,49 +2605,39 @@ class GenericSignatureBuilder::InferRequirementsWalker : public TypeWalker {
     if (!genericSig)
       return Action::Stop;
 
-    /// Retrieves the type substitution.
-    auto args = boundGeneric->getGenericArgs();
-    auto genericSigDepth =
-      genericSig->getInnermostGenericParams().front()->getDepth();
-    auto getTypeSubstitution = [&](SubstitutableType *dependentType) -> Type {
-      if (auto gp = dyn_cast<GenericTypeParamType>(dependentType)) {
-        if (gp->getDepth() == genericSigDepth)
-          return args[gp->getIndex()];
-
-        return gp;
-      }
-
-      return dependentType;
-    };
+    /// Retrieve the substitution.
+    auto allSubs = boundGeneric->gatherAllSubstitutions(&module, nullptr);
+    auto subMap = genericSig->getSubstitutionMap(allSubs);
 
     // Handle the requirements.
     // FIXME: Inaccurate TypeReprs.
     auto source = FloatingRequirementSource::forInferred(typeRepr);
-    for (const auto &rawReq : genericSig->getRequirements()) {
-      if (auto req = rawReq.subst(getTypeSubstitution,
-                                  Builder.getLookupConformanceFn()))
-        Builder.addRequirement(*req, source);
+    for (const auto &req : genericSig->getRequirements()) {
+      Builder.addRequirement(req, source, &subMap);
     }
 
     return Action::Continue;
   }
 };
 
-void GenericSignatureBuilder::inferRequirements(TypeLoc type) {
+void GenericSignatureBuilder::inferRequirements(ModuleDecl &module,
+                                                TypeLoc type) {
   if (!type.getType())
     return;
   // FIXME: Crummy source-location information.
-  InferRequirementsWalker walker(*this, type.getTypeRepr());
+  InferRequirementsWalker walker(module, *this, type.getTypeRepr());
   type.getType().walk(walker);
 }
 
-void GenericSignatureBuilder::inferRequirements(ParameterList *params,
-                                         GenericParamList *genericParams) {
+void GenericSignatureBuilder::inferRequirements(
+                                          ModuleDecl &module,
+                                          ParameterList *params,
+                                          GenericParamList *genericParams) {
   if (genericParams == nullptr)
     return;
 
   for (auto P : *params)
-    inferRequirements(P->getTypeLoc());
+    inferRequirements(module, P->getTypeLoc());
 }
 
 /// Perform typo correction on the given nested type, producing the

lib/Sema/TypeCheckDecl.cpp

@@ -7464,7 +7464,8 @@ checkExtensionGenericParams(TypeChecker &tc, ExtensionDecl *ext, Type type,
 
   // Local function used to infer requirements from the extended type.
   auto inferExtendedTypeReqs = [&](GenericSignatureBuilder &builder) {
-    builder.inferRequirements(TypeLoc::withoutLoc(extInterfaceType));
+    builder.inferRequirements(*ext->getModuleContext(),
+                              TypeLoc::withoutLoc(extInterfaceType));
   };
 
   // Validate the generic type signature.

lib/Sema/TypeCheckGeneric.cpp

@@ -323,7 +323,7 @@ void TypeChecker::checkGenericParamList(GenericSignatureBuilder *builder,
 
       // Infer requirements from the inherited types.
       for (const auto &inherited : param->getInherited()) {
-        builder->inferRequirements(inherited);
+        builder->inferRequirements(*lookupDC->getParentModule(), inherited);
       }
     }
   }
@@ -508,7 +508,8 @@ static bool checkGenericFuncSignature(TypeChecker &tc,
 
     // Infer requirements from the pattern.
     if (builder) {
-      builder->inferRequirements(params, genericParams);
+      builder->inferRequirements(*func->getParentModule(), params,
+                                 genericParams);
     }
   }
 
@@ -527,7 +528,8 @@ static bool checkGenericFuncSignature(TypeChecker &tc,
       // Infer requirements from it.
       if (builder && genericParams &&
           fn->getBodyResultTypeLoc().getTypeRepr()) {
-        builder->inferRequirements(fn->getBodyResultTypeLoc());
+        builder->inferRequirements(*func->getParentModule(),
+                                   fn->getBodyResultTypeLoc());
       }
     }
   }
@@ -863,7 +865,8 @@ static bool checkGenericSubscriptSignature(TypeChecker &tc,
   // Infer requirements from it.
   if (genericParams && builder &&
       subscript->getElementTypeLoc().getTypeRepr()) {
-    builder->inferRequirements(subscript->getElementTypeLoc());
+    builder->inferRequirements(*subscript->getParentModule(),
+                               subscript->getElementTypeLoc());
   }
 
   // Check the indices.
@@ -875,7 +878,8 @@ static bool checkGenericSubscriptSignature(TypeChecker &tc,
 
   // Infer requirements from the pattern.
   if (builder)
-    builder->inferRequirements(params, genericParams);
+    builder->inferRequirements(*subscript->getParentModule(), params,
+                               genericParams);
 
   return badType;
 }