Handle labeled singleton tuples in the setter value argument.

This can get introduced by somewhat pathological behavior in the
importer combined with SILGenApply's reliance on parallel tuple
destructuring.  Both of these should be fixed, but this patch is
much simpler.

rdar://34913800

Author: rjmccall

lib/SILGen/ArgumentSource.cpp

@@ -59,8 +59,26 @@ void ArgumentSource::rewriteType(CanType newType) & {
     Storage.get<RValueStorage>(StoredKind).Value.rewriteType(newType);
     return;
   case Kind::Expr:
-    Expr *expr = Storage.get<Expr*>(StoredKind);
-    if (expr->getType()->isEqual(newType)) return;
+    Expr *&expr = Storage.get<Expr*>(StoredKind);
+    CanType oldType = expr->getType()->getCanonicalType();
+
+    // Usually nothing is required.
+    if (oldType == newType) return;
+
+    // Sometimes we need to wrap the expression in a single-element tuple.
+    // This is only necessary because we don't break down the argument list
+    // when dealing with SILGenApply.
+    if (auto newTuple = dyn_cast<TupleType>(newType)) {
+      if (newTuple->getNumElements() == 1 &&
+          newTuple.getElementType(0) == oldType) {
+        expr = TupleExpr::create(newType->getASTContext(),
+                                 SourceLoc(), expr, {}, {}, SourceLoc(),
+                                 /*trailing closure*/ false,
+                                 /*implicit*/ true, newType);
+        return;
+      }
+    }
+
     llvm_unreachable("unimplemented! hope it doesn't happen");
   }
   llvm_unreachable("bad kind");

test/SILGen/Inputs/usr/include/BridgeTestFoundation.h

@@ -89,3 +89,7 @@ void escapeNonnullBlock(void (^_Nonnull block)(void));
 void noescapeBlockAlias(__attribute__((noescape)) dispatch_block_t block);
 void noescapeNonnullBlockAlias(__attribute__((noescape)) _Nonnull dispatch_block_t block);
 void escapeBlockAlias(dispatch_block_t block);
+
+@interface ObjectWithSplitProperty : NSObject
+@property (nonatomic, setter=private_setFlagForSomething:) BOOL flagForSomething;
+@end

test/SILGen/objc_properties.swift

@@ -248,3 +248,11 @@ class HasLazyProperty : NSObject, HasProperty {
 // CHECK-LABEL: sil hidden @_T015objc_properties15HasLazyPropertyC6windowSo8NSObjectCSgvg : $@convention(method) (@guaranteed HasLazyProperty) -> @owned Optional<NSObject> {
 // CHECK: class_method %0 : $HasLazyProperty, #HasLazyProperty.instanceMethod!1 : (HasLazyProperty) -> () -> NSObject?
 // CHECK: return
+
+//   The way we import this setter splits the name into the parameter list,
+//   which can cause fits for SILGenApply the way it's currently implemented.
+// CHECK-LABEL: sil hidden @_T015objc_properties26testPropSetWithPreposition
+func testPropSetWithPreposition(object: ObjectWithSplitProperty?) {
+  // CHECK: #ObjectWithSplitProperty.flagForSomething!setter.1.foreign : (ObjectWithSplitProperty) -> (Bool) -> (), $@convention(objc_method) (ObjCBool, ObjectWithSplitProperty) -> ()
+  object?.flagForSomething = false
+}