[Sema] ban multi-arguments to tuple coercion

Implements part of SE-0110. Single argument in closures will not be accepted if
there exists explicit type with a number of arguments that's not 1.

```swift
let f: (Int, Int) -> Void = { x in } // this is now an error
```

Note there's a second part of SE-0110 which could be considered additive,
which says one must add an extra pair of parens to specify a single arugment
type that is a tuple:

```swift
let g ((Int, Int)) -> Void = { y in } // y should have type (Int, Int)
```

This patch does not implement that part.

Author: dduan

lib/Sema/CSApply.cpp

@@ -6417,7 +6417,7 @@ namespace {
         // Coerce the pattern, in case we resolved something.
         auto fnType = closure->getType()->castTo<FunctionType>();
         auto *params = closure->getParameters();
-        if (tc.coerceParameterListToType(params, closure, fnType->getInput()))
+        if (tc.coerceParameterListToType(params, closure, fnType))
           return { false, nullptr };
 
         // If this is a single-expression closure, convert the expression

lib/Sema/CSDiag.cpp

@@ -5407,7 +5407,7 @@ bool FailureDiagnosis::visitClosureExpr(ClosureExpr *CE) {
       return true;
     }
 
-    if (CS->TC.coerceParameterListToType(params, CE, inferredArgType))
+    if (CS->TC.coerceParameterListToType(params, CE, fnType))
       return true;
 
     expectedResultType = fnType->getResult();

lib/Sema/TypeCheckPattern.cpp

@@ -1683,8 +1683,9 @@ bool TypeChecker::coercePatternToType(Pattern *&P, DeclContext *dc, Type type,
 /// TODO: These diagnostics should be a lot better now that we know this is
 /// all specific to closures.
 ///
-bool TypeChecker::coerceParameterListToType(ParameterList *P, DeclContext *DC,
-                                            Type paramListType) {
+bool TypeChecker::coerceParameterListToType(ParameterList *P, ClosureExpr *CE,
+                                            AnyFunctionType *FN) {
+  Type paramListType = FN->getInput();
   bool hadError = paramListType->is<ErrorType>();
 
   // Sometimes a scalar type gets applied to a single-argument parameter list.
@@ -1693,7 +1694,7 @@ bool TypeChecker::coerceParameterListToType(ParameterList *P, DeclContext *DC,
 
     // Check that the type, if explicitly spelled, is ok.
     if (param->getTypeLoc().getTypeRepr()) {
-      hadError |= validateParameterType(param, DC, TypeResolutionOptions(),
+      hadError |= validateParameterType(param, CE, TypeResolutionOptions(),
                                         nullptr, *this);
 
       // Now that we've type checked the explicit argument type, see if it
@@ -1735,11 +1736,10 @@ bool TypeChecker::coerceParameterListToType(ParameterList *P, DeclContext *DC,
   // The number of elements must match exactly.
   // TODO: incomplete tuple patterns, with some syntax.
   if (!hadError && tupleTy->getNumElements() != P->size()) {
-    if (P->size() == 1)
-      return handleParameter(P->get(0), paramListType);
-    
-    diagnose(P->getStartLoc(), diag::tuple_pattern_length_mismatch,
-             paramListType);
+    auto fnType = FunctionType::get(paramListType->getDesugaredType(),
+                                    FN->getResult());
+    diagnose(P->getStartLoc(), diag::closure_argument_list_tuple,
+             fnType, tupleTy->getNumElements(), P->size());
     hadError = true;
   }
 

lib/Sema/TypeChecker.h

@@ -1386,7 +1386,8 @@ class TypeChecker final : public LazyResolver {
   /// contextual type.
   ///
   /// \returns true if an error occurred, false otherwise.
-  bool coerceParameterListToType(ParameterList *P, DeclContext *dc, Type type);
+  bool coerceParameterListToType(ParameterList *P, ClosureExpr *CE,
+                                 AnyFunctionType *FN);
 
 
   /// Type-check an initialized variable pattern declaration.

stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift

@@ -1807,7 +1807,7 @@ self.test("\(testNamePrefix)._preprocessingPass/semantics") {
     let s = makeWrappedSequence(test.sequence.map(OpaqueValue.init))
     var wasInvoked = false
     let result = s._preprocessingPass {
-      (sequence) -> OpaqueValue<Int> in
+      () -> OpaqueValue<Int> in
       wasInvoked = true
 
       expectEqualSequence(
@@ -1830,7 +1830,7 @@ self.test("\(testNamePrefix)._preprocessingPass/semantics") {
     var result: OpaqueValue<Int>? = nil
     do {
       result = try s._preprocessingPass {
-        (sequence) -> OpaqueValue<Int> in
+        () -> OpaqueValue<Int> in
         wasInvoked = true
         throw TestError.error2
       }

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -2387,7 +2387,7 @@ public func expectEqualsUnordered<
   let x: [(T, T)] =
     expected.sorted(by: comparePairLess)
   let y: [(T, T)] =
-    actual.map { ($0.0, $0.1) }
+    actual.map { ($0, $1) }
       .sorted(by: comparePairLess)
 
   func comparePairEquals(_ lhs: (T, T), rhs: (key: T, value: T)) -> Bool {

stdlib/private/StdlibUnittest/TypeIndexed.swift

@@ -105,7 +105,7 @@ public func expectEqual<V: Comparable>(
   file: String = #file, line: UInt = #line
 ) {
   expectEqualsUnordered(
-    expected.map { (key: TypeIdentifier($0.0), value: $0.1) },
+    expected.map { (key: TypeIdentifier($0), value: $1) },
     actual.byType,
     message(), stackTrace: stackTrace) { $0 <=> $1 }
 }

stdlib/public/SDK/AppKit/AppKit.swift

@@ -54,8 +54,8 @@ extension NSView : _DefaultCustomPlaygroundQuickLookable {
 public extension NSGradient {
   convenience init?(colorsAndLocations objects: (NSColor, CGFloat)...) {
     self.init(
-      colors: objects.map { $0.0 },
-      atLocations: objects.map { $0.1 },
+      colors: objects.map { c, _ in c },
+      atLocations: objects.map { _, l in l },
       colorSpace: NSColorSpace.genericRGB())
   }
 }

stdlib/public/SDK/Foundation/Foundation.swift

@@ -570,8 +570,8 @@ extension NSDictionary : ExpressibleByDictionaryLiteral {
     dictionaryLiteral elements: (NSCopying, AnyObject)...
   ) {
     self.init(
-      objects: elements.map { $0.1 },
-      forKeys: elements.map { $0.0 },
+      objects: elements.map { _, v in v },
+      forKeys: elements.map { k, _ in k },
       count: elements.count)
   }
 }

stdlib/public/SDK/WatchKit/WatchKit.swift

@@ -29,8 +29,8 @@ extension WKInterfaceController {
     withNamesAndContexts namesAndContexts: [(name: String, context: AnyObject)]
   ) {
     WKInterfaceController.reloadRootControllers(
-      withNames: namesAndContexts.map { $0.name },
-      contexts: namesAndContexts.map { $0.context })
+      withNames: namesAndContexts.map { name, _ in name },
+      contexts: namesAndContexts.map { _, context in context })
   }
 
   @available(*, deprecated,
@@ -47,8 +47,8 @@ extension WKInterfaceController {
     withNamesAndContexts namesAndContexts: [(name: String, context: AnyObject)]
   ) {
     self.presentController(
-      withNames: namesAndContexts.map { $0.name },
-      contexts: namesAndContexts.map { $0.context })
+      withNames: namesAndContexts.map { name, _ in name },
+      contexts: namesAndContexts.map { _, context in context })
   }
 }