Merge pull request #6315 from jckarter/subst-generic-args

Provide callback-based variants of *FunctionType::substGenericArgs.

Author: jckarter

include/swift/AST/Types.h

@@ -2580,6 +2580,12 @@ class GenericFunctionType : public AnyFunctionType,
   ///
   /// The order of Substitutions must match the order of generic parameters.
   FunctionType *substGenericArgs(ArrayRef<Substitution> subs);
+  
+  /// Substitute the given generic arguments into this generic
+  /// function type using the given substitution and conformance lookup
+  /// callbacks.
+  FunctionType *substGenericArgs(TypeSubstitutionFn subs,
+                                 LookupConformanceFn conformances);
 
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getGenericSignature(), getInput(), getResult(),
@@ -3295,6 +3301,9 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
 
   CanSILFunctionType substGenericArgs(SILModule &silModule,
                                       ArrayRef<Substitution> subs);
+  CanSILFunctionType substGenericArgs(SILModule &silModule,
+                                      TypeSubstitutionFn subs,
+                                      LookupConformanceFn conformances);
 
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getGenericSignature(), getExtInfo(), getCalleeConvention(),

lib/AST/Type.cpp

@@ -2765,16 +2765,21 @@ Type ProtocolCompositionType::get(const ASTContext &C,
 
 FunctionType *
 GenericFunctionType::substGenericArgs(ArrayRef<Substitution> args) {
-  auto params = getGenericParams();
-  (void)params;
-  
   auto subs = getGenericSignature()->getSubstitutionMap(args);
 
   Type input = getInput().subst(subs);
   Type result = getResult().subst(subs);
   return FunctionType::get(input, result, getExtInfo());
 }
 
+FunctionType *
+GenericFunctionType::substGenericArgs(TypeSubstitutionFn subs,
+                                      LookupConformanceFn conformances) {
+  Type input = getInput().subst(subs, conformances);
+  Type result = getResult().subst(subs, conformances);
+  return FunctionType::get(input, result, getExtInfo());
+}
+
 static Type getMemberForBaseType(LookupConformanceFn lookupConformances,
                                  Type origBase,
                                  Type substBase,

lib/SIL/SILFunctionType.cpp

@@ -2097,13 +2097,29 @@ namespace {
   class SILTypeSubstituter :
       public CanTypeVisitor<SILTypeSubstituter, CanType> {
     SILModule &TheSILModule;
-    const SubstitutionMap &Subs;
+    // Order dependency - Context must initialize before Subst and Conformances
+    Optional<std::pair<QueryTypeSubstitutionMap,
+                       LookUpConformanceInSubstitutionMap>> Context;
+    TypeSubstitutionFn Subst;
+    LookupConformanceFn Conformances;
 
     ASTContext &getASTContext() { return TheSILModule.getASTContext(); }
 
   public:
     SILTypeSubstituter(SILModule &silModule, const SubstitutionMap &subs)
-      : TheSILModule(silModule), Subs(subs)
+      : TheSILModule(silModule),
+        Context({QueryTypeSubstitutionMap{subs.getMap()},
+                 LookUpConformanceInSubstitutionMap(subs)}),
+        Subst(Context->first),
+        Conformances(Context->second)
+    {}
+
+    SILTypeSubstituter(SILModule &silModule,
+                       TypeSubstitutionFn Subst,
+                       LookupConformanceFn Conformances)
+      : TheSILModule(silModule),
+        Subst(Subst),
+        Conformances(Conformances)
     {}
 
     // SIL type lowering only does special things to tuples and functions.
@@ -2242,7 +2258,7 @@ namespace {
                .getSwiftRValueType() == origType);
 
       CanType substType =
-        origType.subst(Subs, None)->getCanonicalType();
+        origType.subst(Subst, Conformances, None)->getCanonicalType();
 
       // If the substitution didn't change anything, we know that the
       // original type was a lowered type, so we're good.
@@ -2288,6 +2304,16 @@ SILFunctionType::substGenericArgs(SILModule &silModule,
                                           /*dropGenerics*/ true);
 }
 
+CanSILFunctionType
+SILFunctionType::substGenericArgs(SILModule &silModule,
+                                  TypeSubstitutionFn subs,
+                                  LookupConformanceFn conformances) {
+  if (!isPolymorphic()) return CanSILFunctionType(this);
+  SILTypeSubstituter substituter(silModule, subs, conformances);
+  return substituter.visitSILFunctionType(CanSILFunctionType(this),
+                                          /*dropGenerics*/ true);
+}
+
 /// Fast path for bridging types in a function type without uncurrying.
 CanAnyFunctionType
 TypeConverter::getBridgedFunctionType(AbstractionPattern pattern,