[clang-tidy] Implement FixIts for C arrays

[ccotter]

Summary

Add FixIts for C arrays declared in function definitions.
In this change, we'll generate FixIts for statically sized arrays
but not variable sized arrays. There are a few other edge cases not
implemented, but this change covers most common cases.

For demonstration/testing purposes, https://github.com/llvm/llvm-project/commit/9bd02233a35e358c4a69b7773dbaf98df65caa86 is the result of running the tool on llvm-project's llvm, clang, and clang-tools-extra directories. These changes compile cleanly after applying the fixits.

[ccotter]

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

531

I could not figure out how to get FileCheck to handle // CHECK-FIXES: std::array<int, 3> ar = {{0,1,2}}; without interpreting {{ as the beginning of a regex. Is there a way to escape one of the curly braces?

[ccotter]

• Add more tests for whitespace

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

93

Please do not use auto unless type is explicitly stated in same statement or iterator.

497

auto could be used here.

573

Should be global option, because it's used in other checks.

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

71–79

Missing documentation for IncludeStyle option if it'll remain local.

[ccotter]

• Add option doc, remove auto

[ccotter]

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

573

Could you clarify this a bit? This is how most other tests consume IncludeStyle (Options.getLocalOrGlobal("IncludeStyle", utils::IncludeSorter::IS_LLVM).

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

573

@carlosgalvezp is best person to answer because he recently introduced global option for source files and headers.

[ccotter]

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

573

bump @carlosgalvezp

[PiotrZSL]

To be honest, that's lot of hard to understand code that at start is unmaintainable.
I don't see anyone even trying to understand all this and do some fixes in future.

Consider some refactoring, to reduce amount of code, split it into some functions, add some comments (steps) inside functions.
I hope you will be with us for next 2 years to implement fixes...

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

54–57

use optionally instead of anyOf + anything

249–253

style:

return Token.IsSpecifier || (!ConsumedStar && Token.IsQualifier);

399–404

style: remove {}

446–448

style: else return false;

465–469

style: merge into single if

495

InitListExpr::classof(SpelledExpr)

530

https://www.llvm.org/docs/CommandGuide/FileCheck.html
"In the rare case that you want to match double braces explicitly from the input, you can use something ugly like {{[}][}]}} as your pattern."

539

unused

543

remove {}

573

Local:
  - key: modernize-avoid-c-arrays.IncludeStyle
     value: google

Global:
  - key: IncludeStyle
     value: google

Your code is correct, simply if there is local defined, it will be used, if there is global defined, then global will be used.

clang-tools-extra/clang-tidy/utils/LexerUtils.cpp

122–123

Actually this function is bugged: https://reviews.llvm.org/D146881
I dont think that isBeforeInTranslationUnit is needed here, if you need it then there is something wrong with a range.

clang-tools-extra/clang-tidy/utils/TypeUtils.cpp

51–52

style: const

113–115

Style: no need for {}

clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp

170–172

I don't think this check should replace those strings, simply that could break code, image someone is using this later as an argument to some function that expect pointer.
For strings std::string_view would be better alternative (at least add a bypass for this).
And all those changes are not safe if variable is used for pointer arithmetic.

[ccotter]

• feedback

[ccotter]

rebase

[ccotter]

• Fix double curly brace matching in tests

[ccotter]

• Add tests for char[]

[ccotter]

clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp

170–172

The logic I implemented should fix pointer arithmetic (e.g., str + 1 is replaced by str.begin() + 1. I have tests for this for int[], but added more for char[]. string_view is not appropriate conversion here since the arrays may be modified etc.

[ccotter]

• format

[ccotter]

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

495

Why classof vs dyn_cast? The codebase seems to overwhelmingly use dyn_cst, and I need to use the downcast type anyway..

530

Thanks..fixed!

[carlosgalvezp]

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

573

Yep, this is similar to HeaderFileExtensions, current state is that all checks duplicate the same code when it should instead be just a global option. Since the global option is not available yet, let's leave it as it is and I will put up a patch to deprecate the local options.

Luckily this time it will be much easier since the value is just a string!

[ccotter]

rebase

[PiotrZSL]

Test are failing, and I do not think that converting c-strings into std::array is a good idea....

[carlosgalvezp]

In D145138#4561799, @PiotrZSL wrote:

Test are failing, and I do not think that converting c-strings into std::array is a good idea....

+1, they should typically be char const* instead.

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.h

 //===--- AvoidCArraysCheck.h - clang-tidy -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H
 
 #include "../ClangTidyCheck.h"
+#include "../utils/IncludeInserter.h"
 
 namespace clang::tidy::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) {}
+  AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context);
+  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
+                           Preprocessor *ModuleExpanderPP) override;
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  Preprocessor *PP = nullptr;
+  utils::IncludeInserter IncludeInserter;
+  bool replaceDecl(ArrayTypeLoc ATL, const VarDecl *Var, bool UseCTAD,
+                   ASTContext &Context, std::vector<FixItHint> &FixIts);
+  bool replaceArrayReferences(const VarDecl *Var, const FunctionDecl *Func,
+                              ASTContext &Context,
+                              std::vector<FixItHint> &FixIts);
+  std::vector<FixItHint> replaceArray(ArrayTypeLoc ATL,
+                                      const DeclStmt *VarDeclStmt,
+                                      const VarDecl *Var, ASTContext &Context);
 };
 
 } // namespace clang::tidy::modernize
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

 //===--- AvoidCArraysCheck.cpp - clang-tidy -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AvoidCArraysCheck.h"
+#include "../utils/LexerUtils.h"
+#include "../utils/TypeUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/Lex/Preprocessor.h"
+#include <optional>
+#include <tuple>
 
 using namespace clang::ast_matchers;
 
 namespace {
 
 AST_MATCHER(clang::TypeLoc, hasValidBeginLoc) {
   return Node.getBeginLoc().isValid();
 }
AST_MATCHER(clang::ParmVarDecl, isArgvOfMain) {
   const auto *FD = llvm::dyn_cast<clang::FunctionDecl>(DC);
   return FD ? FD->isMain() : false;
 }
 
 } // namespace
 
 namespace clang::tidy::modernize {
 
+using utils::type::ClassifiedToken;
+
 void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       typeLoc(hasValidBeginLoc(), hasType(arrayType()),
+              optionally(hasParent(varDecl(hasParent(declStmt().bind("decl")),
+                                           hasAncestor(functionDecl()))
+                                       .bind("var"))),
               unless(anyOf(hasParent(parmVarDecl(isArgvOfMain())),
                            hasParent(varDecl(isExternC())),
                            hasParent(fieldDecl(
                                hasParent(recordDecl(isExternCContext())))),
                            hasAncestor(functionDecl(isExternC())))))
           .bind("typeloc"),
       this);
 }
 
+SourceLocation findEndOfToken(SourceLocation Loc, const ASTContext &Context) {
+  const SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+
+  SourceLocation Orig = Loc;
+  Loc = Loc.getLocWithOffset(1);
+  while (Loc.isValid()) {
+    SourceLocation PrevTokenLoc =
+        utils::lexer::findPreviousTokenStart(Loc, SM, LangOpts);
+    if (PrevTokenLoc != Orig)
+      return Loc.getLocWithOffset(-1);
+    Loc = Loc.getLocWithOffset(1);
+  }
+  return SourceLocation{};
+}
+
+SourceLocation getPreviousTokenLoc(SourceLocation Location,
+                                   const SourceManager &SM,
+                                   const LangOptions &LangOpts,
+                                   bool SkipComments = false) {
+  Token Token;
+  Token.setKind(tok::unknown);
+
+  Location = Location.getLocWithOffset(-1);
+  if (Location.isInvalid())
+    return Location;
+
+  SourceLocation StartOfFile = SM.getLocForStartOfFile(SM.getFileID(Location));
+  while (Location != StartOfFile) {
+    Location = Lexer::GetBeginningOfToken(Location, SM, LangOpts);
+    if (!Lexer::getRawToken(Location, Token, SM, LangOpts) &&
+        (!SkipComments || !Token.is(tok::comment)))
+      break;
+    Location = Location.getLocWithOffset(-1);
+  }
+  return Location;
+}
+
+SourceLocation getVarLocForReplacement(const VarDecl *Var,
+                                       const ASTContext &Context) {
+  const SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+  SourceLocation EndLoc = getPreviousTokenLoc(Var->getLocation(), SM, LangOpts);
+  if (!EndLoc.isValid())
+    return SourceLocation{};
+  EndLoc = findEndOfToken(EndLoc, Context);
+  if (!EndLoc.isValid())
+    return SourceLocation{};
+  CharSourceRange Range{SourceRange{EndLoc, EndLoc.getLocWithOffset(1)}, false};
+  StringRef Text = Lexer::getSourceText(Range, SM, LangOpts);
+  if (Text.empty())
+    return SourceLocation{};
+  if (std::isspace(Text[0]))
+    return EndLoc.getLocWithOffset(1);
+  return EndLoc;
+}
+
+// Collects the qualifiers, specifiers, and type tokens and combines them
+// into source text strings suitable for std::array<>/std::vector<>
+// replacement. Specifiers are placed outside of the array/vector template
+// type, and the qualifiers and type tokens themselves are placed within
+// the array/vector template type.
+//
+// Any text between the final non-specifer token and the following specifier
+// token is moved to appear after the ">" in the eventual
+// std::array<>/std::vector<> declaration.
+//
+// The logic works in two passes: first, classifying the tokens and collecting
+// the source text associated with each token including any whitespace/comments
+// that should remain "attached" to the token. Second, the tokens and text
+// are parsed using a "simple" algorithm to determine whether qualifiers are
+// associated with the array, or the array element. In particular, handling
+// pointers requires extra care to distinguish a qualifier on the pointer type
+// vs qualifier on the type being pointed to. Since QualType/TypeLoc do not
+// store per qualifier source location information, this bespoke logic cannot
+// handle every possible case (see tests marked with FIXMEs), but it gets
+// the most common cases.
+std::optional<std::tuple<std::string, std::string, std::string>>
+extractTypeComponents(Preprocessor *PP, TypeLoc TL, const VarDecl *Var,
+                      const ASTContext &Context) {
+  const SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+
+  SourceLocation EndLoc = getVarLocForReplacement(Var, Context);
+  if (!EndLoc.isValid())
+    return std::nullopt;
+  std::optional<SmallVector<ClassifiedToken, 8>> MaybeTokens =
+      utils::type::classifyDeclTypeTokens(*PP, Var->getBeginLoc(), EndLoc,
+                                          Context);
+  if (!MaybeTokens || MaybeTokens->size() == 0)
+    return std::nullopt;
+
+  unsigned LastTypeIndex = -1;
+  for (auto [Index, Token] : llvm::enumerate(*MaybeTokens)) {
+    if (!Token.IsSpecifier && !Token.IsQualifier)
+      LastTypeIndex = Index;
+  }
+
+  struct TokenAndText {
+    ClassifiedToken T;
+    std::string Text;
+
+    TokenAndText(ClassifiedToken T, StringRef Text) : T(T), Text(Text) {}
+  };
+
+  std::string Specifiers;
+  std::string QualType;
+  std::string BaseType;
+  std::string Suffix;
+
+  SmallVector<TokenAndText, 8> Tokens;
+  for (auto [Index, Current] : llvm::enumerate(*MaybeTokens)) {
+    if (Index == MaybeTokens->size() - 1) {
+      if (Index == LastTypeIndex) {
+        CharSourceRange CSR{SourceRange{Current.T.getLocation()}, true};
+        Tokens.emplace_back(Current, Lexer::getSourceText(CSR, SM, LangOpts));
+
+        SourceLocation SuffixStart =
+            findEndOfToken(Current.T.getLocation(), Context);
+        Suffix = Lexer::getSourceText(
+            CharSourceRange{SourceRange{SuffixStart, EndLoc}, false}, SM,
+            LangOpts);
+      } else {
+        CharSourceRange CSR{SourceRange{Current.T.getLocation(), EndLoc},
+                            false};
+        Tokens.emplace_back(Current, Lexer::getSourceText(CSR, SM, LangOpts));
+      }
+    } else {
+      const ClassifiedToken &Next = (*MaybeTokens)[Index + 1];
+      if (Index == LastTypeIndex) {
+        Tokens.emplace_back(
+            Current,
+            Lexer::getSourceText(
+                CharSourceRange{SourceRange{Current.T.getLocation()}, true}, SM,
+                LangOpts));
+
+        SourceLocation SuffixStart =
+            findEndOfToken(Current.T.getLocation(), Context);
+        Suffix = Lexer::getSourceText(
+            CharSourceRange{SourceRange{SuffixStart, Next.T.getLocation()},
+                            false},
+            SM, LangOpts);
+      } else {
+        Tokens.emplace_back(
+            Current, Lexer::getSourceText(
+                         CharSourceRange{SourceRange{Current.T.getLocation(),
+                                                     Next.T.getLocation()},
+                                         false},
+                         SM, LangOpts));
+      }
+    }
+  }
+
+  // Track whether we've seen a '*' token while scanning right to left.
+  bool ConsumedStar = false;
+  std::optional<SourceLocation> StarLoc;
+  if (PointerTypeLoc PTL = TL.getUnqualifiedLoc().getAs<PointerTypeLoc>())
+    StarLoc.emplace(PTL.getStarLoc());
+
+  // Track if we correctly found the CV qualifiers of the array. After
+  // processing the tokens, validate our assumptions and bail out if
+  // any assumption is not correct.
+  bool SawConst = false;
+  bool SawVolatile = false;
+
+  // TypeLoc'c SourceLocation starts at the first non-qualifier, so any
+  // associated type qualifier is not included. However, type qualifiers
+  // may be embeded in the type ('unsigned const int').
+  auto WithinTypeRange = [&, UnqualifiedTL = TL.getUnqualifiedLoc()](
+                             const ClassifiedToken &Token) -> bool {
+    if (!Token.IsQualifier)
+      return false;
+
+    FullSourceLoc TokLoc{Token.T.getLocation(), SM};
+    return FullSourceLoc(UnqualifiedTL.getBeginLoc(), SM)
+               .isBeforeInTranslationUnitThan(TokLoc) &&
+           TokLoc.isBeforeInTranslationUnitThan(UnqualifiedTL.getEndLoc());
+  };
+  auto IsSpec = [&](const ClassifiedToken &Token) -> bool {
+    if (WithinTypeRange(Token))
+      return false;
+
+    if (ConsumedStar)
+      return Token.IsSpecifier;
+    else
+      return Token.IsSpecifier || Token.IsQualifier;
+  };
+  auto AppendTypeToken = [&](const ClassifiedToken &Token, StringRef Text) {
+    if (StarLoc.has_value() && Token.T.getLocation() == *StarLoc)
+      ConsumedStar = true;
+
+    if (!WithinTypeRange(Token) && !ConsumedStar) {
+      if (Token.T.is(tok::kw_const))
+        SawConst = true;
+      if (Token.T.is(tok::kw_volatile))
+        SawVolatile = true;
+    }
+
+    if (IsSpec(Token)) {
+      Specifiers = (Text + Specifiers).str();
+    } else {
+      if (ConsumedStar)
+        QualType = (Text + QualType).str();
+      else
+        BaseType = (Text + BaseType).str();
+    }
+  };
+  for (const auto &T : llvm::reverse(Tokens))
+    AppendTypeToken(T.T, T.Text);
+
+  if (ConsumedStar)
+    Specifiers += BaseType;
+  else {
+    assert(QualType.size() == 0);
+    QualType = BaseType;
+  }
+
+  if (TL.getType().isLocalVolatileQualified() ^ SawVolatile)
+    return {};
+  if (TL.getType().isLocalConstQualified() ^ SawConst)
+    return {};
+
+  return std::make_tuple(std::move(Specifiers), std::move(QualType),
+                         std::move(Suffix));
+}
+
+bool AvoidCArraysCheck::replaceDecl(ArrayTypeLoc ATL, const VarDecl *Var,
+                                    bool UseCTAD, ASTContext &Context,
+                                    std::vector<FixItHint> &FixIts) {
+  const SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+
+  std::optional<std::tuple<std::string, std::string, std::string>>
+      TypeComponents =
+          extractTypeComponents(PP, ATL.getElementLoc(), Var, Context);
+  if (!TypeComponents)
+    return {};
+  auto [Specifiers, QualType, Suffix] = *TypeComponents;
+
+  if (UseCTAD && Suffix.empty())
+    Suffix = " ";
+
+  std::string Replacement;
+  const bool IsVLA = ATL.getTypePtr()->isVariableArrayType();
+  const bool IsCharElem =
+      ATL.getElementLoc().getTypePtr()->isAnyCharacterType();
+  if (UseCTAD) {
+    // FIXME - support vector
+    if (IsVLA)
+      return false;
+    else
+      Replacement += Specifiers + "std::array" + Suffix;
+  } else {
+    // FIXME - support vector
+    if (IsVLA)
+      return false;
+    else
+      Replacement += Specifiers + "std::array<" + QualType + ", ";
+    if (ATL.getSizeExpr()) {
+      Replacement += Lexer::getSourceText(
+          CharSourceRange::getCharRange(
+              ATL.getLBracketLoc().getLocWithOffset(1), ATL.getRBracketLoc()),
+          SM, LangOpts);
+    } else {
+      if (!Var->hasInit())
+        return false;
+
+      const Expr *InitExpr = Var->getInit();
+      if (const auto *EWC = dyn_cast<ExprWithCleanups>(InitExpr))
+        InitExpr = EWC->getSubExpr();
+
+      if (const auto *ILE = dyn_cast<InitListExpr>(InitExpr)) {
+        if (IsCharElem) {
+          if (ILE->getNumInits() != 1)
+            return false;
+          const Expr *FirstInitExpr = ILE->getInit(0);
+          if (const auto *SE = dyn_cast<StringLiteral>(FirstInitExpr))
+            Replacement += std::to_string(SE->getLength() + 1);
+          else
+            return false;
+        } else {
+          Replacement += std::to_string(ILE->getNumInits());
+        }
+      } else if (const auto *SE = dyn_cast<StringLiteral>(InitExpr))
+        Replacement += std::to_string(SE->getLength() + 1);
+      else
+        return false;
+    }
+    Replacement += ">" + Suffix;
+  }
+
+  SourceLocation EndLoc = getVarLocForReplacement(Var, Context);
+  CharSourceRange ReplacementRange =
+      CharSourceRange::getCharRange(Var->getBeginLoc(), EndLoc);
+
+  FixIts.push_back(FixItHint::CreateReplacement(ReplacementRange, Replacement));
+  FixIts.push_back(FixItHint::CreateRemoval(ATL.getBracketsRange()));
+  return true;
+}
+
+bool AvoidCArraysCheck::replaceArrayReferences(const VarDecl *Var,
+                                               const FunctionDecl *Func,
+                                               ASTContext &Context,
+                                               std::vector<FixItHint> &FixIts) {
+  const SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+
+  auto NonParensExpr = [](auto &&...Matchers) {
+    return expr(std::forward<decltype(Matchers)>(Matchers)...,
+                unless(parenExpr()));
+  };
+  SmallVector<BoundNodes, 4> Matches = match(
+      findAll(declRefExpr(
+                  to(equalsNode(Var)), unless(hasAncestor(typeAliasDecl())),
+                  optionally(hasParent(varDecl(hasParent(declStmt(
+                      hasParent(cxxForRangeStmt().bind("range-for"))))))),
+                  optionally(hasAncestor(
+                      NonParensExpr(
+                          optionally(unaryExprOrTypeTraitExpr().bind("sizeof")),
+                          optionally(
+                              hasAncestor(NonParensExpr().bind("parent2Expr"))))
+                          .bind("parent1"))))
+                  .bind("ref")),
+      *Func->getBody(), Context);
+  for (const BoundNodes &Match : Matches) {
+    const DeclRefExpr *Ref = Match.getNodeAs<DeclRefExpr>("ref");
+    if (Match.getNodeAs<CXXForRangeStmt>("range-for"))
+      continue;
+    if (Match.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof"))
+      continue;
+
+    const Expr *Parent1 = Match.getNodeAs<Expr>("parent1");
+    const Expr *Parent2Expr = Match.getNodeAs<Expr>("parent2Expr");
+    if (!Parent1)
+      return false;
+
+    if (const auto *Cast = dyn_cast<ImplicitCastExpr>(Parent1)) {
+      if (Cast->getCastKind() != CK_ArrayToPointerDecay)
+        return false;
+      if (const auto *Subscript =
+              dyn_cast_or_null<ArraySubscriptExpr>(Parent2Expr)) {
+        if (Subscript->getLHS() == Parent1) {
+          // Nothing to change in this case, e.g., 'arr[1]'
+          continue;
+        } else {
+          // Swap order of subscript, e.g., '1[arr]'
+          const bool NotTokenRange = true;
+          CharSourceRange NameRange{
+              SourceRange{Subscript->getBase()->getBeginLoc(),
+                          Subscript->getBase()->getEndLoc()},
+              NotTokenRange};
+          StringRef Name = Lexer::getSourceText(NameRange, SM, LangOpts);
+          CharSourceRange IdxRange{
+              SourceRange{Subscript->getIdx()->getBeginLoc(),
+                          Subscript->getIdx()->getEndLoc()},
+              NotTokenRange};
+          StringRef Idx = Lexer::getSourceText(IdxRange, SM, LangOpts);
+          FixIts.push_back(FixItHint::CreateReplacement(NameRange, Idx));
+          FixIts.push_back(FixItHint::CreateReplacement(IdxRange, Name));
+        }
+      } else {
+        const bool IsTokenRange = true;
+        if (Ref->getBeginLoc().isMacroID())
+          return false;
+
+        CharSourceRange NameRange{
+            SourceRange{Ref->getBeginLoc(), Ref->getEndLoc()}, IsTokenRange};
+        StringRef Name = Lexer::getSourceText(NameRange, SM, LangOpts);
+        FixIts.push_back(
+            FixItHint::CreateReplacement(NameRange, (Name + ".begin()").str()));
+        continue;
+      }
+    } else
+      return false;
+  }
+
+  return true;
+}
+
+std::vector<FixItHint>
+AvoidCArraysCheck::replaceArray(ArrayTypeLoc ATL, const DeclStmt *VarDeclStmt,
+                                const VarDecl *Var, ASTContext &Context) {
+  const FunctionDecl *Func = dyn_cast<FunctionDecl>(Var->getDeclContext());
+  if (!Func || !Func->getBody())
+    return {};
+
+  const SourceManager &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
+
+  const Type *ElemType = ATL.getElementLoc().getTypePtr();
+  if (ElemType->isArrayType() || ElemType->isFunctionPointerType() ||
+      ElemType->isMemberFunctionPointerType())
+    return {};
+
+  std::vector<FixItHint> FixIts;
+  if (!replaceArrayReferences(Var, Func, Context, FixIts))
+    return {};
+
+  if (!VarDeclStmt->isSingleDecl())
+    return {};
+
+  const Expr *InitExpr = Var->hasInit() ? Var->getInit() : nullptr;
+  if (const auto *EWC = dyn_cast_or_null<ExprWithCleanups>(InitExpr))
+    InitExpr = EWC->getSubExpr();
+
+  // Determine if we can use a CTAD declaration
+  const bool IsCharElem =
+      ATL.getElementLoc().getTypePtr()->isAnyCharacterType();
+  bool UseCTAD = false;
+  if (getLangOpts().CPlusPlus17 && InitExpr && !ATL.getSizeExpr() &&
+      !IsCharElem) {
+    if (const auto *ILE = dyn_cast<InitListExpr>(Var->getInit())) {
+      if (ILE->getNumInits() > 0) {
+        UseCTAD = llvm::all_of(
+            ILE->inits(),
+            [ElemType =
+                 ATL.getElementLoc().getType().getTypePtr()](const Expr *E) {
+              const Expr *SpelledExpr = E->IgnoreUnlessSpelledInSource();
+              if (dyn_cast<InitListExpr>(SpelledExpr))
+                return false;
+              const auto *ConstructExpr =
+                  dyn_cast<CXXConstructExpr>(SpelledExpr);
+              if (ConstructExpr &&
+                  !dyn_cast<CXXTemporaryObjectExpr>(SpelledExpr) &&
+                  ConstructExpr->isListInitialization())
+                return false;
+              return SpelledExpr->getType().getTypePtr() == ElemType;
+            });
+      }
+    }
+  }
+
+  // Add FixIt {} around initializer
+  if (InitExpr && !UseCTAD) {
+    SourceRange InitRange;
+    if (const auto *SE = dyn_cast<StringLiteral>(InitExpr)) {
+      std::optional<Token> NextToken =
+          Lexer::findNextToken(SE->getEndLoc(), SM, LangOpts);
+      if (!NextToken)
+        return {};
+      InitRange = SourceRange{SE->getBeginLoc(), NextToken->getLocation()};
+    } else if (const auto *ILE = dyn_cast<InitListExpr>(InitExpr)) {
+      std::optional<Token> NextToken =
+          Lexer::findNextToken(ILE->getEndLoc(), SM, LangOpts);
+      if (!NextToken)
+        return {};
+      InitRange = SourceRange{ILE->getBeginLoc(), NextToken->getLocation()};
+    }
+
+    if (InitRange.isValid()) {
+      if (utils::lexer::rangeContainsExpansionsOrDirectives(InitRange, SM,
+                                                            LangOpts))
+        return {};
+      FixIts.push_back(FixItHint::CreateInsertion(InitRange.getBegin(), "{"));
+      FixIts.push_back(FixItHint::CreateInsertion(InitRange.getEnd(), "}"));
+    }
+  }
+
+  if (!replaceDecl(ATL, Var, UseCTAD, Context, FixIts))
+    return {};
+
+  std::optional<FixItHint> IncludeFixIt =
+      IncludeInserter.createIncludeInsertion(SM.getFileID(Var->getBeginLoc()),
+                                             "<array>");
+  if (IncludeFixIt)
+    FixIts.push_back(std::move(*IncludeFixIt));
+
+  return FixIts;
+}
+
 void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
 
-  diag(ArrayType->getBeginLoc(),
+  bool IsVLA = ArrayType->getTypePtr()->isVariableArrayType();
+  auto Diag = diag(ArrayType->getBeginLoc(),
                    "do not declare %select{C-style|C VLA}0 arrays, use "
                    "%select{std::array<>|std::vector<>}0 instead")
-      << ArrayType->getTypePtr()->isVariableArrayType();
+              << IsVLA;
+
+  const auto *Var = Result.Nodes.getNodeAs<VarDecl>("var");
+  const auto *VarDeclStmt = Result.Nodes.getNodeAs<DeclStmt>("decl");
+  if (!Var || !VarDeclStmt)
+    return;
+
+  // FIXME: Support variables with attributes
+  if (Var->hasAttrs())
+    return;
+
+  ArrayTypeLoc ATL = ArrayType->getUnqualifiedLoc().getAs<ArrayTypeLoc>();
+  if (!ATL)
+    return;
+  Diag << replaceArray(ATL, VarDeclStmt, Var, *Result.Context);
+}
+
+void AvoidCArraysCheck::registerPPCallbacks(const SourceManager &SM,
+                                            Preprocessor *PP,
+                                            Preprocessor *ModuleExpanderPP) {
+  this->PP = PP;
+  IncludeInserter.registerPreprocessor(PP);
 }
 
+void AvoidCArraysCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
+}
+
+AvoidCArraysCheck::AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
+                                               utils::IncludeSorter::IS_LLVM),
+                      areDiagsSelfContained()) {}
+
 } // namespace clang::tidy::modernize

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.h

 //===--- UseTrailingReturnTypeCheck.h - clang-tidy---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETRAILINGRETURNTYPECHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETRAILINGRETURNTYPECHECK_H
 
 #include "../ClangTidyCheck.h"
 #include "clang/Lex/Token.h"
 #include <optional>
 
 namespace clang::tidy::modernize {
 
-struct ClassifiedToken {
-  Token T;
-  bool IsQualifier;
-  bool IsSpecifier;
-};
-
 /// Rewrites function signatures to use a trailing return type.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/modernize/use-trailing-return-type.html
 class UseTrailingReturnTypeCheck : public ClangTidyCheck {
 public:
   UseTrailingReturnTypeCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   Preprocessor *PP = nullptr;
 
   SourceLocation findTrailingReturnTypeSourceLocation(
       const FunctionDecl &F, const FunctionTypeLoc &FTL, const ASTContext &Ctx,
       const SourceManager &SM, const LangOptions &LangOpts);
-  std::optional<SmallVector<ClassifiedToken, 8>>
-  classifyTokensBeforeFunctionName(const FunctionDecl &F, const ASTContext &Ctx,
-                                   const SourceManager &SM,
-                                   const LangOptions &LangOpts);
   SourceRange findReturnTypeAndCVSourceRange(const FunctionDecl &F,
                                              const TypeLoc &ReturnLoc,
                                              const ASTContext &Ctx,
                                              const SourceManager &SM,
                                              const LangOptions &LangOpts);
   void keepSpecifiers(std::string &ReturnType, std::string &Auto,
                       SourceRange ReturnTypeCVRange, const FunctionDecl &F,
                       const FriendDecl *Fr, const ASTContext &Ctx,
                       const SourceManager &SM, const LangOptions &LangOpts);
 };
 
 } // namespace clang::tidy::modernize
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETRAILINGRETURNTYPECHECK_H

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

 //===--- UseTrailingReturnTypeCheck.cpp - clang-tidy-----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "UseTrailingReturnTypeCheck.h"
+#include "../utils/TypeUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/FixIt.h"
 #include "llvm/ADT/StringExtras.h"
 
 #include <cctype>
 #include <optional>
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::modernize {
+
+using utils::type::ClassifiedToken;
+
 namespace {
 struct UnqualNameVisitor : public RecursiveASTVisitor<UnqualNameVisitor> {
 public:
   UnqualNameVisitor(const FunctionDecl &F) : F(F) {}
 
   bool Collision = false;
 
   bool shouldWalkTypesOfTypeLocs() const { return false; }
if (T.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
       Result = T.getEndLoc();
       continue;
     }
     break;
   }
   return Result;
 }
 
-static bool isCvr(Token T) {
-  return T.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict);
-}
-
-static bool isSpecifier(Token T) {
-  return T.isOneOf(tok::kw_constexpr, tok::kw_inline, tok::kw_extern,
-                   tok::kw_static, tok::kw_friend, tok::kw_virtual);
-}
-
-static std::optional<ClassifiedToken>
-classifyToken(const FunctionDecl &F, Preprocessor &PP, Token Tok) {
-  ClassifiedToken CT;
-  CT.T = Tok;
-  CT.IsQualifier = true;
-  CT.IsSpecifier = true;
-  bool ContainsQualifiers = false;
-  bool ContainsSpecifiers = false;
-  bool ContainsSomethingElse = false;
-
-  Token End;
-  End.startToken();
-  End.setKind(tok::eof);
-  SmallVector<Token, 2> Stream{Tok, End};
-
-  // FIXME: do not report these token to Preprocessor.TokenWatcher.
-  PP.EnterTokenStream(Stream, false, /*IsReinject=*/false);
-  while (true) {
-    Token T;
-    PP.Lex(T);
-    if (T.is(tok::eof))
-      break;
-
-    bool Qual = isCvr(T);
-    bool Spec = isSpecifier(T);
-    CT.IsQualifier &= Qual;
-    CT.IsSpecifier &= Spec;
-    ContainsQualifiers |= Qual;
-    ContainsSpecifiers |= Spec;
-    ContainsSomethingElse |= !Qual && !Spec;
-  }
-
-  // If the Token/Macro contains more than one type of tokens, we would need
-  // to split the macro in order to move parts to the trailing return type.
-  if (ContainsQualifiers + ContainsSpecifiers + ContainsSomethingElse > 1)
-    return std::nullopt;
-
-  return CT;
-}
-
-std::optional<SmallVector<ClassifiedToken, 8>>
-UseTrailingReturnTypeCheck::classifyTokensBeforeFunctionName(
-    const FunctionDecl &F, const ASTContext &Ctx, const SourceManager &SM,
-    const LangOptions &LangOpts) {
-  SourceLocation BeginF = expandIfMacroId(F.getBeginLoc(), SM);
-  SourceLocation BeginNameF = expandIfMacroId(F.getLocation(), SM);
-
-  // Create tokens for everything before the name of the function.
-  std::pair<FileID, unsigned> Loc = SM.getDecomposedLoc(BeginF);
-  StringRef File = SM.getBufferData(Loc.first);
-  const char *TokenBegin = File.data() + Loc.second;
-  Lexer Lexer(SM.getLocForStartOfFile(Loc.first), LangOpts, File.begin(),
-              TokenBegin, File.end());
-  Token T;
-  SmallVector<ClassifiedToken, 8> ClassifiedTokens;
-  while (!Lexer.LexFromRawLexer(T) &&
-         SM.isBeforeInTranslationUnit(T.getLocation(), BeginNameF)) {
-    if (T.is(tok::raw_identifier)) {
-      IdentifierInfo &Info = Ctx.Idents.get(
-          StringRef(SM.getCharacterData(T.getLocation()), T.getLength()));
-
-      if (Info.hasMacroDefinition()) {
-        const MacroInfo *MI = PP->getMacroInfo(&Info);
-        if (!MI || MI->isFunctionLike()) {
-          // Cannot handle function style macros.
-          diag(F.getLocation(), Message);
-          return std::nullopt;
-        }
-      }
-
-      T.setIdentifierInfo(&Info);
-      T.setKind(Info.getTokenID());
-    }
-
-    if (std::optional<ClassifiedToken> CT = classifyToken(F, *PP, T))
-      ClassifiedTokens.push_back(*CT);
-    else {
-      diag(F.getLocation(), Message);
-      return std::nullopt;
-    }
-  }
-
-  return ClassifiedTokens;
-}
-
 static bool hasAnyNestedLocalQualifiers(QualType Type) {
   bool Result = Type.hasLocalQualifiers();
   if (Type->isPointerType())
     Result = Result || hasAnyNestedLocalQualifiers(
                            Type->castAs<PointerType>()->getPointeeType());
   if (Type->isReferenceType())
     Result = Result || hasAnyNestedLocalQualifiers(
                            Type->castAs<ReferenceType>()->getPointeeType());
SourceRange UseTrailingReturnTypeCheck::findReturnTypeAndCVSourceRange(
 
 
   // If the return type has no local qualifiers, it's source range is accurate.
   if (!hasAnyNestedLocalQualifiers(F.getReturnType()))
     return ReturnTypeRange;
 
   // Include qualifiers to the left and right of the return type.
   std::optional<SmallVector<ClassifiedToken, 8>> MaybeTokens =
-      classifyTokensBeforeFunctionName(F, Ctx, SM, LangOpts);
-  if (!MaybeTokens)
+      utils::type::classifyDeclTypeTokens(*PP, F, Ctx);
+  if (!MaybeTokens) {
+    diag(F.getLocation(), Message);
     return {};
+  }
   const SmallVector<ClassifiedToken, 8> &Tokens = *MaybeTokens;
 
   ReturnTypeRange.setBegin(expandIfMacroId(ReturnTypeRange.getBegin(), SM));
   ReturnTypeRange.setEnd(expandIfMacroId(ReturnTypeRange.getEnd(), SM));
 
   bool ExtendedLeft = false;
   for (size_t I = 0; I < Tokens.size(); I++) {
     // If we found the beginning of the return type, include left qualifiers.
void UseTrailingReturnTypeCheck::keepSpecifiers(
   if (!F.isConstexpr() && !F.isInlineSpecified() &&
       F.getStorageClass() != SC_Extern && F.getStorageClass() != SC_Static &&
       !Fr && !(M && M->isVirtualAsWritten()))
     return;
 
   // Tokenize return type. If it contains macros which contain a mix of
   // qualifiers, specifiers and types, give up.
   std::optional<SmallVector<ClassifiedToken, 8>> MaybeTokens =
-      classifyTokensBeforeFunctionName(F, Ctx, SM, LangOpts);
-  if (!MaybeTokens)
+      utils::type::classifyDeclTypeTokens(*PP, F, Ctx);
+  if (!MaybeTokens) {
+    diag(F.getLocation(), Message);
     return;
+  }
 
   // Find specifiers, remove them from the return type, add them to 'auto'.
   unsigned int ReturnTypeBeginOffset =
       SM.getDecomposedLoc(ReturnTypeCVRange.getBegin()).second;
   size_t InitialAutoLength = Auto.size();
   unsigned int DeletedChars = 0;
   for (ClassifiedToken CT : *MaybeTokens) {
     if (SM.isBeforeInTranslationUnit(CT.T.getLocation(),

clang-tools-extra/clang-tidy/utils/CMakeLists.txt

add_clang_library(clangTidyUtils
   IncludeInserter.cpp
   IncludeSorter.cpp
   LexerUtils.cpp
   NamespaceAliaser.cpp
   OptionsUtils.cpp
   RenamerClangTidyCheck.cpp
   TransformerClangTidyCheck.cpp
   TypeTraits.cpp
+  TypeUtils.cpp
   UsingInserter.cpp
 
   LINK_LIBS
   clangTidy
 
   DEPENDS
   omp_gen
   )

clang-tools-extra/clang-tidy/utils/LexerUtils.cpp

 //===--- LexerUtils.cpp - clang-tidy---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 }
 
 bool rangeContainsExpansionsOrDirectives(SourceRange Range,
                                          const SourceManager &SM,
                                          const LangOptions &LangOpts) {
   assert(Range.isValid() && "Invalid Range for relexing provided");
   SourceLocation Loc = Range.getBegin();
 
   while (Loc <= Range.getEnd()) {
+  //while (SM.isBeforeInTranslationUnit(Loc, Range.getEnd())) {
     if (Loc.isMacroID())
       return true;
 
     std::optional<Token> Tok = Lexer::findNextToken(Loc, SM, LangOpts);
 
     if (!Tok)
       return true;
 

clang-tools-extra/clang-tidy/utils/TypeUtils.h

+//===--- TypeUtils.h - clang-tidy--------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_TYPE_UTILS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_TYPE_UTILS_H
+
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Lex/Token.h"
+#include "llvm/ADT/SmallVector.h"
+#include <optional>
+
+namespace clang {
+
+class ASTContext;
+class Decl;
+class Preprocessor;
+
+namespace tidy::utils::type {
+
+struct ClassifiedToken {
+  Token T;
+  bool IsQualifier;
+  bool IsSpecifier;
+};
+
+// Classify the qualifiers and specifier tokens of a declaration.
+std::optional<SmallVector<ClassifiedToken, 8>>
+classifyDeclTypeTokens(Preprocessor &PP, SourceLocation BeginLoc,
+                       SourceLocation EndLoc, const ASTContext &Ctx);
+
+std::optional<SmallVector<ClassifiedToken, 8>>
+classifyDeclTypeTokens(Preprocessor &PP, const Decl &D, const ASTContext &Ctx);
+
+} // namespace tidy::utils::type
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_TYPE_UTILS_H

clang-tools-extra/clang-tidy/utils/TypeUtils.cpp

+//===--- TypeUtils.cpp - clang-tidy----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "TypeUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/Lex/Preprocessor.h"
+#include <optional>
+
+namespace clang::tidy::utils::type {
+
+static bool isCvr(Token T) {
+  return T.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict);
+}
+
+static bool isSpecifier(Token T) {
+  return T.isOneOf(tok::kw_constexpr, tok::kw_inline, tok::kw_extern,
+                   tok::kw_static, tok::kw_friend, tok::kw_virtual,
+                   tok::kw_thread_local, tok::kw_register);
+}
+
+static std::optional<ClassifiedToken> classifyToken(Preprocessor &PP,
+                                                    Token Tok) {
+  ClassifiedToken CT;
+  CT.T = Tok;
+  CT.IsQualifier = true;
+  CT.IsSpecifier = true;
+  bool ContainsQualifiers = false;
+  bool ContainsSpecifiers = false;
+  bool ContainsSomethingElse = false;
+
+  Token End;
+  End.startToken();
+  End.setKind(tok::eof);
+  SmallVector<Token, 2> Stream{Tok, End};
+
+  // FIXME: do not report these token to Preprocessor.TokenWatcher.
+  PP.EnterTokenStream(Stream, false, /*IsReinject=*/false);
+  while (true) {
+    Token T;
+    PP.Lex(T);
+    if (T.is(tok::eof))
+      break;
+
+    const bool Qual = isCvr(T);
+    const bool Spec = isSpecifier(T);
+    CT.IsQualifier &= Qual;
+    CT.IsSpecifier &= Spec;
+    ContainsQualifiers |= Qual;
+    ContainsSpecifiers |= Spec;
+    ContainsSomethingElse |= !Qual && !Spec;
+  }
+
+  // If the Token/Macro contains more than one type of tokens, we would need
+  // to split the macro in order to move parts to the trailing return type.
+  if (ContainsQualifiers + ContainsSpecifiers + ContainsSomethingElse > 1)
+    return std::nullopt;
+
+  return CT;
+}
+
+static SourceLocation expandIfMacroId(SourceLocation Loc,
+                                      const SourceManager &SM) {
+  if (Loc.isMacroID())
+    Loc = expandIfMacroId(SM.getImmediateExpansionRange(Loc).getBegin(), SM);
+  assert(!Loc.isMacroID() &&
+         "SourceLocation must not be a macro ID after recursive expansion");
+  return Loc;
+}
+
+std::optional<SmallVector<ClassifiedToken, 8>>
+classifyDeclTypeTokens(Preprocessor &PP, SourceLocation BeginLoc,
+                       SourceLocation EndLoc, const ASTContext &Ctx) {
+  const SourceManager &SM = Ctx.getSourceManager();
+  const LangOptions &LangOpts = Ctx.getLangOpts();
+  BeginLoc = expandIfMacroId(BeginLoc, SM);
+  EndLoc = expandIfMacroId(EndLoc, SM);
+
+  // Create tokens for everything before the name of the function.
+  std::pair<FileID, unsigned> Loc = SM.getDecomposedLoc(BeginLoc);
+  StringRef File = SM.getBufferData(Loc.first);
+  const char *TokenBegin = File.data() + Loc.second;
+  Lexer Lexer(SM.getLocForStartOfFile(Loc.first), LangOpts, File.begin(),
+              TokenBegin, File.end());
+  Token T;
+  SmallVector<ClassifiedToken, 8> ClassifiedTokens;
+  while (!Lexer.LexFromRawLexer(T) &&
+         SM.isBeforeInTranslationUnit(T.getLocation(), EndLoc)) {
+    if (T.is(tok::raw_identifier)) {
+      IdentifierInfo &Info = Ctx.Idents.get(
+          StringRef(SM.getCharacterData(T.getLocation()), T.getLength()));
+
+      if (Info.hasMacroDefinition()) {
+        const MacroInfo *MI = PP.getMacroInfo(&Info);
+        if (!MI || MI->isFunctionLike()) {
+          // Cannot handle function style macros.
+          return std::nullopt;
+        }
+      }
+
+      T.setIdentifierInfo(&Info);
+      T.setKind(Info.getTokenID());
+    }
+
+    if (std::optional<ClassifiedToken> CT = classifyToken(PP, T))
+      ClassifiedTokens.push_back(*CT);
+    else
+      return std::nullopt;
+  }
+
+  return ClassifiedTokens;
+}
+
+std::optional<SmallVector<ClassifiedToken, 8>>
+classifyDeclTypeTokens(Preprocessor &PP, const Decl &D, const ASTContext &Ctx) {
+  return classifyDeclTypeTokens(PP, D.getBeginLoc(), D.getLocation(), Ctx);
+}
+
+} // namespace clang::tidy::utils::type

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`performance-enum-size
   class based on the range of its enumerators.
 
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+- Improved :doc: `modernize-avoid-c-arrays
+  <clang-tidy/checks/modernize/avoid-c-arrays>` check to provide fix-its for
+  C-style arrays declared in function bodies.
+
 Removed checks
 ^^^^^^^^^^^^^^
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 

clang-tools-extra/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.
+Fix-its are generated for C-style arrays in function bodies. Fix-its are not
+provided in other contexts (e.g., class member variables).
 
 .. 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
 
+  void somefunction() {
+    int a[10]; // warning: do not declare C-style arrays, use std::array<> instead
+               // replaced with 'std::array<int, 10> a'
+    int v = a[0];
+    int* ptr = a; // replaced with 'int* ptr = a.begin()'
+
+    int a2[] = {1,2,3}; // warning: do not declare C-style arrays, use std::array<> instead
+                        // In C++14 and older, replaced with 'std::array<int, 3> a2 = {{1,2,3}}'
+                        // In C++17 and newer, replaced with 'std::array a2 = {1,2,3}'
+  }
+
 
 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
     }
   }
 
   }
 
 Similarly, the ``main()`` function is ignored. Its second and third parameters
 can be either ``char* argv[]`` or ``char** argv``, but cannot be
 ``std::array<>``.
+
+Options
+-------
+
+.. option:: IncludeStyle
+
+   A string specifying which include-style is used, `llvm` or `google`. Default
+   is `llvm`.

clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-cxx17.cpp

+// RUN: %check_clang_tidy -std=c++17 %s modernize-avoid-c-arrays %t
+
+//CHECK-FIXES: #include <array>
+
+template <class T1, class T2>
+struct Pair {
+  T1 t1;
+  T2 t2;
+};
+
+struct Obj1 {};
+struct Obj2 {
+  Obj2(const Obj1& = {});
+};
+
+struct StringRef {
+  StringRef(const char*);
+  StringRef(const StringRef&);
+};
+
+void ctad_replacements() {
+  const int ci1{}, ci2{};
+  int i1, i2;
+
+  int ar[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 10> ar;
+
+  int init[] = {1,2,3};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array init = {1,2,3};
+  int init2[3] = {1,2,3};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 3> init2 = { {1,2,3} };
+  char init3[] = "abcdef";
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 7> init3 = { "abcdef" };
+  char init4[] = "";
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 1> init4 = { "" };
+  char init5[] = {"abc"};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 4> init5 = { {"abc"} };
+  char init6[] = {"abc" "def"};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 7> init6 = { {"abc" "def"} };
+  int init7[] = {'c',2,3};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 3> init7 = { {'c',2,3} };
+  const int init8[] = {1,2,3};
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: const std::array init8 = {1,2,3};
+  int const init9[] = {1,2,3};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: const std::array init9 = {1,2,3};
+  int const init10[] = {i1, i2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: const std::array init10 = {i1, i2};
+  int const init11[] = {ci1, ci2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: const std::array init11 = {ci1, ci2};
+  int init12[] = {ci1, ci2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array init12 = {ci1, ci2};
+  constexpr volatile int static const init13[] = {1,2,3};
+  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: constexpr volatile static const std::array init13 = {1,2,3};
+  const Obj1 init14[] = {Obj1(), Obj1()};
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: const std::array init14 = {Obj1(), Obj1()};
+
+  using IntPair = Pair<int,int>;
+  IntPair init15[] = {IntPair{1,2}, IntPair{3,4}};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array init15 = {IntPair{1,2}, IntPair{3,4}};
+  using IntPair = Pair<int,int>;
+  IntPair init16[] = { {1,2}, {3,4} };
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<IntPair, 2> init16 = { { {1,2}, {3,4} } };
+
+  StringRef init17[] = {"a", "b"};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<StringRef, 2> init17 = { {"a", "b"} };
+  StringRef sr1(""),sr2("");
+  StringRef init18[] = {sr1, sr2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array init18 = {sr1, sr2};
+  StringRef init19[] = {StringRef(""), StringRef("")};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array init19 = {StringRef(""), StringRef("")};
+  StringRef init20[] = { {""} };
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<StringRef, 1> init20 = { { {""} } };
+  StringRef const init21[] = { StringRef{""} };
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: const std::array init21 = { StringRef{""} };
+
+  int x0,x1;
+  int* init22[] = {&x0, &x1};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array init22 = {&x0, &x1};
+  int*init23[] = {&x0, &x1};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array init23 = {&x0, &x1};
+  static thread_local int* const init24[] = {&x0, &x1};
+  // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: static thread_local const std::array init24 = {&x0, &x1};
+}
+
+void replace_cv_within_type() {
+  // FIXME: clang's AST TypeLoc etc do not give SourceLocations of individual
+  // qualifiers etc. In combined types (e.g. 'unsigned int') with a cv
+  // qualifier in the middle of the type (e.g., 'unsigned volatile int'), we
+  // do not support pulling the qualifier out to appear before the std::array
+  // decl.
+
+  unsigned const int ui1{}, ui2{};
+
+  unsigned volatile int ar1[] = {1u,2u};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: unsigned volatile int ar1[] = {1u,2u};
+  volatile unsigned int ar2[] = {1u,2u};
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: volatile std::array ar2 = {1u,2u};
+  unsigned int volatile ar3[] = {1u,2u};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: volatile std::array ar3 = {1u,2u};
+  unsigned const int* volatile ar4[] = {&ui1, &ui2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: volatile std::array ar4 = {&ui1, &ui2};
+}

clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp

-// RUN: %check_clang_tidy %s modernize-avoid-c-arrays %t
+// RUN: %check_clang_tidy -std=c++11 %s modernize-avoid-c-arrays %t
+
+//CHECK-FIXES: #include <array>
 
 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() {

 
 struct Bar {
 
   int f[3] = {1, 2};
 
   int j[1];
 };
 }
+
+template <class T> struct TStruct {};
+
+void replacements() {
+  int ar[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 10> ar;
+  TStruct<int> ar2[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<TStruct<int>, 10> ar2;
+  TStruct< int > ar3[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<TStruct< int >, 10> ar3;
+  int * ar4[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int *, 10> ar4;
+  int * /*comment*/ar5[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int *, 10> /*comment*/ar5;
+  volatile const int * ar6[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<volatile const int *, 10> ar6;
+  volatile int ar7[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: volatile std::array<int, 10> ar7;
+  int const * ar8[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int const *, 10> ar8;
+  int ar9[1];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 1> ar9;
+  static int volatile constexpr ar10[10] = {};
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: static volatile constexpr std::array<int, 10> ar10 = {{[{][{]}}{{[}][}]}};
+  thread_local int ar11[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: thread_local std::array<int, 10> ar11;
+  thread_local/*a*/int/*b*/ar12[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: thread_local/*a*/std::array<int, 10>/*b*/ar12;
+  /*a*/ int/*b*/ /*c*/*/*d*/ /*e*/ /*f*/ar13[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: /*a*/ std::array<int/*b*/ /*c*/*, 10>/*d*/ /*e*/ /*f*/ar13;
+  TStruct<int*> ar14[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<TStruct<int*>, 10> ar14;
+  volatile TStruct<const int*> ar15[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: volatile std::array<TStruct<const int*>, 10> ar15;
+  TStruct<int const*> ar16[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<TStruct<int const*>, 10> ar16;
+  TStruct<unsigned const int> ar17[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<TStruct<unsigned const int>, 10> ar17;
+  volatile int static thread_local * ar18[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: static thread_local std::array<volatile int *, 10> ar18;
+
+  // Note, there is a tab '\t' before the semicolon in the declaration below.
+  int ar19[3] ;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 3> ar19 ;
+
+  int
+  ar20[3];
+  // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 3>
+  // CHECK-FIXES-NEXT: ar20;
+
+  int init[] = {1,2,3};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 3> init = {{[{][{]}}1,2,3{{[}][}]}};
+  int init2[3] = {1,2,3};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 3> init2 = {{[{][{]}}1,2,3{{[}][}]}};
+  int init3[3] = {1,2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 3> init3 = {{[{][{]}}1,2{{[}][}]}};
+  char init4[] = "abcdef";
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 7> init4 = {"abcdef"};
+  wchar_t init5[] = L"abcdef";
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<wchar_t, 7> init5 = {L"abcdef"};
+  char init6[] = "";
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 1> init6 = {""};
+  char init7[] = "\0";
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 2> init7 = {"\0"};
+  char init8[] = {"abc"};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 4> init8 = {{[{][{]}}"abc"{{[}][}]}};
+  char init9[] = R"LONG(a
+  really
+  long
+  string)LONG";
+  // CHECK-MESSAGES: :[[@LINE-4]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 27> init9 = {R"LONG(a
+  // CHECK-FIXES-NEXT:   really
+  // CHECK-FIXES-NEXT:   long
+  // CHECK-FIXES-NEXT:   string)LONG"};
+  char init10[] = {"abc" "def"};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 7> init10 = {{[{][{]}}"abc" "def"{{[}][}]}};
+  const char* init11 = {nullptr};
+  const char* const init12[] = {"abc","def"};
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: const std::array<const char*, 2> init12 = {{[{][{]}}"abc","def"{{[}][}]}};
+  const char*const init13[] = {"abc","def"};
+  // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: const std::array<const char*, 2>init13 = {{[{][{]}}"abc","def"{{[}][}]}};
+
+  // CHECK-MESSAGES: :[[@LINE+2]]:9: warning: do not declare C-style arrays, use std::array<> instead
+#define NAME "ABC"
+  const char init14[] = NAME
+#if 1
+    " "
+#endif
+    ;
+
+  // Note: there are two tab '\t' characters between the 'int', '*', and 'init15' tokens below.
+  int  *  init15[1] = {nullptr};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int *, 1>  init15 = {{[{][{]}}nullptr{{[}][}]}};
+
+  int two_d[10][5];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: int two_d[10][5];
+  int three_d[10][5][3];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: int three_d[10][5][3];
+}
+
+void replace_cv_within_type() {
+  // FIXME: clang's AST TypeLoc etc do not give SourceLocations of individual
+  // qualifiers etc. In combined types (e.g. 'unsigned int') with a cv
+  // qualifier in the middle of the type (e.g., 'unsigned volatile int'), we
+  // do not support pulling the qualifier out to appear before the std::array
+  // decl.
+
+  unsigned volatile int ar1[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: unsigned volatile int ar1[10];
+  volatile unsigned int ar2[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: volatile std::array<unsigned int, 10> ar2;
+  unsigned int volatile ar3[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: volatile std::array<unsigned int, 10> ar3;
+  unsigned const int* volatile ar4[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: volatile std::array<unsigned const int*, 10> ar4;
+}
+
+void consumes_ptr(int*);
+void consumes_ptr(char*);
+void replacement_with_refs() {
+  int ar[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<int, 10> ar;
+
+  for (int i = 0; i != sizeof(ar)/sizeof(ar[0]); ++i) { ar[i]++; }
+  // CHECK-FIXES: for (int i = 0; i != sizeof(ar)/sizeof(ar[0]); ++i) { ar[i]++; }
+  for (int i: ar) {}
+  // CHECK-FIXES: for (int i: ar) {}
+
+  int* ptr = ar;
+  // CHECK-FIXES: int* ptr = ar.begin();
+  const int* cptr = ar;
+  // CHECK-FIXES: const int* cptr = ar.begin();
+  ptr = (ar+1);
+  // CHECK-FIXES: ptr = (ar.begin()+1);
+
+  int a;
+  a = ar[0] + (ar)[1] + ((ar))[2];
+  // CHECK-FIXES: a = ar[0] + (ar)[1] + ((ar))[2];
+  a = 0[ar] + (0)[ar] + 0[(ar)];
+  // CHECK-FIXES: a = ar[0] + ar[(0)] + (ar)[0];
+  a = *(ar+2);
+  // CHECK-FIXES: a = *(ar.begin()+2);
+  consumes_ptr(ar);
+  // CHECK-FIXES: consumes_ptr(ar.begin());
+
+  unsigned sz = sizeof(ar) + sizeof((ar)) + sizeof(ar[0]) + sizeof ar;
+  // CHECK-FIXES: unsigned sz = sizeof(ar) + sizeof((ar)) + sizeof(ar[0]) + sizeof ar;
+}
+
+void replacement_with_refs_string_array() {
+  char str[] = {"abcdef"};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<char, 7> str = {{[{][{]}}"abcdef"{{[}][}]}};
+
+  consumes_ptr(str);
+  // CHECK-FIXES: consumes_ptr(str.begin());
+
+  char* cp;
+  cp = str + 0;
+  // CHECK-FIXES: cp = str.begin() + 0;
+  cp = str + 1;
+  // CHECK-FIXES: cp = str.begin() + 1;
+  cp = &str[0];
+  // CHECK-FIXES: cp = &str[0];
+}
+
+void cannot_replace_reference_taken() {
+  int ar[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  int (&ref)[10] = ar;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+}
+
+struct SomeClass {
+  void fn1(int);
+  void fn2(int);
+};
+void fn1(int);
+void fn2(int);
+void cannot_replace_array_of_function_pointers() {
+  void (*fns1[])(int) = {fn1, fn2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+
+  using FnPtr = void(*)(int);
+  FnPtr fns2[] = {fn1, fn2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+
+  void (SomeClass::*fns3[])(int) = {&SomeClass::fn1, &SomeClass::fn2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+
+  using MemFnPtr = void(SomeClass::*)(int);
+  MemFnPtr fns4[] = {&SomeClass::fn1, &SomeClass::fn2};
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+}
+
+void consume_array_ref(int (&)[10]);
+// CHECK-MESSAGES: :[[@LINE-1]]:24: warning: do not declare C-style arrays, use std::array<> instead
+void cannot_replace_reference_taken_in_call() {
+  int ar[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  consume_array_ref(ar);
+}
+
+void vla_not_replaced(int n) {
+  int ar[n];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C VLA arrays, use std::vector<> instead
+}
+
+struct Obj1 {};
+struct Obj2 {
+  Obj2(const Obj1& = {});
+};
+void init_expr_with_temp() {
+  Obj2 ar[] = { {} };
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+  // CHECK-FIXES: std::array<Obj2, 1> ar = {{[{][{]}} {} {{[}][}]}};
+}
+
+struct AStruct {
+  #define DEFINES_METHOD_WITH_ARRAY void method() { int ar[10]; }
+  DEFINES_METHOD_WITH_ARRAY
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+};
+
+void macros_not_replaced() {
+  int d[3];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use std::array<> instead
+#define EXPANDS_X(x) x
+  EXPANDS_X(consumes_ptr(d));
+}
+
+void attrs_not_replaced() {
+  [[maybe_unused]] int ar1[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: do not declare C-style arrays, use std::array<> instead
+  __attribute__((__unused__)) int ar2[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: do not declare C-style arrays, use std::array<> instead
+}