PR45881: Properly use CXXThisOverride for templated lambda

[ychen]

Summary

• this used in lambda expression parameter declarations needs no capture.
• Set up CXXThisOverride for default template arguments of a lambda.

A similar fix to this is c3d2ebb60f604.

[aaron.ballman]

Mostly just superficial comments from me at this point.

clang/lib/Sema/SemaTemplate.cpp

5114–5115

clang/lib/Sema/SemaTemplateDeduction.cpp

2865

2867

[ychen]

• Address comments.

[ychen]

ping...

[ychen]

ping

[tambre]

clang/test/SemaCXX/cxx2a-lambda-decltype-this.cpp

1–4 ↗

(On Diff #346010)

-fblocks doesn't seem like it'd be necessary?

It would probably be a good idea to rename this to cxx20-lambda-decltype-this.cpp and use -std=c++20 from the get-go since C++20 has been finalized.

[ychen]

• address feedback

[gulfem]

We recently enabled assertions in our Fuchsia builds, and our builds started to fail:

FAILED: obj/src/lib/storage/vfs/cpp/libcpp.fuchsia_vfs.cc.o
../../../recipe_cleanup/clangLhcV7J/bin/clang++ -MD -MF obj/src/lib/storage/vfs/cpp/libcpp.fuchsia_vfs.cc.o.d -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS=1 -…
clang++: clang/lib/Sema/SemaExprCXX.cpp:1144: clang::QualType adjustCVQualifiersForCXXThisWithinLambda(ArrayRef<clang::sema::FunctionScopeInfo *>, clang::QualType, clang::DeclContext *, clang::ASTC…
clang++: error: clang frontend command failed with exit code 134 (use -v to see invocation)

https://luci-milo.appspot.com/ui/p/fuchsia/builders/ci/clang_toolchain.core.x64-debug/b8837288282633988801/overview

This patch seems to be fixing the issue that we are running.
Is there a way to speed up the process in this review, so our broken builds can be fixed?

[gulfem]

@aaron.ballman would it be possible for you to review this patch, so we can fix our broken builds?

[aaron.ballman]

LGTM, but please wait a day or so before landing in case @rsmith spots something I've missed (the only change I wasn't 100% certain on was lifting the assert predicate; it seems correct to me, but I'm wary of removing asserts).

[gulfem]

Any update on this review? Our builds are still broken.

[ychen]

In D102531#2987367, @gulfem wrote:

Any update on this review? Our builds are still broken.

I'll commit this by the end of the day if @rsmith wasn't able to take a look.

[gulfem]

I'll commit this by the end of the day if @rsmith wasn't able to take a look.

Sounds good, thank you very much!

clang/lib/Sema/SemaExprCXX.cpp

for (int I = FunctionScopes.size();
     if (C.isCopyCapture()) {
       ClassType.removeLocalCVRQualifiers(Qualifiers::CVRMask);
       if (CurLSI->CallOperator->isConst())
         ClassType.addConst();
       return ASTCtx.getPointerType(ClassType);
     }
   }
 
-  // 2) We've run out of ScopeInfos but check if CurDC is a lambda (which can
-  // happen during instantiation of its nested generic lambda call operator)
-  if (isLambdaCallOperator(CurDC)) {
-    assert(CurLSI && "While computing 'this' capture-type for a generic "
-                     "lambda, we must have a corresponding LambdaScopeInfo");
+  // 2) We've run out of ScopeInfos but check 1. if CurDC is a lambda (which
+  //    can happen during instantiation of its nested generic lambda call
+  //    operator); 2. if we're in a lambda scope (lambda body).
+  if (CurLSI && isLambdaCallOperator(CurDC)) {
     assert(isGenericLambdaCallOperatorSpecialization(CurLSI->CallOperator) &&
            "While computing 'this' capture-type for a generic lambda, when we "
            "run out of enclosing LSI's, yet the enclosing DC is a "
            "lambda-call-operator we must be (i.e. Current LSI) in a generic "
            "lambda call oeprator");
     assert(CurDC == getLambdaAwareParentOfDeclContext(CurLSI->CallOperator));
 
     auto IsThisCaptured =

clang/lib/Sema/SemaTemplate.cpp

if (ArgType->getType()->isInstantiationDependentType()) {
     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
 
     // Only substitute for the innermost template argument list.
     MultiLevelTemplateArgumentList TemplateArgLists;
     TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
     for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
       TemplateArgLists.addOuterTemplateArguments(None);
 
-    Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
+    bool ForLambdaCallOperator = false;
+    if (const auto *Rec = dyn_cast<CXXRecordDecl>(Template->getDeclContext()))
+      ForLambdaCallOperator = Rec->isLambda();
+    Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext(),
+                                   !ForLambdaCallOperator);
     ArgType =
         SemaRef.SubstType(ArgType, TemplateArgLists,
                           Param->getDefaultArgumentLoc(), Param->getDeclName());
   }
 
   return ArgType;
 }
 

clang/lib/Sema/SemaTemplateDeduction.cpp

for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
     bool HasDefaultArg = false;
     TemplateDecl *TD = dyn_cast<TemplateDecl>(Template);
     if (!TD) {
       assert(isa<ClassTemplatePartialSpecializationDecl>(Template) ||
              isa<VarTemplatePartialSpecializationDecl>(Template));
       return Sema::TDK_Incomplete;
     }
 
-    TemplateArgumentLoc DefArg = S.SubstDefaultTemplateArgumentIfAvailable(
+    TemplateArgumentLoc DefArg;
+    {
+      Qualifiers ThisTypeQuals;
+      CXXRecordDecl *ThisContext = nullptr;
+      if (auto *Rec = dyn_cast<CXXRecordDecl>(TD->getDeclContext()))
+        if (Rec->isLambda())
+          if (auto *Method = dyn_cast<CXXMethodDecl>(Rec->getDeclContext())) {
+            ThisContext = Method->getParent();
+            ThisTypeQuals = Method->getMethodQualifiers();
+          }
+
+      Sema::CXXThisScopeRAII ThisScope(S, ThisContext, ThisTypeQuals,
+                                       S.getLangOpts().CPlusPlus17);
+
+      DefArg = S.SubstDefaultTemplateArgumentIfAvailable(
           TD, TD->getLocation(), TD->getSourceRange().getEnd(), Param, Builder,
           HasDefaultArg);
+    }
 
     // If there was no default argument, deduction is incomplete.
     if (DefArg.getArgument().isNull()) {
       Info.Param = makeTemplateParameter(
           const_cast<NamedDecl *>(TemplateParams->getParam(I)));
       Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder));
       if (PartialOverloading) break;
 

clang/test/SemaCXX/cxx1z-lambda-star-this.cpp

auto m3() {
     return [] { return [] () -> decltype(data){ return 0; }; };
   }
 };
 
 } // namespace ns2
 
 } // namespace PR32831
 
+namespace PR45881 {
+struct A {
+    void f();
+};
+int id(A*);
+void A::f() {
+    auto z = [*this](auto z2, decltype(z2(this)) z3){};
+    z(id,3);
+}
+} // namespace PR45881

clang/test/SemaCXX/cxx20-lambda-decltype-this.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -emit-llvm-only %s
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fdelayed-template-parsing %s
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fms-extensions %s
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fdelayed-template-parsing -fms-extensions %s
+
+namespace PR45881 {
+struct A {
+    void f();
+};
+int id(A*);
+void A::f() {
+    auto z = [*this](auto z2, decltype(z2(this)) z3){};
+    z(id,3);
+}
+
+struct B {
+    void f();
+};
+void B::f() {
+    auto z = []<typename TT, typename TTT=decltype(TT()(this))>(){return 0;};
+    z.template operator()<int(*)(B*)>();
+}
+
+struct C {
+    void f();
+};
+void C::f() {
+    auto z = []<typename TT, decltype(TT()(this)) n>(){return 0;};
+    z.template operator()<int(*)(C*), 8>();
+}
+} // namespace PR45881