[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

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

clang/lib/Sema/SemaInit.cpp

983

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

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

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

clang/docs/ReleaseNotes.rst

.. code-block:: c
     func((void *)0); // Previously required to be rejected, is now accepted.
 
     nullptr_t val;
     val = 0; // Previously required to be rejected, is now accepted.
     val = (void *)0; // Previously required to be rejected, is now accepted.
 
     bool b = nullptr; // Was incorrectly rejected by Clang, is now accepted.
 
-
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 - Clang now saves the address of ABI-indirect function parameters on the stack,
   improving the debug information available in programs compiled without
   optimizations.
 - Clang now supports ``__builtin_nondeterministic_value`` that returns a
   nondeterministic value of the same type as the provided argument.
 - Clang now supports ``__builtin_FILE_NAME()`` which returns the same
- Clang now correctly diagnoses when the argument to ``alignas`` or ``_Alignas``
   incorrect mention of ``alignof`` in a diagnostic about ``alignas``).
 - Clang will now show a margin with line numbers to the left of each line
   of code it prints for diagnostics. This can be disabled using
   ``-fno-diagnostics-show-line-numbers``. At the same time, the maximum
   number of code lines it prints has been increased from 1 to 16. This
   can be controlled using ``-fcaret-diagnostics-max-lines=``.
 - Clang no longer emits ``-Wunused-variable`` warnings for variables declared
   with ``__attribute__((cleanup(...)))`` to match GCC's behavior.
+- Add ``-Wincomplete-array-initializer-list`` warning to detect missing
+  elements in initializer lists assigned to array types.
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix segfault while running clang-rename on a non existing file.
   (`#36471 <https://github.com/llvm/llvm-project/issues/36471>`_)
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.

clang/include/clang/Basic/DiagnosticGroups.td

 def InvalidPPToken : DiagGroup<"invalid-pp-token">;
 def Trigraphs      : DiagGroup<"trigraphs">;
 
 def UndefinedReinterpretCast : DiagGroup<"undefined-reinterpret-cast">;
 def ReinterpretBaseClass : DiagGroup<"reinterpret-base-class">;
 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]>;

clang/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|"

clang/lib/Sema/SemaInit.cpp

if (!VerifyOnly || hasAnyDesignatedInits(IL)) {
     if (!VerifyOnly)
       FullyStructuredList->setSyntacticForm(IL);
   }
 
   CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
                         /*TopLevelObject=*/true);
 
   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;

clang/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 };