[clang-tidy] Avoid C arrays check

[lebedev.ri]

Summary

PR39224
As discussed, we can't always do the transform automatically due to that array-to-pointer decay of C array.
In order to detect whether we can do said transform, we'd need to be able to see all usages of said array,
which is, i would say, rather impossible if e.g. it is in the header.
Thus right now no fixit exists.

Exceptions: extern "C" code.

References:

• CPPCG ES.27: Use std::array or stack_array for arrays on the stack
• CPPCG SL.con.1: Prefer using STL array or vector instead of a C array
• HICPP 4.1.1 Ensure that a function argument does not undergo an array-to-pointer conversion
• MISRA 5-2-12 An identifier with array type passed as a function argument shall not decay to a pointer

[JonasToth]

modernize would be a fitting module, wouldn't it?

[JonasToth]

docs/clang-tidy/checks/list.rst

13

spurious change

156

here as well

docs/clang-tidy/checks/misc-avoid-c-arrays.rst

51 ↗

(On Diff #171315)

The last two lines do not add value, i think you can safely remove them

test/clang-tidy/misc-avoid-c-arrays.cpp

14 ↗

(On Diff #171315)

Please add a case with templates, where T itself is the array type, maybe there are other fancy template tricks that could create an array implictly?

[Eugene.Zelenko]

May be this check belongs to modernize?

docs/clang-tidy/checks/misc-avoid-c-arrays.rst

6 ↗

(On Diff #171315)

Finds.

9 ↗

(On Diff #171315)

However

30 ↗

(On Diff #171315)

Please remove ellipsis. and newline.

[lebedev.ri]

test/clang-tidy/misc-avoid-c-arrays.cpp

14 ↗

(On Diff #171315)

Oh i see, array<int[4], 2> is not diagnosed, that is where it gets interesting :S
So i need to match type(arrayType()), and then find the location to complain about
(the type does not seem to have it).

[JonasToth]

test/clang-tidy/misc-avoid-c-arrays.cpp

14 ↗

(On Diff #171315)

you could leave it as known limitation as well.
If the type T is then diagnosed as array creation through template-instantiation the warning is still valid.

[lebedev.ri]

• Moved into modernize
• Detect based on TypeLoc, which means we now catch *everything*, including using-declarations. Note the unique_ptr example.

[Eugene.Zelenko]

Will be good idea to add aliases at least for existing modules.

[lebedev.ri]

In D53771#1278177, @Eugene.Zelenko wrote:

Will be good idea to add aliases at least for existing modules.

Added CPPCG, HICPP aliases.

[Eugene.Zelenko]

docs/clang-tidy/checks/cppcoreguidelines-avoid-c-arrays.rst

7

Please make same length as header.

docs/clang-tidy/checks/hicpp-avoid-c-arrays.rst

9

Please fill as much as possible to 80 character. Probably same for other alias.

docs/clang-tidy/checks/modernize-avoid-c-arrays.rst

7

Please fill as much as possible to 80 character. Same for other alias.

[lebedev.ri]

Docs fixes.

docs/clang-tidy/checks/cppcoreguidelines-avoid-c-arrays.rst

7

Whoops, i noticed that in the main doc, but not here, sorry.

[JonasToth]

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

82

please conserve the alphabetical order here

clang-tidy/hicpp/HICPPTidyModule.cpp

56

i would this one should be before avoid-goto.

clang-tidy/modernize/AvoidCArraysCheck.cpp

45

What about struct-decls that are externC?

docs/clang-tidy/checks/modernize-avoid-c-arrays.rst

16

Not sure if we want the rational of not providing fixits here in this detail. Maybe it's better to formulate it as fix-it are potentially dangerous in header files and are therefor not emitted right now? Some places would be save to transform and we might want to provide these in the future.

test/clang-tidy/modernize-avoid-c-arrays.cpp

49

Please add a test for extern c structs, maybe even in the form extern "C" struct Foo { ... };.

Additionally to that, maybe the opposite case should be tested too: extern "C++" in C-Code.

[lebedev.ri]

Address review notes.

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

82

Sorted all the CheckFactories.registerCheck<>(); lines.

clang-tidy/modernize/AvoidCArraysCheck.cpp

45

Hm, what is a struct-decl?

[JonasToth]

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

82

the avoid-* checks seem to be displaced now.

clang-tidy/modernize/AvoidCArraysCheck.cpp

45

we chatted in irc, but for reference

extern "C" {
struct Foo {

};
}

45

you can mark all comments as done here, as they are implemented.

test/clang-tidy/modernize-avoid-c-arrays.cpp

3

what about variable-length arrays? I think they should be diagnosed as well, but plain replacement with std::array would be incorrect, more a std::vector would fit.

[lebedev.ri]

(only comments, patch to follow)

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

82

How it should be sorted? By the new check name? Or the internal class name?
If it is not the latter, then sorting is really problematic as it can't be automatized.

test/clang-tidy/modernize-avoid-c-arrays.cpp

10–11

This is VLA.
Note that VLA are C99, they (thankfully!) don't exist in C++ standard at all.
Looks like variableArrayType() should single-out this, so let's see..

[lebedev.ri]

Better diag for VLA arrays.

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

82

Maybe now is better?

[JonasToth]

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

82

yes, thats the correct position :)

[lebedev.ri]

Comments? :)

[JonasToth]

clang-tidy/modernize/AvoidCArraysCheck.cpp

27

Nit: these parens are superflous

65

Why isa<> and not isVariableArrayType() (does it exist?)
isa<> would not resolve typedefs, but I think they should be considered.

[lebedev.ri]

Use isVariableArrayType()

clang-tidy/modernize/AvoidCArraysCheck.cpp

65

Hmm, interesting point.
I'm not sure ATM how to expose it in tests, but it counts as a cleanup anyway.

[JonasToth]

from my side mostly ok. I think the typedef points should be clarified, but I dont see more issues.

test/clang-tidy/modernize-avoid-c-arrays.cpp

33

What happens for a variable of type k? Does the check warn, or only in the typedef?

[lebedev.ri]

test/clang-tidy/modernize-avoid-c-arrays.cpp

33

Only here, on the typeloc, like the Semi-FIXME i just added there ^ states.

[JonasToth]

LGTM.
Please give other reviewers a chance to take a look at it too.

[lebedev.ri]

*Maybe* we should be actually diagnosing the each actual declaration, not just the typeloc.
Else if you use one typedef, and // NOLINT it, you will silence it for all the decls that use it.

In D53771#1294241, @JonasToth wrote:

LGTM.
Please give other reviewers a chance to take a look at it too.

Thank you for the review!
I will keep this open for a few more days.

[JonasToth]

In D53771#1294244, @lebedev.ri wrote:

*Maybe* we should be actually diagnosing the each actual declaration, not just the typeloc.
Else if you use one typedef, and // NOLINT it, you will silence it for all the decls that use it.

As my BB is getting closer to being useful, we can gather some statistics first and decide afterwards :)

In D53771#1294241, @JonasToth wrote:

LGTM.
Please give other reviewers a chance to take a look at it too.

Thank you for the review!
I will keep this open for a few more days.

np, i think until monday is enough.

clang-tidy/cppcoreguidelines/CMakeLists.txt

add_clang_library(clangTidyCppCoreGuidelinesModule
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyMiscModule
+  clangTidyModernizeModule
   clangTidyReadabilityModule
   clangTidyUtils
   clangTooling
   )

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 //===--- CppCoreGuidelinesModule.cpp - clang-tidy -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../misc/NonPrivateMemberVariablesInClassesCheck.h"
 #include "../misc/UnconventionalAssignOperatorCheck.h"
+#include "../modernize/AvoidCArraysCheck.h"
 #include "../readability/MagicNumbersCheck.h"
 #include "AvoidGotoCheck.h"
 #include "InterfacesGlobalInitCheck.h"
 #include "MacroUsageCheck.h"
 #include "NarrowingConversionsCheck.h"
 #include "NoMallocCheck.h"
 #include "OwningMemoryCheck.h"
 #include "ProBoundsArrayToPointerDecayCheck.h"

 namespace cppcoreguidelines {
 
 /// A module containing checks of the C++ Core Guidelines
 class CppCoreGuidelinesModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<AvoidGotoCheck>(
         "cppcoreguidelines-avoid-goto");
-    CheckFactories.registerCheck<readability::MagicNumbersCheck>(
-        "cppcoreguidelines-avoid-magic-numbers");
     CheckFactories.registerCheck<InterfacesGlobalInitCheck>(
         "cppcoreguidelines-interfaces-global-init");
     CheckFactories.registerCheck<MacroUsageCheck>(
         "cppcoreguidelines-macro-usage");
     CheckFactories.registerCheck<NarrowingConversionsCheck>(
         "cppcoreguidelines-narrowing-conversions");
     CheckFactories.registerCheck<NoMallocCheck>("cppcoreguidelines-no-malloc");
-    CheckFactories.registerCheck<misc::NonPrivateMemberVariablesInClassesCheck>(
-        "cppcoreguidelines-non-private-member-variables-in-classes");
     CheckFactories.registerCheck<OwningMemoryCheck>(
         "cppcoreguidelines-owning-memory");
     CheckFactories.registerCheck<ProBoundsArrayToPointerDecayCheck>(
         "cppcoreguidelines-pro-bounds-array-to-pointer-decay");
     CheckFactories.registerCheck<ProBoundsConstantArrayIndexCheck>(
         "cppcoreguidelines-pro-bounds-constant-array-index");
     CheckFactories.registerCheck<ProBoundsPointerArithmeticCheck>(
         "cppcoreguidelines-pro-bounds-pointer-arithmetic");
     CheckFactories.registerCheck<ProTypeConstCastCheck>(
         "cppcoreguidelines-pro-type-const-cast");
     CheckFactories.registerCheck<ProTypeCstyleCastCheck>(
         "cppcoreguidelines-pro-type-cstyle-cast");
     CheckFactories.registerCheck<ProTypeMemberInitCheck>(
         "cppcoreguidelines-pro-type-member-init");
     CheckFactories.registerCheck<ProTypeReinterpretCastCheck>(
         "cppcoreguidelines-pro-type-reinterpret-cast");
     CheckFactories.registerCheck<ProTypeStaticCastDowncastCheck>(
         "cppcoreguidelines-pro-type-static-cast-downcast");
     CheckFactories.registerCheck<ProTypeUnionAccessCheck>(
         "cppcoreguidelines-pro-type-union-access");
     CheckFactories.registerCheck<ProTypeVarargCheck>(
         "cppcoreguidelines-pro-type-vararg");
+    CheckFactories.registerCheck<SlicingCheck>("cppcoreguidelines-slicing");
     CheckFactories.registerCheck<SpecialMemberFunctionsCheck>(
         "cppcoreguidelines-special-member-functions");
-    CheckFactories.registerCheck<SlicingCheck>("cppcoreguidelines-slicing");
+    CheckFactories.registerCheck<misc::NonPrivateMemberVariablesInClassesCheck>(
+        "cppcoreguidelines-non-private-member-variables-in-classes");
     CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
         "cppcoreguidelines-c-copy-assignment-signature");
+    CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
+        "cppcoreguidelines-avoid-c-arrays");
+    CheckFactories.registerCheck<readability::MagicNumbersCheck>(
+        "cppcoreguidelines-avoid-magic-numbers");
   }
 
   ClangTidyOptions getModuleOptions() override {
     ClangTidyOptions Options;
     ClangTidyOptions::OptionMap &Opts = Options.CheckOptions;
 
     Opts["cppcoreguidelines-non-private-member-variables-in-classes."
          "IgnoreClassesWithAllMemberVariablesBeingPublic"] = "1";

clang-tidy/hicpp/HICPPTidyModule.cpp

 #include "../cppcoreguidelines/ProTypeMemberInitCheck.h"
 #include "../cppcoreguidelines/ProTypeVarargCheck.h"
 #include "../cppcoreguidelines/SpecialMemberFunctionsCheck.h"
 #include "../google/DefaultArgumentsCheck.h"
 #include "../google/ExplicitConstructorCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../bugprone/UndelegatedConstructorCheck.h"
+#include "../modernize/AvoidCArraysCheck.h"
 #include "../modernize/DeprecatedHeadersCheck.h"
 #include "../modernize/UseAutoCheck.h"
 #include "../modernize/UseEmplaceCheck.h"
 #include "../modernize/UseEqualsDefaultCheck.h"
 #include "../modernize/UseEqualsDeleteCheck.h"
 #include "../modernize/UseNoexceptCheck.h"
 #include "../modernize/UseNullptrCheck.h"
 #include "../modernize/UseOverrideCheck.h"

 
 namespace clang {
 namespace tidy {
 namespace hicpp {
 
 class HICPPModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
+        "hicpp-avoid-c-arrays");
     CheckFactories.registerCheck<cppcoreguidelines::AvoidGotoCheck>(
         "hicpp-avoid-goto");
     CheckFactories.registerCheck<readability::BracesAroundStatementsCheck>(
         "hicpp-braces-around-statements");
     CheckFactories.registerCheck<modernize::DeprecatedHeadersCheck>(
         "hicpp-deprecated-headers");
     CheckFactories.registerCheck<ExceptionBaseclassCheck>(
         "hicpp-exception-baseclass");
     CheckFactories.registerCheck<MultiwayPathsCoveredCheck>(
         "hicpp-multiway-paths-covered");
     CheckFactories.registerCheck<SignedBitwiseCheck>("hicpp-signed-bitwise");

clang-tidy/modernize/AvoidCArraysCheck.h

+//===--- AvoidCArraysCheck.h - clang-tidy -----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+/// Find C-style array types and recommend to use std::array<>.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-avoid-c-arrays.html
+class AvoidCArraysCheck : public ClangTidyCheck {
+public:
+  AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H

clang-tidy/modernize/AvoidCArraysCheck.cpp

+//===--- AvoidCArraysCheck.cpp - clang-tidy -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AvoidCArraysCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace {
+
+AST_MATCHER(clang::TypeLoc, hasValidBeginLoc) {
+  return Node.getBeginLoc().isValid();
+}
+
+AST_MATCHER_P(clang::TypeLoc, hasType,
+              clang::ast_matchers::internal::Matcher<clang::Type>,
+              InnerMatcher) {
+  const clang::Type *TypeNode = Node.getTypePtr();
+  return (TypeNode != nullptr &&
+          InnerMatcher.matches(*TypeNode, Finder, Builder));
+}
+
+AST_MATCHER(clang::RecordDecl, isExternCContext) {
+  return Node.isExternCContext();
+}
+
+} // namespace
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
+  // std::array<> is avaliable since C++11.
+  if (!getLangOpts().CPlusPlus11)
+    return;
+
+  Finder->addMatcher(
+      typeLoc(hasValidBeginLoc(), hasType(arrayType()),
+              unless(anyOf(hasParent(varDecl(isExternC())),
+                           hasParent(fieldDecl(
+                               hasParent(recordDecl(isExternCContext())))),
+                           hasAncestor(functionDecl(isExternC())))))
+          .bind("typeloc"),
+      this);
+}
+
+void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
+  diag(ArrayType->getBeginLoc(),
+       "do not declare C-style arrays, use std::array<> instead");
+}
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang

clang-tidy/modernize/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyModernizeModule
   AvoidBindCheck.cpp
+  AvoidCArraysCheck.cpp
   ConcatNestedNamespacesCheck.cpp
   DeprecatedHeadersCheck.cpp
   DeprecatedIosBaseAliasesCheck.cpp
   LoopConvertCheck.cpp
   LoopConvertUtils.cpp
   MakeSharedCheck.cpp
   MakeSmartPtrCheck.cpp
   MakeUniqueCheck.cpp

clang-tidy/modernize/ModernizeTidyModule.cpp

 //===--- ModernizeTidyModule.cpp - clang-tidy -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "AvoidBindCheck.h"
+#include "AvoidCArraysCheck.h"
 #include "ConcatNestedNamespacesCheck.h"
 #include "DeprecatedHeadersCheck.h"
 #include "DeprecatedIosBaseAliasesCheck.h"
 #include "LoopConvertCheck.h"
 #include "MakeSharedCheck.h"
 #include "MakeUniqueCheck.h"
 #include "PassByValueCheck.h"
 #include "RawStringLiteralCheck.h"

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class ModernizeModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");
+    CheckFactories.registerCheck<AvoidCArraysCheck>("modernize-avoid-c-arrays");
     CheckFactories.registerCheck<ConcatNestedNamespacesCheck>(
         "modernize-concat-nested-namespaces");
     CheckFactories.registerCheck<DeprecatedHeadersCheck>(
         "modernize-deprecated-headers");
     CheckFactories.registerCheck<DeprecatedIosBaseAliasesCheck>(
         "modernize-deprecated-ios-base-aliases");
     CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");
     CheckFactories.registerCheck<MakeSharedCheck>("modernize-make-shared");

docs/ReleaseNotes.rst

 
 - New :doc:`misc-non-private-member-variables-in-classes
   <clang-tidy/checks/misc-non-private-member-variables-in-classes>` check.
 
   Finds classes that not only contain the data (non-static member variables),
   but also have logic (non-static member functions), and diagnoses all member
   variables that have any other scope other than ``private``.
 
+- New :doc:`modernize-avoid-c-arrays
+  <clang-tidy/checks/modernize-avoid-c-arrays>` check.
+
+  Finds C-style array types and recommend to use ``std::array<>``.
+
 - New :doc:`modernize-concat-nested-namespaces
   <clang-tidy/checks/modernize-concat-nested-namespaces>` check.
 
   Checks for uses of nested namespaces in the form of
   ``namespace a { namespace b { ... }}`` and offers change to
   syntax introduced in C++17 standard: ``namespace a::b { ... }``.
 
 - New :doc:`modernize-deprecated-ios-base-aliases
- New :doc:`readability-uppercase-literal-suffix
   suffix, and suggests to make the suffix uppercase. The list of destination
   suffixes can be optionally provided.
 
 - New alias :doc:`cert-dcl16-c
   <clang-tidy/checks/cert-dcl16-c>` to :doc:`readability-uppercase-literal-suffix
   <clang-tidy/checks/readability-uppercase-literal-suffix>`
   added.
 
+- New alias :doc:`cppcoreguidelines-avoid-c-arrays
+  <clang-tidy/checks/cppcoreguidelines-avoid-c-arrays>`
+  to :doc:`modernize-avoid-c-arrays
+  <clang-tidy/checks/modernize-avoid-c-arrays>` added.
+
 - New alias :doc:`cppcoreguidelines-non-private-member-variables-in-classes
   <clang-tidy/checks/cppcoreguidelines-non-private-member-variables-in-classes>`
   to :doc:`misc-non-private-member-variables-in-classes
   <clang-tidy/checks/misc-non-private-member-variables-in-classes>`
   added.
 
+- New alias :doc:`hicpp-avoid-c-arrays
+  <clang-tidy/checks/hicpp-avoid-c-arrays>`
+  to :doc:`modernize-avoid-c-arrays
+  <clang-tidy/checks/modernize-avoid-c-arrays>` added.
+
 - New alias :doc:`hicpp-uppercase-literal-suffix
   <clang-tidy/checks/hicpp-uppercase-literal-suffix>` to
   :doc:`readability-uppercase-literal-suffix
   <clang-tidy/checks/readability-uppercase-literal-suffix>`
   added.
 
 - The :doc:`readability-redundant-smartptr-get
   <clang-tidy/checks/readability-redundant-smartptr-get>` check does not warn

docs/clang-tidy/checks/cppcoreguidelines-avoid-c-arrays.rst

+.. title:: clang-tidy - cppcoreguidelines-avoid-c-arrays
+.. meta::
+   :http-equiv=refresh: 5;URL=modernize-avoid-c-arrays.html
+
+cppcoreguidelines-avoid-c-arrays
+================================
+
+The cppcoreguidelines-avoid-c-arrays check is an alias, please see
+`modernize-avoid-c-arrays <modernize-avoid-c-arrays.html>`_
+for more information.

docs/clang-tidy/checks/hicpp-avoid-c-arrays.rst

+.. title:: clang-tidy - hicpp-avoid-c-arrays
+.. meta::
+   :http-equiv=refresh: 5;URL=modernize-avoid-c-arrays.html
+
+hicpp-avoid-c-arrays
+====================
+
+The hicpp-avoid-c-arrays check is an alias, please see
+`modernize-avoid-c-arrays <modernize-avoid-c-arrays.html>`_
+for more information.

docs/clang-tidy/checks/list.rst

 .. title:: clang-tidy - Clang-Tidy Checks
 
 Clang-Tidy Checks
 =================
 
 .. toctree::
    abseil-duration-division
    abseil-duration-factory-float
    abseil-faster-strsplit-delimiter
    abseil-no-internal-dependencies
    abseil-no-namespace
    abseil-redundant-strcat-calls
    abseil-string-find-startswith
    abseil-str-cat-append
    android-cloexec-accept
    android-cloexec-accept4
    android-cloexec-creat
    android-cloexec-dup
    android-cloexec-epoll-create
    android-cloexec-epoll-create1
    android-cloexec-fopen
.. toctree::
    cert-fio38-c (redirects to misc-non-copyable-objects) <cert-fio38-c>
    cert-flp30-c
    cert-msc30-c (redirects to cert-msc50-cpp) <cert-msc30-c>
    cert-msc32-c (redirects to cert-msc51-cpp) <cert-msc32-c>
    cert-msc50-cpp
    cert-msc51-cpp
    cert-oop11-cpp (redirects to performance-move-constructor-init) <cert-oop11-cpp>
    cppcoreguidelines-avoid-goto
+   cppcoreguidelines-avoid-c-arrays (redirects to modernize-avoid-c-arrays) <cppcoreguidelines-avoid-c-arrays>
    cppcoreguidelines-avoid-magic-numbers (redirects to readability-magic-numbers) <cppcoreguidelines-avoid-magic-numbers>
    cppcoreguidelines-c-copy-assignment-signature (redirects to misc-unconventional-assign-operator) <cppcoreguidelines-c-copy-assignment-signature>
    cppcoreguidelines-interfaces-global-init
    cppcoreguidelines-macro-usage
    cppcoreguidelines-narrowing-conversions
    cppcoreguidelines-no-malloc
    cppcoreguidelines-non-private-member-variables-in-classes (redirects to misc-non-private-member-variables-in-classes) <cppcoreguidelines-non-private-member-variables-in-classes>
    cppcoreguidelines-owning-memory
.. toctree::
    google-readability-braces-around-statements (redirects to readability-braces-around-statements) <google-readability-braces-around-statements>
    google-readability-casting
    google-readability-function-size (redirects to readability-function-size) <google-readability-function-size>
    google-readability-namespace-comments (redirects to llvm-namespace-comment) <google-readability-namespace-comments>
    google-readability-todo
    google-runtime-int
    google-runtime-operator
    google-runtime-references
+   hicpp-avoid-c-arrays (redirects to modernize-avoid-c-arrays) <hicpp-avoid-c-arrays>
    hicpp-avoid-goto
    hicpp-braces-around-statements (redirects to readability-braces-around-statements) <hicpp-braces-around-statements>
    hicpp-deprecated-headers (redirects to modernize-deprecated-headers) <hicpp-deprecated-headers>
    hicpp-exception-baseclass
    hicpp-explicit-conversions (redirects to google-explicit-constructor) <hicpp-explicit-conversions>
    hicpp-function-size (redirects to readability-function-size) <hicpp-function-size>
    hicpp-invalid-access-moved (redirects to bugprone-use-after-move) <hicpp-invalid-access-moved>
    hicpp-member-init (redirects to cppcoreguidelines-pro-type-member-init) <hicpp-member-init>
    hicpp-move-const-arg (redirects to performance-move-const-arg) <hicpp-move-const-arg>
    hicpp-multiway-paths-covered
    hicpp-named-parameter (redirects to readability-named-parameter) <hicpp-named-parameter>
    hicpp-new-delete-operators (redirects to misc-new-delete-overloads) <hicpp-new-delete-operators>
    hicpp-no-array-decay (redirects to cppcoreguidelines-pro-bounds-array-to-pointer-decay) <hicpp-no-array-decay>
    hicpp-no-assembler
    hicpp-no-malloc (redirects to cppcoreguidelines-no-malloc) <hicpp-no-malloc>
    hicpp-noexcept-move (redirects to misc-noexcept-moveconstructor) <hicpp-noexcept-move>
    hicpp-signed-bitwise
    hicpp-special-member-functions (redirects to cppcoreguidelines-special-member-functions) <hicpp-special-member-functions>
    hicpp-static-assert (redirects to misc-static-assert) <hicpp-static-assert>
    hicpp-undelegated-constructor (redirects to bugprone-undelegated-constructor) <hicpp-undelegated-constructor>
    hicpp-use-auto (redirects to modernize-use-auto) <hicpp-use-auto>
    hicpp-use-emplace (redirects to modernize-use-emplace) <hicpp-use-emplace>
    hicpp-use-equals-default (redirects to modernize-use-equals-default) <hicpp-use-equals-default>
    hicpp-use-equals-delete (redirects to modernize-use-equals-delete) <hicpp-use-equals-delete>
    hicpp-use-noexcept (redirects to modernize-use-noexcept) <hicpp-use-noexcept>
    hicpp-use-nullptr (redirects to modernize-use-nullptr) <hicpp-use-nullptr>
    hicpp-use-override (redirects to modernize-use-override) <hicpp-use-override>
    hicpp-vararg (redirects to cppcoreguidelines-pro-type-vararg) <hicpp-vararg>
    hicpp-uppercase-literal-suffix (redirects to readability-uppercase-literal-suffix) <hicpp-uppercase-literal-suffix>
.. toctree::
    misc-static-assert
    misc-throw-by-value-catch-by-reference
    misc-unconventional-assign-operator
    misc-uniqueptr-reset-release
    misc-unused-alias-decls
    misc-unused-parameters
    misc-unused-using-decls
    modernize-avoid-bind
+   modernize-avoid-c-arrays
    modernize-concat-nested-namespaces
    modernize-deprecated-headers
    modernize-deprecated-ios-base-aliases
    modernize-loop-convert
    modernize-make-shared
    modernize-make-unique
    modernize-pass-by-value
    modernize-raw-string-literal

docs/clang-tidy/checks/modernize-avoid-c-arrays.rst

+.. title:: clang-tidy - modernize-avoid-c-arrays
+
+modernize-avoid-c-arrays
+========================
+
+`cppcoreguidelines-avoid-c-arrays` redirects here as an alias for this check.
+
+`hicpp-avoid-c-arrays` redirects here as an alias for this check.
+
+Finds C-style array types and recommend to use ``std::array<>``.
+All types of C arrays are diagnosed.
+
+However, fix-it are potentially dangerous in header files and are therefore not
+emitted right now.
+
+.. code:: c++
+
+  int a[] = {1, 2}; // warning: do not declare C-style arrays, use std::array<> instead
+
+  int b[1]; // warning: do not declare C-style arrays, use std::array<> instead
+
+  void foo() {
+    int c[b[0]]; // warning: do not declare C-style arrays, use std::array<> instead
+  }
+
+  template <typename T, int Size>
+  class array {
+    T d[Size]; // warning: do not declare C-style arrays, use std::array<> instead
+
+    int e[1]; // warning: do not declare C-style arrays, use std::array<> instead
+  };
+
+  array<int[4], 2> d; // warning: do not declare C-style arrays, use std::array<> instead
+
+  using k = int[4]; // warning: do not declare C-style arrays, use std::array<> instead
+
+
+However, the ``extern "C"`` code is ignored, since it is common to share
+such headers between C code, and C++ code.
+
+.. code:: c++
+
+  // Some header
+  extern "C" {
+
+  int f[] = {1, 2}; // not diagnosed
+
+  int j[1]; // not diagnosed
+
+  inline void bar() {
+    {
+      int j[j[0]]; // not diagnosed
+    }
+  }
+
+  }

test/clang-tidy/modernize-avoid-c-arrays.cpp

+// RUN: %check_clang_tidy %s modernize-avoid-c-arrays %t
+
+int a[] = {1, 2};
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use std::array<> instead
+
+int b[1];
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use std::array<> instead
+
+void foo() {
+  int c[b[0]];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+}
+
+template <typename T, int Size>
+class array {
+  T d[Size];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+
+  int e[1];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+};
+
+array<int[4], 2> d;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: do not declare C-style arrays, use std::array<> instead
+
+using k = int[4];
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: do not declare C-style arrays, use std::array<> instead
+
+array<k, 2> dk;
+
+template <typename T>
+class unique_ptr {
+  T *d;
+
+  int e[1];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+};
+
+unique_ptr<int[]> d2;
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: do not declare C-style arrays, use std::array<> instead
+
+using k2 = int[];
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: do not declare C-style arrays, use std::array<> instead
+
+unique_ptr<k2> dk2;
+
+// Some header
+extern "C" {
+
+int f[] = {1, 2};
+
+int j[1];
+
+inline void bar() {
+  {
+    int j[j[0]];
+  }
+}
+
+extern "C++" {
+int f3[] = {1, 2};
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use std::array<> instead
+
+int j3[1];
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use std::array<> instead
+
+struct Foo {
+  int f3[3] = {1, 2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+
+  int j3[1];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+};
+}
+
+struct Bar {
+
+  int f[3] = {1, 2};
+
+  int j[1];
+};
+}