[clang] Properly print unnamed members in diagnostics

[Fznamznon]

Summary

Use member's type when printing.
This also fixes a bug in warning diagnostic for out of order
initialization with designated initializers so it points to a valid
source location when an anonymous member is being initialized.

Fixes https://github.com/llvm/llvm-project/issues/63759

[shafik]

Thank you for this fix, it is a lot cleaner than I was expecting.

clang/include/clang/AST/Decl.h

3186

So it looks like w/o this we would end up using NamedDecl::printName(...) is that right?

clang/test/AST/ast-dump-APValue-anon-union.cpp

43

I am curious what the rest of the diagnostic message from anonymous union at... says.

[Fznamznon]

clang/include/clang/AST/Decl.h

3186

Right.

clang/test/AST/ast-dump-APValue-anon-union.cpp

43

It points to the source location of anonymous member definition, I'm seeing "/absolute/path/to/file/ast-dump-APValue-anon-union.cpp::20:3"

[shafik]

LGTM

[aaron.ballman]

LGTM aside from a small nit

clang/lib/AST/Decl.cpp

4567–4569

This way we're not reimplementing the same logic that NamedDecl does (in case we update that logic at some point in the future).

clang/docs/ReleaseNotes.rst

- Clang now respects ``-fwrapv`` and ``-ftrapv`` for ``__builtin_abs`` and
   `#45794 <https://github.com/llvm/llvm-project/issues/45794>`_)
 - Fixed an issue where accesses to the local variables of a coroutine during
   ``await_suspend`` could be misoptimized, including accesses to the awaiter
   object itself.
   (`#56301 <https://github.com/llvm/llvm-project/issues/56301>`_)
   The current solution may bring performance regressions if the awaiters have
   non-static data members. See
   `#64945 <https://github.com/llvm/llvm-project/issues/64945>`_ for details.
+- Clang now prints unnamed members in diagnostic messages instead of giving an
+  empty ''. Fixes
+  (`#63759 <https://github.com/llvm/llvm-project/issues/63759>`_)
 
 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to Attribute Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to C++ Support

clang/include/clang/AST/Decl.h

public:
 
   /// Retrieves the canonical declaration of this field.
   FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
   const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
+
+  void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override;
 };
 
 /// An instance of this object exists for each enum constant
 /// that is defined.  For example, in "enum X {a,b}", each of a/b are
 /// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
 /// TagType for the X EnumDecl.
 class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
   Stmt *Init; // an integer constant expression

clang/lib/AST/Decl.cpp

assert((getParent()->isLambda() || getParent()->isCapturedRecord()) &&
          "capturing type in non-lambda or captured record.");
   assert(StorageKind == ISK_NoInit && !BitField &&
          "bit-field or field with default member initializer cannot capture "
          "VLA type");
   StorageKind = ISK_CapturedVLAType;
   CapturedVLAType = VLAType;
 }
 
+void FieldDecl::printName(raw_ostream &OS, const PrintingPolicy &Policy) const {
+  // Print unnamed members using name of their type.
+  if (isAnonymousStructOrUnion()) {
+    this->getType().print(OS, Policy);
+    return;
+  }
+  // Otherwise, do the normal printing.
+  DeclaratorDecl::printName(OS, Policy);
+}
+
 //===----------------------------------------------------------------------===//
 // TagDecl Implementation
 //===----------------------------------------------------------------------===//
 
 TagDecl::TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
                  SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
                  SourceLocation StartL)
     : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),

clang/lib/Sema/SemaInit.cpp

if (IsFirstDesignator && !VerifyOnly && SemaRef.getLangOpts().CPlusPlus &&
         if (*NextField != RD->field_end() &&
             declaresSameEntity(*FI, **NextField))
           break;
         PrevField = *FI;
       }
 
       if (PrevField &&
           PrevField->getFieldIndex() > KnownField->getFieldIndex()) {
-        SemaRef.Diag(DIE->getBeginLoc(), diag::ext_designated_init_reordered)
+        SemaRef.Diag(DIE->getInit()->getBeginLoc(),
+                     diag::ext_designated_init_reordered)
             << KnownField << PrevField << DIE->getSourceRange();
 
         unsigned OldIndex = StructuredIndex - 1;
         if (StructuredList && OldIndex <= StructuredList->getNumInits()) {
           if (Expr *PrevInit = StructuredList->getInit(OldIndex)) {
             SemaRef.Diag(PrevInit->getBeginLoc(),
                          diag::note_previous_field_init)
                 << PrevField << PrevInit->getSourceRange();

clang/test/AST/ast-dump-APValue-anon-union.cpp

void Test() {
   // CHECK-NEXT:  |   | `-field: Union .i Int 42
 
   constexpr U0 u0a{};
   // CHECK:  | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}> col:{{.*}} u0a 'const U0':'const U0' constexpr listinit
   // CHECK-NEXT:  |   |-value: Union None
 
   constexpr U0 u0b{3.1415f};
   // CHECK:  | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}> col:{{.*}} u0b 'const U0':'const U0' constexpr listinit
-  // CHECK-NEXT:  |   |-value: Union . Union .f Float 3.141500e+00
+  // CHECK-NEXT:  |   |-value: Union .U0::(anonymous union at {{.*}}) Union .f Float 3.141500e+00
 
   constexpr U1 u1a{};
   // CHECK:  | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}> col:{{.*}} u1a 'const U1':'const U1' constexpr listinit
-  // CHECK-NEXT:  |   |-value: Union . Union .f Float 0.000000e+00
+  // CHECK-NEXT:  |   |-value: Union .U1::(anonymous union at {{.*}}) Union .f Float 0.000000e+00
 
   constexpr U1 u1b{3.1415f};
   // CHECK:    `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}> col:{{.*}} u1b 'const U1':'const U1' constexpr listinit
-  // CHECK-NEXT:      |-value: Union . Union .f Float 3.141500e+00
+  // CHECK-NEXT:      |-value: Union .U1::(anonymous union at {{.*}}) Union .f Float 3.141500e+00
 }

clang/test/CXX/special/class.dtor/p5-0x.cpp

 B3 b3; // expected-error {{deleted function}}
 struct B4 {
   B4();
   InaccessibleDtor a[4]; // expected-note {{because field 'a' has an inaccessible destructor}}
 };
 B4 b4; // expected-error {{deleted function}}
 union B5 {
   B5();
-  // FIXME: Describe the anonymous union member better than ''.
-  union { // expected-note {{because field '' has a deleted destructor}}
+  union { // expected-note-re {{because field 'B5::(anonymous union at {{.+}})' has a deleted destructor}}
     DeletedDtor a; // expected-note {{because field 'a' has a deleted destructor}}
   };
 };
 B5 b5; // expected-error {{deleted function}}
 union B6 {
   B6();
-  union { // expected-note {{because field '' has a deleted destructor}}
+  union { // expected-note-re {{because field 'B6::(anonymous union at {{.+}})' has a deleted destructor}}
     InaccessibleDtor a; // expected-note {{because field 'a' has an inaccessible destructor}}
   };
 };
 B6 b6; // expected-error {{deleted function}}
 
 // -- any direct or virtual base class has a deleted or inaccessible destructor.
 struct C1 : DeletedDtor { C1(); } c1; // expected-error {{deleted function}} expected-note {{base class 'DeletedDtor' has a deleted destructor}}
 struct C2 : InaccessibleDtor { C2(); } c2; // expected-error {{deleted function}} expected-note {{base class 'InaccessibleDtor' has an inaccessible destructor}}

clang/test/Sema/transparent-union.c

union pr15134 {
   // alignment than required by the first field of the transparent union.
 } __attribute__((transparent_union));
 
 union pr15134v2 {
   struct { // expected-note {{alignment of first field is 32 bits}}
     unsigned int u1;
     unsigned int u2;
   };
-  struct {  // expected-warning {{alignment of field '' (64 bits) does not match the alignment of the first field in transparent union; transparent_union attribute ignored}}
+  struct {  // expected-warning-re {{alignment of field 'struct pr15134v2::(anonymous at {{.+}})' (64 bits) does not match the alignment of the first field in transparent union; transparent_union attribute ignored}}
     unsigned int u3;
   } __attribute__((aligned(8)));
 } __attribute__((transparent_union));
 
 union pr30520v { void b; } __attribute__((transparent_union)); // expected-error {{field has incomplete type 'void'}}
 
 union pr30520a { int b[]; } __attribute__((transparent_union)); // expected-error {{flexible array member 'b' in a union is not allowed}}
 

clang/test/SemaCXX/cxx0x-nontrivial-union.cpp

union {
       struct {
         X x;
       };
     };
   };
 
   template<typename T> struct Test2 {
     union {
-      struct {  // expected-note {{default constructor of 'Test2<pr16061::X>' is implicitly deleted because variant field '' has a non-trivial default constructor}}
+      struct {  // expected-note-re {{default constructor of 'Test2<pr16061::X>' is implicitly deleted because variant field 'struct (anonymous struct at{{.+}})' has a non-trivial default constructor}}
         T x;
       };
     };
   };
 
   Test2<X> t2x;  // expected-error {{call to implicitly-deleted default constructor of 'Test2<X>'}}
 }
 

clang/test/SemaCXX/cxx2a-initializer-aggregates.cpp

.e = 1, // reorder-note {{previous initialization for field 'e' is here}}
             // pedantic-error@-1 {{mixture of designated and non-designated initializers in the same initializer list is a C99 extension}}
     .d = 1, // reorder-error {{field 'e' will be initialized after field 'd'}}
             // reorder-note@-1 {{previous initialization for field 'd' is here}}
     .c = 1, // reorder-error {{field 'd' will be initialized after field 'c'}} // reorder-note {{previous initialization for field 'c' is here}}
     .b = 1, // reorder-error {{field 'c' will be initialized after field 'b'}} // reorder-note {{previous initialization for field 'b' is here}}
     .a = 1, // reorder-error {{field 'b' will be initialized after field 'a'}}
 };
 }
+
+namespace GH63759 {
+struct C {
+  int y = 1;
+  union {
+    int a;
+    short b;
+  };
+  int x = 1;
+};
+
+void foo() {
+  C c1 = {.x = 3, .a = 1}; // reorder-error-re {{ISO C++ requires field designators to be specified in declaration order; field 'x' will be initialized after field 'GH63759::C::(anonymous union at {{.*}})'}}
+                           // reorder-note@-1 {{previous initialization for field 'x' is here}}
+
+  C c2 = {.a = 3, .y = 1}; // reorder-error-re {{ISO C++ requires field designators to be specified in declaration order; field 'GH63759::C::(anonymous union at {{.*}})' will be initialized after field 'y'}}
+                           // reorder-note-re@-1 {{previous initialization for field 'GH63759::C::(anonymous union at {{.*}})' is here}}
+                           //
+}
+}

clang/test/SemaObjCXX/arc-0x.mm

struct S0 {
     union {
       id f0; // expected-note-re 6 {{{{.*}} of '(anonymous union at {{.*}})' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
       char f1;
     };
   };
 
   struct S1 {
     union {
-      union { // expected-note {{copy constructor of 'S1' is implicitly deleted because field '' has a deleted copy constructor}} expected-note {{copy assignment operator of 'S1' is implicitly deleted because field '' has a deleted copy assignment operator}} expected-note 4 {{'S1' is implicitly deleted because field '' has a deleted}}
+      union { // expected-note-re {{copy constructor of 'S1' is implicitly deleted because field 'test_union::S1::(anonymous union at {{.*}})' has a deleted copy constructor}} expected-note-re {{copy assignment operator of 'S1' is implicitly deleted because field 'test_union::S1::(anonymous union at {{.*}})' has a deleted copy assignment operator}} expected-note-re 4 {{'S1' is implicitly deleted because field 'test_union::S1::(anonymous union at {{.*}})' has a deleted}}
         id f0; // expected-note-re 2 {{{{.*}} of '(anonymous union at {{.*}}' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
         char f1;
       };
       int f2;
     };
   };
 
   struct S2 {
     union {
       // FIXME: the note should say 'f0' is causing the special functions to be deleted.
-      struct { // expected-note 6 {{'S2' is implicitly deleted because variant field '' has a non-trivial}}
+      struct { // expected-note-re 6 {{'S2' is implicitly deleted because variant field 'test_union::S2::(anonymous struct at {{.*}})' has a non-trivial}}
         id f0;
         int f1;
       };
       int f2;
     };
     int f3;
   };
 
   U0 *x0;
   U1 *x1;
   U2 *x2;
   U3 *x3;
   S0 *x4;
   S1 *x5;
   S2 *x6;
 
   static union { // expected-error {{call to implicitly-deleted default constructor of}}
     id g0; // expected-note-re {{default constructor of '(unnamed union at {{.*}}' is implicitly deleted because variant field 'g0' is an ObjC pointer}}
   };
 
   static union { // expected-error {{call to implicitly-deleted default constructor of}}
-    union { // expected-note-re {{default constructor of '(unnamed union at {{.*}}' is implicitly deleted because field '' has a deleted default constructor}}
-      union { // expected-note-re {{default constructor of '(anonymous union at {{.*}}' is implicitly deleted because field '' has a deleted default constructor}}
+    union { // expected-note-re {{default constructor of '(unnamed union at {{.*}}' is implicitly deleted because field 'test_union::(anonymous union at {{.*}})' has a deleted default constructor}}
+      union { // expected-note-re {{default constructor of '(anonymous union at {{.*}}' is implicitly deleted because field 'test_union::(anonymous union at {{.*}})' has a deleted default constructor}}
         __weak id g1; // expected-note-re {{default constructor of '(anonymous union at {{.*}}' is implicitly deleted because variant field 'g1' is an ObjC pointer}}
         int g2;
       };
       int g3;
     };
     int g4;
   };