Add -Wdefault-const-init

Author: AaronBallman

clang/docs/ReleaseNotes.rst

@@ -140,6 +140,9 @@ C Language Changes
 - Clang now allows an ``inline`` specifier on a typedef declaration of a
   function type in Microsoft compatibility mode. #GH124869
 - Clang now allows ``restrict`` qualifier for array types with pointer elements (#GH92847).
+- Clang now diagnoses ``const``-qualified object definitions without an
+  initializer, under the new warning ``-Wdefault-const-init`` (which is grouped
+  under ``-Wc++-compat``, as this construct is not compatible with C++). #GH19297
 
 C2y Feature Support
 ^^^^^^^^^^^^^^^^^^^

clang/include/clang/Basic/DiagnosticGroups.td

@@ -154,8 +154,9 @@ def BuiltinRequiresHeader : DiagGroup<"builtin-requires-header">;
 def C99Compat : DiagGroup<"c99-compat">;
 def C23Compat : DiagGroup<"c23-compat">;
 def : DiagGroup<"c2x-compat", [C23Compat]>;
+def DefaultConstInit : DiagGroup<"default-const-init">;
 
-def CXXCompat: DiagGroup<"c++-compat">;
+def CXXCompat: DiagGroup<"c++-compat", [DefaultConstInit]>;
 def ExternCCompat : DiagGroup<"extern-c-compat">;
 def KeywordCompat : DiagGroup<"keyword-compat">;
 def GNUCaseRange : DiagGroup<"gnu-case-range">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -8197,6 +8197,12 @@ def err_address_space_qualified_new : Error<
 def err_address_space_qualified_delete : Error<
   "'delete' cannot delete objects of type %0 in address space '%1'">;
 
+def note_default_init_const_member : Note<
+  "member %0 declared 'const' here">;
+def warn_default_init_const : Warning<
+  "default initialization of an object of type %0%select{| with const member}1"
+  "%select{| leaves the object unitialized and}2 is incompatible with C++">,
+  InGroup<DefaultConstInit>;
 def err_default_init_const : Error<
   "default initialization of an object of const type %0"
   "%select{| without a user-provided default constructor}1">;

clang/lib/Sema/Sema.cpp

@@ -1448,6 +1448,16 @@ void Sema::ActOnEndOfTranslationUnit() {
     // No initialization is performed for a tentative definition.
     CheckCompleteVariableDeclaration(VD);
 
+    // In C, if the definition is const-qualified and has no initializer, it
+    // is left uninitialized unless it has static or thread storage duration.
+    QualType Type = VD->getType();
+    if (!VD->isInvalidDecl() && !getLangOpts().CPlusPlus &&
+        Type.isConstQualified() && !VD->getAnyInitializer())
+      Diag(VD->getLocation(), diag::warn_default_init_const)
+          << Type << /*not a field*/0
+          << (VD->getStorageDuration() != SD_Static &&
+              VD->getStorageDuration() != SD_Thread);
+
     // Notify the consumer that we've completed a tentative definition.
     if (!VD->isInvalidDecl())
       Consumer.CompleteTentativeDefinition(VD);

clang/lib/Sema/SemaDecl.cpp

@@ -14333,6 +14333,14 @@ void Sema::ActOnUninitializedDecl(Decl *RealDecl) {
       return;
     }
 
+    // In C, if the definition is const-qualified and has no initializer, it
+    // is left uninitialized unless it has static or thread storage duration.
+    if (!getLangOpts().CPlusPlus && Type.isConstQualified())
+      Diag(Var->getLocation(), diag::warn_default_init_const)
+          << Type << /*not a field*/0
+          << (Var->getStorageDuration() != SD_Static &&
+              Var->getStorageDuration() != SD_Thread);
+
     // Check for jumps past the implicit initializer.  C++0x
     // clarifies that this applies to a "variable with automatic
     // storage duration", not a "local variable".

clang/lib/Sema/SemaInit.cpp

@@ -6496,6 +6496,17 @@ static bool canPerformArrayCopy(const InitializedEntity &Entity) {
   return false;
 }
 
+static const FieldDecl *GetConstField(const RecordDecl *RD) {
+  for (const FieldDecl *FD : RD->fields()) {
+    QualType QT = FD->getType();
+    if (QT.isConstQualified())
+      return FD;
+    if (const auto *RD = QT->getAsRecordDecl())
+      return GetConstField(RD);
+  }
+  return nullptr;
+}
+
 void InitializationSequence::InitializeFrom(Sema &S,
                                             const InitializedEntity &Entity,
                                             const InitializationKind &Kind,
@@ -6563,13 +6574,26 @@ void InitializationSequence::InitializeFrom(Sema &S,
 
   if (!S.getLangOpts().CPlusPlus &&
       Kind.getKind() == InitializationKind::IK_Default) {
-    RecordDecl *Rec = DestType->getAsRecordDecl();
-    if (Rec && Rec->hasUninitializedExplicitInitFields()) {
+    if (RecordDecl *Rec = DestType->getAsRecordDecl()) {
       VarDecl *Var = dyn_cast_or_null<VarDecl>(Entity.getDecl());
-      if (Var && !Initializer) {
-        S.Diag(Var->getLocation(), diag::warn_field_requires_explicit_init)
-            << /* Var-in-Record */ 1 << Rec;
-        emitUninitializedExplicitInitFields(S, Rec);
+      if (Rec->hasUninitializedExplicitInitFields()) {
+        if (Var && !Initializer) {
+          S.Diag(Var->getLocation(), diag::warn_field_requires_explicit_init)
+              << /* Var-in-Record */ 1 << Rec;
+          emitUninitializedExplicitInitFields(S, Rec);
+        }
+      }
+      // If the record has any members which are const (recursively checked),
+      // then we want to diagnose those as being unitialized if there is no
+      // initializer present.
+      if (!Initializer) {
+        if (const FieldDecl *FD = GetConstField(Rec)) {
+          S.Diag(Var->getLocation(), diag::warn_default_init_const)
+              << Var->getType() << /*member*/ 1
+              << (Var->getStorageDuration() != SD_Static &&
+                  Var->getStorageDuration() != SD_Thread);
+          S.Diag(FD->getLocation(), diag::note_default_init_const_member) << FD;
+        }
       }
     }
   }

clang/test/Sema/typedef-retain.c

@@ -16,7 +16,8 @@ void test2(float4 a, int4p result, int i) {
 typedef int a[5];
 void test3(void) {
   typedef const a b;
-  b r;       // expected-note {{variable 'r' declared const here}}
+  b r;       // expected-note {{variable 'r' declared const here}} \
+                expected-warning {{default initialization of an object of type 'b' (aka 'const int[5]') leaves the object unitialized and is incompatible with C++}}
   r[0] = 10; // expected-error {{cannot assign to variable 'r' with const-qualified type 'b' (aka 'const int[5]')}}
 }
 

clang/test/Sema/warn-default-const-init.c

@@ -0,0 +1,54 @@
+// RUN: %clang_cc1 -fsyntax-only -verify=c -Wdefault-const-init %s
+// RUN: %clang_cc1 -fsyntax-only -verify=c -Wc++-compat %s
+// RUN: %clang_cc1 -fsyntax-only -verify=c %s
+// RUN: %clang_cc1 -fsyntax-only -verify=cxx -x c++ %s
+// RUN: %clang_cc1 -fsyntax-only -verify=good -Wc++-compat -Wno-default-const-init %s
+// good-no-diagnostics
+
+struct A { int i; };
+struct S{ const int i; };              // c-note 2 {{member 'i' declared 'const' here}} \
+                                          cxx-note 3 {{default constructor of 'S' is implicitly deleted because field 'i' of const-qualified type 'const int' would not be initialized}}
+struct T { struct S s; };              // cxx-note {{default constructor of 'T' is implicitly deleted because field 's' has a deleted default constructor}}
+struct U { struct S s; const int j; };
+struct V { int i; const struct A a; }; // c-note {{member 'a' declared 'const' here}} \
+                                          cxx-note {{default constructor of 'V' is implicitly deleted because field 'a' of const-qualified type 'const struct A' would not be initialized}}
+
+void f() {
+  struct S s1; // c-warning {{default initialization of an object of type 'struct S' with const member leaves the object unitialized and is incompatible with C++}} \
+                  cxx-error {{call to implicitly-deleted default constructor of 'struct S'}}
+  struct S s2 = { 0 };
+}
+void g() {
+  struct T t1; // c-warning {{default initialization of an object of type 'struct T' with const member leaves the object unitialized and is incompatible with C++}} \
+                  cxx-error {{call to implicitly-deleted default constructor of 'struct T'}}
+  struct T t2 = { { 0 } };
+}
+void h() {
+  struct U u1 = { { 0 } };
+  struct U u2 = { { 0 }, 0 };
+}
+void x() {
+  struct V v1; // c-warning {{default initialization of an object of type 'struct V' with const member leaves the object unitialized and is incompatible with C++}} \
+                  cxx-error {{call to implicitly-deleted default constructor of 'struct V'}}
+  struct V v2 = { 0 };
+  struct V v3 = { 0, { 0 } };
+}
+
+// Test a tentative definition which does eventually get an initializer.
+extern const int i;
+const int i = 12;
+
+static const int j; // c-warning {{default initialization of an object of type 'const int' is incompatible with C++}} \
+                       cxx-error {{default initialization of an object of const type 'const int'}}
+const int k;        // c-warning {{default initialization of an object of type 'const int' is incompatible with C++}} \
+                       cxx-error {{default initialization of an object of const type 'const int'}}
+const struct S s;   // c-warning {{default initialization of an object of type 'const struct S' is incompatible with C++}} \
+                       cxx-error {{call to implicitly-deleted default constructor of 'const struct S'}}
+
+void func() {
+  const int a;        // c-warning {{default initialization of an object of type 'const int' leaves the object unitialized and is incompatible with C++}} \
+                         cxx-error {{default initialization of an object of const type 'const int'}}
+  static const int b; // c-warning {{default initialization of an object of type 'const int' is incompatible with C++}} \
+                         cxx-error {{default initialization of an object of const type 'const int'}}
+}
+