[clang] Warning for incomplete array initializer lists

[Sinitax]

Summary

This patch implements a warning for incomplete array initializer lists.

Without warnings a 'gap' in an array can go unnoticed when the size increases. Consider what happens with the array const char *err_msg[ERR_TYPE_COUNT] = { ... } when a new ERR_.. enum value is added.

Related: https://github.com/llvm/llvm-project/issues/22692

[Sinitax]

Remove new warning from -Wuninitialized group for backwards-compatibility.

[Sinitax]

Add new warning to its own group.

[Sinitax]

Apply git-clang-format.

[shafik]

Adding reviewer for more visibility

[philnik]

clang/include/clang/Basic/DiagnosticGroups.td

732 ↗

(On Diff #528387)

Why do you make this a new warning group instead of just adding it to -Wuninitialized?

clang/lib/Sema/SemaInit.cpp

983 ↗

(On Diff #528387)

You'll want to add tests for this in clang/test/Sema

[erichkeane]

Needs release notes and tests. Patch needs full-context added.

clang/include/clang/Basic/DiagnosticGroups.td

732 ↗

(On Diff #528387)

I think the new group makes sense, but it should be a part of Uninitialized as well (see 733).

clang/lib/Sema/SemaInit.cpp

991 ↗

(On Diff #528387)

should probably just do range-for here, use the .inits here instead. Perhaps even better is a llvm::find of nullptr.

[Sinitax]

Rename warning to -Wincomplete-array-initializer-list for clarity, and add test case.

[Sinitax]

Rebased changes onto commit tagged 'llvmorg-17-init', and added release notes.

[Sinitax]

Why do you make this a new warning group instead of just adding it to -Wuninitialized?

I think a separate group is best, since the warning emits false positives: an intentional empty-initialization (such as char buf[BUF_SIZ] = { 0 }) is indistinguishable from unintentionally incomplete initialization (such as int pair[2] = { ENUM_A /*, ENUM_B */ }).

For this reason users would want to selectively enable it..

#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wincomplete-initializer-list"

const char *errmsg[ERR_COUNT] = {
    [ERR_A] = "error a",
};

#pragma clang diagnostic pop

.. but I'm not really satisfied with this solution. Feedback on how to differentiate between the aforementioned cases, if possible, is appreciated.

[Sinitax]

Rebase patch against branch main.

[Sinitax]

Fix test.

[cor3ntin]

Can you test in c++ mode?

I'd like to see a test for something like

struct {
	int a, b, c, d  = 1; // d has an initializer
} bar2 = {
	.a = 1,
	.b = 1,
	.c = 1
};

Otherwise looks good

include/clang/Basic/DiagnosticGroups.td

 def Unicode  : DiagGroup<"unicode">;
 def UninitializedMaybe : DiagGroup<"conditional-uninitialized">;
 def UninitializedSometimes : DiagGroup<"sometimes-uninitialized">;
 def UninitializedStaticSelfInit : DiagGroup<"static-self-init">;
 def UninitializedConstReference : DiagGroup<"uninitialized-const-reference">;
 def Uninitialized  : DiagGroup<"uninitialized", [UninitializedSometimes,
                                                  UninitializedStaticSelfInit,
                                                  UninitializedConstReference]>;
+def IncompleteArrayInitializerList : DiagGroup<"incomplete-array-initializer-list">;
 def IgnoredPragmaIntrinsic : DiagGroup<"ignored-pragma-intrinsic">;
 // #pragma optimize is often used to avoid to work around MSVC codegen bugs or
 // to disable inlining. It's not completely clear what alternative to suggest
 // (#pragma clang optimize, noinline) so suggest nothing for now.
 def IgnoredPragmaOptimize : DiagGroup<"ignored-pragma-optimize">;
 def UnknownPragmas : DiagGroup<"unknown-pragmas">;
 def IgnoredPragmas : DiagGroup<"ignored-pragmas",
     [IgnoredPragmaIntrinsic, IgnoredPragmaOptimize]>;

include/clang/Basic/DiagnosticSemaKinds.td

def warn_static_self_reference_in_init : Warning<
   InGroup<UninitializedStaticSelfInit>;
 def warn_uninit_self_reference_in_init : Warning<
   "variable %0 is uninitialized when used within its own initialization">,
   InGroup<Uninitialized>;
 def warn_uninit_self_reference_in_reference_init : Warning<
   "reference %0 is not yet bound to a value when used within its own"
   " initialization">,
   InGroup<Uninitialized>;
+def warn_incomplete_array_initializer_list : Warning<
+  "incomplete array initializer list">,
+  InGroup<IncompleteArrayInitializerList>, DefaultIgnore;
 def warn_uninit_var : Warning<
   "variable %0 is uninitialized when %select{used here|captured by block}1">,
   InGroup<Uninitialized>, DefaultIgnore;
 def warn_sometimes_uninit_var : Warning<
   "variable %0 is %select{used|captured}1 uninitialized whenever "
   "%select{'%3' condition is %select{true|false}4|"
   "'%3' loop %select{is entered|exits because its condition is false}4|"
   "'%3' loop %select{condition is true|exits because its condition is false}4|"

lib/Sema/SemaInit.cpp

InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
 
   if (!hadError && FullyStructuredList) {
     bool RequiresSecondPass = false;
     FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass,
                                /*OuterILE=*/nullptr, /*OuterIndex=*/0);
     if (RequiresSecondPass && !hadError)
       FillInEmptyInitializations(Entity, FullyStructuredList,
                                  RequiresSecondPass, nullptr, 0);
+
+    if (T->isArrayType() && VerifyOnly) {
+      const auto *CAType = dyn_cast<ConstantArrayType>(T);
+      if (CAType && FullyStructuredList->getNumInits()
+          < CAType->getSize().getZExtValue()) {
+        S.Diag(IL->getBeginLoc(), diag::warn_incomplete_array_initializer_list)
+          << IL->getSourceRange();
+      } else {
+        auto inits = FullyStructuredList->inits();
+        if (llvm::find(inits, nullptr) != inits.end())
+            S.Diag(IL->getBeginLoc(), diag::warn_incomplete_array_initializer_list)
+              << IL->getSourceRange();
+      }
+    }
   }
   if (hadError && FullyStructuredList)
     FullyStructuredList->markError();
 }
 
 int InitListChecker::numArrayElements(QualType DeclType) {
   // FIXME: use a proper constant
   int maxElements = 0x7FFFFFFF;

test/Sema/warn-incomplete-array-initializer-list.c

+// RUN: %clang_cc1 -fsyntax-only -Wincomplete-array-initializer-list -verify -std=c99 %s
+
+// missing array initializer in between
+enum {
+  FOO1_A,
+  FOO1_MISSING,
+  FOO1_B,
+  FOO1_COUNT
+};
+const char *foo1[] = { // expected-warning{{incomplete array initializer list}}
+  [FOO1_A] = "a", 
+  [FOO1_B] = "b",
+};
+
+// missing array initializer at end
+enum {
+  FOO2_A,
+  FOO2_B,
+  FOO2_MISSING,
+  FOO2_COUNT
+};
+const char *foo2[FOO2_COUNT] = { //expected-warning{{incomplete array initializer list}}
+  [FOO2_A] = "a",
+  [FOO2_B] = "b",
+};
+
+// complete array initializer
+int foo3[4] = { 1, 1, 1, 1 };
+
+// missing struct initializer in between
+struct {
+  int a, b, c, d;
+} bar1 = {
+  .a = 1,
+  .b = 1,
+  .d = 1
+};
+
+// missing struct initializer at end
+struct {
+  int a, b, c, d;
+} bar2 = {
+  .a = 1,
+  .b = 1,
+  .c = 1
+};
+
+// complete struct initializer
+struct {
+  int a, b, c, d;
+} bar3 = { 1, 1, 1, 1 };