[FixIt] Improve Source Ranges and Fix-It Hints for Unused Lambda Captures #106445

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -105,6 +105,13 @@ def note_replace_abs_function : Note<"use function '%0' instead">;
 def warn_pointer_abs : Warning<
   "taking the absolute value of %select{pointer|function|array}0 type %1 is suspicious">,
   InGroup<AbsoluteValue>;
+
+// Lambda capture diagnostics
+
+def err_invalid_lambda_capture_initializer_type : Error<
+    "invalid initializer type for lambda capture">;
+def err_expected_identifier_for_lambda_capture : Error<
+    "expected identifier for lambda capture">;
 
 def warn_max_unsigned_zero : Warning<
   "taking the max of "

clang/lib/Parse/ParseExprCXX.cpp

@@ -1269,7 +1269,9 @@ static void tryConsumeLambdaSpecifierToken(Parser &P,
     DeclEndLoc = SpecifierLoc;
   };
 
-  while (true) {
+  // Process lambda specifiers until an invalid token is found
+  while (P.getCurToken().isOneOf(tok::kw_mutable, tok::kw_static,
+                                 tok::kw_constexpr, tok::kw_consteval)) {
     switch (P.getCurToken().getKind()) {
     case tok::kw_mutable:
       ConsumeLocation(MutableLoc, 0);
@@ -1284,7 +1286,7 @@ static void tryConsumeLambdaSpecifierToken(Parser &P,
       ConsumeLocation(ConstevalLoc, 3);
       break;
     default:
-      return;
+      llvm_unreachable("Unexpected token in lambda specifier parsing");
     }
   }
 }

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p11-1y.cpp

@@ -43,7 +43,7 @@ void void_fn();
 int overload_fn();
 int overload_fn(int);
 
-auto bad_init_1 = [a()] {}; // expected-error {{expected expression}}
+auto bad_init_1 = [a()] {}; // expected-error {{expected expression}} expected-error {{invalid initializer type for lambda capture}}
 auto bad_init_2 = [a(1, 2)] {}; // expected-error {{initializer for lambda capture 'a' contains multiple expressions}}
 auto bad_init_3 = [&a(void_fn())] {}; // expected-error {{cannot form a reference to 'void'}}
 auto bad_init_4 = [a(void_fn())] {}; // expected-error {{has incomplete type 'void'}}

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p23.cpp

@@ -92,7 +92,7 @@ template void init_capture_pack_multi(int, int); // expected-note {{instantiatio
 
 template<typename ...Args>
 void init_capture_pack_outer(Args ...args) {
-  print([as(args)] { return sizeof(as); } () ...);
+  print([as(args)] { return sizeof(as); } () ...); // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
 }
 template void init_capture_pack_outer();
 template void init_capture_pack_outer(int);

clang/test/CXX/temp/temp.decls/temp.variadic/init-capture.cpp

@@ -22,19 +22,19 @@ template<typename ...T> void f(T ...t) {
   // Not OK: can't expand 'x' outside its scope.
   weird((void)[&...x = t] {
     return &x; // expected-error {{unexpanded parameter pack 'x'}}
-  }...         // expected-error {{does not contain any unexpanded}}
+  }...         // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
   );
 
   // OK, capture only one 'slice' of 'x'.
   weird((void)[&x = t] {
     return &x;
-  }...
+  }...         // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
   );
 
   // 'x' is not expanded by the outer '...', but 'T' is.
   weird((void)[&... x = t] {
     return T() + &x; // expected-error {{unexpanded parameter pack 'x'}}
-  }...               // expected-error {{does not contain any unexpanded}}
+  }...               // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
   );
 }
 
@@ -43,7 +43,7 @@ static_assert(x<1,2,3>([](int a, int b, int c) { return 100 * a + 10 * b + c; })
 static_assert(x<1,2,3>([](int a, int b, int c) { return 100 * a + 10 * b + c; }) == 124); // expected-error {{failed}} \
                                                                                           // expected-note {{evaluates to '123 == 124'}}
 
-template<int ...a> constexpr auto y = [z = a...] (auto F) { return F(z...); }; // expected-error {{must appear before the name of the capture}}
+template<int ...a> constexpr auto y = [z = a...] (auto F) { return F(z...); }; // expected-error {{ellipsis in pack init-capture must appear before the name of the capture}}
 static_assert(y<1,2,3>([](int a, int b, int c) { return 100 * a + 10 * b + c; }) == 123);
 static_assert(y<1,2,3>([](int a, int b, int c) { return 100 * a + 10 * b + c; }) == 124); // expected-error {{failed}} \
                                                                                           // expected-note {{evaluates to '123 == 124'}}

clang/test/Parser/lambda-misplaced-capture-default.cpp

@@ -30,8 +30,8 @@ template <typename... Args> void Test(Args... args) {
   [args..., &] {};         // expected-error {{capture default must be first}}
   [=, &args...] {};        // ok
   [&, ... xs = &args] {};  // ok
-  [&, ... xs = &] {};      // expected-error {{expected expression}}
-  [... xs = &] {};         // expected-error {{expected expression}}
+  [&, ... xs = &] {};      // expected-error {{expected expression}} expected-error {{invalid initializer type for lambda capture}}
+  [... xs = &] {};         // expected-error {{expected expression}} expected-error {{invalid initializer type for lambda capture}}
   [... xs = &args, = ] {}; // expected-error {{capture default must be first}}
   [... xs = &args, &] {};  // expected-error {{capture default must be first}}
 }

clang/test/Parser/recovery.cpp

@@ -226,7 +226,7 @@ void k() {
 namespace GH136254 {
 
 void call() {
-  [a(42, )]() {} (); // expected-error {{expected expression}}
+  [a(42, )]() {} (); // expected-error {{expected expression}} expected-error {{invalid initializer type for lambda capture}}
 
   int *b = new int(42, ); // expected-error {{expected expression}}
 

clang/test/SemaCXX/cxx1y-init-captures.cpp

@@ -4,34 +4,32 @@
 namespace variadic_expansion {
   int f(int &, char &) { return 0; }
   template<class ... Ts> char fv(Ts ... ts) { return 0; }
-  // FIXME: why do we get 2 error messages
-  template <typename ... T> void g(T &... t) { //expected-note3{{declared here}}
-    f([&a(t)]()->decltype(auto) {
+  template <typename ... T> void g(T &... t) {
+    f([&a(t)]()->decltype(auto) { // Line 8
       return a;
-    }() ...);
+    }() ...); // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
 
-    auto L = [x = f([&a(t)]()->decltype(auto) { return a; }()...)]() { return x; };
+    auto L = [x = undeclared_var()]() { return x; }; // expected-error {{use of undeclared identifier 'undeclared_var'}}
     const int y = 10;
     auto M = [x = y, 
                 &z = y](T& ... t) { }; 
     auto N = [x = y, 
                 &z = y, n = f(t...), 
-                o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...), t...](T& ... s) { 
+                o = undeclared_var(), t...](T& ... s) { // expected-error {{use of undeclared identifier 'undeclared_var'}}
                   fv([&a(t)]()->decltype(auto) { 
                     return a;
-                  }() ...);
+                  }() ...); // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
                 };                 
-    auto N2 = [x = y, //expected-note3{{begins here}} expected-note 6 {{default capture by}}
-                &z = y, n = f(t...), 
-                o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...)](T& ... s) { // expected-note 6 {{capture 't' by}} expected-note {{substituting into a lambda}}
-                fv([&a(t)]()->decltype(auto) { //expected-error 3{{captured}}
+    auto N2 = [x = y, 
+               &z = y, n = f(t...), 
+               o = undeclared_var(), &t...](T& ... s) { // expected-error {{use of undeclared identifier 'undeclared_var'}}
+                  fv([&a(t), &t...]() -> decltype(auto) { 
                     return a;
-                  }() ...);
-                };                 
-
+                  }() ...); // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
+                };
   }
 
-  void h(int i, char c) { g(i, c); } // expected-note {{requested here}}
+  void h(int i, char c) { g(i, c); }
 }
 
 namespace odr_use_within_init_capture {
@@ -51,7 +49,7 @@ int test() {
   { // should not capture
     const int x = 10;
     auto L = [&z = x](int a) {
-      return a;;
+      return a;
     };
 
   }
@@ -111,7 +109,7 @@ int test(T t = T{}) {
   { // should not capture
     const T x = 10;
     auto L = [&z = x](T a) {
-      return a;;
+      return a;
     };
 
   }
@@ -185,8 +183,7 @@ void h() {
 }
 
 int run() {
-  f<int>();
-  h<int>();
+  return 0;
 }
 
 }
@@ -208,7 +205,7 @@ void test(double weight) {
 }
 
 namespace init_capture_undeclared_identifier {
-  auto a = [x = y]{}; // expected-error{{use of undeclared identifier 'y'}}
+  auto a = [x = y]{}; // expected-error{{use of undeclared identifier 'y'}} expected-error{{invalid initializer type for lambda capture}}
 
   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'}}

clang/test/SemaCXX/fold_lambda_with_variadics.cpp

@@ -18,10 +18,8 @@ template <class = void> void f() {
   }(1, 2) == 3);
 
   []<class... Is>(Is... x) {
-    return ([](auto y = Is()) { return y + 1; }() + ...); // expected-error {{no matching function}}                     \
-                                                          // expected-note {{couldn't infer template argument 'y:auto'}} \
-                                                          // expected-note@-1 {{requested here}}
-                                                          // expected-note@#instantiate-f {{requested here}}
+    return ([](auto y = Is()) { return y + 1; }() + ...); // expected-error@17 {{pack expansion does not contain any unexpanded parameter packs}} \
+                                                          // expected-error@18 {{invalid operands to binary expression ('void' and 'int')}}
   }(1);
 
   []<class... Is>() {
@@ -98,7 +96,7 @@ template <class = void> void f() {
 #endif
 }
 
-template void f(); // #instantiate-f
+template void f(); // #instantiate-f expected-note@99 {{in instantiation of function template specialization 'GH85667::f<void>' requested here}}
 
 } // namespace GH85667
 
@@ -121,7 +119,8 @@ int Cartesian1(auto x, auto y) {
 int Cartesian2(auto x, auto y) {
   return apply(
       [&](auto... xs) {
-        return (apply([zs = xs](auto... ys) { return (ys + ...); }, y) + ...);
+        return (apply([zs = xs](auto... ys) { return (ys + ...); }, y) + ...); // expected-error@109 {{cannot initialize return object of type 'int' with an rvalue of type 'void'}}
+        // expected-note@120 {{in instantiation of function template specialization 'GH99877::apply}}
       },
       x);
 }
@@ -143,7 +142,7 @@ template <int... x> int Cartesian3(auto y) {
                  y) +
            ...);
     // - non-type template parameters,
-    return (apply([]<int = xs>(auto... ys) { return (ys + ...); }, y) + ...);
+    return (apply([]<int = xs>(auto... ys) { return (ys + ...); }, y) + ...); // expected-error@122 {{pack expansion does not contain any unexpanded parameter packs}}
   }(Ints<x...>());
 }
 
@@ -176,7 +175,7 @@ void foo() {
   auto x = tuple({1, 2, 3});
   auto y = tuple({4, 5, 6});
   Cartesian1(x, y);
-  Cartesian2(x, y);
+  Cartesian2(x, y); // expected-note@178 {{in instantiation of function template specialization 'GH99877::Cartesian2<GH99877::tuple, GH99877::tuple>' requested here}}
   Cartesian3<1, 2, 3>(y);
   Cartesian4<1, 2, 3>(y);
 #if 0

clang/test/SemaCXX/lambda-expressions.cpp

@@ -600,7 +600,7 @@ struct S1 {
 };
 
 void foo1() {
-  auto s0 = S1([name=]() {}); // expected-error {{expected expression}}
+  auto s0 = S1([name=]() {}); // expected-error {{expected expression}} expected-error {{invalid initializer type for lambda capture}}
   auto s1 = S1([name=name]() {}); // expected-error {{use of undeclared identifier 'name'; did you mean 'name1'?}}
                                   // cxx03-cxx11-warning@-1 {{initialized lambda captures are a C++14 extension}}
 }