Sema: Fix a couple of crashes in tuple arguments tests

There's a general problem where a SubscriptExpr has an argument
that's a LoadExpr loading a tuple from an lvalue. For some reason
we don't construct the ParenExpr in this case, which confused
CSDiag.

Also, in Swift 3 mode, add a total hack to fudge things in
matchCallArguments() in the case where we erroneously lost
ParenType sugar.

Author: slavapestov

lib/Sema/CSApply.cpp

@@ -4702,6 +4702,15 @@ Expr *ExprRewriter::coerceCallArguments(
     bool hasTrailingClosure,
     ConstraintLocatorBuilder locator) {
 
+  // Total hack: In Swift 3 mode, we can end up with an arity mismatch due to
+  // loss of ParenType sugar.
+  if (cs.getASTContext().isSwiftVersion3()) {
+    if (isa<TupleExpr>(arg))
+      if (auto *parenType = dyn_cast<ParenType>(paramType.getPointer()))
+        if (isa<TupleType>(parenType->getUnderlyingType().getPointer()))
+          paramType = parenType->getUnderlyingType();
+  }
+
   bool allParamsMatch = cs.getType(arg)->isEqual(paramType);
 
   // Find the callee declaration.

lib/Sema/CSDiag.cpp

@@ -5051,7 +5051,13 @@ static bool diagnoseSingleCandidateFailures(CalleeCandidateInfo &CCI,
               TC.Context.SourceMgr, FnExpr->getEndLoc());
         }
       } else {
-        llvm_unreachable("unexpected argument expression type");
+        // FIXME: Due to a quirk of CSApply, we can end up without a
+        // ParenExpr if the argument has an '@lvalue TupleType'.
+        assert((isa<TupleType>(ArgExpr->getType().getPointer()) ||
+                isa<ParenType>(ArgExpr->getType().getPointer())) &&
+                "unexpected argument expression type");
+        insertLoc = ArgExpr->getLoc();
+
         // Can't be TupleShuffleExpr because this argExpr is not yet resolved.
       }
 

test/Compatibility/tuple_arguments.swift

@@ -549,7 +549,7 @@ do {
 }
 
 struct SubscriptTwo {
-  subscript(_ x: Int, _ y: Int) -> Int { get { return 0 } set { } } // expected-note 2 {{'subscript' declared here}}
+  subscript(_ x: Int, _ y: Int) -> Int { get { return 0 } set { } } // expected-note 3 {{'subscript' declared here}}
 }
 
 struct SubscriptTuple {
@@ -590,8 +590,7 @@ do {
   var s1 = SubscriptTwo()
   _ = s1[a, b]
   _ = s1[(a, b)] // expected-error {{missing argument for parameter #2 in call}}
-
-  // _ = s1[d] // FIXME: Crashes in Swift 3 mode
+  _ = s1[d] // expected-error {{missing argument for parameter #2 in call}}
 
   var s2 = SubscriptTuple()
   _ = s2[a, b] // expected-error {{extra argument in call}}}
@@ -1023,7 +1022,7 @@ do {
   var d = (a, b)
 
   var s1 = GenericSubscript<(Double, Double)>()
-  // _ = s1[a, b] // FIXME: Crashes in Swift 3 mode
+  _ = s1[a, b]
   _ = s1[(a, b)] // expected-error {{expression type '@lvalue Int' is ambiguous without more context}}
   _ = s1[d] // expected-error {{expression type '@lvalue Int' is ambiguous without more context}}
 

test/Constraints/tuple_arguments.swift

@@ -534,7 +534,7 @@ do {
 }
 
 struct SubscriptTwo {
-  subscript(_ x: Int, _ y: Int) -> Int { get { return 0 } set { } } // expected-note 4 {{'subscript' declared here}}
+  subscript(_ x: Int, _ y: Int) -> Int { get { return 0 } set { } } // expected-note 5 {{'subscript' declared here}}
 }
 
 struct SubscriptTuple {
@@ -575,9 +575,7 @@ do {
   var s1 = SubscriptTwo()
   _ = s1[a, b]
   _ = s1[(a, b)] // expected-error {{missing argument for parameter #2 in call}}
-
-  // FIXME: Crashes in CSDiag
-  // _ = s1[d]
+  _ = s1[d] // expected-error {{missing argument for parameter #2 in call}}
 
   var s2 = SubscriptTuple()
   _ = s2[a, b] // expected-error {{extra argument in call}}}