Push lambda scope earlier when transforming lambda expression

[comex]

Summary

When first parsing a lambda expression, BuildDeclRefExpr is called on the parameter declarations with the lambda scope already pushed. But when transforming a lambda expression as part of instantiating an outer template, BuildDeclRefExpr is called again without the scope pushed. This causes tryCaptureVariable to get confused when a lambda parameter references an earlier parameter, e.g.:

[](auto c, int x = sizeof(decltype(c))) {}

Fix this by moving up the call to PushLambdaScope in TreeTransform::TransformLambdaExpr to match Parser::ParseLambdaExpressionAfterIntroducer.

(Note: I do not have commit access.)

[comex]

Oops, I forgot to re-run git diff after fixing the patch.

[Mordante]

clang/test/SemaTemplate/default-arguments-cxx0x.cpp

1

Wouldn't it be better to keep the original C++11 test and add a second RUN: for the C++14 test?
Then guard the new test with #if __cplusplus >= 201402L

[comex]

clang/test/SemaTemplate/default-arguments-cxx0x.cpp

1

Perhaps, but most tests aren't run multiple times with different -std options, and I didn't see any reason this test in particular needed that. Maybe it should just be renamed to default-arguments-cxx14.cpp.

[Mordante]

clang/test/SemaTemplate/default-arguments-cxx0x.cpp

1

I'm rather new here so I don't know what the renaming policy is, so I leave it to the more experienced reviewers.

[lebedev.ri]

clang/test/SemaTemplate/default-arguments-cxx0x.cpp

1

The description does not call it out specifically i think - why does this need -std=c++14?
That being said i see absolutely no reason not to just have two run lines here.

118

This is only simply checking that clang doesn't crash on this, right?
Add a comment about that?

[comex]

Addressed review comments.

clang/test/SemaTemplate/default-arguments-cxx0x.cpp

1

The ability to make a lambda parameter auto-typed is a C++14 feature.

Okay, I'll just add two run lines.

118

Okay.

clang/lib/Sema/TreeTransform.h

if (OldVD->isParameterPack()) {
         SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
         Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
       }
     } else {
       SubstInitCapture(SourceLocation(), None);
     }
   }
 
+  LambdaScopeInfo *LSI = getSema().PushLambdaScope();
+  Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
+  LSI->GLTemplateParameterList = TPL;
+
   // Transform the template parameters, and add them to the current
   // instantiation scope. The null case is handled correctly.
   auto TPL = getDerived().TransformTemplateParameterList(
       E->getTemplateParameterList());
 
   // Transform the type of the original lambda's call operator.
   // The transformation MUST be done in the CurrentInstantiationScope since
   // it introduces a mapping of the original to the newly created
QualType NewCallOpType = TransformFunctionProtoType(
                                               ExceptionStorage, Changed);
         });
     if (NewCallOpType.isNull())
       return ExprError();
     NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context,
                                                         NewCallOpType);
   }
 
-  LambdaScopeInfo *LSI = getSema().PushLambdaScope();
-  Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
-  LSI->GLTemplateParameterList = TPL;
-
   // Create the local class that will describe the lambda.
   CXXRecordDecl *OldClass = E->getLambdaClass();
   CXXRecordDecl *Class
     = getSema().createLambdaClosureType(E->getIntroducerRange(),
                                         NewCallOpTSI,
                                         /*KnownDependent=*/false,
                                         E->getCaptureDefault());
   getDerived().transformedLocalDecl(OldClass, {Class});

clang/test/SemaTemplate/default-arguments-cxx0x.cpp

-// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++14 -verify %s
 // expected-no-diagnostics
 
 // Test default template arguments for function templates.
 template<typename T = int>
 void f0();
 
 template<typename T>
 void f0();
namespace rdar34167492 {
   };
 
   class A {
     A() noexcept = default;
     A(const A&) noexcept = default;
     S<int> _a{};
   };
 }
+
+namespace lambda {
+template <class T>
+void bar() {
+  (void) [](auto c, int x = sizeof(decltype(c))) {};
+}
+void foo() {
+  bar<int>();
+}
+} // namespace lambda