SILGen: Clean up ad-hoc SubstitutionList construction when calling intrinsics

Change emitApplyOfLibraryIntrinsic() to take a SubstitutionMap,
and use the correct abstractions to build the map.

This gets rid of the last remaining uses of gatherAllSubstitutions()
in SIL.

Author: slavapestov

lib/SILGen/SILGenApply.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/Basic/Range.h"
 #include "swift/Basic/Unicode.h"
 #include "swift/SIL/PrettyStackTrace.h"
@@ -4533,9 +4534,13 @@ RValue SILGenFunction::emitApplyExpr(Expr *e, SGFContext c) {
 RValue
 SILGenFunction::emitApplyOfLibraryIntrinsic(SILLocation loc,
                                             FuncDecl *fn,
-                                            SubstitutionList subs,
+                                            const SubstitutionMap &subMap,
                                             ArrayRef<ManagedValue> args,
                                             SGFContext ctx) {
+  SmallVector<Substitution, 4> subs;
+  if (auto *genericSig = fn->getGenericSignature())
+    genericSig->getSubstitutions(subMap, subs);
+
   auto callee = Callee::forDirect(*this, SILDeclRef(fn), loc);
   callee.setSubstitutions(subs);
 
@@ -4785,13 +4790,11 @@ SILGenFunction::emitUninitializedArrayAllocation(Type ArrayTy,
   auto &Ctx = getASTContext();
   auto allocate = Ctx.getAllocateUninitializedArray(nullptr);
 
-  auto arrayElementTy = ArrayTy->castTo<BoundGenericType>()
-    ->getGenericArgs()[0];
-
   // Invoke the intrinsic, which returns a tuple.
-  Substitution sub{arrayElementTy, {}};
+  auto subMap = ArrayTy->getContextSubstitutionMap(SGM.M.getSwiftModule(),
+                                                   Ctx.getArrayDecl());
   auto result = emitApplyOfLibraryIntrinsic(Loc, allocate,
-                                            sub,
+                                            subMap,
                                             ManagedValue::forUnmanaged(Length),
                                             SGFContext());
 
@@ -4808,12 +4811,12 @@ void SILGenFunction::emitUninitializedArrayDeallocation(SILLocation loc,
   auto &Ctx = getASTContext();
   auto deallocate = Ctx.getDeallocateUninitializedArray(nullptr);
 
-  CanType arrayElementTy =
-    array->getType().castTo<BoundGenericType>().getGenericArgs()[0];
+  CanType arrayTy = array->getType().getSwiftRValueType();
 
   // Invoke the intrinsic.
-  Substitution sub{arrayElementTy, {}};
-  emitApplyOfLibraryIntrinsic(loc, deallocate, sub,
+  auto subMap = arrayTy->getContextSubstitutionMap(SGM.M.getSwiftModule(),
+                                                   Ctx.getArrayDecl());
+  emitApplyOfLibraryIntrinsic(loc, deallocate, subMap,
                               ManagedValue::forUnmanaged(array),
                               SGFContext());
 }

lib/SILGen/SILGenBridging.cpp

@@ -499,15 +499,21 @@ static ManagedValue emitNativeToCBridgedNonoptionalValue(SILGenFunction &gen,
   // Call into the stdlib intrinsic.
   if (auto bridgeAnything =
         gen.getASTContext().getBridgeAnythingToObjectiveC(nullptr)) {
-    Substitution sub(loweredNativeTy, {});
+    auto *genericSig = bridgeAnything->getGenericSignature();
+    auto subMap = genericSig->getSubstitutionMap(
+      [&](SubstitutableType *t) -> Type {
+        return loweredNativeTy;
+      },
+      MakeAbstractConformanceForGenericType());
+
     // Put the value into memory if necessary.
     assert(v.getType().isTrivial(gen.SGM.M) || v.hasCleanup());
     if (v.getType().isObject()) {
       auto tmp = gen.emitTemporaryAllocation(loc, v.getType());
       v.forwardInto(gen, loc, tmp);
       v = gen.emitManagedBufferWithCleanup(tmp);
     }
-    return gen.emitApplyOfLibraryIntrinsic(loc, bridgeAnything, sub, v,
+    return gen.emitApplyOfLibraryIntrinsic(loc, bridgeAnything, subMap, v,
                                            SGFContext())
       .getAsSingleValue(gen, loc);
   }
@@ -768,7 +774,7 @@ static ManagedValue emitCBridgedToNativeValue(SILGenFunction &gen,
     auto optionalMV = ManagedValue(optionalV, v.getCleanup());
     return gen.emitApplyOfLibraryIntrinsic(loc,
                            gen.getASTContext().getBridgeAnyObjectToAny(nullptr),
-                           {}, optionalMV, SGFContext())
+                           SubstitutionMap(), optionalMV, SGFContext())
       .getAsSingleValue(gen, loc);
   }
 

lib/SILGen/SILGenConvert.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/type_traits.h"
 #include "swift/SIL/SILArgument.h"
@@ -204,7 +205,7 @@ SILGenFunction::emitPreconditionOptionalHasValue(SILLocation loc,
     ManagedValue args[4];
     emitSourceLocationArgs(*this, loc, args);
 
-    emitApplyOfLibraryIntrinsic(loc, diagnoseFailure, {}, args,
+    emitApplyOfLibraryIntrinsic(loc, diagnoseFailure, SubstitutionMap(), args,
                                 SGFContext());
   }
 
@@ -388,12 +389,20 @@ SILGenFunction::emitPointerToPointer(SILLocation loc,
   auto origValue = emitManagedBufferWithCleanup(origBuf);
 
   // Invoke the conversion intrinsic to convert to the destination type.
-  Substitution subs[2] = {
-    getPointerSubstitution(inputType),
-    getPointerSubstitution(outputType),
-  };
+  auto *M = SGM.M.getSwiftModule();
+  auto *proto = getPointerProtocol();
+  auto firstSubMap = inputType->getContextSubstitutionMap(M, proto);
+  auto secondSubMap = outputType->getContextSubstitutionMap(M, proto);
+
+  auto *genericSig = converter->getGenericSignature();
+  auto subMap =
+    SubstitutionMap::combineSubstitutionMaps(firstSubMap,
+                                             secondSubMap,
+                                             CombineSubstitutionMaps::AtIndex,
+                                             1, 0,
+                                             genericSig);
 
-  return emitApplyOfLibraryIntrinsic(loc, converter, subs, origValue, C);
+  return emitApplyOfLibraryIntrinsic(loc, converter, subMap, origValue, C);
 }
 
 
@@ -509,9 +518,10 @@ ManagedValue SILGenFunction::emitExistentialErasure(
       if (!getEmbeddedNSErrorFn)
         return emitUndef(loc, existentialTL.getLoweredType());
 
-      Substitution getEmbeddedNSErrorSubstitutions[1] = {
-        Substitution(concreteFormalType, conformances)
-      };
+      auto getEmbeddedNSErrorSubstitutions =
+        SubstitutionMap::getProtocolSubstitutions(ctx.getErrorDecl(),
+                                                  concreteFormalType,
+                                                  conformances[0]);
 
       ManagedValue concreteValue = F(SGFContext());
       ManagedValue potentialNSError =

lib/SILGen/SILGenDynamicCast.cpp

@@ -583,46 +583,28 @@ static RValue emitCollectionDowncastExpr(SILGenFunction &SGF,
                                          SGFContext C,
                                          bool conditional) {
   // Compute substitutions for the intrinsic call.
-  auto fromCollection = cast<BoundGenericStructType>(
-                          sourceType->getCanonicalType());
-  auto toCollection = cast<BoundGenericStructType>(
-                        destType->getCanonicalType());
+  auto fromCollection = sourceType->getCanonicalType();
+  auto toCollection = destType->getCanonicalType();
   // Get the intrinsic function.
   auto &ctx = SGF.getASTContext();
   FuncDecl *fn = nullptr;
-  if (fromCollection->getDecl() == ctx.getArrayDecl()) {
+  if (fromCollection->getAnyNominal() == ctx.getArrayDecl()) {
     fn = conditional ? SGF.SGM.getArrayConditionalCast(loc)
                      : SGF.SGM.getArrayForceCast(loc);
-  } else if (fromCollection->getDecl() == ctx.getDictionaryDecl()) {
+  } else if (fromCollection->getAnyNominal() == ctx.getDictionaryDecl()) {
     fn = (conditional
            ? SGF.SGM.getDictionaryDownCastConditional(loc)
            : SGF.SGM.getDictionaryDownCast(loc));
-  } else if (fromCollection->getDecl() == ctx.getSetDecl()) {
+  } else if (fromCollection->getAnyNominal() == ctx.getSetDecl()) {
     fn = (conditional
            ? SGF.SGM.getSetDownCastConditional(loc)
            : SGF.SGM.getSetDownCast(loc));
   } else {
     llvm_unreachable("unsupported collection upcast kind");
   }
 
-  // This will have been diagnosed by the accessors above.
-  if (!fn) return SGF.emitUndefRValue(loc, destType);
-
-  auto fnGenericParams = fn->getGenericSignature()->getGenericParams();
-  auto fromSubsts = fromCollection->gatherAllSubstitutions(
-      SGF.SGM.SwiftModule, nullptr);
-  auto toSubsts = toCollection->gatherAllSubstitutions(
-      SGF.SGM.SwiftModule, nullptr);
-  assert(fnGenericParams.size() == fromSubsts.size() + toSubsts.size() &&
-         "wrong number of generic collection parameters");
-  (void) fnGenericParams;
-
-  // Form type parameter substitutions.
-  SmallVector<Substitution, 4> subs;
-  subs.append(fromSubsts.begin(), fromSubsts.end());
-  subs.append(toSubsts.begin(), toSubsts.end());
-
-  return SGF.emitApplyOfLibraryIntrinsic(loc, fn, subs, {source}, C);
+  return SGF.emitCollectionConversion(loc, fn, fromCollection, toCollection,
+                                      source, C);
 }
 
 static ManagedValue