[Parser] Correct initalizer typos before lambda capture type is deduced.

[vsapsai]

Summary

This is the same assertion as in https://reviews.llvm.org/D25206 that is
triggered when RecordLayoutBuilder tries to compute the size of a field
(for capture "typo_boo" in the test case) whose type hasn't been
deduced.

The fix is to add CorrectDelayedTyposInExpr call to the cases when we
aren't disambiguating between an Obj-C message send and a lambda
expression.

rdar://problem/31760839

[arphaman]

There's also a crash with the ( ... ) initializer:

namespace init_capture_undeclared_identifier {
  auto a = [x = y]{};

  int typo_foo;
  auto b = [x (typo_boo )]{}; 
}

I think you should move the added correction code before if (Init.isUsable()) to ensure that all paths are covered.

[vsapsai]

Address review comments.

Moved CorrectDelayedTyposInExpr according to review comment and added
mentioned test case.

Removed the assertion as it didn't catch the expression

ParenListExpr 0x7f8297060e40 'NULL TYPE'
`-TypoExpr 0x7f8297060e30 '<dependent type>' lvalue

Didn't remove CorrectDelayedTyposInExpr for the case when we disambiguate
between lambda and Obj-C message send because we use corrected expression in
annotation token. Checked that correcting typos the second time returns the
same expression because there are no typos anymore.

[arphaman]

LGTM, Thanks.

You should obtain commit access if you haven't already done so (https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access). I can commit this on your behalf as well if you want.

[vsapsai]

Thanks for review, Alex. I've requested commit access and plan to commit the change myself to make sure everything works as expected.

cfe/trunk/lib/Parse/ParseExprCXX.cpp

while (Tok.isNot(tok::r_square)) {
     //          return y;
     //     }
     //   };
     // }
     // If x was not const, the second use would require 'L' to capture, and
     // that would be an error.
 
     ParsedType InitCaptureType;
+    if (!Init.isInvalid())
+      Init = Actions.CorrectDelayedTyposInExpr(Init.get());
     if (Init.isUsable()) {
       // Get the pointer and store it in an lvalue, so we can use it as an
       // out argument.
       Expr *InitExpr = Init.get();
       // This performs any lvalue-to-rvalue conversions if necessary, which
       // can affect what gets captured in the containing decl-context.
       InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
           Loc, Kind == LCK_ByRef, Id, InitKind, InitExpr);

cfe/trunk/test/SemaCXX/cxx1y-init-captures.cpp

 void test(double weight) {
   double init;
   auto find = [max = init](auto current) {
     max = current; // expected-error{{cannot assign to a variable captured by copy in a non-mutable lambda}}
   };
   find(weight); // expected-note {{in instantiation of function template specialization}}
 }
 }
+
+namespace init_capture_undeclared_identifier {
+  auto a = [x = y]{}; // expected-error{{use of undeclared identifier 'y'}}
+
+  int typo_foo; // expected-note 2 {{'typo_foo' declared here}}
+  auto b = [x = typo_boo]{}; // expected-error{{use of undeclared identifier 'typo_boo'; did you mean 'typo_foo'}}
+  auto c = [x(typo_boo)]{}; // expected-error{{use of undeclared identifier 'typo_boo'; did you mean 'typo_foo'}}
+}