[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 ↗

(On Diff #171315)

spurious change

154 ↗

(On Diff #171315)

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

6 ↗

(On Diff #171423)

Please make same length as header.

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

8 ↗

(On Diff #171423)

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

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

6 ↗

(On Diff #171423)

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

6 ↗

(On Diff #171423)

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

[JonasToth]

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

84 ↗

(On Diff #171425)

please conserve the alphabetical order here

clang-tidy/hicpp/HICPPTidyModule.cpp

54 ↗

(On Diff #171425)

i would this one should be before avoid-goto.

clang-tidy/modernize/AvoidCArraysCheck.cpp

44 ↗

(On Diff #171425)

What about struct-decls that are externC?

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

15 ↗

(On Diff #171425)

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

48 ↗

(On Diff #171425)

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

84 ↗

(On Diff #171425)

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

clang-tidy/modernize/AvoidCArraysCheck.cpp

44 ↗

(On Diff #171425)

Hm, what is a struct-decl?

[JonasToth]

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

84 ↗

(On Diff #171425)

the avoid-* checks seem to be displaced now.

clang-tidy/modernize/AvoidCArraysCheck.cpp

44 ↗

(On Diff #171425)

we chatted in irc, but for reference

extern "C" {
struct Foo {

};
}

44 ↗

(On Diff #171425)

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

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

3 ↗

(On Diff #171747)

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

84 ↗

(On Diff #171425)

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 ↗

(On Diff #171747)

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

84 ↗

(On Diff #171425)

Maybe now is better?

[JonasToth]

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

84 ↗

(On Diff #171425)

yes, thats the correct position :)

[lebedev.ri]

Comments? :)

[JonasToth]

clang-tidy/modernize/AvoidCArraysCheck.cpp

26 ↗

(On Diff #172520)

Nit: these parens are superflous

64 ↗

(On Diff #172520)

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

64 ↗

(On Diff #172520)

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

32 ↗

(On Diff #173514)

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

32 ↗

(On Diff #173514)

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-tools-extra/trunk/clang-tidy/cppcoreguidelines/CMakeLists.txt

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

clang-tools-extra/trunk/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 clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 /// A module containing checks of the C++ Core Guidelines
 class CppCoreGuidelinesModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
+        "cppcoreguidelines-avoid-c-arrays");
     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");

clang-tools-extra/trunk/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");

clang-tools-extra/trunk/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<> / std::vector<>.
+///
+/// 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-tools-extra/trunk/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");
+
+  static constexpr llvm::StringLiteral UseArray = llvm::StringLiteral(
+      "do not declare C-style arrays, use std::array<> instead");
+  static constexpr llvm::StringLiteral UseVector = llvm::StringLiteral(
+      "do not declare C VLA arrays, use std::vector<> instead");
+
+  diag(ArrayType->getBeginLoc(),
+       ArrayType->getTypePtr()->isVariableArrayType() ? UseVector : UseArray);
+}
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/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-tools-extra/trunk/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");

clang-tools-extra/trunk/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<>`` /
+  ``std::vector<>``.
+
 - 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

clang-tools-extra/trunk/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.

clang-tools-extra/trunk/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.

clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst

.. 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>
.. 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

clang-tools-extra/trunk/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<>`` /
+``std::vector<>``. 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 VLA arrays, use std::vector<> 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
+    }
+  }
+
+  }

clang-tools-extra/trunk/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 VLA arrays, use std::vector<> instead
+
+  using d = decltype(c);
+  d e;
+  // Semi-FIXME: we do not diagnose these last two lines separately,
+  // because we point at typeLoc.getBeginLoc(), which is the decl before that
+  // (int c[b[0]];), which is already diagnosed.
+}
+
+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];
+};
+}