SILGen: Apply function_conversion peephole to CaptureListExprs.

Don't let a capture list suppress the reabstraction peephole when a closure
literal appears in a context with a function conversion.

Author: jckarter

lib/SILGen/SILGenExpr.cpp

@@ -1804,7 +1804,7 @@ RValue RValueEmitter::visitFunctionConversionExpr(FunctionConversionExpr *e,
   // TODO: Move this up when we can emit closures directly with C calling
   // convention.
   auto subExpr = e->getSubExpr()->getSemanticsProvidingExpr();
-  if (isa<AbstractClosureExpr>(subExpr)
+  if ((isa<AbstractClosureExpr>(subExpr) || isa<CaptureListExpr>(subExpr))
       && canPeepholeLiteralClosureConversion(subExpr->getType(),
                                              e->getType())) {
     // If we're emitting into a context with a preferred abstraction pattern

lib/SILGen/SILGenPoly.cpp

@@ -82,6 +82,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define DEBUG_TYPE "silgen-poly"
 #include "ExecutorBreadcrumb.h"
 #include "Initialization.h"
 #include "LValue.h"
@@ -3055,6 +3056,24 @@ static ManagedValue createThunk(SILGenFunction &SGF,
   auto substSourceType = fn.getType().castTo<SILFunctionType>();
   auto substExpectedType = expectedTL.getLoweredType().castTo<SILFunctionType>();
 
+  LLVM_DEBUG(llvm::dbgs() << "=== Generating reabstraction thunk from:\n";
+             substSourceType.dump(llvm::dbgs());
+             llvm::dbgs() << "\n    to:\n";
+             substExpectedType.dump(llvm::dbgs());
+             llvm::dbgs() << "\n    for source location:\n";
+             if (auto d = loc.getAsASTNode<Decl>()) {
+               d->dump(llvm::dbgs());
+             } else if (auto e = loc.getAsASTNode<Expr>()) {
+               e->dump(llvm::dbgs());
+             } else if (auto s = loc.getAsASTNode<Stmt>()) {
+               s->dump(llvm::dbgs());
+             } else if (auto p = loc.getAsASTNode<Pattern>()) {
+               p->dump(llvm::dbgs());
+             } else {
+               loc.dump();
+             }
+             llvm::dbgs() << "\n");
+  
   // Apply substitutions in the source and destination types, since the thunk
   // doesn't change because of different function representations.
   CanSILFunctionType sourceType;

test/SILGen/closure_literal_reabstraction.swift

@@ -0,0 +1,26 @@
+// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+
+func gen<T, U>(f: (T) throws -> U) {}
+
+struct Butt {
+    var x: Int
+}
+
+// CHECK-LABEL: sil {{.*}} @{{.*}}reabstractCaptureListExprArgument
+// CHECK:         [[CLOSURE_FN:%.*]] = function_ref {{.*}}U_
+// CHECK:         [[CLOSURE:%.*]] = partial_apply {{.*}}[[CLOSURE_FN]]
+// CHECK:         [[CLOSURE_NE:%.*]] = convert_escape_to_noescape {{.*}} [[CLOSURE]]
+// CHECK:         apply {{.*}}<Int, Int>([[CLOSURE_NE]])
+func reabstractCaptureListExprArgument() {
+    gen(f: {[x = 42] y in x + y })
+}
+
+// CHECK-LABEL: sil {{.*}} @{{.*}}reabstractKeyPathFunctionArgument
+// CHECK:         [[CLOSURE_FN:%.*]] = function_ref {{.*}}U_
+// CHECK:         [[KP_ARG:%.*]] = copy_value {{.*}} $KeyPath
+// CHECK:         [[CLOSURE:%.*]] = partial_apply {{.*}}[[CLOSURE_FN]]([[KP_ARG]])
+// CHECK:         [[CLOSURE_NE:%.*]] = convert_escape_to_noescape {{.*}} [[CLOSURE]]
+// CHECK:         apply {{.*}}<Butt, Int>([[CLOSURE_NE]])
+func reabstractKeyPathFunctionArgument() {
+    gen(f: \Butt.x)
+}