[Sema][C] members of anonymous struct inherit QualType

[nickdesaulniers]

Summary

When declaring an anonymous struct with const or volatile
qualifiers, ensure the members of that anonymous struct are created with
that qualifier.

GCC behaves this way, and WG14 is currently discussing this behavior.

See also:

• https://bugs.llvm.org/show_bug.cgi?id=48755
• https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98826

[nickdesaulniers]

clang/lib/Sema/SemaDecl.cpp

5179

Maybe there's a way to have Context.getTypeDeclType return the qualified type here? (I couldn't find a way, but only looked today).

[aaron.ballman]

I know we don't have to deal with restrict because that qualifies a pointer (so there's no way to use it with an anonymous struct), but are there others? There's DeclSpec::TQ_unaligned (which has no corresponding qualifier in Qualifiers::TQ despite the comment about keeping them in sync). Similarly, what about:

struct S {
  _Atomic struct {
    int i;
  };
}

void foo(void) {
  struct S s;
  s.i = 12; // Is this an atomic assignment?
}

Further, do we have to worry about things which are not type specifiers but still impact the declaration, like various type attributes?

clang/test/AST/ast-dump-decl.c

132

This looks wrong to me -- I would have assumed the type would be const int and not int, which would match the behavior if the type was directly qualified: https://godbolt.org/

[nickdesaulniers]

Prefer https://reviews.llvm.org/D125167.

clang/test/AST/ast-dump-decl.c

132

Sorry, that godbolt link appears to be malformed (missing unique link)?

clang/lib/Sema/SemaDecl.cpp

Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
   // Mock up a declarator.
   Declarator Dc(DS, DeclaratorContext::Member);
   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,
+    QualType QT = Context.getTypeDeclType(Record);
+    if (!getLangOpts().CPlusPlus) {
+      if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
+        QT.addConst();
+      if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
+        QT.addVolatile();
+    }
+    Anon = FieldDecl::Create(Context, OwningClass, DS.getBeginLoc(),
+                             Record->getLocation(),
+                             /*IdentifierInfo=*/nullptr, QT, 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);

clang/test/AST/ast-dump-decl.c

 // CHECK:      EnumConstantDecl{{.*}} TestEnumConstantDeclInit 'int'
 // CHECK-NEXT:   ConstantExpr
 // CHECK-NEXT:     IntegerLiteral
 
 struct testIndirectFieldDecl {
   struct {
     int TestIndirectFieldDecl;
   };
+  const struct {
+    int Test48755Const;
+  };
+  volatile struct {
+    int Test48755Volatile;
+  };
 };
 // CHECK:      IndirectFieldDecl{{.*}} TestIndirectFieldDecl 'int'
 // CHECK-NEXT:   Field{{.*}} ''
 // CHECK-NEXT:   Field{{.*}} 'TestIndirectFieldDecl'
 
+// CHECK: IndirectFieldDecl{{.*}} Test48755Const 'int'
+// CHECK-NEXT: Field{{.*}} 'const struct testIndirectFieldDecl::{{.*}}'
+
+// CHECK: IndirectFieldDecl{{.*}} Test48755Volatile 'int'
+// CHECK-NEXT: Field{{.*}} 'volatile struct testIndirectFieldDecl::{{.*}}'
+
+
 // FIXME: It would be nice to dump the enum and its enumerators.
 int TestFunctionDecl(int x, enum { e } y) {
   return x;
 }
 // CHECK:      FunctionDecl{{.*}} TestFunctionDecl 'int (int, enum {{.*}})'
 // CHECK-NEXT:   ParmVarDecl{{.*}} x
 // CHECK-NEXT:   ParmVarDecl{{.*}} y
 // CHECK-NEXT:   CompoundStmt

clang/test/AST/ast-dump-records.c

union G {
   // CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-5]]:9> col:9 implicit e 'int'
   // CHECK-NEXT: Field 0x{{[^ ]*}} '' 'struct G::(anonymous at {{.*}}:[[@LINE-8]]:3)'
   // CHECK-NEXT: Field 0x{{[^ ]*}} 'e' 'int'
   // CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <col:12> col:12 implicit f 'int'
   // CHECK-NEXT: Field 0x{{[^ ]*}} '' 'struct G::(anonymous at {{.*}}:[[@LINE-11]]:3)'
   // CHECK-NEXT: Field 0x{{[^ ]*}} 'f' 'int'
 };
 
+struct H {
+  const struct {
+    int bar;
+  };
+  volatile struct {
+    int baz;
+  };
+};
+// CHECK: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-8]]:1, line:[[@LINE-1]]:1> line:[[@LINE-8]]:8 struct H definition
+// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-8]]:9, line:[[@LINE-6]]:3> line:[[@LINE-8]]:9 struct definition
+// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-8]]:5, col:9> col:9 bar 'int'
+// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-10]]:3, col:9> col:9 implicit 'const struct H::(anonymous at {{.*}}:[[@LINE-10]]:9)'
+// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-10]]:9> col:9 implicit bar 'int'
+// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'const struct H::(anonymous at {{.*}}:[[@LINE-12]]:9)'
+// CHECK-NEXT: Field 0x{{[^ ]*}} 'bar' 'int'
+// CHECK-NEXT: RecordDecl 0x{{[^ ]*}} <line:[[@LINE-11]]:12, line:[[@LINE-9]]:3> line:[[@LINE-11]]:12 struct definition
+// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-11]]:5, col:9> col:9 baz 'int'
+// CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <line:[[@LINE-13]]:3, col:12> col:12 implicit 'volatile struct H::(anonymous at {{.*}}:[[@LINE-13]]:12)'
+// CHECK-NEXT: IndirectFieldDecl 0x{{[^ ]*}} <line:[[@LINE-13]]:9> col:9 implicit baz 'int'
+// CHECK-NEXT: Field 0x{{[^ ]*}} '' 'volatile struct H::(anonymous at {{.*}}:[[@LINE-15]]:12)'
+// CHECK-NEXT: Field 0x{{[^ ]*}} 'baz' 'int'

clang/test/Sema/struct-decl-anonymous-members.c

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+struct dummy {
+  const struct { // expected-note {{non-static data member '' declared const here}}
+    int a;
+    // 'b' here should be 'const volatile' qualified.
+    volatile struct { int b; };
+  };
+  int c;
+};
+
+extern void fn(const int *); // expected-note {{passing argument to parameter here}}
+extern void fn2(volatile int *); // expected-note {{passing argument to parameter here}}
+
+void test(struct dummy *a) {
+  fn(&a->b); // expected-warning {{passing 'const volatile int *' to parameter of type 'const int *' discards qualifiers}}
+  fn2(&a->b); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile int *' discards qualifiers}}
+  a->a = a->c; // expected-error {{cannot assign to non-static data member '' with const-qualified type}}
+}

clang/test/Sema/struct-decl.c

struct InAnonymousFollowedByAnon {
   };
 };
 
 // This is the behavior in C++ as well, so making sure we reproduce it here.
 struct InAnonymousFollowedByEmpty {
   struct FlexibleArrayMem a; // expected-warning {{field 'a' with variable sized type 'struct FlexibleArrayMem' not at the end of a struct or class is a GNU extension}}
   struct {};
 };
+
+struct QualifiedAnonymousMembers {
+  const struct { int foo; };
+  volatile struct { int bar; };
+};