[PR36880] Avoid -Wunused-lambda-capture false positive for explicit this capture used in an unresolved member in a generic lambda

[arphaman]

Summary

Clang emits an incorrect -Wunused-lambda-capture for 'this' capture in a generic lambda in a template where 'this' is used implicitly in an unresolved member expression. This patch ensures that the use of 'this' is checked as a potential lambda capture use when the lambda is instantiated.

rdar://38803903

[efriedma]

lib/Sema/TreeTransform.h

11269

This doesn't make sense; in general, you can't tell whether an UnresolvedMemberExpr requires a "this" capture.

template<typename T> class C : T {
static int f(int);
int f(double);
public:
int g() {
  return []{ return f(T::x); }();
}
};

struct A { static int x; };
void x(C<A> c) { c.g(); }

[arphaman]

lib/Sema/TreeTransform.h

11269

Good point, we still emit a false positive warning for

template <class T> struct DummyTemplate {
  template <class T2> void methodTemplate(const T2 &) {}
  static void methodTemplate(float *) { }

  void ToTemplate(const int &param) {
    [this](const auto &p) { methodTemplate(p); }(param); // incorrect warning!
  }
};

void main() {
  int i = 0;
  DummyTemplate<bool> dt;
  dt.ToTemplate(i);
}

I will work on a better fix.

include/clang/AST/ExprCXX.h

CreateEmpty(const ASTContext &C, bool HasTemplateKWAndArgsInfo,
               unsigned NumTemplateArgs);
 
   /// \brief True if this is an implicit access, i.e., one in which the
   /// member being accessed was not written in the source.
   ///
   /// The source location of the operator is invalid in this case.
   bool isImplicitAccess() const;
 
+  /// True if this an implicit access with a 'this' base object.
+  bool isImplicitCXXThisAccess() const;
+
   /// \brief Retrieve the base object of this member expressions,
   /// e.g., the \c x in \c x.m.
   Expr *getBase() {
     assert(!isImplicitAccess());
     return cast<Expr>(Base);
   }
   const Expr *getBase() const {
     assert(!isImplicitAccess());

lib/AST/ExprCXX.cpp

 
 bool UnresolvedMemberExpr::isImplicitAccess() const {
   if (!Base)
     return true;
   
   return cast<Expr>(Base)->isImplicitCXXThis();
 }
 
+bool UnresolvedMemberExpr::isImplicitCXXThisAccess() const {
+  if (!Base)
+    return false;
+  return cast<Expr>(Base)->isImplicitCXXThis();
+}
+
 UnresolvedMemberExpr *UnresolvedMemberExpr::Create(
     const ASTContext &C, bool HasUnresolvedUsing, Expr *Base, QualType BaseType,
     bool IsArrow, SourceLocation OperatorLoc,
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
     const DeclarationNameInfo &MemberNameInfo,
     const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,
     UnresolvedSetIterator End) {
   bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();

lib/Sema/TreeTransform.h

     if (Base.isInvalid())
       return ExprError();
     Base = getSema().PerformMemberExprBaseConversion(Base.get(),
                                                      Old->isArrow());
     if (Base.isInvalid())
       return ExprError();
     BaseType = Base.get()->getType();
   } else {
+    // Check an implicit 'this' base expression to ensure that an explicit
+    // 'this' capture is marked as 'used'.
+    if (Old->isImplicitCXXThisAccess())
+      getSema().CheckCXXThisCapture(Old->getMemberNameInfo().getLoc(),
+                                    /*Explicit=*/false,
+                                    /*BuildAndDiagnose=*/false);
     BaseType = getDerived().TransformType(Old->getBaseType());
   }
 
   NestedNameSpecifierLoc QualifierLoc;
   if (Old->getQualifierLoc()) {
     QualifierLoc
     = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
     if (!QualifierLoc)

test/SemaCXX/warn-unused-lambda-capture.cpp

 namespace pr35555 {
 int a;
 void b() {
   int c[a];
   auto vla_used = [&c] { return c[0]; };
   auto vla_unused = [&c] {}; // expected-warning{{lambda capture 'c' is not used}}
 }
 } // namespace pr35555
+
+namespace pr36880 {
+
+template <class T> struct DummyTemplate {
+  template <class T2> void methodTemplate(const T2 &) {}
+
+  void ToTemplate(const int &param) {
+    [this](const auto &p) { methodTemplate(p); }(param); // no warning
+  }
+};
+
+void main() {
+  int i = 0;
+  DummyTemplate<bool> dt;
+  dt.ToTemplate(i);
+}
+
+} // namespace pr36880