[Clang] Implement P2169 A nice placeholder with no name

[cor3ntin]

Summary

This is a C++ feature that allows the use of _ to
declare multiple variable of that name in the same scope;
these variables can then not be referred to.

In addition, while P2169 does not extend to parameter
declarations, we stop warning on unused parameters of that name,
for consistency.

The feature is backported to all C++ language modes.

[tbaeder]

clang/test/Lexer/unicode.c

30

Are these changes only for the case where we compile as c++? I know lots of C (and c++?) projects use _ as GNU gettext identifier to mark a translatable string.

[cor3ntin]

clang/test/Lexer/unicode.c

30

Are these changes only for the case where we compile as c++

Yes

I know lots of C (and c++?) projects use _ as GNU gettext identifier to mark a translatable string.

That's doesn't interfere with this feature. if _ is defined as a macro, it's simply not possible to declare a variable of that name, let alone more than one.

[erichkeane]

clang/lib/Sema/SemaDecl.cpp

2031

Why would we get here? Doesn't line 1995 pick this up? Or am I missing where D is modified?

ALSO, I'd suggest making this VD->isPlaceholderVar, as to not annoy the SA tools.

clang/lib/Sema/SemaDeclCXX.cpp

726

Not a fan of this function name... Perhaps Diag instead of Note?

[shafik]

clang/lib/AST/Decl.cpp

1867

It is not obvious to me if this is a drive by fix or this has a larger effect in the context of this change. Is there a test that demonstrates the effect of this change?

[shafik]

clang/lib/Sema/SemaDecl.cpp

18284

Why can't we fold this into FieldDecl::Create? This comment applies in some other places as well.

[cor3ntin]

• Address Shafik's an Erich's comments
• Add missing serialization code

[cor3ntin]

clang/lib/AST/Decl.cpp

1867

That's a left over from when the patched allowed placeholder in parameter names (EWG voted against that). thanks!

clang/lib/Sema/SemaDecl.cpp

2031

Yep, this was dead code, thanks!

18284

By adding a parameter to FieldDecl::Create? We could, I'm not sure it would necessarily be cleaner. Let me know what you prefer.

[cor3ntin]

Rebase

[ChuanqiXu]

clang/lib/Serialization/ASTWriterDecl.cpp

2043 ↗

(On Diff #534329)

In case IsPlaceholder must be 0 when use the abbreviation for FieldDecl, it is better to use Abv->Add(BitCodeAbbrevOp(0)); here.

2077 ↗

(On Diff #534329)

ditto

2233 ↗

(On Diff #534329)

ditto

2311 ↗

(On Diff #534329)

ditto.

[cor3ntin]

Address ChuanqiXu's feedback

[cor3ntin]

• Fix missed Decl abbreviation change
• Fix feature macro test

[shafik]

clang/lib/Sema/SemaDecl.cpp

18284

It seems like having the code consolidated make for better maintainability and figuring this out for future folks but I am willing to be convinced otherwise.

[aaron.ballman]

clang/docs/ReleaseNotes.rst

68–69

Should we consider adding this as an extension to C? It would be conforming there as well because it wouldn't change the behavior of any correct C code, right?

clang/include/clang/AST/DeclBase.h

340–342 ↗

(On Diff #534592)

This seems a bit heavy to put on every Decl, it only matters for declarations with names, right? Should this be on NamedDecl instead? And should it be using terminology like "name independent"?

Actually, do we need this bit at all? Would it work for NamedDecl to have a function that returns whether the declaration name is _ or not? Oh, I suppose we can't get away with that because void _(int x); does not introduce a placeholder identifier but a regular one, right?

clang/include/clang/Basic/DiagnosticSemaKinds.td

6615

I don't think this helps the user understand what's wrong with their code, especially given the somewhat odd language rules around the feature. How about: ambiguous reference to multiply-defined placeholder '_' or something along those lines? Then the note can show the previous declarations of the placeholders that are in scope? e.g.,

void g() {
int _; // note: placeholder declared here
_ = 0;
int _; // note: placeholder declared here
_ = 0; // error: `ambiguous reference to multiply-defined placeholder '_'`
}

CC @cjdb

clang/include/clang/Sema/Lookup.h

121

clang/lib/Sema/SemaDecl.cpp

2179–2180

What's the rationale here? I know the standard has a recommended practice, but I don't see why that should apply to the case where the user assigns a value to the placeholder but never references it otherwise.

7528

Please spell out the type here.

7529

7531–7533

8377

18284

We need to support partial construction because of AST deserialization, but it seems to me that we don't need to add a new parameter to FieldDecl::Create() anyway; can't we have the FieldDecl constructor look at the given IdentifierInfo * in that case, and if it's nonnull, set the placeholder from that?

clang/lib/Sema/SemaDeclCXX.cpp

887

assert(VarName && "Cannot have an unnamed binding declaration"); ?

919

clang/lib/Sema/SemaLambda.cpp

1151–1153

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

32

I don't understand what this diagnostic is trying to tell me, can you explain a bit more?

80

Weird.. is this expected? You can have two variables named _ in block scope, but you can't have two parameters named _ despite them inhabiting the same block scope?

[cjdb]

clang/include/clang/Basic/DiagnosticSemaKinds.td

6615

Agreed. I'd suggest a rewording though: I took "multiply" to mean the maths term until completing the sentence, rather than its alternative meaning of "multiple instances" (which is more or less the same meaning, but "multiply" maps to the x * y operation for me).

Perhaps ambiguous reference to placeholder '_', which has multiple definitions? Not sold on that being the best wording, but it does avoid the hardcoded-word-at-8yo problem :)

[cor3ntin]

clang/docs/ReleaseNotes.rst

68–69

Maybe we should consult WG14 first?
It's of very questionable usefulness without structured bindings and destructors.

clang/include/clang/AST/DeclBase.h

340–342 ↗

(On Diff #534592)

I think you made me realize we can probably compute that completely without using bits. Oups.
It would certainly simplify things. I'll investigate!

clang/include/clang/Basic/DiagnosticSemaKinds.td

6615

@cjdb I like your suggestion. maybe "which is defined multiple times?" - pedantically a bunch of things have been defined once each, it's not a redefinition of the same entity in the c++ sense

clang/lib/Sema/SemaDecl.cpp

2179–2180

The intent is that this behave like [[maybe_unused]]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

32

The no side effect one?
You are assigning something that has no side effect to something that you may never be able to name, so the whole thing is likely dead code.
I welcome improvements suggestions

80

Yes, CWG decided against having it in parameter declarations, because otherwise we'd need them in template parameters which we didn't want to do.
And it would be useless, you can simply not name them.

[cor3ntin]

Address some of Aarons comments before getting rid of the bit in Decl

[aaron.ballman]

clang/docs/ReleaseNotes.rst

68–69

We certainly could ask WG14 for their opinion, but the scenario I was thinking this would help with is for complex macros where variables are sometimes defined but the names are not important as they shouldn't escape. However, I think those scenarios generally introduce different scopes (often with GNU statement expressions) so there's not a naming conflict that we'd need to avoid. So I'm fine skipping C for now until we hit a concrete use case.

clang/include/clang/AST/DeclBase.h

340–342 ↗

(On Diff #534592)

Thank you!

clang/include/clang/Basic/DiagnosticSemaKinds.td

6615

I like either of your suggestions better than my use of "multiply-defined." :-)

clang/lib/Sema/SemaDecl.cpp

2179–2180

Ah, thank you! I think we should make a slightly wider change here then. Let's move VD->hasAttr<UnusedAttr>() out of the first if statement and into this one, then add a comment about the relationship between the attribute and this feautre. WDYT?

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

32

Yeah, the no side effect one.

Corentin and I discussed this off-list and I understand the situation a bit better now. Basically, an init capture named _ either has a side effect on construction and/or destruction (like an RAII object) or it cannot be used within the lambda. However, it does still have effects (for example, it impacts whether the lambda has a function conversion operator).

That makes this kind of tricky to word. Given that it's a QoI warning, I'd recommend we leave this bit for a follow-up so that we can land the majority of the functionality and we can add the safety rails later.

80

I guess I see the same amount of utility in allowing an init capture named _ as I do a function parameter named _ as a local variable named _ (if it is an RAII type, it can do useful things in theory; otherwise, it's not a useful declaration).

[cor3ntin]

• Address more feedback
• reword diag
• remove diag for unused init capture
• Remove the IsPlaceholder bit, as placeholder variables can be determined without data

[cor3ntin]

clang/include/clang/AST/DeclBase.h

340–342 ↗

(On Diff #534592)

Removed!

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

32

Removed

80

side effects are the main motivation for local variables beside structured bindings (and pattern matching later)

[aaron.ballman]

I've not spotted anything major, but I would like some additional test coverage. Btw, you need to add this to the table in https://github.com/llvm/llvm-project/blob/189033e6bede96de0d74e61715fcd1b48d95e247/clang/docs/LanguageExtensions.rst?plain=1#L1429 because this is an extension we intentionally support in older language modes (we want to let folks like libc++ rely on this behavior in Clang).

clang/lib/AST/Decl.cpp

1113–1120

clang/lib/Sema/SemaDecl.cpp

1979–1980

This could take const LangOptions & instead of const Sema & as we don't actually use Sema here.

[aaron.ballman]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

4

Can you also add tests for global namespace and anonymous namespaces?

Can you add coverage for:

int _ = 12;
auto lam = [_ = 0]{}; // gets a placeholder extension warning (I don't think we issue a shadow warning currently, but probably should?)

and

void func() {
  // Is a placeholder variable and so it does not get a -Wunused-but-set warning despite
  int _ = 12;
  int x = 12; // Gets -Wunused-but-set warning
}

20

I think we want additional comments explaining why there's only three instances of this warning instead of four because this situation is kind of weird. The first declaration *is* a placeholder, so we suppress unused variable warnings for it. However, because a single variable named _ is valid code in earlier language modes, it's not really an *extension* until we introduce the second variable named _ in the same scope in terms of conformance. It doesn't help users to issue an extension warning on the first declaration because the diagnostic behavior change is more likely appreciated than a surprising change.

I think this information should be documented somewhere (perhaps just in the release notes with an example since we don't have much to document about the extension itself).

53

64–71

Can you add a test for this case:

struct WhoWritesCodeLikeThis {
  int _;
  void f() {
    int _;
    _ = 12; // Not ambiguous reference to placeholder, accesses the local variable which shadows the field
    (void)({ int _ = 12; _;}); // Also not an ambiguous reference to a placeholder, accesses the GNU statement expression variable which shadows the local variable
  }
  // None of the _ declarations should get the extension warning
};

and for:

typedef int _;
typedef int _; // Not a placeholder, but also not a redefinition, so this_is_fine.gif

and for:

struct S {
  int _, _;
};
constexpr int oh_no = __builtin_offsetof(S, _); // Ambiguous reference error
int S::* ref = &S::_; // Ambiguous reference error

and for:

struct S {
  int _, _;
  void func() __attribute__((diagnose_if(_ != 0, "oh no!", "warning")));
};

[cor3ntin]

• Address Aaron's feedback
  • Add more tests
  • Add a longer description of the feature in the release notes
  • address nitpicks

• Improve error message when using __builtin_offsetof

[aaron.ballman]

CCing David and Eric -- do you see any concerns regarding debug information for these changes?

[cor3ntin]

Some tests with lldb

(lldb) b main
Breakpoint 1: where = placeholder`main + 4 at debug_placeholder.cpp:2:9, address = 0x0000555555555134
(lldb) run
Process 4044833 launched: '/home/cor3ntin/dev/compilers/LLVM/build-release/placeholder' (x86_64)
Process 4044833 stopped
* thread #1, name = 'placeholder', stop reason = breakpoint 1.1
    frame #0: 0x0000555555555134 placeholder`main at debug_placeholder.cpp:2:9
   1    int main() {
-> 2        int _ = 0;
   3        int _ = 0;
   4        int _ = 0;
   5        {
   6            int _ = 0;
   7            int _ = 0;
(lldb) step
Process 4044833 stopped
* thread #1, name = 'placeholder', stop reason = step in
    frame #0: 0x000055555555513b placeholder`main at debug_placeholder.cpp:3:9
   1    int main() {
   2        int _ = 0;
-> 3        int _ = 0;
   4        int _ = 0;
   5        {
   6            int _ = 0;
   7            int _ = 0;
(lldb) step
Process 4044833 stopped
* thread #1, name = 'placeholder', stop reason = step in
    frame #0: 0x0000555555555142 placeholder`main at debug_placeholder.cpp:4:9
   1    int main() {
   2        int _ = 0;
   3        int _ = 0;
-> 4        int _ = 0;
   5        {
   6            int _ = 0;
   7            int _ = 0;
(lldb) frame variable
(int) _ = 0
(int) _ = 0
(int) _ = 0
(lldb) step
Process 4044833 stopped
* thread #1, name = 'placeholder', stop reason = step in
    frame #0: 0x0000555555555149 placeholder`main at debug_placeholder.cpp:6:13
   3        int _ = 0;
   4        int _ = 0;
   5        {
-> 6            int _ = 0;
   7            int _ = 0;
   8        }
   9    }
(lldb) step
Process 4044833 stopped
* thread #1, name = 'placeholder', stop reason = step in
    frame #0: 0x0000555555555150 placeholder`main at debug_placeholder.cpp:7:13
   4        int _ = 0;
   5        {
   6            int _ = 0;
-> 7            int _ = 0;
   8        }
   9    }
(lldb) frame variable
(int) _ = 0
(int) _ = 0
(int) _ = 0
(int) _ = 0
(int) _ = 32767
(lldb)

Seems to work well enough @hubert.reinterpretcast

[hubert.reinterpretcast]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

Can we have tests for:

struct { int _, _; } a = { ._ = 0 };

and

struct A {
  A();
  int _, _;
};

A::A() : _(0) {}

[dblaikie]

Maybe try testing with more different values, to demonstrate which entities the debugger is finding?

int _ = 1;
int _ = 2;
{
  int _ = 3;
  int _ = 7;
}

Or something like that. But, honestly, if the point is that these variables should be unnameable - perhaps we shouldn't generate any DWARF for them?

[hubert.reinterpretcast]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

Codegen test for

static union { int _ = 42; };
int &ref = _;
int foo() { return 13; }
static union { int _ = foo(); };
int main(void) { return ref; }

might be interesting.

I suspect that this case was missed in the committee discussion of the paper @cor3ntin.

3

Less controversial tests to consider:

struct A {
  int _;
  union { int _; };
};
struct B { union { int _, _; }; };

[hubert.reinterpretcast]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

In a similar vein, a codegen test for:

struct A { A(); };
inline void f [[gnu::used]]() {
  static union { A _{}; };
  static union { A _{}; };
}

Perhaps not intended to be allowed though (premise was no symbols with "linkage"?)

[cor3ntin]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

What's interesting about

static union { int _ = 42; };
int &ref = _;
int foo() { return 13; }
static union { int _ = foo(); };
int main(void) { return ref; }

?
It's already supported by clang https://godbolt.org/z/6j89EdnEo

I'm adding the other tests (and fixing the associated bugs, of which there were a few...)

3

Perhaps not intended to be allowed though (premise was no symbols with "linkage"?)

Yes, this should be ill-formed, anything where we would have to mangle multiple _ should be ill-formed.
I do believe that's covered though, _ does not have storage duration.

[cor3ntin]

In D153536#4474733, @dblaikie wrote:

Maybe try testing with more different values, to demonstrate which entities the debugger is finding?

int _ = 1;
int _ = 2;
{
  int _ = 3;
  int _ = 7;
}

Or something like that. But, honestly, if the point is that these variables should be unnameable - perhaps we shouldn't generate any DWARF for them?

The variables should still be inspectable, ideally. It's true it makes no sense to be able to use them in expressions, and maybe if lldb use clang to evaluate expressions that would just work?

[philnik]

Would it be possible to make __ also a placeholder, so standard libraries can use this before C++26? Or is _ already a reserved identifier? (I don't think so)

[dblaikie]

In D153536#4475199, @cor3ntin wrote:

In D153536#4474733, @dblaikie wrote:

Maybe try testing with more different values, to demonstrate which entities the debugger is finding?

int _ = 1;
int _ = 2;
{
  int _ = 3;
  int _ = 7;
}

Or something like that. But, honestly, if the point is that these variables should be unnameable - perhaps we shouldn't generate any DWARF for them?

The variables should still be inspectable, ideally. It's true it makes no sense to be able to use them in expressions, and maybe if lldb use clang to evaluate expressions that would just work?

I think that's going to be tricky - because we don't emit DWARF to say where one variable's lifetime starts compared to another in the same scope - so likely a debugger would just always show the first or last variable with the same name in a given scope (so in the above example you could probably only print {1,3} or {2,7}) - and getting it wrong is more likely and more problematic than existing cases of shadowed variables. If we can't get this right, which I don't think we can, practically speaking, at the moment (the DWARF feature we'd have to support to do this better would probably be DW_AT_start_scope to say at what instruction the lifetime of a variable starts) - it may be best not to include it at all?

[cor3ntin]

In D153536#4475240, @dblaikie wrote:

In D153536#4475199, @cor3ntin wrote:

In D153536#4474733, @dblaikie wrote:

Maybe try testing with more different values, to demonstrate which entities the debugger is finding?

int _ = 1;
int _ = 2;
{
  int _ = 3;
  int _ = 7;
}

Or something like that. But, honestly, if the point is that these variables should be unnameable - perhaps we shouldn't generate any DWARF for them?

The variables should still be inspectable, ideally. It's true it makes no sense to be able to use them in expressions, and maybe if lldb use clang to evaluate expressions that would just work?

I think that's going to be tricky - because we don't emit DWARF to say where one variable's lifetime starts compared to another in the same scope - so likely a debugger would just always show the first or last variable with the same name in a given scope (so in the above example you could probably only print {1,3} or {2,7}) - and getting it wrong is more likely and more problematic than existing cases of shadowed variables. If we can't get this right, which I don't think we can, practically speaking, at the moment (the DWARF feature we'd have to support to do this better would probably be DW_AT_start_scope to say at what instruction the lifetime of a variable starts) - it may be best not to include it at all?

It doesn't seems to be confused on simple examples

cpp
* thread #1, name = 'placeholder', stop reason = step in
    frame #0: 0x0000555555555157 placeholder`main at debug_placeholder.cpp:8:13
   5        {
   6            int _ = 4;
   7            int _ = 5;
-> 8            int _ = 6;
   9        }
   10   }
(lldb) frame variable
(int) _ = 1
(int) _ = 2
(int) _ = 3
(int) _ = 4
(int) _ = 5
(int) _ = -9432

That being said, if you think it's more prudent, I would not mind

[cor3ntin]

In D153536#4475215, @philnik wrote:

Would it be possible to make __ also a placeholder, so standard libraries can use this before C++26? Or is _ already a reserved identifier? (I don't think so)

I don't see an issue allowing that in the std namespace. If we allow it everywhere, I'm afraid people will rely on it, which would hurt portability/be confusing.

[cor3ntin]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

What's interesting about

static union { int _ = 42; };
int &ref = _;
int foo() { return 13; }
static union { int _ = foo(); };
int main(void) { return ref; }

?
It's already supported by clang https://godbolt.org/z/6j89EdnEo

I'm adding the other tests (and fixing the associated bugs, of which there were a few...)

I see it now. Thanks, I hate it. There is apparently a preexisting bug.
And yes, i think we should say something about members of anonymous union declared at namespace scope in the standard.... I realize now this is missing
Thanks for catching that.

[hubert.reinterpretcast]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

Thanks for catching that.

Glad to be of help!

[hubert.reinterpretcast]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

I do believe that's covered though, _ does not have storage duration.

It's not covered by the wording: _ is a non-static data member.

[dblaikie]

In D153536#4475308, @cor3ntin wrote:

In D153536#4475240, @dblaikie wrote:

In D153536#4475199, @cor3ntin wrote:

In D153536#4474733, @dblaikie wrote:

Maybe try testing with more different values, to demonstrate which entities the debugger is finding?

int _ = 1;
int _ = 2;
{
  int _ = 3;
  int _ = 7;
}

Or something like that. But, honestly, if the point is that these variables should be unnameable - perhaps we shouldn't generate any DWARF for them?

The variables should still be inspectable, ideally. It's true it makes no sense to be able to use them in expressions, and maybe if lldb use clang to evaluate expressions that would just work?

I think that's going to be tricky - because we don't emit DWARF to say where one variable's lifetime starts compared to another in the same scope - so likely a debugger would just always show the first or last variable with the same name in a given scope (so in the above example you could probably only print {1,3} or {2,7}) - and getting it wrong is more likely and more problematic than existing cases of shadowed variables. If we can't get this right, which I don't think we can, practically speaking, at the moment (the DWARF feature we'd have to support to do this better would probably be DW_AT_start_scope to say at what instruction the lifetime of a variable starts) - it may be best not to include it at all?

It doesn't seems to be confused on simple examples

cpp
* thread #1, name = 'placeholder', stop reason = step in
    frame #0: 0x0000555555555157 placeholder`main at debug_placeholder.cpp:8:13
   5        {
   6            int _ = 4;
   7            int _ = 5;
-> 8            int _ = 6;
   9        }
   10   }
(lldb) frame variable
(int) _ = 1
(int) _ = 2
(int) _ = 3
(int) _ = 4
(int) _ = 5
(int) _ = -9432

That being said, if you think it's more prudent, I would not mind

Huh, I guess maybe it's got some heuristics based on line number. Could probably thwart those by stamping this out with a macro (which would cause all code in the macro to be attributed to the line where the macro is named) - add some function calls in, so you can step back up from the call to get to more precise locations and you'd probably see some problems. That's probably a bit contrived (but maybe not - perhaps _ would be more common in macros).

*shrug* maybe it's OK enough.

[cor3ntin]

Address Hubert's feedback

• Add code and tests to properly support member initializer
• Add code and tests to support designated initializers
• Correctly hamdle members of anonymous union
• Make placeholder redeclaration in anonymous static union ill-formed, even if the wording fails to handle that case.

[cor3ntin]

Add tests for static structured bindings

[hubert.reinterpretcast]

In D153536#4474066, @cor3ntin wrote:

Seems to work well enough @hubert.reinterpretcast

It seems the class member case trips up debuggers.

union U {
  struct A { int _, _; } a;
  struct B { int x, y; } b;
};
U u = {{1, 2}};

int main(void) { return u.b.x; }

(lldb) b main
Breakpoint 1: where = a.out`main + 28 at placeholderDbg.cc:7:18, address = 0x000000000001080c
(lldb) r
Process 2339034 launched: '/terrannew/hstong/.Lpcoral03/llvmbld/a.out' (powerpc64le)
Process 2339034 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x000000010001080c a.out`main at placeholderDbg.cc:7:18
   4    };
   5    U u = {{1, 2}};
   6
-> 7    int main(void) { return u.b.x; }
(lldb) print u
(U) {
  a = (_ = 1)
  b = (x = 1, y = 2)
}
(lldb)

[hubert.reinterpretcast]

In D153536#4479275, @hubert.reinterpretcast wrote:

It seems the class member case trips up debuggers.

If llvm-dwarfdump is to be believed, it looks like a compiler bug (two members reported at the same offset).

0x000000a3:       DW_TAG_member [4]   (0x0000009d)
                    DW_AT_name [DW_FORM_string] ("_")
                    DW_AT_type [DW_FORM_ref4]   (cu + 0x00de => {0x000000de} "int")
                    DW_AT_decl_file [DW_FORM_data1]     ("/terrannew/hstong/.Lpcoral03/llvmbld/placeholderDbg.cc")
                    DW_AT_decl_line [DW_FORM_data1]     (2)
                    DW_AT_data_member_location [DW_FORM_data1]  (0x00)

0x000000ad:       DW_TAG_member [4]   (0x0000009d)
                    DW_AT_name [DW_FORM_string] ("_")
                    DW_AT_type [DW_FORM_ref4]   (cu + 0x00de => {0x000000de} "int")
                    DW_AT_decl_file [DW_FORM_data1]     ("/terrannew/hstong/.Lpcoral03/llvmbld/placeholderDbg.cc")
                    DW_AT_decl_line [DW_FORM_data1]     (2)
                    DW_AT_data_member_location [DW_FORM_data1]  (0x00)

[hubert.reinterpretcast]

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

@cor3ntin, it seems the designated initializer case has not been added.

47

Just noting: This case is allowed by the wording, and I suspect it requires extended discussion.

[hubert.reinterpretcast]

In D153536#4483182, @hubert.reinterpretcast wrote:

If llvm-dwarfdump is to be believed, it looks like a compiler bug (two members reported at the same offset).

Similarly, only one local variable out of two in the same line reported:

$ cat placeholderDbg2.cc
extern "C" int printf(const char *, ...);
struct A {
  A(int x) : x(x) { }
  ~A() { printf("%d\n", x); }
  int x;
};
int main() {
  A _ = 0, _ = 1;
  return 0;
}
Return:  0x00:0   Sat Jul  8 23:52:46 2023 EDT

(lldb) target create "a.out"
Current executable set to '/terrannew/hstong/.Lpcoral03/llvmbld/a.out' (powerpc64le).
(lldb) b 9
Breakpoint 1: where = a.out`main + 68 at placeholderDbg2.cc:9:3, address = 0x0000000000010ab4
(lldb) r
Process 2951717 launched: '/terrannew/hstong/.Lpcoral03/llvmbld/a.out' (powerpc64le)
Process 2951717 stopped
* thread #1, name = 'a.out', stop reason = breakpoint 1.1
    frame #0: 0x0000000100010ab4 a.out`main at placeholderDbg2.cc:9:3
   6    };
   7    int main() {
   8      A _ = 0, _ = 1;
-> 9      return 0;
   10   }
(lldb) var
(A) _ = (x = 0)
(lldb) c
Process 2951717 resuming
1
0
Process 2951717 exited with status = 0 (0x00000000)
(lldb) q

0x0000009b:   DW_TAG_subprogram [14] * (0x0000000b)
                DW_AT_low_pc [DW_FORM_addr]     (0x0000000000010a70)
                DW_AT_high_pc [DW_FORM_data4]   (0x000000b4)
                DW_AT_frame_base [DW_FORM_exprloc]      (DW_OP_reg31 X31)
                DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000086] = "main")
                DW_AT_decl_file [DW_FORM_data1] ("/terrannew/hstong/.Lpcoral03/llvmbld/placeholderDbg2.cc")
                DW_AT_decl_line [DW_FORM_data1] (7)
                DW_AT_type [DW_FORM_ref4]       (cu + 0x008f => {0x0000008f} "int")
                DW_AT_external [DW_FORM_flag_present]   (true)

0x000000b4:     DW_TAG_variable [15]   (0x0000009b)
                  DW_AT_location [DW_FORM_exprloc]      (DW_OP_fbreg +128)
                  DW_AT_name [DW_FORM_strp]     ( .debug_str[0x0000008b] = "_")
                  DW_AT_decl_file [DW_FORM_data1]       ("/terrannew/hstong/.Lpcoral03/llvmbld/placeholderDbg2.cc")
                  DW_AT_decl_line [DW_FORM_data1]       (8)
                  DW_AT_type [DW_FORM_ref4]     (cu + 0x005a => {0x0000005a} "A")

0x000000c3:     NULL

[cor3ntin]

Add more lookup tests

[cor3ntin]

Add missing designated initializer test

[hubert.reinterpretcast]

In D153536#4483191, @hubert.reinterpretcast wrote:

Similarly, only one local variable out of two in the same line reported:

I can confirm that adding a lexical block scope causes both variables to be recorded into the debug info (thus this is a debug info generation issue unique to the new feature).

[cor3ntin]

@dblaikie Would you be willing to look at the debugger side of things in a subsequent patch? I'm not familiar with debug symbol code gen so I'm not sure I'd be able to improve thing the right way.

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

3

Thanks for noticing!

[hubert.reinterpretcast]

clang/docs/ReleaseNotes.rst

68–71

Use double backticks to start/end inline code in RST.

clang/lib/Sema/SemaInit.cpp

2695

Needs rebase on top of 632dd6a4ca00.

[dblaikie]

In D153536#4490918, @cor3ntin wrote:

@dblaikie Would you be willing to look at the debugger side of things in a subsequent patch? I'm not familiar with debug symbol code gen so I'm not sure I'd be able to improve thing the right way.

Not sure I've got the time to do the fix myself, but might be able to provide pointers.

but at least at a first blush I can't reproduce the failures shown...

struct t1 {
  int _;
  int _;
};
t1 v1;
int main() {
  int _;
  int _;
}

0x0000002e:   DW_TAG_structure_type
                DW_AT_calling_convention        (DW_CC_pass_by_value)
                DW_AT_name      ("t1")
                DW_AT_byte_size (0x08)
                DW_AT_decl_file ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                DW_AT_decl_line (1)

0x00000034:     DW_TAG_member
                  DW_AT_name    ("_")
                  DW_AT_type    (0x00000047 "int")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                  DW_AT_decl_line       (2)
                  DW_AT_data_member_location    (0x00)

0x0000003d:     DW_TAG_member
                  DW_AT_name    ("_")
                  DW_AT_type    (0x00000047 "int")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                  DW_AT_decl_line       (2)
                  DW_AT_data_member_location    (0x00)

0x00000046:     NULL

0x00000047:   DW_TAG_base_type
                DW_AT_name      ("int")
                DW_AT_encoding  (DW_ATE_signed)
                DW_AT_byte_size (0x04)

0x0000004b:   DW_TAG_subprogram
                DW_AT_low_pc    (0x0000000000000000)
                DW_AT_high_pc   (0x0000000000000008)
                DW_AT_frame_base        (DW_OP_reg6 RBP)
                DW_AT_name      ("main")
                DW_AT_decl_file ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                DW_AT_decl_line (6)
                DW_AT_type      (0x00000047 "int")
                DW_AT_external  (true)

0x0000005a:     DW_TAG_variable
                  DW_AT_location        (DW_OP_fbreg -4)
                  DW_AT_name    ("_")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                  DW_AT_decl_line       (7)
                  DW_AT_type    (0x00000047 "int")

0x00000065:     DW_TAG_variable
                  DW_AT_location        (DW_OP_fbreg -8)
                  DW_AT_name    ("_")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                  DW_AT_decl_line       (8)
                  DW_AT_type    (0x00000047 "int")

Looks OK to me - two local variables with the same name, two member variables with the same name.

so probably at least one bug in lldb because it does seem to think t1 has only one member. But the DWARF I see for the local variables doesn't seem to match the dump shown in https://reviews.llvm.org/D153536#4483191

[cor3ntin]

FYI, my current aim is to land that early in the Clang 18 cycle, that should give us time to find any remaining issue and maybe improve debugger support!

[hubert.reinterpretcast]

In D153536#4512897, @dblaikie wrote:

but at least at a first blush I can't reproduce the failures shown...

@dblaikie, you did reproduce the issue with the members. Both entries have DW_AT_decl_line 2 and DW_AT_data_member_location 0 (the second entry should indicate DW_AT_decl_line 3 and DW_AT_data_member_location 4):

0x0000002e:   DW_TAG_structure_type
                DW_AT_calling_convention        (DW_CC_pass_by_value)
                DW_AT_name      ("t1")
                DW_AT_byte_size (0x08)
                DW_AT_decl_file ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                DW_AT_decl_line (1)

0x00000034:     DW_TAG_member
                  DW_AT_name    ("_")
                  DW_AT_type    (0x00000047 "int")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                  DW_AT_decl_line       (2)
                  DW_AT_data_member_location    (0x00)

0x0000003d:     DW_TAG_member
                  DW_AT_name    ("_")
                  DW_AT_type    (0x00000047 "int")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                  DW_AT_decl_line       (2)
                  DW_AT_data_member_location    (0x00)

0x00000046:     NULL

As for the block-scope case, I am still able to reproduce the issue (and also your result that does not exhibit the issue). The key seems to be having the _s on the same line.

[dblaikie]

In D153536#4521156, @hubert.reinterpretcast wrote:

In D153536#4512897, @dblaikie wrote:

but at least at a first blush I can't reproduce the failures shown...

@dblaikie, you did reproduce the issue with the members. Both entries have DW_AT_decl_line 2 and DW_AT_data_member_location 0 (the second entry should indicate DW_AT_decl_line 3 and DW_AT_data_member_location 4):

0x0000002e:   DW_TAG_structure_type
                DW_AT_calling_convention        (DW_CC_pass_by_value)
                DW_AT_name      ("t1")
                DW_AT_byte_size (0x08)
                DW_AT_decl_file ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                DW_AT_decl_line (1)

0x00000034:     DW_TAG_member
                  DW_AT_name    ("_")
                  DW_AT_type    (0x00000047 "int")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                  DW_AT_decl_line       (2)
                  DW_AT_data_member_location    (0x00)

0x0000003d:     DW_TAG_member
                  DW_AT_name    ("_")
                  DW_AT_type    (0x00000047 "int")
                  DW_AT_decl_file       ("/usr/local/google/home/blaikie/dev/scratch/unused_member.cpp")
                  DW_AT_decl_line       (2)
                  DW_AT_data_member_location    (0x00)

0x00000046:     NULL

As for the block-scope case, I am still able to reproduce the issue (and also your result that does not exhibit the issue). The key seems to be having the _s on the same line.

Ah, fair enough - probably easy enough for you to look for some kind of map with inadequate key material in CGDebugInfo somewhere, I'd guess...

[cor3ntin]

From yesterday's C++ clang WG meeting

• We can land this now
• We need to track the debugger issue
• We should mention the lack of debugging support in the release notes
• We should strive to improve the situation in the 18 time frame but it would not be blocker as few people may be impacted.
• We should remember to modify the release notes when debugger support is improved if that happens before clang 18

[aaron.ballman]

In D153536#4556485, @cor3ntin wrote:

From yesterday's C++ clang WG meeting

• We can land this now
• We need to track the debugger issue
• We should mention the lack of debugging support in the release notes
• We should strive to improve the situation in the 18 time frame but it would not be blocker as few people may be impacted.
• We should remember to modify the release notes when debugger support is improved if that happens before clang 18

Agreed; there are some minor things that need to be tweaked before landing this now, but I think the patch is pretty close to finished.

clang/lib/Sema/SemaDeclCXX.cpp

4359

4370

4382

clang/www/cxx_status.html

153

[cor3ntin]

• Rebase
• Address Aaron's comments
• Mention the lack of debugging support in the release notes.

[cor3ntin]

Fix release notes formatting

[aaron.ballman]

LGTM aside from some minor tweaks (some extra parens to remove, a spurious comment to remove).

clang/lib/Sema/SemaDeclCXX.cpp

4359

4370

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

2–3

[cor3ntin]

Fix nits

[vitalybuka]

This patch brakes https://lab.llvm.org/buildbot/#/builders/168/builds/14997
Not sure what is wrong there, probably the test need to be updated. Can you please take a look?

[aaron.ballman]

In D153536#4570513, @vitalybuka wrote:

This patch brakes https://lab.llvm.org/buildbot/#/builders/168/builds/14997
Not sure what is wrong there, probably the test need to be updated. Can you please take a look?

I'm a bit confused -- the linked bot is green and the failures to either side of the linked run are both failing for the same reason (which seems to be unrelated to the changes in this patch). It looks like this bot went red here: https://lab.llvm.org/buildbot/#/builders/168/builds/14944 and hasn't reliably come back to green.

[vitalybuka]

In D153536#4570534, @aaron.ballman wrote:

In D153536#4570513, @vitalybuka wrote:

This patch brakes https://lab.llvm.org/buildbot/#/builders/168/builds/14997
Not sure what is wrong there, probably the test need to be updated. Can you please take a look?

I'm a bit confused -- the linked bot is green and the failures to either side of the linked run are both failing for the same reason (which seems to be unrelated to the changes in this patch). It looks like this bot went red here: https://lab.llvm.org/buildbot/#/builders/168/builds/14944 and hasn't reliably come back to green.

Sorry copy-pasted wrong url. This green is manual request on revision before this patch.

Correct failure https://lab.llvm.org/buildbot/#/builders/168/builds/14944
So it's persistently red after that.

If anyone wondering, I've bisected to this patch on buildbot host.
For whatever reason does not reproduce on my workstation.

[cor3ntin]

Looking at the failing test (clang-tools-extra/clangd/test/crash-preamble.test), I'd be very surprising if it is related to a front end change like this PR. Any idea @sammccall ?

[vitalybuka]

Not a test update

The second line of the test triggers:

RUN: not --crash clangd -lit-test -sync=0 < %s 2> %t.async.err

Signalled while building preamble
  Filename: =================================================================
==2319884==ERROR: AddressSanitizer: stack-use-after-return on address 0x7f310f6eb210 at pc 0x55a3ecaab9f5 bp 0x7f3115c49920 sp 0x7f3115c49918
READ of size 1 at 0x7f310f6eb210 thread T3
    #0 0x55a3ecaab9f4 in __is_long /b/sanitizer-x86_64-linux-bootstrap-asan/build/libcxx_build_asan/include/c++/v1/string:1734:33
    #1 0x55a3ecaab9f4 in __get_pointer /b/sanitizer-x86_64-linux-bootstrap-asan/build/libcxx_build_asan/include/c++/v1/string:1869:17
    #2 0x55a3ecaab9f4 in data /b/sanitizer-x86_64-linux-bootstrap-asan/build/libcxx_build_asan/include/c++/v1/string:1559:73
    #3 0x55a3ecaab9f4 in operator<< /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Support/raw_ostream.h:249:22
    #4 0x55a3ecaab9f4 in clang::clangd::(anonymous namespace)::crashDumpCompileCommand(llvm::raw_ostream&, clang::tooling::CompileCommand const&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/TUScheduler.cpp:1012:24
    #5 0x55a3ecaab285 in clang::clangd::(anonymous namespace)::crashDumpParseInputs(llvm::raw_ostream&, clang::clangd::ParseInputs const&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/TUScheduler.cpp:1038:3
    #6 0x55a3ecec1c9d in operator() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/ADT/FunctionExtras.h:382:12
    #7 0x55a3ecec1c9d in clang::clangd::ThreadCrashReporter::runCrashHandlers() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/ThreadCrashReporter.cpp:30:5
    #8 0x55a3ebacfd78 in operator() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/tool/ClangdMain.cpp:717:9
    #9 0x55a3ebacfd78 in clang::clangd::clangdMain(int, char**)::$_0::__invoke(void*) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/tool/ClangdMain.cpp:716:7
    #10 0x55a3e87c27ba in llvm::sys::RunSignalHandlers() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/lib/Support/Signals.cpp:103:5
    #11 0x55a3e87cbd01 in SignalHandler(int) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/lib/Support/Unix/Signals.inc:403:3
    #12 0x7f3115a3bcef  (/lib/x86_64-linux-gnu/libc.so.6+0x3bcef) (BuildId: d1704d25fbbb72fa95d517b883131828c0883fe9)
    #13 0x7f3115a9226a in pthread_kill (/lib/x86_64-linux-gnu/libc.so.6+0x9226a) (BuildId: d1704d25fbbb72fa95d517b883131828c0883fe9)
    #14 0x7f3115a3bc45 in raise (/lib/x86_64-linux-gnu/libc.so.6+0x3bc45) (BuildId: d1704d25fbbb72fa95d517b883131828c0883fe9)
    #15 0x7f3115a227fb in abort (/lib/x86_64-linux-gnu/libc.so.6+0x227fb) (BuildId: d1704d25fbbb72fa95d517b883131828c0883fe9)
    #16 0x55a3e869c429 in llvm::report_fatal_error(llvm::Twine const&, bool) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/lib/Support/ErrorHandling.cpp:123:5
    #17 0x55a3e869c014 in llvm::report_fatal_error(char const*, bool) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/lib/Support/ErrorHandling.cpp:83:3
    #18 0x55a3e9a2bb12 in (anonymous namespace)::PragmaDebugHandler::HandlePragma(clang::Preprocessor&, clang::PragmaIntroducer, clang::Token&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Lex/Pragma.cpp:1102:9
    #19 0x55a3e9a0f270 in clang::Preprocessor::HandlePragmaDirective(clang::PragmaIntroducer) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Lex/Pragma.cpp:178:19
    #20 0x55a3e98e92a1 in clang::Preprocessor::HandleDirective(clang::Token&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Lex/PPDirectives.cpp:1265:14
    #21 0x55a3e98a427a in clang::Lexer::LexTokenInternal(clang::Token&, bool) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Lex/Lexer.cpp:4362:7
    #22 0x55a3e989754c in clang::Lexer::Lex(clang::Token&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Lex/Lexer.cpp:3578:24
    #23 0x55a3e9a5fb72 in clang::Preprocessor::Lex(clang::Token&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Lex/Preprocessor.cpp:886:33
    #24 0x55a3eee8d7ef in ConsumeToken /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/include/clang/Parse/Parser.h:504:8
    #25 0x55a3eee8d7ef in clang::Parser::Initialize() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Parse/Parser.cpp:568:3
    #26 0x55a3eee7732f in clang::ParseAST(clang::Sema&, bool, bool) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Parse/ParseAST.cpp:156:7
    #27 0x55a3ec4ddff4 in clang::FrontendAction::Execute() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Frontend/FrontendAction.cpp:1063:8
    #28 0x55a3ec2320b6 in clang::PrecompiledPreamble::Build(clang::CompilerInvocation const&, llvm::MemoryBuffer const*, clang::PreambleBounds, clang::DiagnosticsEngine&, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>, std::__1::shared_ptr<clang::PCHContainerOperations>, bool, llvm::StringRef, clang::PreambleCallbacks&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang/lib/Frontend/PrecompiledPreamble.cpp:535:30
    #29 0x55a3ec9094b9 in clang::clangd::buildPreamble(llvm::StringRef, clang::CompilerInvocation, clang::clangd::ParseInputs const&, bool, std::__1::function<void (clang::clangd::CapturedASTCtx, std::__1::shared_ptr<clang::include_cleaner::PragmaIncludes const>)>, clang::clangd::PreambleBuildStats*) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/Preamble.cpp:663:24
    #30 0x55a3ecaaf64c in clang::clangd::(anonymous namespace)::PreambleThread::build(clang::clangd::(anonymous namespace)::PreambleThread::Request) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/TUScheduler.cpp:1080:17
    #31 0x55a3ecaad02b in run /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/TUScheduler.cpp:505:9
    #32 0x55a3ecaad02b in operator() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/TUScheduler.cpp:819:55
    #33 0x55a3ecaad02b in void llvm::detail::UniqueFunctionBase<void>::CallImpl<clang::clangd::(anonymous namespace)::ASTWorker::create(llvm::StringRef, clang::clangd::GlobalCompilationDatabase const&, clang::clangd::TUScheduler::ASTCache&, clang::clangd::TUScheduler::HeaderIncluderCache&, clang::clangd::AsyncTaskRunner*, clang::clangd::Semaphore&, clang::clangd::TUScheduler::Options const&, clang::clangd::ParsingCallbacks&)::$_1>(void*) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/ADT/FunctionExtras.h:220:12
    #34 0x55a3ecec3715 in operator() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/ADT/FunctionExtras.h:382:12
    #35 0x55a3ecec3715 in operator() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/Threading.cpp:101:5
    #36 0x55a3ecec3715 in operator()<(lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/Threading.cpp:98:15) &> /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Support/thread.h:43:11
    #37 0x55a3ecec3715 in __invoke<(lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Support/thread.h:42:9), (lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/Threading.cpp:98:15) &> /b/sanitizer-x86_64-linux-bootstrap-asan/build/libcxx_build_asan/include/c++/v1/__type_traits/invoke.h:340:25
    #38 0x55a3ecec3715 in __apply_tuple_impl<(lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Support/thread.h:42:9), std::__1::tuple<(lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/Threading.cpp:98:15)> &, 0UL> /b/sanitizer-x86_64-linux-bootstrap-asan/build/libcxx_build_asan/include/c++/v1/tuple:1825:1
    #39 0x55a3ecec3715 in apply<(lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Support/thread.h:42:9), std::__1::tuple<(lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/Threading.cpp:98:15)> &> /b/sanitizer-x86_64-linux-bootstrap-asan/build/libcxx_build_asan/include/c++/v1/tuple:1834:1
    #40 0x55a3ecec3715 in GenericThreadProxy<std::__1::tuple<(lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/Threading.cpp:98:15)> > /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Support/thread.h:41:5
    #41 0x55a3ecec3715 in void* llvm::thread::ThreadProxy<std::__1::tuple<clang::clangd::AsyncTaskRunner::runAsync(llvm::Twine const&, llvm::unique_function<void ()>)::$_1>>(void*) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Support/thread.h:55:5
    #42 0x55a3e8393668 in asan_thread_start(void*) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/compiler-rt/lib/asan/asan_interceptors.cpp:234:28
    #43 0x7f3115a90401  (/lib/x86_64-linux-gnu/libc.so.6+0x90401) (BuildId: d1704d25fbbb72fa95d517b883131828c0883fe9)
    #44 0x7f3115b1f58f  (/lib/x86_64-linux-gnu/libc.so.6+0x11f58f) (BuildId: d1704d25fbbb72fa95d517b883131828c0883fe9)

Address 0x7f310f6eb210 is located in stack of thread T3 at offset 528 in frame
    #0 0x55a3efe9b3ff in llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseType() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Demangle/ItaniumDemangle.h:3772

  This frame has 20 object(s):
    [32, 40) 'ClassType.i' (line 3668)
    [64, 72) 'MemberType.i' (line 3671)
    [96, 104) 'Dimension.i' (line 3640)
    [128, 144) 'ref.tmp.i' (line 3643)
    [160, 168) 'Ty.i' (line 3657)
    [192, 200) 'Result' (line 3773)
    [224, 240) 'Res' (line 3886)
    [256, 264) 'DimensionNumber' (line 3916)
    [288, 304) 'ref.tmp' (line 3916)
    [320, 328) 'Size' (line 3931)
    [352, 368) 'ref.tmp179' (line 3931)
    [384, 392) 'Child' (line 3978)
    [416, 424) 'TA' (line 4032)
    [448, 456) 'Ptr' (line 4042)
    [480, 488) 'Ref' (line 4051)
    [512, 520) 'Ref309' (line 4060) <== Memory access at offset 528 overflows this variable
    [544, 552) 'P' (line 4069)
    [576, 584) 'P333' (line 4078)
    [608, 609) 'IsSubst' (line 4087)
    [624, 632) 'TA364' (line 4105)
HINT: this may be a false positive if your program uses some custom stack unwind mechanism, swapcontext or vfork
      (longjmp and C++ exceptions *are* supported)
Thread T3 created by T0 here:
    #0 0x55a3e837bdaf in pthread_create /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/compiler-rt/lib/asan/asan_interceptors.cpp:245:3
    #1 0x55a3e87ce1c4 in llvm::llvm_execute_on_thread_impl(void* (*)(void*), void*, std::__1::optional<unsigned int>) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/lib/Support/Unix/Threading.inc:85:17
    #2 0x55a3ecec2e1d in thread<(lambda at /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/Threading.cpp:98:15)> /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/Support/thread.h:131:12
    #3 0x55a3ecec2e1d in clang::clangd::AsyncTaskRunner::runAsync(llvm::Twine const&, llvm::unique_function<void ()>) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/support/Threading.cpp:107:16
    #4 0x55a3eca955c5 in create /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/TUScheduler.cpp:818:12
    #5 0x55a3eca955c5 in clang::clangd::TUScheduler::update(llvm::StringRef, clang::clangd::ParseInputs, clang::clangd::WantDiagnostics) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/TUScheduler.cpp:1671:30
    #6 0x55a3ec160093 in clang::clangd::ClangdServer::addDocument(llvm::StringRef, llvm::StringRef, llvm::StringRef, clang::clangd::WantDiagnostics, bool) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/ClangdServer.cpp:303:33
    #7 0x55a3ec0447d6 in clang::clangd::ClangdLSPServer::onDocumentDidOpen(clang::clangd::DidOpenTextDocumentParams const&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/ClangdLSPServer.cpp:701:11
    #8 0x55a3ec111568 in void clang::clangd::LSPBinder::notification<clang::clangd::DidOpenTextDocumentParams, clang::clangd::ClangdLSPServer>(llvm::StringLiteral, clang::clangd::ClangdLSPServer*, void (clang::clangd::ClangdLSPServer::*)(clang::clangd::DidOpenTextDocumentParams const&))::'lambda'(llvm::json::Value)::operator()(llvm::json::Value) const /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/LSPBinder.h:153:5
    #9 0x55a3ec1112fc in void llvm::detail::UniqueFunctionBase<void, llvm::json::Value>::CallImpl<void clang::clangd::LSPBinder::notification<clang::clangd::DidOpenTextDocumentParams, clang::clangd::ClangdLSPServer>(llvm::StringLiteral, clang::clangd::ClangdLSPServer*, void (clang::clangd::ClangdLSPServer::*)(clang::clangd::DidOpenTextDocumentParams const&))::'lambda'(llvm::json::Value)>(void*, llvm::json::Value&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/ADT/FunctionExtras.h:220:12
    #10 0x55a3ec08f34b in operator() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/llvm/include/llvm/ADT/FunctionExtras.h:382:12
    #11 0x55a3ec08f34b in clang::clangd::ClangdLSPServer::MessageHandler::onNotify(llvm::StringRef, llvm::json::Value) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/ClangdLSPServer.cpp:200:7
    #12 0x55a3ec852a14 in handleMessage /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/JSONTransport.cpp:196:18
    #13 0x55a3ec852a14 in clang::clangd::(anonymous namespace)::JSONTransport::loop(clang::clangd::Transport::MessageHandler&) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/JSONTransport.cpp:120:16
    #14 0x55a3ec079073 in clang::clangd::ClangdLSPServer::run() /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/ClangdLSPServer.cpp:1693:25
    #15 0x55a3ebabacd7 in clang::clangd::clangdMain(int, char**) /b/sanitizer-x86_64-linux-bootstrap-asan/build/llvm-project/clang-tools-extra/clangd/tool/ClangdMain.cpp:1006:28
    #16 0x7f3115a2350f  (/lib/x86_64-linux-gnu/libc.so.6+0x2350f) (BuildId: d1704d25fbbb72fa95d517b883131828c0883fe9)

SUMMARY: AddressSanitizer: stack-use-after-return /b/sanitizer-x86_64-linux-bootstrap-asan/build/libcxx_build_asan/include/c++/v1/string:1734:33 in __is_long
Shadow bytes around the buggy address:
  0x7f310f6eaf80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7f310f6eb000: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x7f310f6eb080: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x7f310f6eb100: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x7f310f6eb180: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
=>0x7f310f6eb200: f5 f5[f5]f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x7f310f6eb280: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x7f310f6eb300: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x7f310f6eb380: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x7f310f6eb400: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
  0x7f310f6eb480: f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5 f5
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07 
  Heap left redzone:       fa
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Container overflow:      fc
  Array cookie:            ac
  Intra object redzone:    bb
  ASan internal:           fe
  Left alloca redzone:     ca
  Right alloca redzone:    cb
==2319884==ABORTING

[aaron.ballman]

In D153536#4570561, @vitalybuka wrote:

In D153536#4570534, @aaron.ballman wrote:

In D153536#4570513, @vitalybuka wrote:

This patch brakes https://lab.llvm.org/buildbot/#/builders/168/builds/14997
Not sure what is wrong there, probably the test need to be updated. Can you please take a look?

I'm a bit confused -- the linked bot is green and the failures to either side of the linked run are both failing for the same reason (which seems to be unrelated to the changes in this patch). It looks like this bot went red here: https://lab.llvm.org/buildbot/#/builders/168/builds/14944 and hasn't reliably come back to green.

Sorry copy-pasted wrong url. This green is manual request on revision before this patch.

Correct failure https://lab.llvm.org/buildbot/#/builders/168/builds/14944
So it's persistently red after that.

If anyone wondering, I've bisected to this patch on buildbot host.
For whatever reason does not reproduce on my workstation.

Thanks! We might need someone from clangd to help here. The logs do not have any information explaining what's failing with the test, and looking at the test code, I struggle to see how these changes would impact that test. We've had some significant issues with flaky clangd tests (https://github.com/clangd/clangd/issues/1712), so it's possible this is happenstance.

[vitalybuka]

Thanks! We might need someone from clangd to help here. The logs do not have any information explaining what's failing with the test, and looking at the test code, I struggle to see how these changes would impact that test. We've had some significant issues with flaky clangd tests (https://github.com/clangd/clangd/issues/1712), so it's possible this is happenstance.

I tried to debug that, and it looks like false Asan report. Maybe a bug in FakeStack::GC related code.

[aaron.ballman]

In D153536#4571435, @vitalybuka wrote:

Thanks! We might need someone from clangd to help here. The logs do not have any information explaining what's failing with the test, and looking at the test code, I struggle to see how these changes would impact that test. We've had some significant issues with flaky clangd tests (https://github.com/clangd/clangd/issues/1712), so it's possible this is happenstance.

I tried to debug that, and it looks like false Asan report. Maybe a bug in FakeStack::GC related code.

Thank you for looking into it! I came to the same general conclusion; and it seems the impacted bot has gone back to green in the meantime: https://lab.llvm.org/buildbot/#/builders/168/builds/15031 so hopefully we're in good shape.

[vitalybuka]

In D153536#4576683, @aaron.ballman wrote:

In D153536#4571435, @vitalybuka wrote:

Thanks! We might need someone from clangd to help here. The logs do not have any information explaining what's failing with the test, and looking at the test code, I struggle to see how these changes would impact that test. We've had some significant issues with flaky clangd tests (https://github.com/clangd/clangd/issues/1712), so it's possible this is happenstance.

I tried to debug that, and it looks like false Asan report. Maybe a bug in FakeStack::GC related code.

Thank you for looking into it! I came to the same general conclusion; and it seems the impacted bot has gone back to green in the meantime: https://lab.llvm.org/buildbot/#/builders/168/builds/15031 so hopefully we're in good shape.

Yes. Fixed by D157552. It's amusing to see this unrelated patch exposing ~10 years old bug, which was never reported before.

[aaron.ballman]

In D153536#4577187, @vitalybuka wrote:

In D153536#4576683, @aaron.ballman wrote:

In D153536#4571435, @vitalybuka wrote:

Thanks! We might need someone from clangd to help here. The logs do not have any information explaining what's failing with the test, and looking at the test code, I struggle to see how these changes would impact that test. We've had some significant issues with flaky clangd tests (https://github.com/clangd/clangd/issues/1712), so it's possible this is happenstance.

I tried to debug that, and it looks like false Asan report. Maybe a bug in FakeStack::GC related code.

Thank you for looking into it! I came to the same general conclusion; and it seems the impacted bot has gone back to green in the meantime: https://lab.llvm.org/buildbot/#/builders/168/builds/15031 so hopefully we're in good shape.

Yes. Fixed by D157552. It's amusing to see this unrelated patch exposing ~10 years old bug, which was never reported before.

Oh wow! Great fix, thank you!

clang/docs/ReleaseNotes.rst

 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 C++23 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 C++2c Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
+- Implemented `P2169R4: A nice placeholder with no name <https://wg21.link/P2169R4>`_. This allows using ``_``
+  as a variable name multiple times in the same scope and is supported in all C++ language modes as an extension.
+  An extension warning is produced when multiple variables are introduced by ``_`` in the same scope.
+  Unused warnings are no longer produced for variables named ``_``.
+  Currently, inspecting placeholders variables in a debugger when more than one are declared in the same scope
+  is not supported.
+
+  .. code-block:: cpp
+    struct S {
+      int _, _; // Was invalid, now OK
+    };
+    void func() {
+      int _, _; // Was invalid, now OK
+    }
+    void other() {
+      int _; // Previously diagnosed under -Wunused, no longer diagnosed
+    }
+
+
+
 Resolutions to C++ Defect Reports
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 C Language Changes
 ------------------
 - ``structs``, ``unions``, and ``arrays`` that are const may now be used as
   constant expressions.  This change is more consistent with the behavior of
   GCC.

clang/include/clang/AST/Decl.h

public:
   ///
   /// Language features which can retroactively change linkage (like a
   /// typedef name for linkage purposes) may need to consider this,
   /// but hopefully only in transitory ways during parsing.
   bool hasLinkageBeenComputed() const {
     return hasCachedLinkage();
   }
 
+  bool isPlaceholderVar(const LangOptions &LangOpts) const;
+
   /// Looks through UsingDecls and ObjCCompatibleAliasDecls for
   /// the underlying named decl.
   NamedDecl *getUnderlyingDecl() {
     // Fast-path the common case.
     if (this->getKind() != UsingShadow &&
         this->getKind() != ConstructorUsingShadow &&
         this->getKind() != ObjCCompatibleAlias &&
         this->getKind() != NamespaceAlias)

clang/include/clang/Basic/DiagnosticSemaKinds.td

: Error<"_Atomic cannot be applied to "
             "%select{incomplete |array |function |reference |atomic |qualified "
             "|sizeless ||integer }0type "
             "%1 %select{|||||||which is not trivially copyable|}0">;
 def warn_atomic_member_access : Warning<
   "accessing a member of an atomic structure or union is undefined behavior">,
   InGroup<DiagGroup<"atomic-access">>, DefaultError;
 
 // Expressions.
+def err_using_placeholder_variable : Error<
+  "ambiguous reference to placeholder '_', which is defined multiple times">;
+def note_reference_placeholder : Note<
+  "placeholder declared here">;
+def ext_placeholder_var_definition : ExtWarn<
+  "placeholder variables are a C++2c extension">, InGroup<CXX26>;
+def warn_cxx23_placeholder_var_definition : Warning<
+  "placeholder variables are incompatible with C++ standards before C++2c">,
+  DefaultIgnore, InGroup<CXXPre26Compat>;
+
 def ext_sizeof_alignof_function_type : Extension<
   "invalid application of '%0' to a function type">, InGroup<PointerArith>;
 def ext_sizeof_alignof_void_type : Extension<
   "invalid application of '%0' to a void type">, InGroup<PointerArith>;
 def err_opencl_sizeof_alignof_type : Error<
   "invalid application of '%0' to a void type">;
 def err_sizeof_alignof_incomplete_or_sizeless_type : Error<
   "invalid application of '%0' to %select{an incomplete|sizeless}1 type %2">;

clang/include/clang/Basic/IdentifierTable.h

public:
 
   /// Determine whether \p this is a name reserved for future standardization or
   /// the implementation (C++ [usrlit.suffix]).
   ReservedLiteralSuffixIdStatus isReservedLiteralSuffixId() const;
 
   /// If the identifier is an "uglified" reserved name, return a cleaned form.
   /// e.g. _Foo => Foo. Otherwise, just returns the name.
   StringRef deuglifiedName() const;
+  bool isPlaceholder() const {
+    return getLength() == 1 && getNameStart()[0] == '_';
+  }
 
   /// Provide less than operator for lexicographical sorting.
   bool operator<(const IdentifierInfo &RHS) const {
     return getName() < RHS.getName();
   }
 
 private:
   /// The Preprocessor::HandleIdentifier does several special (but rare)

clang/include/clang/Sema/Lookup.h

enum AmbiguityKind {
     ///   int test() {
     ///     using namespace B;
     ///     return i; // error 'i' is found in namespace A and A::B
     ///    }
     /// }
     /// @endcode
     AmbiguousReference,
 
+    /// Name lookup results in an ambiguity because multiple placeholder
+    /// variables were found in the same scope.
+    /// @code
+    /// void f() {
+    ///    int _ = 0;
+    ///    int _ = 0;
+    ///    return _; // ambiguous use of placeholder variable
+    /// }
+    /// @endcode
+    AmbiguousReferenceToPlaceholderVariable,
+
     /// Name lookup results in an ambiguity because an entity with a
     /// tag name was hidden by an entity with an ordinary name from
     /// a different context.
     /// @code
     /// namespace A { struct Foo {}; }
     /// namespace B { void Foo(); }
     /// namespace C {
     ///   using namespace A;

clang/include/clang/Sema/Sema.h

NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
                                   LookupResult &Previous, bool &Redeclaration);
   NamedDecl *ActOnVariableDeclarator(
       Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo,
       LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists,
       bool &AddToScope, ArrayRef<BindingDecl *> Bindings = std::nullopt);
   NamedDecl *
   ActOnDecompositionDeclarator(Scope *S, Declarator &D,
                                MultiTemplateParamsArg TemplateParamLists);
+  void DiagPlaceholderVariableDefinition(SourceLocation Loc);
+  bool DiagRedefinedPlaceholderFieldDecl(SourceLocation Loc,
+                                         RecordDecl *ClassDecl,
+                                         const IdentifierInfo *Name);
   // Returns true if the variable declaration is a redeclaration
   bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
   void CheckVariableDeclarationType(VarDecl *NewVD);
   bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
                                      Expr *Init);
   void CheckCompleteVariableDeclaration(VarDecl *VD);
   void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
   void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
                                    bool IsExplicitInstantiation,
                                    RecordDecl *&AnonRecord);
 
   Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
                                     AccessSpecifier AS,
                                     RecordDecl *Record,
                                     const PrintingPolicy &Policy);
 
+  /// Called once it is known whether
+  /// a tag declaration is an anonymous union or struct.
+  void ActOnDefinedDeclarationSpecifier(Decl *D);
+
+  void DiagPlaceholderFieldDeclDefinitions(RecordDecl *Record);
+
   Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
                                        RecordDecl *Record);
 
   /// Common ways to introduce type names without a tag for use in diagnostics.
   /// Keep in sync with err_tag_reference_non_tag.
   enum NonTagKind {
     NTK_NonStruct,
     NTK_NonClass,
public:
   void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
 
   NamespaceDecl *getStdNamespace() const;
   NamespaceDecl *getOrCreateStdNamespace();
 
   CXXRecordDecl *getStdBadAlloc() const;
   EnumDecl *getStdAlignValT() const;
 
+  ValueDecl *tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl,
+                                           const IdentifierInfo *MemberOrBase);
+
 private:
   // A cache representing if we've fully checked the various comparison category
   // types stored in ASTContext. The bit-index corresponds to the integer value
   // of a ComparisonCategoryType enumerator.
   llvm::SmallBitVector FullyCheckedComparisonCategories;
 
   ValueDecl *tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
                                          CXXScopeSpec &SS,

clang/lib/AST/Decl.cpp

if (!hasCachedLinkage())
     return true;
 
   Linkage L = LinkageComputer{}
                   .computeLVForDecl(this, LVComputationKind::forLinkageOnly())
                   .getLinkage();
   return L == getCachedLinkage();
 }
 
+bool NamedDecl::isPlaceholderVar(const LangOptions &LangOpts) const {
+  // [C++2c] [basic.scope.scope]/p5
+  // A declaration is name-independent if its name is _ and it declares
+  // - a variable with automatic storage duration,
+  // - a structured binding not inhabiting a namespace scope,
+  // - the variable introduced by an init-capture
+  // - or a non-static data member.
+
+  if (!LangOpts.CPlusPlus || !getIdentifier() ||
+      !getIdentifier()->isPlaceholder())
+    return false;
+  if (isa<FieldDecl>(this))
+    return true;
+  if (auto *IFD = dyn_cast<IndirectFieldDecl>(this)) {
+    if (!getDeclContext()->isFunctionOrMethod() &&
+        !getDeclContext()->isRecord())
+      return false;
+    VarDecl *VD = IFD->getVarDecl();
+    return !VD || VD->getStorageDuration() == SD_Automatic;
+  }
+  // and it declares a variable with automatic storage duration
+  if (const auto *VD = dyn_cast<VarDecl>(this)) {
+    if (isa<ParmVarDecl>(VD))
+      return false;
+    if (VD->isInitCapture())
+      return true;
+    return VD->getStorageDuration() == StorageDuration::SD_Automatic;
+  }
+  if (const auto *BD = dyn_cast<BindingDecl>(this);
+      BD && getDeclContext()->isFunctionOrMethod()) {
+    VarDecl *VD = BD->getHoldingVar();
+    return !VD || VD->getStorageDuration() == StorageDuration::SD_Automatic;
+  }
+  return false;
+}
+
 ReservedIdentifierStatus
 NamedDecl::isReserved(const LangOptions &LangOpts) const {
   const IdentifierInfo *II = getIdentifier();
 
   // This triggers at least for CXXLiteralIdentifiers, which we already checked
   // at lexing time.
   if (!II)
     return ReservedIdentifierStatus::NotReserved;
bool NamedDecl::declarationReplaces(NamedDecl *OldD, bool IsKnownNewer) const {
   // For method declarations, we never replace. (Why?)
   if (isa<ObjCMethodDecl>(this))
     return false;
 
   // For parameters, pick the newer one. This is either an error or (in
   // Objective-C) permitted as an extension.
   if (isa<ParmVarDecl>(this))
     return true;
 
   // Inline namespaces can give us two declarations with the same
   // name and kind in the same scope but different contexts; we should
   // keep both declarations in this case.
   if (!this->getDeclContext()->getRedeclContext()->Equals(
           OldD->getDeclContext()->getRedeclContext()))
     return false;
 
   // Using declarations can be replaced if they import the same name from the

clang/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.CPlusPlus23) {
     Builder.defineMacro("__cpp_multidimensional_subscript", "202211L");
   }
 
   // We provide those C++23 features as extensions in earlier language modes, so
   // we also define their feature test macros.
   if (LangOpts.CPlusPlus11)
     Builder.defineMacro("__cpp_static_call_operator", "202207L");
   Builder.defineMacro("__cpp_named_character_escapes", "202207L");
+  Builder.defineMacro("__cpp_placeholder_variables", "202306L");
 
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "202207L");
   Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
 }
 
 /// InitializeOpenCLFeatureTestMacros - Define OpenCL macros based on target
 /// settings and language version

clang/lib/Parse/ParseDecl.cpp

Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(
   // declaration-specifiers init-declarator-list[opt] ';'
   if (Tok.is(tok::semi)) {
     ProhibitAttributes(DeclAttrs);
     DeclEnd = Tok.getLocation();
     if (RequireSemi) ConsumeToken();
     RecordDecl *AnonRecord = nullptr;
     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
         getCurScope(), AS_none, DS, ParsedAttributesView::none(), AnonRecord);
+    Actions.ActOnDefinedDeclarationSpecifier(TheDecl);
     DS.complete(TheDecl);
     if (AnonRecord) {
       Decl* decls[] = {AnonRecord, TheDecl};
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
+  if (DS.hasTagDefinition())
+    Actions.ActOnDefinedDeclarationSpecifier(DS.getRepAsDecl());
+
   if (DeclSpecStart)
     DS.SetRangeStart(*DeclSpecStart);
 
   return ParseDeclGroup(DS, Context, DeclAttrs, &DeclEnd, FRI);
 }
 
 /// Returns true if this might be the start of a declarator, or a common typo
 /// for a declarator.

clang/lib/Parse/ParseDeclCXX.cpp

Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS,
 
   if (TryConsumeToken(tok::semi)) {
     if (DS.isFriendSpecified())
       ProhibitAttributes(DeclAttrs);
 
     RecordDecl *AnonRecord = nullptr;
     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
         getCurScope(), AS, DS, DeclAttrs, TemplateParams, false, AnonRecord);
+    Actions.ActOnDefinedDeclarationSpecifier(TheDecl);
     DS.complete(TheDecl);
     if (AnonRecord) {
       Decl *decls[] = {AnonRecord, TheDecl};
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
+  if (DS.hasTagDefinition())
+    Actions.ActOnDefinedDeclarationSpecifier(DS.getRepAsDecl());
+
   ParsingDeclarator DeclaratorInfo(*this, DS, DeclAttrs,
                                    DeclaratorContext::Member);
   if (TemplateInfo.TemplateParams)
     DeclaratorInfo.setTemplateParameterLists(TemplateParams);
   VirtSpecifiers VS;
 
   // Hold late-parsed attributes so we can attach a Decl to them later.
   LateParsedAttrList LateParsedAttrs;

clang/lib/Parse/ParseTemplate.cpp

if (Tok.is(tok::semi)) {
     DeclEnd = ConsumeToken();
     RecordDecl *AnonRecord = nullptr;
     Decl *Decl = Actions.ParsedFreeStandingDeclSpec(
         getCurScope(), AS, DS, ParsedAttributesView::none(),
         TemplateInfo.TemplateParams ? *TemplateInfo.TemplateParams
                                     : MultiTemplateParamsArg(),
         TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation,
         AnonRecord);
+    Actions.ActOnDefinedDeclarationSpecifier(Decl);
     assert(!AnonRecord &&
            "Anonymous unions/structs should not be valid with template");
     DS.complete(Decl);
     return Decl;
   }
 
+  if (DS.hasTagDefinition())
+    Actions.ActOnDefinedDeclarationSpecifier(DS.getRepAsDecl());
+
   // Move the attributes from the prefix into the DS.
   if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation)
     ProhibitAttributes(prefixAttrs);
 
   // Parse the declarator.
   ParsingDeclarator DeclaratorInfo(*this, DS, prefixAttrs,
                                    (DeclaratorContext)Context);
   if (TemplateInfo.TemplateParams)

clang/lib/Parse/Parser.cpp

SourceLocation CorrectLocationForAttributes =
                   LengthOfTSTToken(DS.getTypeSpecType()))
             : SourceLocation();
     ProhibitAttributes(Attrs, CorrectLocationForAttributes);
     ConsumeToken();
     RecordDecl *AnonRecord = nullptr;
     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
         getCurScope(), AS_none, DS, ParsedAttributesView::none(), AnonRecord);
     DS.complete(TheDecl);
+    Actions.ActOnDefinedDeclarationSpecifier(TheDecl);
     if (AnonRecord) {
       Decl* decls[] = {AnonRecord, TheDecl};
       return Actions.BuildDeclaratorGroup(decls);
     }
     return Actions.ConvertDeclToDeclGroup(TheDecl);
   }
 
+  if (DS.hasTagDefinition())
+    Actions.ActOnDefinedDeclarationSpecifier(DS.getRepAsDecl());
+
   // ObjC2 allows prefix attributes on class interfaces and protocols.
   // FIXME: This still needs better diagnostics. We should only accept
   // attributes here, no types, etc.
   if (getLangOpts().ObjC && Tok.is(tok::at)) {
     SourceLocation AtLoc = ConsumeToken(); // the "@"
     if (!Tok.isObjCAtKeyword(tok::objc_interface) &&
         !Tok.isObjCAtKeyword(tok::objc_protocol) &&
         !Tok.isObjCAtKeyword(tok::objc_implementation)) {

clang/lib/Sema/SemaDecl.cpp

if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
     if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
       return; // First should already be in the vector.
   }
 
   if (ShouldWarnIfUnusedFileScopedDecl(D))
     UnusedFileScopedDecls.push_back(D);
 }
 
-static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
+static bool ShouldDiagnoseUnusedDecl(const LangOptions &LangOpts,
+                                     const NamedDecl *D) {
   if (D->isInvalidDecl())
     return false;
 
   if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
     // For a decomposition declaration, warn if none of the bindings are
     // referenced, instead of if the variable itself is referenced (which
     // it is, by the bindings' expressions).
-    for (auto *BD : DD->bindings())
+    bool IsAllPlaceholders = true;
+    for (auto *BD : DD->bindings()) {
       if (BD->isReferenced())
         return false;
+      IsAllPlaceholders = IsAllPlaceholders && BD->isPlaceholderVar(LangOpts);
+    }
+    if (IsAllPlaceholders)
+      return false;
   } else if (!D->getDeclName()) {
     return false;
   } else if (D->isReferenced() || D->isUsed()) {
     return false;
   }
 
+  if (D->isPlaceholderVar(LangOpts))
+    return false;
+
   if (D->hasAttr<UnusedAttr>() || D->hasAttr<ObjCPreciseLifetimeAttr>() ||
       D->hasAttr<CleanupAttr>())
     return false;
 
   if (isa<LabelDecl>(D))
     return true;
 
   // Except for labels, we only care about unused decls that are local to
if (isa<TypedefNameDecl>(D))
     return true;
 
   // White-list anything that isn't a local variable.
   if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
     return false;
 
   // Types of valid local variables should be complete, so this should succeed.
   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
 
     const Expr *Init = VD->getInit();
     if (const auto *Cleanups = dyn_cast_or_null<ExprWithCleanups>(Init))
       Init = Cleanups->getSubExpr();
 
     const auto *Ty = VD->getType().getTypePtr();
 
     // Only look at the outermost level of typedef.
     if (const TypedefType *TT = Ty->getAs<TypedefType>()) {

 void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
   DiagnoseUnusedDecl(
       D, [this](SourceLocation Loc, PartialDiagnostic PD) { Diag(Loc, PD); });
 }
 
 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
 /// unless they are marked attr(unused).
 void Sema::DiagnoseUnusedDecl(const NamedDecl *D, DiagReceiverTy DiagReceiver) {
-  if (!ShouldDiagnoseUnusedDecl(D))
+  if (!ShouldDiagnoseUnusedDecl(getLangOpts(), D))
     return;
 
   if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
     // typedefs can be referenced later on, so the diagnostics are emitted
     // at end-of-translation-unit.
     UnusedLocalTypedefNameCandidates.insert(TD);
     return;
   }
void Sema::DiagnoseUnusedDecl(const NamedDecl *D, DiagReceiverTy DiagReceiver) {
   SourceLocation DiagLoc = D->getLocation();
   DiagReceiver(DiagLoc, PDiag(DiagID) << D << Hint << SourceRange(DiagLoc));
 }
 
 void Sema::DiagnoseUnusedButSetDecl(const VarDecl *VD,
                                     DiagReceiverTy DiagReceiver) {
   // If it's not referenced, it can't be set. If it has the Cleanup attribute,
   // it's not really unused.
-  if (!VD->isReferenced() || !VD->getDeclName() || VD->hasAttr<UnusedAttr>() ||
-      VD->hasAttr<CleanupAttr>())
+  if (!VD->isReferenced() || !VD->getDeclName() || VD->hasAttr<CleanupAttr>())
+    return;
+
+  //  In C++, `_` variables behave as if they were maybe_unused
+  if (VD->hasAttr<UnusedAttr>() || VD->isPlaceholderVar(getLangOpts()))
     return;
 
   const auto *Ty = VD->getType().getTypePtr()->getBaseElementTypeUnsafe();
 
   if (Ty->isReferenceType() || Ty->isDependentType())
     return;
 
   if (const TagType *TT = Ty->getAs<TagType>()) {
     const TagDecl *Tag = TT->getDecl();
     if (Tag->hasAttr<UnusedAttr>())
       return;
     // In C++, don't warn for record types that don't have WarnUnusedAttr, to
Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
 
   return TagD;
 }
 
 /// We are trying to inject an anonymous member into the given scope;
 /// check if there's an existing declaration that can't be overloaded.
 ///
 /// \return true if this is a forbidden redeclaration
-static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
-                                         Scope *S,
+static bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S,
                                          DeclContext *Owner,
                                          DeclarationName Name,
-                                         SourceLocation NameLoc,
-                                         bool IsUnion) {
-  LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
+                                         SourceLocation NameLoc, bool IsUnion,
+                                         StorageClass SC) {
+  LookupResult R(SemaRef, Name, NameLoc,
+                 Owner->isRecord() ? Sema::LookupMemberName
+                                   : Sema::LookupOrdinaryName,
                  Sema::ForVisibleRedeclaration);
   if (!SemaRef.LookupName(R, S)) return false;
 
   // Pick a representative declaration.
   NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
   assert(PrevDecl && "Expected a non-null Decl");
 
   if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
     return false;
 
+  if (SC == StorageClass::SC_None &&
+      PrevDecl->isPlaceholderVar(SemaRef.getLangOpts()) &&
+      (Owner->isFunctionOrMethod() || Owner->isRecord())) {
+    if (!Owner->isRecord())
+      SemaRef.DiagPlaceholderVariableDefinition(NameLoc);
+    return false;
+  }
+
   SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl)
     << IsUnion << Name;
   SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
 
   return true;
 }
 
+void Sema::ActOnDefinedDeclarationSpecifier(Decl *D) {
+  if (auto *RD = dyn_cast_if_present<RecordDecl>(D))
+    DiagPlaceholderFieldDeclDefinitions(RD);
+}
+
+/// Emit diagnostic warnings for placeholder members.
+/// We can only do that after the class is fully constructed,
+/// as anonymous union/structs can insert placeholders
+/// in their parent scope (which might be a Record).
+void Sema::DiagPlaceholderFieldDeclDefinitions(RecordDecl *Record) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+
+  // This function can be parsed before we have validated the
+  // structure as an anonymous struct
+  if (Record->isAnonymousStructOrUnion())
+    return;
+
+  const NamedDecl *First = 0;
+  for (const Decl *D : Record->decls()) {
+    const NamedDecl *ND = dyn_cast<NamedDecl>(D);
+    if (!ND || !ND->isPlaceholderVar(getLangOpts()))
+      continue;
+    if (!First)
+      First = ND;
+    else
+      DiagPlaceholderVariableDefinition(ND->getLocation());
+  }
+}
+
 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
 /// anonymous struct or union AnonRecord into the owning context Owner
 /// and scope S. This routine will be invoked just after we realize
 /// that an unnamed union or struct is actually an anonymous union or
 /// struct, e.g.,
 ///
 /// @code
 /// union {
 ///   int i;
 ///   float f;
 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
 ///    // f into the surrounding scope.x
 /// @endcode
 ///
 /// This routine is recursive, injecting the names of nested anonymous
 /// structs/unions into the owning context and scope as well.
 static bool
 InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner,
                                     RecordDecl *AnonRecord, AccessSpecifier AS,
+                                    StorageClass SC,
                                     SmallVectorImpl<NamedDecl *> &Chaining) {
   bool Invalid = false;
 
   // Look every FieldDecl and IndirectFieldDecl with a name.
   for (auto *D : AnonRecord->decls()) {
     if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
         cast<NamedDecl>(D)->getDeclName()) {
       ValueDecl *VD = cast<ValueDecl>(D);
       if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
-                                       VD->getLocation(),
-                                       AnonRecord->isUnion())) {
+                                       VD->getLocation(), AnonRecord->isUnion(),
+                                       SC)) {
         // C++ [class.union]p2:
         //   The names of the members of an anonymous union shall be
         //   distinct from the names of any other entity in the
         //   scope in which the anonymous union is declared.
         Invalid = true;
       } else {
         // C++ [class.union]p2:
         //   For the purpose of name lookup, after the anonymous union
Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
   //   name of the class or declare at least one unnamed bit-field
   //
   // For C this is an error even for a named struct, and is diagnosed elsewhere.
   if (getLangOpts().CPlusPlus && Record->field_empty())
     Diag(DS.getBeginLoc(), diag::ext_no_declarators) << DS.getSourceRange();
 
   // Mock up a declarator.
   Declarator Dc(DS, ParsedAttributesView::none(), DeclaratorContext::Member);
+  StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
   TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
   assert(TInfo && "couldn't build declarator info for anonymous struct/union");
 
   // Create a declaration for this anonymous struct/union.
   NamedDecl *Anon = nullptr;
   if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
     Anon = FieldDecl::Create(
         Context, OwningClass, DS.getBeginLoc(), Record->getLocation(),
         /*IdentifierInfo=*/nullptr, Context.getTypeDeclType(Record), TInfo,
         /*BitWidth=*/nullptr, /*Mutable=*/false,
         /*InitStyle=*/ICIS_NoInit);
     Anon->setAccess(AS);
     ProcessDeclAttributes(S, Anon, Dc);
 
     if (getLangOpts().CPlusPlus)
       FieldCollector->Add(cast<FieldDecl>(Anon));
   } else {
     DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
-    StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
     if (SCSpec == DeclSpec::SCS_mutable) {
       // mutable can only appear on non-static class members, so it's always
       // an error here
       Diag(Record->getLocation(), diag::err_mutable_nonmember);
       Invalid = true;
       SC = SC_None;
     }
 
Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
   Owner->addDecl(Anon);
 
   // Inject the members of the anonymous struct/union into the owning
   // context and into the identifier resolver chain for name lookup
   // purposes.
   SmallVector<NamedDecl*, 2> Chain;
   Chain.push_back(Anon);
 
-  if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, Chain))
+  if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, SC,
+                                          Chain))
     Invalid = true;
 
   if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
     if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
       MangleNumberingContext *MCtx;
       Decl *ManglingContextDecl;
       std::tie(MCtx, ManglingContextDecl) =
           getCurrentMangleNumberContext(NewVD->getDeclContext());
Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
   // context and into the identifier resolver chain for name lookup
   // purposes.
   SmallVector<NamedDecl*, 2> Chain;
   Chain.push_back(Anon);
 
   RecordDecl *RecordDef = Record->getDefinition();
   if (RequireCompleteSizedType(Anon->getLocation(), RecTy,
                                diag::err_field_incomplete_or_sizeless) ||
-      InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef,
-                                          AS_none, Chain)) {
+      InjectAnonymousStructOrUnionMembers(
+          *this, S, CurContext, RecordDef, AS_none,
+          StorageClassSpecToVarDeclStorageClass(DS), Chain)) {
     Anon->setInvalidDecl();
     ParentDecl->setInvalidDecl();
   }
 
   return Anon;
 }
 
 /// GetNameForDeclarator - Determine the full declaration name for the

 NamedDecl *Sema::ActOnVariableDeclarator(
     Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo,
     LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists,
     bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {
   QualType R = TInfo->getType();
   DeclarationName Name = GetNameForDeclarator(D).getName();
 
   IdentifierInfo *II = Name.getAsIdentifierInfo();
+  bool IsPlaceholderVariable = false;
 
   if (D.isDecompositionDeclarator()) {
     // Take the name of the first declarator as our name for diagnostic
     // purposes.
     auto &Decomp = D.getDecompositionDeclarator();
     if (!Decomp.bindings().empty()) {
       II = Decomp.bindings()[0].Name;
       Name = II;
     }
   } else if (!II) {
     Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) << Name;
     return nullptr;
   }
 
 
   DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
   StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
 
+  if (LangOpts.CPlusPlus && (DC->isClosure() || DC->isFunctionOrMethod()) &&
+      SC != SC_Static && SC != SC_Extern && II && II->isPlaceholder()) {
+    IsPlaceholderVariable = true;
+    if (!Previous.empty()) {
+      NamedDecl *PrevDecl = *Previous.begin();
+      bool SameDC = PrevDecl->getDeclContext()->getRedeclContext()->Equals(
+          DC->getRedeclContext());
+      if (SameDC && isDeclInScope(PrevDecl, CurContext, S, false))
+        DiagPlaceholderVariableDefinition(D.getIdentifierLoc());
+    }
+  }
+
   // dllimport globals without explicit storage class are treated as extern. We
   // have to change the storage class this early to get the right DeclContext.
   if (SC == SC_None && !DC->isRecord() &&
       hasParsedAttr(S, D, ParsedAttr::AT_DLLImport) &&
       !hasParsedAttr(S, D, ParsedAttr::AT_DLLExport))
     SC = SC_Extern;
 
   DeclContext *OriginalDC = DC;
if (!getLangOpts().CPlusPlus) {
     } else if (D.getCXXScopeSpec().isSet()) {
       // No previous declaration in the qualifying scope.
       Diag(D.getIdentifierLoc(), diag::err_no_member)
         << Name << computeDeclContext(D.getCXXScopeSpec(), true)
         << D.getCXXScopeSpec().getRange();
       NewVD->setInvalidDecl();
     }
 
-    if (!IsVariableTemplateSpecialization)
+    if (!IsVariableTemplateSpecialization && !IsPlaceholderVariable)
       D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
 
     // CheckVariableDeclaration will set NewVD as invalid if something is in
     // error like WebAssembly tables being declared as arrays with a non-zero
     // size, but then parsing continues and emits further errors on that line.
     // To avoid that we check here if it happened and return nullptr.
     if (NewVD->getType()->isWebAssemblyTableType() && NewVD->isInvalidDecl())
       return nullptr;
if (NewTemplate) {
       // template, make a note of that.
       if (PrevVarTemplate &&
           PrevVarTemplate->getInstantiatedFromMemberTemplate())
         PrevVarTemplate->setMemberSpecialization();
     }
   }
 
   // Diagnose shadowed variables iff this isn't a redeclaration.
-  if (ShadowedDecl && !D.isRedeclaration())
+  if (!IsPlaceholderVariable && ShadowedDecl && !D.isRedeclaration())
     CheckShadow(NewVD, ShadowedDecl, Previous);
 
   ProcessPragmaWeak(S, NewVD);
 
   // If this is the first declaration of an extern C variable, update
   // the map of such variables.
   if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
       isIncompleteDeclExternC(*this, NewVD))
if (const auto *RD = dyn_cast<CXXRecordDecl>(NewDC->getParent())) {
               !isLambdaCallOperator(ParentDC)) {
             return;
           }
         }
       }
     }
   }
 
+  // Never warn about shadowing a placeholder variable.
+  if (ShadowedDecl->isPlaceholderVar(getLangOpts()))
+    return;
+
   // Only warn about certain kinds of shadowing for class members.
   if (NewDC && NewDC->isRecord()) {
     // In particular, don't warn about shadowing non-class members.
     if (!OldDC->isRecord())
       return;
 
     // TODO: should we warn about static data members shadowing
     // static data members from base classes?
Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
   QualType parmDeclType = TInfo->getType();
 
   // Check for redeclaration of parameters, e.g. int foo(int x, int x);
   IdentifierInfo *II = D.getIdentifier();
   if (II) {
     LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
                    ForVisibleRedeclaration);
     LookupName(R, S);
-    if (R.isSingleResult()) {
-      NamedDecl *PrevDecl = R.getFoundDecl();
-      if (PrevDecl->isTemplateParameter()) {
+    if (!R.empty()) {
+      NamedDecl *PrevDecl = *R.begin();
+      if (R.isSingleResult() && PrevDecl->isTemplateParameter()) {
         // Maybe we will complain about the shadowed template parameter.
         DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
         // Just pretend that we didn't see the previous declaration.
         PrevDecl = nullptr;
-      } else if (S->isDeclScope(PrevDecl)) {
+      }
+      if (PrevDecl && S->isDeclScope(PrevDecl)) {
         Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
         Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
-
         // Recover by removing the name
         II = nullptr;
         D.SetIdentifier(nullptr, D.getIdentifierLoc());
         D.setInvalidType(true);
       }
     }
   }
 

 void Sema::DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters) {
   // Don't diagnose unused-parameter errors in template instantiations; we
   // will already have done so in the template itself.
   if (inTemplateInstantiation())
     return;
 
   for (const ParmVarDecl *Parameter : Parameters) {
     if (!Parameter->isReferenced() && Parameter->getDeclName() &&
-        !Parameter->hasAttr<UnusedAttr>()) {
+        !Parameter->hasAttr<UnusedAttr>() &&
+        !Parameter->getIdentifier()->isPlaceholder()) {
       Diag(Parameter->getLocation(), diag::warn_unused_parameter)
         << Parameter->getDeclName();
     }
   }
 }
 
 void Sema::DiagnoseSizeOfParametersAndReturnValue(
     ArrayRef<ParmVarDecl *> Parameters, QualType ReturnTy, NamedDecl *D) {
FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
   if (InitStyle != ICIS_NoInit)
     checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
 
   FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
                                        BitWidth, Mutable, InitStyle);
   if (InvalidDecl)
     NewFD->setInvalidDecl();
 
-  if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
+  if (PrevDecl && !isa<TagDecl>(PrevDecl) &&
+      !PrevDecl->isPlaceholderVar(getLangOpts())) {
     Diag(Loc, diag::err_duplicate_member) << II;
     Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
     NewFD->setInvalidDecl();
   }
 
   if (!InvalidDecl && getLangOpts().CPlusPlus) {
     if (Record->isUnion()) {
       if (const RecordType *RT = EltTy->getAs<RecordType>()) {

clang/lib/Sema/SemaDeclCXX.cpp

bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old,
   const FunctionDecl *OldDefinition = nullptr;
   if (New->isThisDeclarationInstantiatedFromAFriendDefinition() &&
       Old->isDefined(OldDefinition, true))
     CheckForFunctionRedefinition(New, OldDefinition);
 
   return Invalid;
 }
 
+void Sema::DiagPlaceholderVariableDefinition(SourceLocation Loc) {
+  Diag(Loc, getLangOpts().CPlusPlus26
+                ? diag::warn_cxx23_placeholder_var_definition
+                : diag::ext_placeholder_var_definition);
+}
+
 NamedDecl *
 Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D,
                                    MultiTemplateParamsArg TemplateParamLists) {
   assert(D.isDecompositionDeclarator());
   const DecompositionDeclarator &Decomp = D.getDecompositionDeclarator();
 
   // The syntax only allows a decomposition declarator as a simple-declaration,
   // a for-range-declaration, or a condition in Clang, but we parse it in more
Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D,
 
   // Build the BindingDecls.
   SmallVector<BindingDecl*, 8> Bindings;
 
   // Build the BindingDecls.
   for (auto &B : D.getDecompositionDeclarator().bindings()) {
     // Check for name conflicts.
     DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
+    IdentifierInfo *VarName = B.Name;
+    assert(VarName && "Cannot have an unnamed binding declaration");
+
     LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                           ForVisibleRedeclaration);
     LookupName(Previous, S,
                /*CreateBuiltins*/DC->getRedeclContext()->isTranslationUnit());
 
     // It's not permitted to shadow a template parameter name.
     if (Previous.isSingleResult() &&
         Previous.getFoundDecl()->isTemplateParameter()) {
       DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
                                       Previous.getFoundDecl());
       Previous.clear();
     }
 
-    auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, B.Name);
+    auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, VarName);
 
     // Find the shadowed declaration before filtering for scope.
     NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty()
                                   ? getShadowedDeclaration(BD, Previous)
                                   : nullptr;
 
     bool ConsiderLinkage = DC->isFunctionOrMethod() &&
                            DS.getStorageClassSpec() == DeclSpec::SCS_extern;
     FilterLookupForScope(Previous, DC, S, ConsiderLinkage,
                          /*AllowInlineNamespace*/false);
 
+    bool IsPlaceholder = DS.getStorageClassSpec() != DeclSpec::SCS_static &&
+                         DC->isFunctionOrMethod() && VarName->isPlaceholder();
     if (!Previous.empty()) {
+      if (IsPlaceholder) {
+        bool sameDC = (Previous.end() - 1)
+                          ->getDeclContext()
+                          ->getRedeclContext()
+                          ->Equals(DC->getRedeclContext());
+        if (sameDC &&
+            isDeclInScope(*(Previous.end() - 1), CurContext, S, false)) {
+          Previous.clear();
+          DiagPlaceholderVariableDefinition(B.NameLoc);
+        }
+      } else {
         auto *Old = Previous.getRepresentativeDecl();
         Diag(B.NameLoc, diag::err_redefinition) << B.Name;
         Diag(Old->getLocation(), diag::note_previous_definition);
+      }
     } else if (ShadowedDecl && !D.isRedeclaration()) {
       CheckShadow(BD, ShadowedDecl, Previous);
     }
     PushOnScopeChains(BD, S, true);
     Bindings.push_back(BD);
     ParsingInitForAutoVars.insert(BD);
   }
 
public:
   }
 
 private:
   CXXRecordDecl *ClassDecl;
 };
 
 }
 
+bool Sema::DiagRedefinedPlaceholderFieldDecl(SourceLocation Loc,
+                                             RecordDecl *ClassDecl,
+                                             const IdentifierInfo *Name) {
+  DeclContextLookupResult Result = ClassDecl->lookup(Name);
+  DeclContextLookupResult::iterator Found =
+      llvm::find_if(Result, [this](const NamedDecl *Elem) {
+        return isa<FieldDecl, IndirectFieldDecl>(Elem) &&
+               Elem->isPlaceholderVar(getLangOpts());
+      });
+  // We did not find a placeholder variable
+  if (Found == Result.end())
+    return false;
+  Diag(Loc, diag::err_using_placeholder_variable) << Name;
+  for (DeclContextLookupResult::iterator It = Found; It != Result.end(); It++) {
+    const NamedDecl *ND = *It;
+    if (ND->getDeclContext() != ND->getDeclContext())
+      break;
+    if (isa<FieldDecl, IndirectFieldDecl>(ND) &&
+        ND->isPlaceholderVar(getLangOpts()))
+      Diag(ND->getLocation(), diag::note_reference_placeholder) << ND;
+  }
+  return true;
+}
+
+ValueDecl *
+Sema::tryLookupUnambiguousFieldDecl(RecordDecl *ClassDecl,
+                                    const IdentifierInfo *MemberOrBase) {
+  ValueDecl *ND = nullptr;
+  for (auto *D : ClassDecl->lookup(MemberOrBase)) {
+    if (isa<FieldDecl, IndirectFieldDecl>(D)) {
+      bool IsPlaceholder = D->isPlaceholderVar(getLangOpts());
+      if (ND) {
+        if (IsPlaceholder && D->getDeclContext() == ND->getDeclContext())
+          return nullptr;
+        break;
+      }
+      if (!IsPlaceholder)
+        return cast<ValueDecl>(D);
+      ND = cast<ValueDecl>(D);
+    }
+  }
+  return ND;
+}
+
 ValueDecl *Sema::tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
                                              CXXScopeSpec &SS,
                                              ParsedType TemplateTypeTy,
                                              IdentifierInfo *MemberOrBase) {
   if (SS.getScopeRep() || TemplateTypeTy)
     return nullptr;
-  for (auto *D : ClassDecl->lookup(MemberOrBase))
-    if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D))
-      return cast<ValueDecl>(D);
-  return nullptr;
+  return tryLookupUnambiguousFieldDecl(ClassDecl, MemberOrBase);
 }
 
 /// Handle a C++ member initializer.
 MemInitResult
 Sema::BuildMemInitializer(Decl *ConstructorD,
                           Scope *S,
                           CXXScopeSpec &SS,
                           IdentifierInfo *MemberOrBase,

clang/lib/Sema/SemaExpr.cpp

for (const OffsetOfComponent &OC : Components) {
     LookupQualifiedName(R, RD);
     FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>();
     IndirectFieldDecl *IndirectMemberDecl = nullptr;
     if (!MemberDecl) {
       if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>()))
         MemberDecl = IndirectMemberDecl->getAnonField();
     }
 
-    if (!MemberDecl)
-      return ExprError(Diag(BuiltinLoc, diag::err_no_member)
-                       << OC.U.IdentInfo << RD << SourceRange(OC.LocStart,
-                                                              OC.LocEnd));
+    if (!MemberDecl) {
+      // Lookup could be ambiguous when looking up a placeholder variable
+      // __builtin_offsetof(S, _).
+      // In that case we would already have emitted a diagnostic
+      if (!R.isAmbiguous())
+        Diag(BuiltinLoc, diag::err_no_member)
+            << OC.U.IdentInfo << RD << SourceRange(OC.LocStart, OC.LocEnd);
+      return ExprError();
+    }
 
     // C99 7.17p3:
     //   (If the specified member is a bit-field, the behavior is undefined.)
     //
     // We diagnose this as an error.
     if (MemberDecl->isBitField()) {
       Diag(OC.LocEnd, diag::err_offsetof_bitfield)
         << MemberDecl->getDeclName()

clang/lib/Sema/SemaInit.cpp

if (!RD) {
           << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
       ++Index;
       return true;
     }
 
     FieldDecl *KnownField = D->getFieldDecl();
     if (!KnownField) {
       const IdentifierInfo *FieldName = D->getFieldName();
-      DeclContext::lookup_result Lookup = RD->lookup(FieldName);
-      for (NamedDecl *ND : Lookup) {
-        if (auto *FD = dyn_cast<FieldDecl>(ND)) {
-          KnownField = FD;
-          break;
-        }
-        if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
-          // In verify mode, don't modify the original.
-          if (VerifyOnly)
-            DIE = CloneDesignatedInitExpr(SemaRef, DIE);
-          ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
-          D = DIE->getDesignator(DesigIdx);
-          KnownField = cast<FieldDecl>(*IFD->chain_begin());
-          break;
-        }
+      ValueDecl *VD = SemaRef.tryLookupUnambiguousFieldDecl(RD, FieldName);
+      if (auto *FD = dyn_cast_if_present<FieldDecl>(VD)) {
+      } else if (auto *IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {
       }
       if (!KnownField) {
         if (VerifyOnly) {
           ++Index;
           return true;  // No typo correction when just trying this out.
         }
 
+        // We found a placeholder variable
+        if (SemaRef.DiagRedefinedPlaceholderFieldDecl(DIE->getBeginLoc(), RD,
+                                                      FieldName)) {
+          ++Index;
+          return true;
+        }
         // Name lookup found something, but it wasn't a field.
-        if (!Lookup.empty()) {
+        if (DeclContextLookupResult Lookup = RD->lookup(FieldName);
+            !Lookup.empty()) {
           SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
               << FieldName;
           SemaRef.Diag(Lookup.front()->getLocation(),
                        diag::note_field_designator_found);
           ++Index;
           return true;
         }
 
         // Name lookup didn't find anything.
         // Determine whether this was a typo for another field name.

clang/lib/Sema/SemaLambda.cpp

if (C->Init.isUsable()) {
       if (auto *BD = R.getAsSingle<BindingDecl>())
         Var = BD;
       else
         Var = R.getAsSingle<VarDecl>();
       if (Var && DiagnoseUseOfDecl(Var, C->Loc))
         continue;
     }
 
     // C++11 [expr.prim.lambda]p10:
     //   [...] each such lookup shall find a variable with automatic storage
     //   duration declared in the reaching scope of the local lambda expression.
     // Note that the 'reaching scope' check happens in tryCaptureVariable().
     if (!Var) {
       Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id;
       continue;
     }
 
     // C++11 [expr.prim.lambda]p8:
     //   An identifier or this shall not appear more than once in a
     //   lambda-capture.
     if (auto [It, Inserted] = CaptureNames.insert(std::pair{C->Id, Var});
         !Inserted) {
       if (C->InitKind == LambdaCaptureInitKind::NoInit &&
           !Var->isInitCapture()) {
         Diag(C->Loc, diag::err_capture_more_than_once)
             << C->Id << It->second->getBeginLoc()
             << FixItHint::CreateRemoval(
                    SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));
-      } else
+        Var->setInvalidDecl();
+      } else if (Var && Var->isPlaceholderVar(getLangOpts())) {
+        DiagPlaceholderVariableDefinition(C->Loc);
+      } else {
         // Previous capture captured something different (one or both was
         // an init-capture): no fixit.
         Diag(C->Loc, diag::err_capture_more_than_once) << C->Id;
         continue;
       }
+    }
 
     // Ignore invalid decls; they'll just confuse the code later.
     if (Var->isInvalidDecl())
       continue;
 
     VarDecl *Underlying = Var->getPotentiallyDecomposedVarDecl();
 
     if (!Underlying->hasLocalStorage()) {

 bool Sema::DiagnoseUnusedLambdaCapture(SourceRange CaptureRange,
                                        const Capture &From) {
   if (CaptureHasSideEffects(From))
     return false;
 
   if (From.isVLATypeCapture())
     return false;
 
+  // FIXME: maybe we should warn on these if we can find a sensible diagnostic
+  // message
+  if (From.isInitCapture() &&
+      From.getVariable()->isPlaceholderVar(getLangOpts()))
+    return false;
+
   auto diag = Diag(From.getLocation(), diag::warn_unused_lambda_capture);
   if (From.isThisCapture())
     diag << "'this'";
   else
     diag << From.getVariable();
   diag << From.isNonODRUsed();
   diag << FixItHint::CreateRemoval(CaptureRange);
   return true;

clang/lib/Sema/SemaLookup.cpp

void LookupResult::resolveKind() {
 
   // Don't do any extra resolution if we've already resolved as ambiguous.
   if (ResultKind == Ambiguous) return;
 
   llvm::SmallDenseMap<const NamedDecl *, unsigned, 16> Unique;
   llvm::SmallDenseMap<QualType, unsigned, 16> UniqueTypes;
 
   bool Ambiguous = false;
+  bool ReferenceToPlaceHolderVariable = false;
   bool HasTag = false, HasFunction = false;
   bool HasFunctionTemplate = false, HasUnresolved = false;
   const NamedDecl *HasNonFunction = nullptr;
 
   llvm::SmallVector<const NamedDecl *, 4> EquivalentNonFunctions;
   llvm::BitVector RemovedDecls(N);
 
   for (unsigned I = 0; I < N; I++) {
if (const auto *TD = dyn_cast<TypeDecl>(D)) {
       if (!UniqueResult.second) {
         // The type is not unique.
         ExistingI = UniqueResult.first->second;
       }
     }
 
     // For non-type declarations, check for a prior lookup result naming this
     // canonical declaration.
-    if (!ExistingI) {
+    if (!D->isPlaceholderVar(getSema().getLangOpts()) && !ExistingI) {
       auto UniqueResult = Unique.insert(std::make_pair(D, I));
       if (!UniqueResult.second) {
         // We've seen this entity before.
         ExistingI = UniqueResult.first->second;
       }
     }
 
     if (ExistingI) {
if (isa<UnresolvedUsingValueDecl>(D)) {
         // module and the other is an internal linkage declaration from another
         // module, just skip it.
         if (getSema().isEquivalentInternalLinkageDeclaration(HasNonFunction,
                                                              D)) {
           EquivalentNonFunctions.push_back(D);
           RemovedDecls.set(I);
           continue;
         }
-
+        if (D->isPlaceholderVar(getSema().getLangOpts()) &&
+            getContextForScopeMatching(D) ==
+                getContextForScopeMatching(Decls[I])) {
+          ReferenceToPlaceHolderVariable = true;
+        }
         Ambiguous = true;
       }
       HasNonFunction = D;
     }
   }
 
   // FIXME: This diagnostic should really be delayed until we're done with
   // the lookup result, in case the ambiguity is resolved by the caller.
   if (!EquivalentNonFunctions.empty() && !Ambiguous)
     getSema().diagnoseEquivalentInternalLinkageDeclarations(
         getNameLoc(), HasNonFunction, EquivalentNonFunctions);
 
   // Remove decls by replacing them with decls from the end (which
   // means that we need to iterate from the end) and then truncating
   // to the new size.
   for (int I = RemovedDecls.find_last(); I >= 0; I = RemovedDecls.find_prev(I))
     Decls[I] = Decls[--N];
   Decls.truncate(N);
 
   if ((HasNonFunction && (HasFunction || HasUnresolved)) ||
       (HideTags && HasTag && (HasFunction || HasNonFunction || HasUnresolved)))
     Ambiguous = true;
 
-  if (Ambiguous)
+  if (Ambiguous && ReferenceToPlaceHolderVariable)
+    setAmbiguous(LookupResult::AmbiguousReferenceToPlaceholderVariable);
+  else if (Ambiguous)
     setAmbiguous(LookupResult::AmbiguousReference);
   else if (HasUnresolved)
     ResultKind = LookupResult::FoundUnresolvedValue;
   else if (N > 1 || HasFunctionTemplate)
     ResultKind = LookupResult::FoundOverloaded;
   else
     ResultKind = LookupResult::Found;
 }
case LookupResult::AmbiguousTagHiding: {
     while (F.hasNext()) {
       if (TagDecls.count(F.next()))
         F.erase();
     }
     F.done();
     break;
   }
 
+  case LookupResult::AmbiguousReferenceToPlaceholderVariable: {
+    Diag(NameLoc, diag::err_using_placeholder_variable) << Name << LookupRange;
+    DeclContext *DC = nullptr;
+    for (auto *D : Result) {
+      Diag(D->getLocation(), diag::note_reference_placeholder) << D;
+      if (DC != nullptr && DC != D->getDeclContext())
+        break;
+      DC = D->getDeclContext();
+    }
+    break;
+  }
+
   case LookupResult::AmbiguousReference: {
     Diag(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange;
 
     for (auto *D : Result)
       Diag(D->getLocation(), diag::note_ambiguous_candidate) << D;
     break;
   }
   }

clang/test/Lexer/cxx-features.cpp

 #elif __cplusplus == 202302L
 #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (cxx23 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx23)
 #else
 #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23, cxx26) (cxx26 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx26)
 #endif
 
 // --- C++26 features ---
 
+#if check(placeholder_variables, 202306, 202306, 202306, 202306, 202306, 202306, 202306)
+#error "wrong value for __cpp_placeholder_variables"
+#endif
+
 // --- C++23 features ---
 
 #if check(implicit_move, 0, 0, 0, 0, 0, 202011, 202011)
 #error "wrong value for __cpp_implicit_move"
 #endif
 
 #if check(size_t_suffix, 0, 0, 0, 0, 0, 202011, 202011)
 #error "wrong value for __cpp_size_t_suffix"

clang/test/Lexer/unicode.c

 // CHECK: static const char *copyright = "Copyright © {{2012}}";
 
 #if PP_ONLY
 COPYRIGHT
 // CHECK: Copyright © {{2012}}
 CHECK : The preprocessor should not complain about Unicode characters like ©.
 #endif
 
-        int _;
+int a;
 
 extern int X\UAAAAAAAA; // expected-error {{not allowed in an identifier}}
 int Y = '\UAAAAAAAA'; // expected-error {{invalid universal character}}
 
 #if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L)
 
 extern int ༀ;
 extern int 𑩐;
 extern int 𐠈;
 extern int ꙮ;
 extern int  \u1B4C;     // BALINESE LETTER ARCHAIC JNYA - Added in Unicode 14
 extern int  \U00016AA2; // TANGSA LETTER GA - Added in Unicode 14
 extern int  \U0001E4D0; // 𞓐 NAG MUNDARI LETTER O - Added in Unicode 15
-extern int _\N{TANGSA LETTER GA};
-extern int _\N{TANGSALETTERGA}; // expected-error {{'TANGSALETTERGA' is not a valid Unicode character name}} \
+extern int a\N{TANGSA LETTER GA};
+extern int a\N{TANGSALETTERGA}; // expected-error {{'TANGSALETTERGA' is not a valid Unicode character name}} \
                                 // expected-error {{expected ';' after top level declarator}} \
                                 // expected-note {{characters names in Unicode escape sequences are sensitive to case and whitespace}}
 
 extern int 𝛛; // expected-warning {{mathematical notation character <U+1D6DB> in an identifier is a Clang extension}}
 extern int ₉; // expected-error {{character <U+2089> not allowed at the start of an identifier}} \\
                  expected-warning {{declaration does not declare anything}}
 
 int a¹b₍₄₂₎∇; // expected-warning 6{{mathematical notation character}}

clang/test/SemaCXX/anonymous-union-export.cpp

 // RUN: %clang_cc1 -std=c++20 -emit-obj -verify -o %t.pcm %s
 
 export module M;
 export { // expected-note 2{{export block begins here}}
     union { bool a; }; // expected-error {{anonymous unions at namespace or global scope must be declared 'static'}} expected-error {{declaration of 'a' with internal linkage cannot be exported}}
-    static union { bool a; }; // expected-error {{declaration of 'a' with internal linkage cannot be exported}}
+    static union { bool b; }; // expected-error {{declaration of 'b' with internal linkage cannot be exported}}
 }

clang/test/SemaCXX/cxx2c-placeholder-vars.cpp

+// RUN: %clang -cc1 -fsyntax-only -verify -std=c++2c -Wunused-parameter -Wunused -Wpre-c++26-compat %s
+
+void static_var() {
+    static int _; // expected-note {{previous definition is here}} \
+                  // expected-note {{candidate}}
+    static int _; // expected-error {{redefinition of '_'}}
+    int _;        // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}} \
+                  // expected-note {{candidate}}
+    _++; // expected-error{{reference to '_' is ambiguous}}
+}
+
+void static_var_2() {
+    int _; // expected-note {{previous definition is here}}
+    static int _; // expected-error {{redefinition of '_'}}
+}
+
+void bindings() {
+    int arr[4] = {0, 1, 2, 3};
+    auto [_, _, _, _] = arr; // expected-warning 3{{placeholder variables are incompatible with C++ standards before C++2c}} \
+                             // expected-note 4{{placeholder declared here}}
+    _ == 42; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+    {
+        // no extension warning as we only introduce a single placeholder.
+        auto [_, a, b, c] = arr; // expected-warning {{unused variable '[_, a, b, c]'}}
+    }
+    {
+        auto [_, _, b, c] = arr; // expected-warning {{unused variable '[_, _, b, c]'}} \
+                                 // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}}
+    }
+    {
+        // There are only 3 extension warnings because the first
+        // introduction of `_` is valid in all C++ standards
+        auto [_, _, _, _] = arr; // expected-warning 3{{placeholder variables are incompatible with C++ standards before C++2c}}
+    }
+}
+
+namespace StaticBindings {
+
+int arr[2] = {0, 1};
+static auto [_, _] = arr; // expected-error {{redefinition of '_'}} \
+                          // expected-note  {{previous definition is here}}
+
+void f() {
+    int arr[2] = {0, 1};
+    static auto [_, _] = arr; // expected-error {{redefinition of '_'}} \
+                            // expected-note  {{previous definition is here}}
+}
+
+}
+
+void lambda() {
+    (void)[_ = 0, _ = 1] { // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}} \
+                           // expected-note 4{{placeholder declared here}}
+        (void)_++; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+    };
+
+    {
+        int _ = 12;
+        (void)[_ = 0]{}; // no warning (different scope)
+    }
+}
+
+namespace global_var {
+    int _; // expected-note {{previous definition is here}}
+    int _; // expected-error {{redefinition of '_'}}
+}
+
+namespace {
+    int _; // expected-note {{previous definition is here}}
+    int _; // expected-error {{redefinition of '_'}}
+}
+
+
+namespace global_fun {
+void _();
+void _();
+
+void _() {} // expected-note {{previous definition is here}}
+void _() {} // expected-error {{redefinition of '_'}}
+void _(int){}
+}
+
+typedef int _;
+typedef int _; // Type redeclaration, nothing to do with placeholders
+
+void extern_test() {
+    extern int _;
+    extern int _; // expected-note {{candidate}}
+    int _; //expected-note {{candidate}}
+    _++; // expected-error {{reference to '_' is ambiguous}}
+}
+
+
+struct Members {
+    int _; // expected-note 2{{placeholder declared here}}
+    int _; // expected-warning{{placeholder variables are incompatible with C++ standards before C++2c}} \
+           // expected-note 2{{placeholder declared here}}
+    void f() {
+        _++; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+    }
+    void attributes() __attribute__((diagnose_if(_ != 0, "oh no!", "warning"))); // expected-error{{ambiguous reference to placeholder '_', which is defined multiple times}}
+};
+
+namespace using_ {
+int _; // expected-note {{target of using declaration}}
+void f() {
+    int _; // expected-note {{conflicting declaration}}
+    _ = 0;
+    using using_::_; // expected-error {{target of using declaration conflicts with declaration already in scope}}
+}
+}
+
+
+void call(int);
+void test_param(int _) {}
+void test_params(int _, int _); // expected-error {{redefinition of parameter '_'}} \
+                                // expected-note {{previous declaration is here}}
+
+template <auto _, auto _> // expected-error {{declaration of '_' shadows template parameter}} \
+                          // expected-note  {{template parameter is declared here}}
+auto i = 0;
+
+template <typename T>
+concept C = requires(T _, T _) {  // expected-error {{redefinition of parameter '_'}} \
+                                // expected-note {{previous declaration is here}}
+    T{};
+};
+
+struct S {
+    int a;
+};
+
+void f(S a, S _) { // expected-warning {{unused parameter 'a'}}
+
+}
+
+void unused_warning() {
+  int _ = 12; // placeholder variable, no unused-but-set warning
+  int x = 12; // expected-warning {{unused variable 'x'}}
+  int _ = 12; // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}}
+}
+
+struct ShadowMembers {
+  int _;
+  void f() {
+    int _;
+    _ = 12; // Ok, access the local variable
+    (void)({ int _ = 12; _;}); // Ok, inside a different scope
+  }
+};
+
+struct MemberPtrs {
+  int _, _; // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}} \
+            // expected-note 4{{placeholder declared here}}
+};
+constexpr int oh_no = __builtin_offsetof(MemberPtrs, _); // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+int MemberPtrs::* ref = &MemberPtrs::_; // expected-error{{ambiguous reference to placeholder '_', which is defined multiple times}}
+
+
+struct MemberInitializer {
+  MemberInitializer() : _(0) {}  // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+  int _, _; // expected-note 2{{placeholder declared here}} \
+            // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}}
+};
+
+struct MemberAndUnion {
+  int _; // expected-note {{placeholder declared here}}
+  union { int _; int _; }; // expected-note 2 {{placeholder declared here}} \
+                           // expected-warning 2{{placeholder variables are incompatible with C++ standards before C++2c}}
+
+
+  MemberAndUnion() : _(0) {} // expected-error {{ambiguous reference to placeholder '_', which is defined multiple time}}
+};
+
+struct Union { union { int _, _, _; }; };   // expected-note 3{{placeholder declared here}} \
+                                            // expected-warning 2{{placeholder variables are incompatible with C++ standards before C++2c}}
+
+void TestUnion() {
+   Union c;
+   c._ = 0; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+}
+
+void AnonymousLocals() {
+    union  {int _, _;}; // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}}  \
+                        // expected-note 2{{placeholder declared here}}
+    union  {int _, _;}; // expected-warning 2{{placeholder variables are incompatible with C++ standards before C++2c}} \
+                        // expected-note 2{{placeholder declared here}}
+    _. = 0; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+}
+
+namespace StaticUnions {
+
+static union { int _ = 42; }; // expected-note {{previous declaration is here}}
+static union { int _ = 43; }; // expected-error {{member of anonymous union redeclares '_'}}
+
+inline void StaticUnion() {
+  static union { int _{}; };  // expected-note {{previous declaration is here}}
+  static union { int _{}; }; // expected-error {{member of anonymous union redeclares '_'}}
+}
+
+}
+
+namespace TagVariables {
+
+[[maybe_unused]] struct {
+    int _, _, _;  // expected-warning 2{{placeholder variables are incompatible with C++ standards before C++2c}}
+} a;
+
+[[maybe_unused]] union {
+    int _, _, _; // expected-warning 2{{placeholder variables are incompatible with C++ standards before C++2c}}
+} b;
+
+}
+
+namespace MemberLookupTests {
+
+struct S {
+    int _, _; // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}} \
+              // expected-note 8{{placeholder declared here}}
+
+    void f() {
+        _ ++ ; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+    }
+};
+
+struct T : S {
+
+};
+
+void Test() {
+    S s{._ =0}; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+    S{}._; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+    T{}._; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+};
+
+};
+
+namespace Bases {
+    struct S {
+        int _, _; // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}} \
+                  // expected-note   2{{placeholder declared here}}
+        int a;
+    };
+    struct T : S{
+        int _, _; // expected-warning {{placeholder variables are incompatible with C++ standards before C++2c}} \
+                  // expected-note   2{{placeholder declared here}}
+        int a;
+        void f() {
+            _; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}}
+            S::_; // expected-error {{ambiguous reference to placeholder '_', which is defined multiple times}} \
+                  // expected-error {{a type specifier is required for all declarations}}
+        }
+    };
+}

clang/www/cxx_status.html

  <tr>
   <td>User-generated <tt>static_assert</tt> messages</td>
   <td><a href="https://wg21.link/P2741R3">P2741R3</a></td>
   <td class="unreleased" align="center">Clang 17</td>
  </tr>
  <tr>
   <td>Placeholder variables with no name</td>
   <td><a href="https://wg21.link/P2169R4">P2169R4</a></td>
-  <td class="none" align="center">No</td>
+  <td class="unreleased" align="center">Clang 18</td>
  </tr>
 </table>
 </details>
 
 <h2 id="cxx23">C++23 implementation status</h2>
 
 <!-- TODO add link to the ISO Standard after it's published. -->
 <p>Clang has support for some of the features of the ISO C++ 2023 standard.</p>