[SILGen] Get keypath emission logic off Substitution.

Author: DougGregor

lib/SILGen/SILGenExpr.cpp

@@ -3651,16 +3651,19 @@ getOrCreateKeyPathEqualsAndHash(SILGenModule &SGM,
         hashable = hashable.subst(index.FormalType,
           [&](Type t) -> Type { return genericEnv->mapTypeIntoContext(t); },
           LookUpConformanceInSignature(*genericSig));
+      }
 
+      if (auto genericSig =
+              hashTy.castTo<SILFunctionType>()->getGenericSignature()) {
         hashableSubsMap =
-            genericEnv->getGenericSignature()->getSubstitutionMap(
+            genericSig->getSubstitutionMap(
               [&](SubstitutableType *type) -> Type { return formalTy; },
               [&](CanType dependentType, Type replacementType,
                   ProtocolType *protoType)->Optional<ProtocolConformanceRef> {
                 return hashable;
               });
       }
-      
+
       auto hashWitness = subSGF.B.createWitnessMethod(loc,
         formalTy, hashable,
         hashRef, hashTy);
@@ -4117,25 +4120,25 @@ visitKeyPathApplicationExpr(KeyPathApplicationExpr *E, SGFContext C) {
 
   auto keyPathDecl = E->getKeyPath()->getType()->getAnyNominal();
   FuncDecl *projectFn;
-  SmallVector<Substitution, 4> subs;
-  
+
+  SmallVector<Type, 2> replacementTypes;
   if (keyPathDecl == SGF.getASTContext().getAnyKeyPathDecl()) {
     // Invoke projectKeyPathAny with the type of the base value.
     // The result is always `Any?`.
     projectFn = SGF.getASTContext().getProjectKeyPathAny(nullptr);
-    subs.push_back(Substitution(E->getBase()->getType(), {}));
+    replacementTypes.push_back(E->getBase()->getType());
   } else {
     auto keyPathTy = E->getKeyPath()->getType()->castTo<BoundGenericType>();
     if (keyPathDecl == SGF.getASTContext().getPartialKeyPathDecl()) {
       // Invoke projectKeyPathPartial with the type of the base value.
       // The result is always `Any`.
       projectFn = SGF.getASTContext().getProjectKeyPathPartial(nullptr);
-      subs.push_back(Substitution(keyPathTy->getGenericArgs()[0], {}));
+      replacementTypes.push_back(keyPathTy->getGenericArgs()[0]);
     } else {
       projectFn = SGF.getASTContext().getProjectKeyPathReadOnly(nullptr);
       // Get the root and leaf type from the key path type.
-      subs.push_back(Substitution(keyPathTy->getGenericArgs()[0], {}));
-      subs.push_back(Substitution(keyPathTy->getGenericArgs()[1], {}));
+      replacementTypes.push_back(keyPathTy->getGenericArgs()[0]);
+      replacementTypes.push_back(keyPathTy->getGenericArgs()[1]);
 
       // Upcast the keypath to KeyPath<T, U> if it isn't already.
       if (keyPathTy->getDecl() != SGF.getASTContext().getKeyPathDecl()) {
@@ -4150,8 +4153,15 @@ visitKeyPathApplicationExpr(KeyPathApplicationExpr *E, SGFContext C) {
     }
   }
 
-  auto genericArgsMap =
-    projectFn->getGenericSignature()->getSubstitutionMap(subs);
+  auto projectionGenericSig = projectFn->getGenericSignature();
+  auto genericArgsMap = projectionGenericSig->getSubstitutionMap(
+      [&](SubstitutableType *type) -> Type {
+        auto genericParam = cast<GenericTypeParamType>(type);
+        auto index =
+            projectionGenericSig->getGenericParamOrdinal(genericParam);
+        return replacementTypes[index];
+      },
+      LookUpConformanceInSignature(*projectionGenericSig));
 
   return SGF.emitApplyOfLibraryIntrinsic(SILLocation(E),
                         projectFn, genericArgsMap, {root, keyPath}, C);

lib/SILGen/SILGenLValue.cpp

@@ -1705,14 +1705,16 @@ namespace {
         llvm_unreachable("not a writable key path type?!");
       }
 
-      Substitution args[] = {
-        Substitution(keyPathTy->getGenericArgs()[0], {}),
-        Substitution(keyPathTy->getGenericArgs()[1], {}),
-      };
-      
-      auto subMap = projectionFunction->getGenericSignature()
-        ->getSubstitutionMap(args);
-      
+      auto projectionGenericSig = projectionFunction->getGenericSignature();
+      auto subMap = projectionGenericSig->getSubstitutionMap(
+          [&](SubstitutableType *type) -> Type {
+            auto genericParam = cast<GenericTypeParamType>(type);
+            auto index =
+                projectionGenericSig->getGenericParamOrdinal(genericParam);
+            return keyPathTy->getGenericArgs()[index];
+          },
+          LookUpConformanceInSignature(*projectionGenericSig));
+
       // The projection function behaves like an owning addressor, returning
       // a pointer to the projected value and an owner reference that keeps
       // it alive.
@@ -1761,13 +1763,17 @@ namespace {
                 SILType::getPrimitiveObjectType(keyPathTy->getCanonicalType()));
       }
 
-      Substitution args[] = {
-        Substitution(keyPathTy->getGenericArgs()[0], {}),
-        Substitution(keyPathTy->getGenericArgs()[1], {}),
-      };
       auto projectFn = C.getProjectKeyPathReadOnly(nullptr);
-      auto subMap = projectFn->getGenericSignature()
-        ->getSubstitutionMap(args);
+
+      auto projectionGenericSig = projectFn->getGenericSignature();
+      auto subMap = projectionGenericSig->getSubstitutionMap(
+          [&](SubstitutableType *type) -> Type {
+            auto genericParam = cast<GenericTypeParamType>(type);
+            auto index =
+                projectionGenericSig->getGenericParamOrdinal(genericParam);
+            return keyPathTy->getGenericArgs()[index];
+          },
+          LookUpConformanceInSignature(*projectionGenericSig));
 
       // Allocate a temporary to own the projected value.
       auto &resultTL = SGF.getTypeLowering(keyPathTy->getGenericArgs()[1]);

lib/SILGen/SILGenPattern.cpp

@@ -2631,8 +2631,10 @@ static void emitDiagnoseOfUnexpectedEnumCase(SILGenFunction &SGF,
   ManagedValue metatype = SGF.B.createValueMetatype(loc, metatypeType, value);
 
   Substitution sub{switchedValueSwiftType, /*Conformances*/None};
-  auto genericArgsMap =
-      diagnoseFailure->getGenericSignature()->getSubstitutionMap(sub);
+  auto diagnoseSignature = diagnoseFailure->getGenericSignature();
+  auto genericArgsMap = diagnoseSignature->getSubstitutionMap(
+      [&](SubstitutableType *type) -> Type { return switchedValueSwiftType; },
+      LookUpConformanceInSignature(*diagnoseSignature));
 
   SGF.emitApplyOfLibraryIntrinsic(loc, diagnoseFailure, genericArgsMap,
                                   metatype,