[TypeChecker] Find outermost paren or tuple while checking invalid inout use

Unwrap `InOutExpr` from all parens until the outermost paren or a tuple
to correctly diagnose calls like `foo(((&bar)))` or `foo(x: (&bar))`,
 and suggest a fix-it with moves `&` outside parens.

Resolves: rdar://problem/71356981

Author: xedin

lib/Sema/PreCheckExpr.cpp

@@ -1056,12 +1056,49 @@ namespace {
           if (isa<SequenceExpr>(parent))
             return finish(true, expr);
 
+          SourceLoc lastInnerParenLoc;
+          // Unwrap to the outermost paren in the sequence.
+          if (isa<ParenExpr>(parent)) {
+            for (;;) {
+              auto nextParent = parents.find(parent);
+              if (nextParent == parents.end())
+                break;
+
+              // e.g. `foo((&bar), x: ...)`
+              if (isa<TupleExpr>(nextParent->second)) {
+                lastInnerParenLoc = cast<ParenExpr>(parent)->getLParenLoc();
+                parent = nextParent->second;
+                break;
+              }
+
+              // e.g. `foo(((&bar))`
+              if (isa<ParenExpr>(nextParent->second)) {
+                lastInnerParenLoc = cast<ParenExpr>(parent)->getLParenLoc();
+                parent = nextParent->second;
+                continue;
+              }
+
+              break;
+            }
+          }
+
           if (isa<TupleExpr>(parent) || isa<ParenExpr>(parent)) {
             auto call = parents.find(parent);
             if (call != parents.end()) {
               if (isa<ApplyExpr>(call->getSecond()) ||
-                  isa<UnresolvedMemberExpr>(call->getSecond()))
+                  isa<UnresolvedMemberExpr>(call->getSecond())) {
+                // If outermost paren is associated with a call or
+                // a member reference, it might be valid to have `&`
+                // before all of the parens.
+                if (lastInnerParenLoc.isValid()) {
+                  auto &DE = getASTContext().Diags;
+                  auto diag = DE.diagnose(expr->getStartLoc(),
+                                          diag::extraneous_address_of);
+                  diag.fixItExchange(expr->getLoc(), lastInnerParenLoc);
+                }
+
                 return finish(true, expr);
+              }
 
               if (isa<SubscriptExpr>(call->getSecond())) {
                 getASTContext().Diags.diagnose(

test/Constraints/lvalues.swift

@@ -266,3 +266,23 @@ func testWritePrefixIterator() {
   var underflow = (1..<10).makeIterator()
   var (writtenCount, afterLastWritten) = a.writePrefix(from: underflow) // expected-error {{passing value of type 'IndexingIterator<(Range<Int>)>' to an inout parameter requires explicit '&'}} {{62-62=&}}
 }
+
+// rdar://problem/71356981 - wrong error message for state passed as inout with ampersand within parentheses
+func look_through_parens_when_checking_inout() {
+  struct Point {
+    var x: Int = 0
+    var y: Int = 0
+  }
+
+  func modifyPoint(_ point: inout Point, _: Int = 42) {}
+  func modifyPoint(_ point: inout Point, msg: String) {}
+  func modifyPoint(source: inout Point) {}
+
+  var point = Point(x: 0, y: 0)
+  modifyPoint((&point)) // expected-error {{use of extraneous '&}} {{16-17=(}} {{15-16=&}}
+  modifyPoint(((&point))) // expected-error {{use of extraneous '&}} {{17-18=(}} {{15-16=&}}
+  modifyPoint(source: (&point)) // expected-error {{use of extraneous '&}} {{24-25=(}} {{23-24=&}}
+  modifyPoint(source: ((&point))) // expected-error {{use of extraneous '&}} {{25-26=(}} {{23-24=&}}
+  modifyPoint((&point), 0) // expected-error {{use of extraneous '&}} {{16-17=(}} {{15-16=&}}
+  modifyPoint((&point), msg: "") // expected-error {{use of extraneous '&}} {{16-17=(}} {{15-16=&}}
+}

test/expr/expressions.swift

@@ -841,7 +841,7 @@ func inoutTests(_ arr: inout Int) {
 
   inoutTests((&x, 24).0) // expected-error {{use of extraneous '&'}}
 
-  inoutTests((&x)) // expected-error {{use of extraneous '&'}}
+  inoutTests((&x)) // expected-error {{use of extraneous '&'}} {{15-16=(}} {{14-15=&}}
   inoutTests(&x)
 
   // <rdar://problem/17489894> inout not rejected as operand to assignment operator