Sema: have createBuiltinCall handle conformances

The only callers of `DerivedConformance::createBuiltinCall` aren't
actually aware of what the generic signature is for the builtin they
want to call. Thus, they can't really provide the needed conformances.

This wasn't an issue when there were no conformances needed for the
substitution map, but with NoncopyableGenerics, we need at least
Copyable conformances for the generic parameters of a builtin. It's easy
enough to make this function just handle generating the conformances
list, so that's the refactoring here.

Author: kavon

lib/Sema/DerivedConformanceActor.cpp

@@ -112,7 +112,7 @@ deriveBodyActor_unownedExecutor(AbstractFunctionDecl *getter, void *) {
   auto builtinCall =
     DerivedConformance::createBuiltinCall(ctx,
                         BuiltinValueKind::BuildDefaultActorExecutorRef,
-                                          {selfType}, {}, {selfArg});
+                                          {selfType}, {selfArg});
 
   // Turn that into an UnownedSerialExecutor.
   auto initCall = constructUnownedSerialExecutor(ctx, builtinCall);

lib/Sema/DerivedConformanceDistributedActor.cpp

@@ -664,7 +664,7 @@ deriveBodyDistributedActor_unownedExecutor(AbstractFunctionDecl *getter, void *)
   auto builtinCall =
       DerivedConformance::createBuiltinCall(ctx,
                                             BuiltinValueKind::BuildDefaultActorExecutorRef,
-                                            {selfType}, {}, {selfArg});
+                                            {selfType}, {selfArg});
   // Turn that into an UnownedSerialExecutor.
   auto initCall = constructDistributedUnownedSerialExecutor(ctx, builtinCall);
   if (!initCall) return failure();

lib/Sema/DerivedConformances.cpp

@@ -462,8 +462,6 @@ CallExpr *
 DerivedConformance::createBuiltinCall(ASTContext &ctx,
                                       BuiltinValueKind builtin,
                                       ArrayRef<Type> typeArgs,
-                                      ArrayRef<ProtocolConformanceRef>
-                                        conformances,
                                       ArrayRef<Expr *> args) {
   auto name = ctx.getIdentifier(getBuiltinName(builtin));
   auto decl = getBuiltinValueDecl(ctx, name);
@@ -472,8 +470,21 @@ DerivedConformance::createBuiltinCall(ASTContext &ctx,
   ConcreteDeclRef declRef = decl;
   auto fnType = decl->getInterfaceType();
   if (auto genericFnType = fnType->getAs<GenericFunctionType>()) {
+    auto builtinModule = decl->getModuleContext();
     auto generics = genericFnType->getGenericSignature();
-    auto subs = SubstitutionMap::get(generics, typeArgs, conformances);
+
+    auto genericParams = generics.getGenericParams();
+    assert(genericParams.size() == typeArgs.size());
+
+    TypeSubstitutionMap map;
+    for (auto i : indices(genericParams))
+      map.insert({genericParams[i]->getCanonicalType()
+                                  ->getAs<SubstitutableType>(),
+                  typeArgs[i]});
+
+    auto subs = SubstitutionMap::get(generics,
+                                     QueryTypeSubstitutionMap{map},
+                                     LookUpConformanceInModule{builtinModule});
     declRef = ConcreteDeclRef(decl, subs);
     fnType = genericFnType->substGenericArgs(subs);
   } else {

lib/Sema/DerivedConformances.h

@@ -387,7 +387,6 @@ class DerivedConformance {
   static CallExpr *createBuiltinCall(ASTContext &ctx,
                                      BuiltinValueKind builtin,
                                      ArrayRef<Type> typeArgs,
-                              ArrayRef<ProtocolConformanceRef> conformances,
                                      ArrayRef<Expr *> args);
 
   /// Build a call to the stdlib function that should be called when unavailable