[clang-tidy] do not diagnose array types within implicit instantiations of a template #132924

stmuench · 2025-03-25T12:17:01Z

So far, the clang-tidy check modernize-avoid-c-arrays also diagnosed array types for type template parameters even though no actual array type got written there but it got deduced to one. In such case, there is nothing a developer can do at that location to fix the diagnostic. Since in this case, the location where the template got actually instantiated would have to be adjusted. And this is in most cases some totally distant code where implementers of a template do not have access to. Also adding suppressions to the declaration of the template is not an option since that would clutter the code unnecessarily and is in many cases also simply not possible (e.g. for users of a template). Hence, we propose to not diagnose any occurrence of an array type in an implicit instantiation of a template but rather at the point where template arguments involve array types.

github-actions · 2025-03-25T12:17:20Z

Thank you for submitting a Pull Request (PR) to the LLVM Project!

This PR will be automatically labeled and the relevant teams will be notified.

If you wish to, you can add reviewers by using the "Reviewers" section on this page.

If this is not working for you, it is probably because you do not have write permissions for the repository. In which case you can instead tag reviewers by name in a comment by using @ followed by their GitHub username.

If you have received no comments on your PR for a week, you can request a review by "ping"ing the PR by adding a comment “Ping”. The common courtesy "ping" rate is once a week. Please remember that you are asking for valuable time from other developers.

If you have further questions, they may be answered by the LLVM GitHub User Guide.

You can also ask questions in a comment on this PR, on the LLVM Discord or on the forums.

llvmbot · 2025-03-25T18:13:25Z

@llvm/pr-subscribers-clang-tools-extra

Author: St. Muench (stmuench)

Changes

So far, the clang-tidy check modernize-avoid-c-arrays also diagnosed array types for type template parameters even though no actual array type got written there but it got deduced to one. In such case, there is nothing a developer can do at that location to fix the diagnostic. Since actually, the location where the template got instantiated would have to be adjusted. And this is in most cases some totally distant code where implementers of a template do not have access to. Also adding suppressions to the declaration of the template is not an option since that would clutter the code unnecessarily and is in many cases also simply not possible. Hence, we propose to not diagnose any occurrence of an array type in an implicit instantiation of a template but rather at the point where template arguments involve array types.

Full diff: https://github.com/llvm/llvm-project/pull/132924.diff

3 Files Affected:

(modified) clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp (+56-4)
(modified) clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp (+12)
(modified) clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp (+159)

diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp b/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
index 0804aa76d953c..e26b8cf885ea3 100644
--- a/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
@@ -39,6 +39,30 @@ AST_MATCHER(clang::ParmVarDecl, isArgvOfMain) {
   return FD ? FD->isMain() : false;
 }
 
+bool isWithinImplicitTemplateInstantiation(const TypeLoc *ArrayType,
+                                           ASTContext *Context) {
+  const auto IsImplicitTemplateInstantiation = [](const auto *Node) {
+    return (Node != nullptr) &&
+           (Node->getTemplateSpecializationKind() == TSK_ImplicitInstantiation);
+  };
+
+  auto ParentNodes = Context->getParents(*ArrayType);
+  while (!ParentNodes.empty()) {
+    const auto &ParentNode = ParentNodes[0];
+    if (IsImplicitTemplateInstantiation(
+            ParentNode.template get<clang::CXXRecordDecl>()) ||
+        IsImplicitTemplateInstantiation(
+            ParentNode.template get<clang::FunctionDecl>()) ||
+        IsImplicitTemplateInstantiation(
+            ParentNode.template get<clang::VarDecl>())) {
+      return true;
+    }
+    ParentNodes = Context->getParents(ParentNode);
+  }
+
+  return false;
+}
+
 } // namespace
 
 AvoidCArraysCheck::AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context)
@@ -70,18 +94,45 @@ void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
               std::move(IgnoreStringArrayIfNeededMatcher))
           .bind("typeloc"),
       this);
+
+  Finder->addMatcher(templateArgumentLoc(hasTypeLoc(
+                         loc(arrayType()).bind("typeloc_in_template_arg"))),
+                     this);
 }
 
 void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
+  clang::TypeLoc ArrayTypeLoc{};
+
+  if (const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
+      ArrayType != nullptr &&
+      not(isWithinImplicitTemplateInstantiation(ArrayType, Result.Context))) {
+    ArrayTypeLoc = *ArrayType;
+  }
+
+  if (const auto *ArrayTypeInTemplateArg =
+          Result.Nodes.getNodeAs<TypeLoc>("typeloc_in_template_arg");
+      ArrayTypeInTemplateArg != nullptr) {
+    if (ArrayTypeInTemplateArg->getSourceRange() !=
+        ArrayTypeInTemplateArg->getLocalSourceRange()) {
+      // only in case the above condition is fulfilled, we matched a written
+      // array type and not a template type parameter which got deduced to one
+      ArrayTypeLoc = *ArrayTypeInTemplateArg;
+    }
+  }
+
+  // check whether the match result is a real array type (based on above checks)
+  if (ArrayTypeLoc.isNull()) {
+    return;
+  }
+
   const bool IsInParam =
       Result.Nodes.getNodeAs<ParmVarDecl>("param_decl") != nullptr;
-  const bool IsVLA = ArrayType->getTypePtr()->isVariableArrayType();
+  const bool IsVLA = ArrayTypeLoc.getTypePtr()->isVariableArrayType();
   enum class RecommendType { Array, Vector, Span };
   llvm::SmallVector<const char *> RecommendTypes{};
   if (IsVLA) {
     RecommendTypes.push_back("'std::vector'");
-  } else if (ArrayType->getTypePtr()->isIncompleteArrayType() && IsInParam) {
+  } else if (ArrayTypeLoc.getTypePtr()->isIncompleteArrayType() && IsInParam) {
     // in function parameter, we also don't know the size of
     // IncompleteArrayType.
     if (Result.Context->getLangOpts().CPlusPlus20)
@@ -93,7 +144,8 @@ void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
   } else {
     RecommendTypes.push_back("'std::array'");
   }
-  diag(ArrayType->getBeginLoc(),
+
+  diag(ArrayTypeLoc.getBeginLoc(),
        "do not declare %select{C-style|C VLA}0 arrays, use %1 instead")
       << IsVLA << llvm::join(RecommendTypes, " or ");
 }
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp
index 906663828a547..18458bd47d347 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp
@@ -7,3 +7,15 @@ const char array[] = {'n', 'a', 'm', 'e', '\0'};
 
 void takeCharArray(const char name[]);
 // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: do not declare C-style arrays, use 'std::array' or 'std::vector' instead [modernize-avoid-c-arrays]
+
+template <typename T = const char[10], typename U = char[10], char[10]>
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-2]]:53: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-3]]:63: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+void func() {}
+
+template <typename T = const char[], typename U = char[], char[]>
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-2]]:51: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-3]]:59: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+void fun() {}
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
index 14eb2852c639a..0b474cc69db36 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
@@ -92,3 +92,162 @@ const char name[] = "Some string";
 
 void takeCharArray(const char name[]);
 // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: do not declare C-style arrays, use 'std::array' or 'std::vector' instead [modernize-avoid-c-arrays]
+
+namespace std {
+  template<class T, class U>
+  struct is_same { constexpr static bool value{false}; };
+
+  template<class T>
+  struct is_same<T, T> { constexpr static bool value{true}; };
+
+  template<class T, class U>
+  constexpr bool is_same_v = is_same<T, U>::value;
+
+  template<class T> struct remove_const { typedef T type; };
+  template<class T> struct remove_const<const T> { typedef T type; };
+
+  template<class T>
+  using remove_const_t = typename remove_const<T>::type;
+
+  template<bool B, class T = void> struct enable_if {};
+  template<class T> struct enable_if<true, T> { typedef T type; };
+
+  template< bool B, class T = void >
+  using enable_if_t = typename enable_if<B, T>::type;
+}
+
+// below, no array type findings are expected within the template parameter declarations since no array type gets written explicitly
+template <typename T,
+          bool = std::is_same_v<T, int>,
+          bool = std::is_same<T, int>::value,
+          bool = std::is_same_v<std::remove_const_t<T>, int>,
+          bool = std::is_same<std::remove_const_t<T>, int>::value,
+          bool = std::is_same_v<typename std::remove_const<T>::type, int>,
+          bool = std::is_same<typename std::remove_const<T>::type, int>::value,
+          std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>), bool> = true,
+          typename std::enable_if<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>), bool>::type = true,
+          typename = std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>)>,
+          typename = typename std::remove_const<T>::type,
+          typename = std::remove_const_t<T>>
+class MyClassTemplate {
+ public:
+  // here, plenty of array type findings are expected for below template parameter declarations since array types get written explicitly
+  template <typename U = T,
+            bool = std::is_same_v<U, int[]>,
+            // CHECK-MESSAGES: :[[@LINE-1]]:38: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            bool = std::is_same<U, int[10]>::value,
+            // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            std::enable_if_t<not(std::is_same_v<std::remove_const_t<U>, int[]>) && not(std::is_same_v<typename std::remove_const<U>::type, char[10]>), bool> = true,
+            // CHECK-MESSAGES: :[[@LINE-1]]:73: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            // CHECK-MESSAGES: :[[@LINE-2]]:140: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            typename = typename std::remove_const<int[10]>::type,
+            // CHECK-MESSAGES: :[[@LINE-1]]:51: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            typename = std::remove_const_t<int[]>>
+            // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+    class MyInnerClassTemplate {
+     public:
+      MyInnerClassTemplate(const U&) {}
+     private:
+      U field[3];
+      // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+    };
+
+    MyClassTemplate(const T&) {}
+
+ private:
+    T field[7];
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+};
+
+// an explicit instantiation
+template
+class MyClassTemplate<int[2]>;
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+using MyArrayType = int[3];
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+// another explicit instantiation
+template
+class MyClassTemplate<MyArrayType>;
+
+// below, no array type findings are expected within the template parameter declarations since no array type gets written explicitly
+template <typename T,
+          bool = std::is_same_v<T, int>,
+          bool = std::is_same<T, int>::value,
+          bool = std::is_same_v<std::remove_const_t<T>, int>,
+          bool = std::is_same<std::remove_const_t<T>, int>::value,
+          bool = std::is_same_v<typename std::remove_const<T>::type, int>,
+          bool = std::is_same<typename std::remove_const<T>::type, int>::value,
+          std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>), bool> = true,
+          typename std::enable_if<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>), bool>::type = true,
+          typename = std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>)>,
+          typename = typename std::remove_const<T>::type,
+          typename = std::remove_const_t<T>>
+void func(const T& param) {
+  int array1[1];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  T array2[2];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  T value;
+}
+
+// here, plenty of array type findings are expected for below template parameter declarations since array types get written explicitly
+template <typename T = int[],
+          // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          bool = std::is_same_v<T, int[]>,
+          // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          bool = std::is_same<T, int[10]>::value,
+          // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int[]>) && not(std::is_same_v<typename std::remove_const<T>::type, char[10]>), bool> = true,
+          // CHECK-MESSAGES: :[[@LINE-1]]:71: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          // CHECK-MESSAGES: :[[@LINE-2]]:138: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          typename = typename std::remove_const<int[10]>::type,
+          // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          typename = std::remove_const_t<int[]>>
+          // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+void fun(const T& param) {
+  int array3[3];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  T array4[4];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  T value;
+}
+
+template<typename T>
+T some_constant{};
+
+// explicit instantiation
+template
+int some_constant<int[5]>[5];
+// FIXME: why no diagnostics here?
+
+// explicit specialization
+template<>
+int some_constant<int[7]>[7]{};
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-2]]:19: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+void testArrayInTemplateType() {
+  int t[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  func(t);
+  fun(t);
+
+  func<decltype(t)>({});
+  fun<decltype(t)>({});
+
+  MyClassTemplate var1{t};
+  MyClassTemplate<decltype(t)> var2{{}};
+
+  decltype(var1)::MyInnerClassTemplate var3{t};
+  decltype(var1)::MyInnerClassTemplate<decltype(t)> var4{{}};
+
+  MyClassTemplate<decltype(t)>::MyInnerClassTemplate var5{t};
+  MyClassTemplate<decltype(t)>::MyInnerClassTemplate<decltype(t)> var6{{}};
+}

llvmbot · 2025-03-25T18:13:26Z

@llvm/pr-subscribers-clang-tidy

Author: St. Muench (stmuench)

Changes

So far, the clang-tidy check modernize-avoid-c-arrays also diagnosed array types for type template parameters even though no actual array type got written there but it got deduced to one. In such case, there is nothing a developer can do at that location to fix the diagnostic. Since actually, the location where the template got instantiated would have to be adjusted. And this is in most cases some totally distant code where implementers of a template do not have access to. Also adding suppressions to the declaration of the template is not an option since that would clutter the code unnecessarily and is in many cases also simply not possible. Hence, we propose to not diagnose any occurrence of an array type in an implicit instantiation of a template but rather at the point where template arguments involve array types.

Full diff: https://github.com/llvm/llvm-project/pull/132924.diff

3 Files Affected:

(modified) clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp (+56-4)
(modified) clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp (+12)
(modified) clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp (+159)

diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp b/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
index 0804aa76d953c..e26b8cf885ea3 100644
--- a/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
@@ -39,6 +39,30 @@ AST_MATCHER(clang::ParmVarDecl, isArgvOfMain) {
   return FD ? FD->isMain() : false;
 }
 
+bool isWithinImplicitTemplateInstantiation(const TypeLoc *ArrayType,
+                                           ASTContext *Context) {
+  const auto IsImplicitTemplateInstantiation = [](const auto *Node) {
+    return (Node != nullptr) &&
+           (Node->getTemplateSpecializationKind() == TSK_ImplicitInstantiation);
+  };
+
+  auto ParentNodes = Context->getParents(*ArrayType);
+  while (!ParentNodes.empty()) {
+    const auto &ParentNode = ParentNodes[0];
+    if (IsImplicitTemplateInstantiation(
+            ParentNode.template get<clang::CXXRecordDecl>()) ||
+        IsImplicitTemplateInstantiation(
+            ParentNode.template get<clang::FunctionDecl>()) ||
+        IsImplicitTemplateInstantiation(
+            ParentNode.template get<clang::VarDecl>())) {
+      return true;
+    }
+    ParentNodes = Context->getParents(ParentNode);
+  }
+
+  return false;
+}
+
 } // namespace
 
 AvoidCArraysCheck::AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context)
@@ -70,18 +94,45 @@ void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
               std::move(IgnoreStringArrayIfNeededMatcher))
           .bind("typeloc"),
       this);
+
+  Finder->addMatcher(templateArgumentLoc(hasTypeLoc(
+                         loc(arrayType()).bind("typeloc_in_template_arg"))),
+                     this);
 }
 
 void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
+  clang::TypeLoc ArrayTypeLoc{};
+
+  if (const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
+      ArrayType != nullptr &&
+      not(isWithinImplicitTemplateInstantiation(ArrayType, Result.Context))) {
+    ArrayTypeLoc = *ArrayType;
+  }
+
+  if (const auto *ArrayTypeInTemplateArg =
+          Result.Nodes.getNodeAs<TypeLoc>("typeloc_in_template_arg");
+      ArrayTypeInTemplateArg != nullptr) {
+    if (ArrayTypeInTemplateArg->getSourceRange() !=
+        ArrayTypeInTemplateArg->getLocalSourceRange()) {
+      // only in case the above condition is fulfilled, we matched a written
+      // array type and not a template type parameter which got deduced to one
+      ArrayTypeLoc = *ArrayTypeInTemplateArg;
+    }
+  }
+
+  // check whether the match result is a real array type (based on above checks)
+  if (ArrayTypeLoc.isNull()) {
+    return;
+  }
+
   const bool IsInParam =
       Result.Nodes.getNodeAs<ParmVarDecl>("param_decl") != nullptr;
-  const bool IsVLA = ArrayType->getTypePtr()->isVariableArrayType();
+  const bool IsVLA = ArrayTypeLoc.getTypePtr()->isVariableArrayType();
   enum class RecommendType { Array, Vector, Span };
   llvm::SmallVector<const char *> RecommendTypes{};
   if (IsVLA) {
     RecommendTypes.push_back("'std::vector'");
-  } else if (ArrayType->getTypePtr()->isIncompleteArrayType() && IsInParam) {
+  } else if (ArrayTypeLoc.getTypePtr()->isIncompleteArrayType() && IsInParam) {
     // in function parameter, we also don't know the size of
     // IncompleteArrayType.
     if (Result.Context->getLangOpts().CPlusPlus20)
@@ -93,7 +144,8 @@ void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
   } else {
     RecommendTypes.push_back("'std::array'");
   }
-  diag(ArrayType->getBeginLoc(),
+
+  diag(ArrayTypeLoc.getBeginLoc(),
        "do not declare %select{C-style|C VLA}0 arrays, use %1 instead")
       << IsVLA << llvm::join(RecommendTypes, " or ");
 }
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp
index 906663828a547..18458bd47d347 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp
@@ -7,3 +7,15 @@ const char array[] = {'n', 'a', 'm', 'e', '\0'};
 
 void takeCharArray(const char name[]);
 // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: do not declare C-style arrays, use 'std::array' or 'std::vector' instead [modernize-avoid-c-arrays]
+
+template <typename T = const char[10], typename U = char[10], char[10]>
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-2]]:53: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-3]]:63: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+void func() {}
+
+template <typename T = const char[], typename U = char[], char[]>
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-2]]:51: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-3]]:59: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+void fun() {}
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
index 14eb2852c639a..0b474cc69db36 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
@@ -92,3 +92,162 @@ const char name[] = "Some string";
 
 void takeCharArray(const char name[]);
 // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: do not declare C-style arrays, use 'std::array' or 'std::vector' instead [modernize-avoid-c-arrays]
+
+namespace std {
+  template<class T, class U>
+  struct is_same { constexpr static bool value{false}; };
+
+  template<class T>
+  struct is_same<T, T> { constexpr static bool value{true}; };
+
+  template<class T, class U>
+  constexpr bool is_same_v = is_same<T, U>::value;
+
+  template<class T> struct remove_const { typedef T type; };
+  template<class T> struct remove_const<const T> { typedef T type; };
+
+  template<class T>
+  using remove_const_t = typename remove_const<T>::type;
+
+  template<bool B, class T = void> struct enable_if {};
+  template<class T> struct enable_if<true, T> { typedef T type; };
+
+  template< bool B, class T = void >
+  using enable_if_t = typename enable_if<B, T>::type;
+}
+
+// below, no array type findings are expected within the template parameter declarations since no array type gets written explicitly
+template <typename T,
+          bool = std::is_same_v<T, int>,
+          bool = std::is_same<T, int>::value,
+          bool = std::is_same_v<std::remove_const_t<T>, int>,
+          bool = std::is_same<std::remove_const_t<T>, int>::value,
+          bool = std::is_same_v<typename std::remove_const<T>::type, int>,
+          bool = std::is_same<typename std::remove_const<T>::type, int>::value,
+          std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>), bool> = true,
+          typename std::enable_if<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>), bool>::type = true,
+          typename = std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>)>,
+          typename = typename std::remove_const<T>::type,
+          typename = std::remove_const_t<T>>
+class MyClassTemplate {
+ public:
+  // here, plenty of array type findings are expected for below template parameter declarations since array types get written explicitly
+  template <typename U = T,
+            bool = std::is_same_v<U, int[]>,
+            // CHECK-MESSAGES: :[[@LINE-1]]:38: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            bool = std::is_same<U, int[10]>::value,
+            // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            std::enable_if_t<not(std::is_same_v<std::remove_const_t<U>, int[]>) && not(std::is_same_v<typename std::remove_const<U>::type, char[10]>), bool> = true,
+            // CHECK-MESSAGES: :[[@LINE-1]]:73: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            // CHECK-MESSAGES: :[[@LINE-2]]:140: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            typename = typename std::remove_const<int[10]>::type,
+            // CHECK-MESSAGES: :[[@LINE-1]]:51: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+            typename = std::remove_const_t<int[]>>
+            // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+    class MyInnerClassTemplate {
+     public:
+      MyInnerClassTemplate(const U&) {}
+     private:
+      U field[3];
+      // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+    };
+
+    MyClassTemplate(const T&) {}
+
+ private:
+    T field[7];
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+};
+
+// an explicit instantiation
+template
+class MyClassTemplate<int[2]>;
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+using MyArrayType = int[3];
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+// another explicit instantiation
+template
+class MyClassTemplate<MyArrayType>;
+
+// below, no array type findings are expected within the template parameter declarations since no array type gets written explicitly
+template <typename T,
+          bool = std::is_same_v<T, int>,
+          bool = std::is_same<T, int>::value,
+          bool = std::is_same_v<std::remove_const_t<T>, int>,
+          bool = std::is_same<std::remove_const_t<T>, int>::value,
+          bool = std::is_same_v<typename std::remove_const<T>::type, int>,
+          bool = std::is_same<typename std::remove_const<T>::type, int>::value,
+          std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>), bool> = true,
+          typename std::enable_if<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>), bool>::type = true,
+          typename = std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>)>,
+          typename = typename std::remove_const<T>::type,
+          typename = std::remove_const_t<T>>
+void func(const T& param) {
+  int array1[1];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  T array2[2];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  T value;
+}
+
+// here, plenty of array type findings are expected for below template parameter declarations since array types get written explicitly
+template <typename T = int[],
+          // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          bool = std::is_same_v<T, int[]>,
+          // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          bool = std::is_same<T, int[10]>::value,
+          // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int[]>) && not(std::is_same_v<typename std::remove_const<T>::type, char[10]>), bool> = true,
+          // CHECK-MESSAGES: :[[@LINE-1]]:71: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          // CHECK-MESSAGES: :[[@LINE-2]]:138: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          typename = typename std::remove_const<int[10]>::type,
+          // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+          typename = std::remove_const_t<int[]>>
+          // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+void fun(const T& param) {
+  int array3[3];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  T array4[4];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  T value;
+}
+
+template<typename T>
+T some_constant{};
+
+// explicit instantiation
+template
+int some_constant<int[5]>[5];
+// FIXME: why no diagnostics here?
+
+// explicit specialization
+template<>
+int some_constant<int[7]>[7]{};
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-2]]:19: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+void testArrayInTemplateType() {
+  int t[10];
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+
+  func(t);
+  fun(t);
+
+  func<decltype(t)>({});
+  fun<decltype(t)>({});
+
+  MyClassTemplate var1{t};
+  MyClassTemplate<decltype(t)> var2{{}};
+
+  decltype(var1)::MyInnerClassTemplate var3{t};
+  decltype(var1)::MyInnerClassTemplate<decltype(t)> var4{{}};
+
+  MyClassTemplate<decltype(t)>::MyInnerClassTemplate var5{t};
+  MyClassTemplate<decltype(t)>::MyInnerClassTemplate<decltype(t)> var6{{}};
+}

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

stmuench · 2025-04-03T16:51:01Z

Ping

stmuench · 2025-04-28T19:13:30Z

@PiotrZSL if it suits your convenience, could you maybe have a look at this PR? Many thanks in advance.

vbvictor

Please add release notes in this patch.
I think the idea is good, but you can look into my review after PiotrZSL's comments.

vbvictor · 2025-04-29T06:10:01Z

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

@@ -39,6 +39,30 @@ AST_MATCHER(clang::ParmVarDecl, isArgvOfMain) {
  return FD ? FD->isMain() : false;
 }

+bool isWithinImplicitTemplateInstantiation(const TypeLoc *MatchedTypeLoc,


Could you please elaborate what is this function for?
I deleted its call in not(isWithinImplicitTemplateInstantiation(...)) and all tests passed.
I suggest we can delete this function or add tests cases to cover added behavior.

Also, if this function is still needed, we should move it to matchers.
The easy way is to write

AST_MATCHER(clang::TypeLoc, isWithinImplicitTemplateInstantiation) { ... }

And add it to

unless(anyOf( hasParent(parmVarDecl(isArgvOfMain())), hasParent(varDecl(isExternC())), hasParent(fieldDecl(hasParent(recordDecl(isExternCContext())))), hasAncestor(functionDecl(isExternC())), isWithinImplicitTemplateInstantiation())),

But I think that this function should not be even needed because we can write something like:

AST_POLYMORPHIC_MATCHER(isImplicitTemplateSpecialization, AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, VarDecl, CXXRecordDecl)) { return (Node.getTemplateSpecializationKind() == TSK_ImplicitInstantiation); } auto IsInImplicitTemplateInstantiation = anyOf(hasAncestor(cxxRecordDecl(isImplicitTemplateSpecialization())), hasAncestor(functionDecl(isImplicitTemplateSpecialization())), hasAncestor(varDecl(isImplicitTemplateSpecialization()))); Finder->addMatcher( typeLoc(hasValidBeginLoc(), hasType(arrayType()), unless(IsInImplicitTemplateInstantiation), //...

I guess example will have the same semantics as your function.

I tried to implement it this way at first but unfortunately the hasAncestor matcher seems to not work correctly for matched TypeLocs. The reason for that is not clear to me at all. That's why I added a manual implementation as workaround.

Could you please elaborate what is this function for? I deleted its call in not(isWithinImplicitTemplateInstantiation(...)) and all tests passed. I suggest we can delete this function or add tests cases to cover added behavior.

If I remove this function on my side, the unit tests start to fail since diagnostics get emitted then for implicit template instantiations.

Hmm, I will try rerunning tests. I thought that all new tests cases came from "template_arg_with_array_type_loc" matcher.

Still, isn't it strange that you narrowed "typeloc" matcher with new isWithinImplicitTemplateInstantiation() call but did not delete any CHECK-MESSAGES from existing test cases?

Maybe previous devs did not cover all cases, so you didn't have to delete and check-messages

Precisely, there were no template types so far in the existing unit tests which got deduced to array types and which were then (unintentionally) diagnosed as such.
That's why I added some.

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

stmuench · 2025-04-30T14:13:18Z

Please add release notes in this patch. I think the idea is good, but you can look into my review after PiotrZSL's comments.

@vbvictor many thanks for your very valuable comments. I incorporated them as far as possible.

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

stmuench · 2025-05-06T10:11:10Z

@PiotrZSL would you have any further remarks for this PR?

stmuench · 2025-05-15T11:17:37Z

@vbvictor since is there no further activity by reviewers here, any idea on how to continue with this PR?

vbvictor · 2025-05-17T14:38:55Z

For now, I think you should wait for an approval/review from one of the clang-tidy maintainers (PiotrZSL, HerrCai0907) that will also help merge this PR. It can take some time, but the new release will only be in July, so don't need to worry about missing your changes for now.
You should "Ping" reviewers with 1-2 week period.

stmuench · 2025-06-25T21:14:27Z

Ping

stmuench · 2025-07-14T18:31:00Z

Ping

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

5chmidti · 2025-07-14T20:26:52Z

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

@@ -66,22 +89,45 @@ void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
                           hasParent(varDecl(isExternC())),
                           hasParent(fieldDecl(
                               hasParent(recordDecl(isExternCContext())))),
-                           hasAncestor(functionDecl(isExternC())))),
+                           hasAncestor(functionDecl(isExternC())),
+                           isWithinImplicitTemplateInstantiation())),


Thinking oud-loud: I'm actually a bit surprised that this whole issue even exists, since the check's traversal kind is set to IgnoreUnlessSpelledInSource

True. Maybe due to an issue in AST Visitor or even AST itself which leads to template arguments of implicit instantiations not getting recognized as implicit ones?
But I am unfortunately lacking knowlege in that area. In case you have ideas how to check this, please share :)

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

vbvictor

Tests lgtm, minor comments on code.
Please rebase on fresh main

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

stmuench · 2025-08-20T20:58:24Z

@5chmidti @vbvictor many thanks for your suggestions, I incorporated all of them

So far, the clang-tidy check `modernize-avoid-c-arrays` also diagnosed array types for type template parameters even though no actual array type got written there but it got deduced to one. In such case, there is nothing a developer can do at that location to fix the diagnostic. Since actually, the location where the template got instantiated would have to be adjusted. And this is in most cases some totally distant code where implementers of a template do not have access to. Also adding suppressions to the declaration of the template is not an option since that would clutter the code unnecessarily and is in many cases also simply not possible. Hence, we propose to not diagnose any occurrence of an array type in an implicit instantiation of a template but rather at the point where template arguments involve array types.

stmuench mentioned this pull request Mar 25, 2025

[clang-tidy] offer option to check sugared types in avoid-c-arrays check #131468

Open

stmuench force-pushed the sm_revise_avoid_c_arrays_check branch 2 times, most recently from 823475c to 8b720d2 Compare March 25, 2025 18:11

stmuench marked this pull request as ready for review March 25, 2025 18:12

llvmbot added clang-tools-extra clang-tidy labels Mar 25, 2025

stmuench commented Mar 25, 2025

View reviewed changes

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

stmuench commented Mar 26, 2025

View reviewed changes

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

EugeneZelenko requested review from HerrCai0907 and PiotrZSL March 26, 2025 14:37

stmuench force-pushed the sm_revise_avoid_c_arrays_check branch 2 times, most recently from 29cfb29 to 7f621bc Compare April 28, 2025 19:10

vbvictor reviewed Apr 29, 2025

View reviewed changes

stmuench force-pushed the sm_revise_avoid_c_arrays_check branch from 7f621bc to fb9f0c3 Compare April 30, 2025 14:11

vbvictor reviewed Apr 30, 2025

View reviewed changes

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp Outdated Show resolved Hide resolved

vbvictor reviewed Apr 30, 2025

View reviewed changes

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp Outdated Show resolved Hide resolved

stmuench force-pushed the sm_revise_avoid_c_arrays_check branch from fb9f0c3 to 1216ef5 Compare May 6, 2025 10:09

stmuench requested a review from vbvictor May 6, 2025 10:10

vbvictor requested a review from 5chmidti June 25, 2025 21:34

5chmidti reviewed Jul 14, 2025

View reviewed changes

vbvictor reviewed Jul 14, 2025

View reviewed changes

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp Outdated Show resolved Hide resolved

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp Outdated Show resolved Hide resolved

stmuench force-pushed the sm_revise_avoid_c_arrays_check branch from 1216ef5 to ef2c51b Compare August 20, 2025 20:56

stmuench force-pushed the sm_revise_avoid_c_arrays_check branch from ef2c51b to 9d8acb1 Compare August 20, 2025 21:01

[clang-tidy] do not diagnose array types within implicit instantiations of a template #132924

Are you sure you want to change the base?

[clang-tidy] do not diagnose array types within implicit instantiations of a template #132924

Uh oh!

Conversation

stmuench commented Mar 25, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions bot commented Mar 25, 2025

Uh oh!

llvmbot commented Mar 25, 2025

Uh oh!

llvmbot commented Mar 25, 2025

Uh oh!

Uh oh!

Uh oh!

stmuench commented Apr 3, 2025

Uh oh!

stmuench commented Apr 28, 2025

Uh oh!

vbvictor left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

vbvictor Apr 29, 2025

Choose a reason for hiding this comment

Uh oh!

vbvictor Apr 29, 2025

Choose a reason for hiding this comment

Uh oh!

stmuench Apr 30, 2025

Choose a reason for hiding this comment

Uh oh!

stmuench Apr 30, 2025

Choose a reason for hiding this comment

Uh oh!

vbvictor Apr 30, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

vbvictor Apr 30, 2025

Choose a reason for hiding this comment

Uh oh!

stmuench Apr 30, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

stmuench commented Apr 30, 2025

Uh oh!

Uh oh!

Uh oh!

stmuench commented May 6, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

stmuench commented May 15, 2025

Uh oh!

vbvictor commented May 17, 2025

Uh oh!

stmuench commented Jun 25, 2025

Uh oh!

stmuench commented Jul 14, 2025

Uh oh!

Uh oh!

Uh oh!

5chmidti Jul 14, 2025

Choose a reason for hiding this comment

Uh oh!

stmuench Jul 19, 2025

Choose a reason for hiding this comment

Uh oh!

Uh oh!

vbvictor left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

stmuench commented Aug 20, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

stmuench commented Mar 25, 2025 •

edited

Loading

vbvictor left a comment •

edited

Loading

vbvictor Apr 30, 2025 •

edited

Loading

stmuench Apr 30, 2025 •

edited

Loading

stmuench commented May 6, 2025 •

edited

Loading

stmuench commented Aug 20, 2025 •

edited

Loading