[clang-tools-extra] [clang-tidy] Add portability-avoid-platform-specific-fundamental-types (PR #146970)
JJ Marr via cfe-commits
cfe-commits at lists.llvm.org
Thu Jul 3 19:29:27 PDT 2025
https://github.com/jj-marr updated https://github.com/llvm/llvm-project/pull/146970
>From 3ef4feb748551806c863529306fefb2bd914e5be Mon Sep 17 00:00:00 2001
From: JJ Marr <jjmarr at gmail.com>
Date: Thu, 3 Jul 2025 17:17:06 -0400
Subject: [PATCH 1/6] AvoidFundamentalIntegerTypesCheck
---
.../AvoidFundamentalIntegerTypesCheck.cpp | 183 ++++++++++++++++++
.../AvoidFundamentalIntegerTypesCheck.h | 46 +++++
.../clang-tidy/modernize/CMakeLists.txt | 1 +
.../modernize/ModernizeTidyModule.cpp | 3 +
.../avoid-fundamental-integer-types.cpp | 108 +++++++++++
5 files changed, 341 insertions(+)
create mode 100644 clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp
create mode 100644 clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h
create mode 100644 clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp
diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp b/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp
new file mode 100644
index 0000000000000..8a393bc894cfe
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp
@@ -0,0 +1,183 @@
+//===--- AvoidFundamentalIntegerTypesCheck.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 "AvoidFundamentalIntegerTypesCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::modernize {
+
+namespace {
+
+AST_MATCHER(clang::TypeLoc, hasValidBeginLoc) {
+ return Node.getBeginLoc().isValid();
+}
+
+AST_MATCHER_P(clang::TypeLoc, hasType,
+ clang::ast_matchers::internal::Matcher<clang::Type>,
+ InnerMatcher) {
+ const clang::Type *TypeNode = Node.getTypePtr();
+ return TypeNode != nullptr &&
+ InnerMatcher.matches(*TypeNode, Finder, Builder);
+}
+
+} // namespace
+
+AvoidFundamentalIntegerTypesCheck::AvoidFundamentalIntegerTypesCheck(
+ StringRef Name, ClangTidyContext *Context)
+ : ClangTidyCheck(Name, Context),
+ IgnoreTypedefs(Options.get("IgnoreTypedefs", false)) {}
+
+void AvoidFundamentalIntegerTypesCheck::storeOptions(
+ ClangTidyOptions::OptionMap &Opts) {
+ Options.store(Opts, "IgnoreTypedefs", IgnoreTypedefs);
+}
+
+bool AvoidFundamentalIntegerTypesCheck::isFundamentalIntegerType(
+ const Type *T) const {
+ if (!T->isBuiltinType())
+ return false;
+
+ const auto *BT = T->getAs<BuiltinType>();
+ if (!BT)
+ return false;
+
+ switch (BT->getKind()) {
+ case BuiltinType::Int:
+ case BuiltinType::UInt:
+ case BuiltinType::Short:
+ case BuiltinType::UShort:
+ case BuiltinType::Long:
+ case BuiltinType::ULong:
+ case BuiltinType::LongLong:
+ case BuiltinType::ULongLong:
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool AvoidFundamentalIntegerTypesCheck::isSemanticType(const Type *T) const {
+ if (!T->isBuiltinType())
+ return false;
+
+ const auto *BT = T->getAs<BuiltinType>();
+ if (!BT)
+ return false;
+
+ switch (BT->getKind()) {
+ case BuiltinType::Bool:
+ case BuiltinType::Char_S:
+ case BuiltinType::Char_U:
+ case BuiltinType::SChar:
+ case BuiltinType::UChar:
+ case BuiltinType::WChar_S:
+ case BuiltinType::WChar_U:
+ case BuiltinType::Char8:
+ case BuiltinType::Char16:
+ case BuiltinType::Char32:
+ return true;
+ default:
+ return false;
+ }
+}
+
+void AvoidFundamentalIntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
+ // Match variable declarations with fundamental integer types
+ Finder->addMatcher(
+ varDecl().bind("var_decl"),
+ this);
+
+ // Match function declarations with fundamental integer return types
+ Finder->addMatcher(
+ functionDecl().bind("func_decl"),
+ this);
+
+ // Match function parameters with fundamental integer types
+ Finder->addMatcher(
+ parmVarDecl().bind("param_decl"),
+ this);
+
+ // Match field declarations with fundamental integer types
+ Finder->addMatcher(
+ fieldDecl().bind("field_decl"),
+ this);
+
+ // Match typedef declarations if not ignoring them
+ if (!IgnoreTypedefs) {
+ Finder->addMatcher(
+ typedefDecl().bind("typedef_decl"),
+ this);
+
+ Finder->addMatcher(
+ typeAliasDecl().bind("alias_decl"),
+ this);
+ }
+}
+
+void AvoidFundamentalIntegerTypesCheck::check(
+ const MatchFinder::MatchResult &Result) {
+ SourceLocation Loc;
+ QualType QT;
+ std::string DeclType;
+
+ if (const auto *VD = Result.Nodes.getNodeAs<VarDecl>("var_decl")) {
+ Loc = VD->getLocation();
+ QT = VD->getType();
+ DeclType = "variable";
+ } else if (const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("func_decl")) {
+ Loc = FD->getLocation();
+ QT = FD->getReturnType();
+ DeclType = "function return type";
+ } else if (const auto *PD = Result.Nodes.getNodeAs<ParmVarDecl>("param_decl")) {
+ Loc = PD->getLocation();
+ QT = PD->getType();
+ DeclType = "function parameter";
+ } else if (const auto *FD = Result.Nodes.getNodeAs<FieldDecl>("field_decl")) {
+ Loc = FD->getLocation();
+ QT = FD->getType();
+ DeclType = "field";
+ } else if (const auto *TD = Result.Nodes.getNodeAs<TypedefDecl>("typedef_decl")) {
+ Loc = TD->getLocation();
+ QT = TD->getUnderlyingType();
+ DeclType = "typedef";
+ } else if (const auto *AD = Result.Nodes.getNodeAs<TypeAliasDecl>("alias_decl")) {
+ Loc = AD->getLocation();
+ QT = AD->getUnderlyingType();
+ DeclType = "type alias";
+ } else {
+ return;
+ }
+
+ if (Loc.isInvalid() || QT.isNull())
+ return;
+
+ const Type *T = QT.getCanonicalType().getTypePtr();
+ if (!T)
+ return;
+
+ // Skip if not a fundamental integer type
+ if (!isFundamentalIntegerType(T))
+ return;
+
+ // Skip semantic types
+ if (isSemanticType(T))
+ return;
+
+ // Get the type name for the diagnostic
+ std::string TypeName = QT.getAsString();
+
+ diag(Loc, "avoid using platform-dependent fundamental integer type '%0'; "
+ "consider using a typedef or fixed-width type instead")
+ << TypeName;
+}
+
+} // namespace clang::tidy::modernize
\ No newline at end of file
diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h b/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h
new file mode 100644
index 0000000000000..41e8cd5ceb87e
--- /dev/null
+++ b/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h
@@ -0,0 +1,46 @@
+//===--- AvoidFundamentalIntegerTypesCheck.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_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::modernize {
+
+/// Find fundamental integer types and recommend using typedefs or fixed-width types.
+///
+/// Detects fundamental integer types (int, short, long, long long, and their
+/// unsigned variants) and warns against their use due to platform-dependent
+/// behavior. Excludes semantic types like char, bool, wchar_t, char16_t,
+/// char32_t, size_t, and ptrdiff_t.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize/avoid-fundamental-integer-types.html
+class AvoidFundamentalIntegerTypesCheck : public ClangTidyCheck {
+public:
+ AvoidFundamentalIntegerTypesCheck(StringRef Name, ClangTidyContext *Context);
+ void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+ void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+ void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+ bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+ return LangOpts.CPlusPlus11;
+ }
+ std::optional<TraversalKind> getCheckTraversalKind() const override {
+ return TK_IgnoreUnlessSpelledInSource;
+ }
+
+private:
+ const bool IgnoreTypedefs;
+ bool isFundamentalIntegerType(const Type *T) const;
+ bool isSemanticType(const Type *T) const;
+};
+
+} // namespace clang::tidy::modernize
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H
\ No newline at end of file
diff --git a/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt b/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
index 619a27b2f9bb6..deb37c1ad9fb3 100644
--- a/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
@@ -6,6 +6,7 @@ set(LLVM_LINK_COMPONENTS
add_clang_library(clangTidyModernizeModule STATIC
AvoidBindCheck.cpp
AvoidCArraysCheck.cpp
+ AvoidFundamentalIntegerTypesCheck.cpp
ConcatNestedNamespacesCheck.cpp
DeprecatedHeadersCheck.cpp
DeprecatedIosBaseAliasesCheck.cpp
diff --git a/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp b/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
index fdf38bc4b6308..a42d55b26a311 100644
--- a/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
@@ -11,6 +11,7 @@
#include "../ClangTidyModuleRegistry.h"
#include "AvoidBindCheck.h"
#include "AvoidCArraysCheck.h"
+#include "AvoidFundamentalIntegerTypesCheck.h"
#include "ConcatNestedNamespacesCheck.h"
#include "DeprecatedHeadersCheck.h"
#include "DeprecatedIosBaseAliasesCheck.h"
@@ -63,6 +64,8 @@ class ModernizeModule : public ClangTidyModule {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");
CheckFactories.registerCheck<AvoidCArraysCheck>("modernize-avoid-c-arrays");
+ CheckFactories.registerCheck<AvoidFundamentalIntegerTypesCheck>(
+ "modernize-avoid-fundamental-integer-types");
CheckFactories.registerCheck<ConcatNestedNamespacesCheck>(
"modernize-concat-nested-namespaces");
CheckFactories.registerCheck<DeprecatedHeadersCheck>(
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp
new file mode 100644
index 0000000000000..7d4860d95a3ce
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp
@@ -0,0 +1,108 @@
+// RUN: %check_clang_tidy %s modernize-avoid-fundamental-integer-types %t
+
+// Test fundamental integer types that should trigger warnings
+int global_int = 42;
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+short global_short = 10;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+long global_long = 100L;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+long long global_long_long = 1000LL;
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'long long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+unsigned int global_unsigned_int = 42U;
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: avoid using platform-dependent fundamental integer type 'unsigned int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+unsigned short global_unsigned_short = 10U;
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: avoid using platform-dependent fundamental integer type 'unsigned short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+unsigned long global_unsigned_long = 100UL;
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: avoid using platform-dependent fundamental integer type 'unsigned long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+unsigned long long global_unsigned_long_long = 1000ULL;
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: avoid using platform-dependent fundamental integer type 'unsigned long long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+// Test semantic types that should NOT trigger warnings
+char global_char = 'a';
+signed char global_signed_char = 'b';
+unsigned char global_unsigned_char = 'c';
+bool global_bool = true;
+wchar_t global_wchar = L'w';
+
+// Test function parameters
+void function_with_int_param(int param) {
+// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+}
+
+void function_with_short_param(short param) {
+// CHECK-MESSAGES: :[[@LINE-1]]:38: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+}
+
+// Test function return types
+int function_returning_int() {
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ return 42;
+}
+
+long function_returning_long() {
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ return 100L;
+}
+
+// Test local variables
+void test_local_variables() {
+ int local_int = 10;
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+ short local_short = 5;
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+ unsigned long local_unsigned_long = 200UL;
+ // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: avoid using platform-dependent fundamental integer type 'unsigned long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+ // These should not trigger warnings
+ char local_char = 'x';
+ bool local_bool = false;
+}
+
+// Test struct/class members
+struct TestStruct {
+ int member_int;
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+ long member_long;
+ // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+ // These should not trigger warnings
+ char member_char;
+ bool member_bool;
+};
+
+class TestClass {
+public:
+ unsigned int public_member;
+ // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: avoid using platform-dependent fundamental integer type 'unsigned int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+private:
+ short private_member;
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+};
+
+// Test typedefs and type aliases
+typedef int MyInt;
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+using MyLong = long;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
+// Test template parameters
+template<typename T>
+void template_function(T param) {}
+
+template<>
+void template_function<int>(int param) {
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+}
\ No newline at end of file
>From 48598ef4bd01a096a5bde29515df3e472cae2e0f Mon Sep 17 00:00:00 2001
From: JJ Marr <jjmarr at gmail.com>
Date: Thu, 3 Jul 2025 17:33:54 -0400
Subject: [PATCH 2/6] Test typedefs properly
---
.../AvoidFundamentalIntegerTypesCheck.cpp | 32 ++++++++---------
.../AvoidFundamentalIntegerTypesCheck.h | 4 +--
.../avoid-fundamental-integer-types.cpp | 35 ++++++++++++++++++-
3 files changed, 50 insertions(+), 21 deletions(-)
diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp b/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp
index 8a393bc894cfe..b5e2484e6396a 100644
--- a/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp
@@ -33,13 +33,7 @@ AST_MATCHER_P(clang::TypeLoc, hasType,
AvoidFundamentalIntegerTypesCheck::AvoidFundamentalIntegerTypesCheck(
StringRef Name, ClangTidyContext *Context)
- : ClangTidyCheck(Name, Context),
- IgnoreTypedefs(Options.get("IgnoreTypedefs", false)) {}
-
-void AvoidFundamentalIntegerTypesCheck::storeOptions(
- ClangTidyOptions::OptionMap &Opts) {
- Options.store(Opts, "IgnoreTypedefs", IgnoreTypedefs);
-}
+ : ClangTidyCheck(Name, Context) {}
bool AvoidFundamentalIntegerTypesCheck::isFundamentalIntegerType(
const Type *T) const {
@@ -111,16 +105,14 @@ void AvoidFundamentalIntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
fieldDecl().bind("field_decl"),
this);
- // Match typedef declarations if not ignoring them
- if (!IgnoreTypedefs) {
- Finder->addMatcher(
- typedefDecl().bind("typedef_decl"),
- this);
+ // Match typedef declarations to check their underlying types
+ Finder->addMatcher(
+ typedefDecl().bind("typedef_decl"),
+ this);
- Finder->addMatcher(
- typeAliasDecl().bind("alias_decl"),
- this);
- }
+ Finder->addMatcher(
+ typeAliasDecl().bind("alias_decl"),
+ this);
}
void AvoidFundamentalIntegerTypesCheck::check(
@@ -160,6 +152,12 @@ void AvoidFundamentalIntegerTypesCheck::check(
if (Loc.isInvalid() || QT.isNull())
return;
+ // Check if the type is already a typedef - if so, don't warn
+ // since the user is already using a typedef (which is what we want)
+ if (QT->getAs<TypedefType>()) {
+ return;
+ }
+
const Type *T = QT.getCanonicalType().getTypePtr();
if (!T)
return;
@@ -180,4 +178,4 @@ void AvoidFundamentalIntegerTypesCheck::check(
<< TypeName;
}
-} // namespace clang::tidy::modernize
\ No newline at end of file
+} // namespace clang::tidy::modernize
diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h b/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h
index 41e8cd5ceb87e..c1e4fb4748e5d 100644
--- a/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h
+++ b/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h
@@ -27,7 +27,6 @@ class AvoidFundamentalIntegerTypesCheck : public ClangTidyCheck {
AvoidFundamentalIntegerTypesCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
- void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
return LangOpts.CPlusPlus11;
}
@@ -36,11 +35,10 @@ class AvoidFundamentalIntegerTypesCheck : public ClangTidyCheck {
}
private:
- const bool IgnoreTypedefs;
bool isFundamentalIntegerType(const Type *T) const;
bool isSemanticType(const Type *T) const;
};
} // namespace clang::tidy::modernize
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H
\ No newline at end of file
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp
index 7d4860d95a3ce..ad2c4e6884e57 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp
@@ -1,5 +1,17 @@
// RUN: %check_clang_tidy %s modernize-avoid-fundamental-integer-types %t
+// Mock fixed-width integer types
+// NOLINTBEGIN(modernize-avoid-fundamental-integer-types)
+typedef unsigned int uint32_t;
+typedef int int32_t;
+typedef unsigned long long uint64_t;
+typedef long long int64_t;
+
+// Mock standard library semantic types
+typedef unsigned long size_t;
+typedef long ptrdiff_t;
+// NOLINTEND(modernize-avoid-fundamental-integer-types)
+
// Test fundamental integer types that should trigger warnings
int global_int = 42;
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
@@ -32,6 +44,16 @@ unsigned char global_unsigned_char = 'c';
bool global_bool = true;
wchar_t global_wchar = L'w';
+// Test fixed-width types that should NOT trigger warnings
+uint32_t global_uint32 = 42U;
+int32_t global_int32 = 42;
+uint64_t global_uint64 = 100ULL;
+int64_t global_int64 = 100LL;
+
+// Test semantic standard library types that should NOT trigger warnings
+size_t global_size = 100;
+ptrdiff_t global_ptrdiff = 50;
+
// Test function parameters
void function_with_int_param(int param) {
// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
@@ -66,6 +88,14 @@ void test_local_variables() {
// These should not trigger warnings
char local_char = 'x';
bool local_bool = false;
+
+ // Fixed-width types should not trigger warnings
+ uint32_t local_uint32 = 42U;
+ int64_t local_int64 = 100LL;
+
+ // Standard library semantic types should not trigger warnings
+ size_t local_size = 200;
+ ptrdiff_t local_ptrdiff = 10;
}
// Test struct/class members
@@ -98,6 +128,9 @@ typedef int MyInt;
using MyLong = long;
// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+typedef long long customType;
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: avoid using platform-dependent fundamental integer type 'long long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+
// Test template parameters
template<typename T>
void template_function(T param) {}
@@ -105,4 +138,4 @@ void template_function(T param) {}
template<>
void template_function<int>(int param) {
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
-}
\ No newline at end of file
+}
>From 524fdd8c480cb3f3652c354a305b27a34fe53e45 Mon Sep 17 00:00:00 2001
From: JJ Marr <jjmarr at gmail.com>
Date: Thu, 3 Jul 2025 18:26:31 -0400
Subject: [PATCH 3/6] Document properly
---
.../docs/clang-tidy/checks/list.rst | 1 +
.../avoid-fundamental-integer-types.rst | 111 ++++++++++++++++++
2 files changed, 112 insertions(+)
create mode 100644 clang-tools-extra/docs/clang-tidy/checks/modernize/avoid-fundamental-integer-types.rst
diff --git a/clang-tools-extra/docs/clang-tidy/checks/list.rst b/clang-tools-extra/docs/clang-tidy/checks/list.rst
index 5098582d0c42b..33c2911fd9ae5 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/list.rst
+++ b/clang-tools-extra/docs/clang-tidy/checks/list.rst
@@ -280,6 +280,7 @@ Clang-Tidy Checks
:doc:`misc-use-internal-linkage <misc/use-internal-linkage>`, "Yes"
:doc:`modernize-avoid-bind <modernize/avoid-bind>`, "Yes"
:doc:`modernize-avoid-c-arrays <modernize/avoid-c-arrays>`,
+ :doc:`modernize-avoid-fundamental-integer-types <modernize/avoid-fundamental-integer-types>`,
:doc:`modernize-concat-nested-namespaces <modernize/concat-nested-namespaces>`, "Yes"
:doc:`modernize-deprecated-headers <modernize/deprecated-headers>`, "Yes"
:doc:`modernize-deprecated-ios-base-aliases <modernize/deprecated-ios-base-aliases>`, "Yes"
diff --git a/clang-tools-extra/docs/clang-tidy/checks/modernize/avoid-fundamental-integer-types.rst b/clang-tools-extra/docs/clang-tidy/checks/modernize/avoid-fundamental-integer-types.rst
new file mode 100644
index 0000000000000..df511e084701f
--- /dev/null
+++ b/clang-tools-extra/docs/clang-tidy/checks/modernize/avoid-fundamental-integer-types.rst
@@ -0,0 +1,111 @@
+.. title:: clang-tidy - modernize-avoid-fundamental-integer-types
+
+modernize-avoid-fundamental-integer-types
+==========================================
+
+Finds fundamental integer types and recommends using typedefs or fixed-width types instead.
+
+This check detects fundamental integer types (``int``, ``short``, ``long``, ``long long``, and their
+``unsigned`` variants) and warns against their use due to non-standard platform-dependent behavior.
+For example, ``long`` is 64 bits on Linux but 32 bits on Windows. There is no standard rationale or
+intent for the sizes of these types.
+
+Instead of fundamental types, use fixed-width types such as ``int32_t`` or implementation-defined
+types with standard semantics, e.g. ``int_fast32_t`` for the fastest integer type greater than or
+equal to 32 bits.
+
+Examples
+--------
+
+.. code-block:: c++
+
+ // Bad: platform-dependent fundamental types
+ int global_int = 42;
+ short global_short = 10;
+ long global_long = 100L;
+ unsigned long global_unsigned_long = 100UL;
+
+ void function_with_int_param(int param) {
+ // ...
+ }
+
+ int function_returning_int() {
+ return 42;
+ }
+
+ struct MyStruct {
+ int member_int;
+ long member_long;
+ };
+
+.. code-block:: c++
+
+ // Good: use fixed-width types or typedefs
+ #include <cstdint>
+
+ int32_t global_int32 = 42;
+ int16_t global_int16 = 10;
+ int64_t global_int64 = 100L;
+ uint64_t global_uint64 = 100UL;
+
+ void function_with_int32_param(int32_t param) {
+ // ...
+ }
+
+ int32_t function_returning_int32() {
+ return 42;
+ }
+
+ struct MyStruct {
+ int32_t member_int32;
+ int64_t member_int64;
+ };
+
+The check will also warn about typedef declarations that use fundamental types as their underlying type:
+
+.. code-block:: c++
+
+ // Bad: typedef using fundamental type
+ typedef long long MyLongType;
+ using MyIntType = int;
+
+.. code-block:: c++
+
+ // Good: use descriptive names or fixed-width types
+ typedef int64_t TimestampType;
+ using CounterType = uint32_t;
+
+Rationale
+---------
+
+Fundamental integer types have platform-dependent sizes and behavior:
+
+- ``int`` is typically 32 bits on modern platforms but is only guaranteed to be 16 bits by the spec
+- ``long int`` is 32 bits on Windows but 64 bits on most Unix systems
+
+The C++ specification does not define these types beyond their minimum sizes. That means they can
+communicate intent in non-standard ways and are often needlessly incompatible. For example, ``int``
+was traditionally the word size of a given processor in 16-bit and 32-bit computing and was a
+reasonable default for performance. This is no longer true on modern 64-bit computers, but the size
+of ``int`` remains fixed at 32 bits for backwards compatibility with code that relied on a 32-bit
+implementation of ``int``.
+
+If code is explicitly relying on the size of an ``int`` being 32 bits, it is better to say so in
+the typename with ``int32_t``. Otherwise, use an appropriate implementation-defined type that
+communicates your intent.
+
+Types Not Flagged
+-----------------
+
+The following types are intentionally not flagged:
+
+- ``char``, ``signed char``, ``unsigned char`` (character types)
+- ``bool`` (boolean type)
+- Standard library typedefs like ``size_t``, ``ptrdiff_t``, or ``uint32_t``.
+- Already typedef'd types, though the check will flag the typedef itself
+
+``char`` is excluded because it is implementation-defined to always be 1 byte, regardless of the
+platform's definition of a byte.
+
+``bool`` is excluded because it can only be true or false, and is not vulnerable to overflow or
+narrowing issues that occur as a result of using implementation-defined types.
>From d5fd2e798ecc6e9fcfd1863f37995c3f179d56c7 Mon Sep 17 00:00:00 2001
From: JJ Marr <jjmarr at gmail.com>
Date: Thu, 3 Jul 2025 21:50:01 -0400
Subject: [PATCH 4/6] Rename files
---
.../AvoidPlatformSpecificFundamentalTypesCheck.cpp} | 0
.../AvoidPlatformSpecificFundamentalTypesCheck.h} | 0
.../avoid-platform-specific-fundamental-types.rst} | 0
.../avoid-platform-specific-fundamental-types.cpp} | 0
4 files changed, 0 insertions(+), 0 deletions(-)
rename clang-tools-extra/clang-tidy/{modernize/AvoidFundamentalIntegerTypesCheck.cpp => portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp} (100%)
rename clang-tools-extra/clang-tidy/{modernize/AvoidFundamentalIntegerTypesCheck.h => portability/AvoidPlatformSpecificFundamentalTypesCheck.h} (100%)
rename clang-tools-extra/docs/clang-tidy/checks/{modernize/avoid-fundamental-integer-types.rst => portability/avoid-platform-specific-fundamental-types.rst} (100%)
rename clang-tools-extra/test/clang-tidy/checkers/{modernize/avoid-fundamental-integer-types.cpp => portability/avoid-platform-specific-fundamental-types.cpp} (100%)
diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp
similarity index 100%
rename from clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.cpp
rename to clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp
diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h
similarity index 100%
rename from clang-tools-extra/clang-tidy/modernize/AvoidFundamentalIntegerTypesCheck.h
rename to clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h
diff --git a/clang-tools-extra/docs/clang-tidy/checks/modernize/avoid-fundamental-integer-types.rst b/clang-tools-extra/docs/clang-tidy/checks/portability/avoid-platform-specific-fundamental-types.rst
similarity index 100%
rename from clang-tools-extra/docs/clang-tidy/checks/modernize/avoid-fundamental-integer-types.rst
rename to clang-tools-extra/docs/clang-tidy/checks/portability/avoid-platform-specific-fundamental-types.rst
diff --git a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp b/clang-tools-extra/test/clang-tidy/checkers/portability/avoid-platform-specific-fundamental-types.cpp
similarity index 100%
rename from clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-fundamental-integer-types.cpp
rename to clang-tools-extra/test/clang-tidy/checkers/portability/avoid-platform-specific-fundamental-types.cpp
>From 25425cc0f12d96d86619d83222d0222bc1d17538 Mon Sep 17 00:00:00 2001
From: JJ Marr <jjmarr at gmail.com>
Date: Thu, 3 Jul 2025 22:27:08 -0400
Subject: [PATCH 5/6] Other renaming for portability change
---
.../clang-tidy/modernize/CMakeLists.txt | 1 -
.../modernize/ModernizeTidyModule.cpp | 3 --
...dPlatformSpecificFundamentalTypesCheck.cpp | 18 +++----
...oidPlatformSpecificFundamentalTypesCheck.h | 18 +++----
.../clang-tidy/portability/CMakeLists.txt | 1 +
.../portability/PortabilityTidyModule.cpp | 3 ++
.../docs/clang-tidy/checks/list.rst | 2 +-
...id-platform-specific-fundamental-types.rst | 6 +--
...id-platform-specific-fundamental-types.cpp | 52 +++++++++----------
9 files changed, 52 insertions(+), 52 deletions(-)
diff --git a/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt b/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
index deb37c1ad9fb3..619a27b2f9bb6 100644
--- a/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/modernize/CMakeLists.txt
@@ -6,7 +6,6 @@ set(LLVM_LINK_COMPONENTS
add_clang_library(clangTidyModernizeModule STATIC
AvoidBindCheck.cpp
AvoidCArraysCheck.cpp
- AvoidFundamentalIntegerTypesCheck.cpp
ConcatNestedNamespacesCheck.cpp
DeprecatedHeadersCheck.cpp
DeprecatedIosBaseAliasesCheck.cpp
diff --git a/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp b/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
index a42d55b26a311..fdf38bc4b6308 100644
--- a/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/ModernizeTidyModule.cpp
@@ -11,7 +11,6 @@
#include "../ClangTidyModuleRegistry.h"
#include "AvoidBindCheck.h"
#include "AvoidCArraysCheck.h"
-#include "AvoidFundamentalIntegerTypesCheck.h"
#include "ConcatNestedNamespacesCheck.h"
#include "DeprecatedHeadersCheck.h"
#include "DeprecatedIosBaseAliasesCheck.h"
@@ -64,8 +63,6 @@ class ModernizeModule : public ClangTidyModule {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");
CheckFactories.registerCheck<AvoidCArraysCheck>("modernize-avoid-c-arrays");
- CheckFactories.registerCheck<AvoidFundamentalIntegerTypesCheck>(
- "modernize-avoid-fundamental-integer-types");
CheckFactories.registerCheck<ConcatNestedNamespacesCheck>(
"modernize-concat-nested-namespaces");
CheckFactories.registerCheck<DeprecatedHeadersCheck>(
diff --git a/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp
index b5e2484e6396a..7eb9619577200 100644
--- a/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp
+++ b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp
@@ -1,4 +1,4 @@
-//===--- AvoidFundamentalIntegerTypesCheck.cpp - clang-tidy ---------------===//
+//===--- AvoidPlatformSpecificFundamentalTypesCheck.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.
@@ -6,14 +6,14 @@
//
//===----------------------------------------------------------------------===//
-#include "AvoidFundamentalIntegerTypesCheck.h"
+#include "AvoidPlatformSpecificFundamentalTypesCheck.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers;
-namespace clang::tidy::modernize {
+namespace clang::tidy::portability {
namespace {
@@ -31,11 +31,11 @@ AST_MATCHER_P(clang::TypeLoc, hasType,
} // namespace
-AvoidFundamentalIntegerTypesCheck::AvoidFundamentalIntegerTypesCheck(
+AvoidPlatformSpecificFundamentalTypesCheck::AvoidPlatformSpecificFundamentalTypesCheck(
StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {}
-bool AvoidFundamentalIntegerTypesCheck::isFundamentalIntegerType(
+bool AvoidPlatformSpecificFundamentalTypesCheck::isFundamentalIntegerType(
const Type *T) const {
if (!T->isBuiltinType())
return false;
@@ -59,7 +59,7 @@ bool AvoidFundamentalIntegerTypesCheck::isFundamentalIntegerType(
}
}
-bool AvoidFundamentalIntegerTypesCheck::isSemanticType(const Type *T) const {
+bool AvoidPlatformSpecificFundamentalTypesCheck::isSemanticType(const Type *T) const {
if (!T->isBuiltinType())
return false;
@@ -84,7 +84,7 @@ bool AvoidFundamentalIntegerTypesCheck::isSemanticType(const Type *T) const {
}
}
-void AvoidFundamentalIntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
+void AvoidPlatformSpecificFundamentalTypesCheck::registerMatchers(MatchFinder *Finder) {
// Match variable declarations with fundamental integer types
Finder->addMatcher(
varDecl().bind("var_decl"),
@@ -115,7 +115,7 @@ void AvoidFundamentalIntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
this);
}
-void AvoidFundamentalIntegerTypesCheck::check(
+void AvoidPlatformSpecificFundamentalTypesCheck::check(
const MatchFinder::MatchResult &Result) {
SourceLocation Loc;
QualType QT;
@@ -178,4 +178,4 @@ void AvoidFundamentalIntegerTypesCheck::check(
<< TypeName;
}
-} // namespace clang::tidy::modernize
+} // namespace clang::tidy::portability
diff --git a/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h
index c1e4fb4748e5d..0b5c8053b5bfe 100644
--- a/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h
+++ b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h
@@ -1,4 +1,4 @@
-//===--- AvoidFundamentalIntegerTypesCheck.h - clang-tidy -------*- C++ -*-===//
+//===--- AvoidPlatformSpecificFundamentalTypesCheck.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.
@@ -6,12 +6,12 @@
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_AVOIDPLATFORMSPECIFICFUNDAMENTALTYPESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_AVOIDPLATFORMSPECIFICFUNDAMENTALTYPESCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang::tidy::modernize {
+namespace clang::tidy::portability {
/// Find fundamental integer types and recommend using typedefs or fixed-width types.
///
@@ -21,10 +21,10 @@ namespace clang::tidy::modernize {
/// char32_t, size_t, and ptrdiff_t.
///
/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/modernize/avoid-fundamental-integer-types.html
-class AvoidFundamentalIntegerTypesCheck : public ClangTidyCheck {
+/// http://clang.llvm.org/extra/clang-tidy/checks/portability/avoid-platform-specific-fundamental-types.html
+class AvoidPlatformSpecificFundamentalTypesCheck : public ClangTidyCheck {
public:
- AvoidFundamentalIntegerTypesCheck(StringRef Name, ClangTidyContext *Context);
+ AvoidPlatformSpecificFundamentalTypesCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
@@ -39,6 +39,6 @@ class AvoidFundamentalIntegerTypesCheck : public ClangTidyCheck {
bool isSemanticType(const Type *T) const;
};
-} // namespace clang::tidy::modernize
+} // namespace clang::tidy::portability
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_AVOIDPLATFORMSPECIFICFUNDAMENTALTYPESCHECK_H
diff --git a/clang-tools-extra/clang-tidy/portability/CMakeLists.txt b/clang-tools-extra/clang-tidy/portability/CMakeLists.txt
index 73d74a550afc0..014c1ea883547 100644
--- a/clang-tools-extra/clang-tidy/portability/CMakeLists.txt
+++ b/clang-tools-extra/clang-tidy/portability/CMakeLists.txt
@@ -5,6 +5,7 @@ set(LLVM_LINK_COMPONENTS
)
add_clang_library(clangTidyPortabilityModule STATIC
+ AvoidPlatformSpecificFundamentalTypesCheck.cpp
AvoidPragmaOnceCheck.cpp
PortabilityTidyModule.cpp
RestrictSystemIncludesCheck.cpp
diff --git a/clang-tools-extra/clang-tidy/portability/PortabilityTidyModule.cpp b/clang-tools-extra/clang-tidy/portability/PortabilityTidyModule.cpp
index 98853556588b3..2e2ddb91934f3 100644
--- a/clang-tools-extra/clang-tidy/portability/PortabilityTidyModule.cpp
+++ b/clang-tools-extra/clang-tidy/portability/PortabilityTidyModule.cpp
@@ -9,6 +9,7 @@
#include "../ClangTidy.h"
#include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h"
+#include "AvoidPlatformSpecificFundamentalTypesCheck.h"
#include "AvoidPragmaOnceCheck.h"
#include "RestrictSystemIncludesCheck.h"
#include "SIMDIntrinsicsCheck.h"
@@ -21,6 +22,8 @@ namespace portability {
class PortabilityModule : public ClangTidyModule {
public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+ CheckFactories.registerCheck<AvoidPlatformSpecificFundamentalTypesCheck>(
+ "portability-avoid-platform-specific-fundamental-types");
CheckFactories.registerCheck<AvoidPragmaOnceCheck>(
"portability-avoid-pragma-once");
CheckFactories.registerCheck<RestrictSystemIncludesCheck>(
diff --git a/clang-tools-extra/docs/clang-tidy/checks/list.rst b/clang-tools-extra/docs/clang-tidy/checks/list.rst
index 33c2911fd9ae5..73d9ef7039ac4 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/list.rst
+++ b/clang-tools-extra/docs/clang-tidy/checks/list.rst
@@ -280,7 +280,6 @@ Clang-Tidy Checks
:doc:`misc-use-internal-linkage <misc/use-internal-linkage>`, "Yes"
:doc:`modernize-avoid-bind <modernize/avoid-bind>`, "Yes"
:doc:`modernize-avoid-c-arrays <modernize/avoid-c-arrays>`,
- :doc:`modernize-avoid-fundamental-integer-types <modernize/avoid-fundamental-integer-types>`,
:doc:`modernize-concat-nested-namespaces <modernize/concat-nested-namespaces>`, "Yes"
:doc:`modernize-deprecated-headers <modernize/deprecated-headers>`, "Yes"
:doc:`modernize-deprecated-ios-base-aliases <modernize/deprecated-ios-base-aliases>`, "Yes"
@@ -354,6 +353,7 @@ Clang-Tidy Checks
:doc:`performance-type-promotion-in-math-fn <performance/type-promotion-in-math-fn>`, "Yes"
:doc:`performance-unnecessary-copy-initialization <performance/unnecessary-copy-initialization>`, "Yes"
:doc:`performance-unnecessary-value-param <performance/unnecessary-value-param>`, "Yes"
+ :doc:`portability-avoid-platform-specific-fundamental-types <portability/avoid-platform-specific-fundamental-types>`,
:doc:`portability-avoid-pragma-once <portability/avoid-pragma-once>`,
:doc:`portability-restrict-system-includes <portability/restrict-system-includes>`, "Yes"
:doc:`portability-simd-intrinsics <portability/simd-intrinsics>`,
diff --git a/clang-tools-extra/docs/clang-tidy/checks/portability/avoid-platform-specific-fundamental-types.rst b/clang-tools-extra/docs/clang-tidy/checks/portability/avoid-platform-specific-fundamental-types.rst
index df511e084701f..3da0b19658343 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/portability/avoid-platform-specific-fundamental-types.rst
+++ b/clang-tools-extra/docs/clang-tidy/checks/portability/avoid-platform-specific-fundamental-types.rst
@@ -1,9 +1,9 @@
-.. title:: clang-tidy - modernize-avoid-fundamental-integer-types
+.. title:: clang-tidy - portability-avoid-platform-specific-fundamental-types
-modernize-avoid-fundamental-integer-types
+portability-avoid-platform-specific-fundamental-types
==========================================
-Finds fundamental integer types and recommends using typedefs or fixed-width types instead.
+Finds fundamental types and recommends using typedefs or fixed-width types instead.
This check detects fundamental integer types (``int``, ``short``, ``long``, ``long long``, and their
``unsigned`` variants) and warns against their use due to non-standard platform-dependent behavior.
diff --git a/clang-tools-extra/test/clang-tidy/checkers/portability/avoid-platform-specific-fundamental-types.cpp b/clang-tools-extra/test/clang-tidy/checkers/portability/avoid-platform-specific-fundamental-types.cpp
index ad2c4e6884e57..3eb2b3b8a3074 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/portability/avoid-platform-specific-fundamental-types.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/portability/avoid-platform-specific-fundamental-types.cpp
@@ -1,7 +1,7 @@
-// RUN: %check_clang_tidy %s modernize-avoid-fundamental-integer-types %t
+// RUN: %check_clang_tidy %s portability-avoid-platform-specific-fundamental-types %t
// Mock fixed-width integer types
-// NOLINTBEGIN(modernize-avoid-fundamental-integer-types)
+// NOLINTBEGIN(portability-avoid-platform-specific-fundamental-types)
typedef unsigned int uint32_t;
typedef int int32_t;
typedef unsigned long long uint64_t;
@@ -10,32 +10,32 @@ typedef long long int64_t;
// Mock standard library semantic types
typedef unsigned long size_t;
typedef long ptrdiff_t;
-// NOLINTEND(modernize-avoid-fundamental-integer-types)
+// NOLINTEND(portability-avoid-platform-specific-fundamental-types)
// Test fundamental integer types that should trigger warnings
int global_int = 42;
-// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
short global_short = 10;
-// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
long global_long = 100L;
-// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
long long global_long_long = 1000LL;
-// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'long long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'long long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
unsigned int global_unsigned_int = 42U;
-// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: avoid using platform-dependent fundamental integer type 'unsigned int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: avoid using platform-dependent fundamental integer type 'unsigned int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
unsigned short global_unsigned_short = 10U;
-// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: avoid using platform-dependent fundamental integer type 'unsigned short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: avoid using platform-dependent fundamental integer type 'unsigned short'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
unsigned long global_unsigned_long = 100UL;
-// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: avoid using platform-dependent fundamental integer type 'unsigned long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: avoid using platform-dependent fundamental integer type 'unsigned long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
unsigned long long global_unsigned_long_long = 1000ULL;
-// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: avoid using platform-dependent fundamental integer type 'unsigned long long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: avoid using platform-dependent fundamental integer type 'unsigned long long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
// Test semantic types that should NOT trigger warnings
char global_char = 'a';
@@ -56,34 +56,34 @@ ptrdiff_t global_ptrdiff = 50;
// Test function parameters
void function_with_int_param(int param) {
-// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
}
void function_with_short_param(short param) {
-// CHECK-MESSAGES: :[[@LINE-1]]:38: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:38: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
}
// Test function return types
int function_returning_int() {
-// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
return 42;
}
long function_returning_long() {
-// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
return 100L;
}
// Test local variables
void test_local_variables() {
int local_int = 10;
- // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
short local_short = 5;
- // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
unsigned long local_unsigned_long = 200UL;
- // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: avoid using platform-dependent fundamental integer type 'unsigned long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: avoid using platform-dependent fundamental integer type 'unsigned long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
// These should not trigger warnings
char local_char = 'x';
@@ -101,10 +101,10 @@ void test_local_variables() {
// Test struct/class members
struct TestStruct {
int member_int;
- // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
long member_long;
- // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
// These should not trigger warnings
char member_char;
@@ -114,22 +114,22 @@ struct TestStruct {
class TestClass {
public:
unsigned int public_member;
- // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: avoid using platform-dependent fundamental integer type 'unsigned int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: avoid using platform-dependent fundamental integer type 'unsigned int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
private:
short private_member;
- // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+ // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: avoid using platform-dependent fundamental integer type 'short'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
};
// Test typedefs and type aliases
typedef int MyInt;
-// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
using MyLong = long;
-// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: avoid using platform-dependent fundamental integer type 'long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
typedef long long customType;
-// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: avoid using platform-dependent fundamental integer type 'long long'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: avoid using platform-dependent fundamental integer type 'long long'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
// Test template parameters
template<typename T>
@@ -137,5 +137,5 @@ void template_function(T param) {}
template<>
void template_function<int>(int param) {
-// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [modernize-avoid-fundamental-integer-types]
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: avoid using platform-dependent fundamental integer type 'int'; consider using a typedef or fixed-width type instead [portability-avoid-platform-specific-fundamental-types]
}
>From 86787ec25d3ebba2afeb570f930e0a3eb5ced730 Mon Sep 17 00:00:00 2001
From: JJ Marr <jjmarr at gmail.com>
Date: Thu, 3 Jul 2025 22:29:08 -0400
Subject: [PATCH 6/6] Formatting fix
---
...dPlatformSpecificFundamentalTypesCheck.cpp | 50 +++++++++----------
...oidPlatformSpecificFundamentalTypesCheck.h | 9 ++--
2 files changed, 29 insertions(+), 30 deletions(-)
diff --git a/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp
index 7eb9619577200..2c04e8020ff3a 100644
--- a/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp
+++ b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp
@@ -1,4 +1,5 @@
-//===--- AvoidPlatformSpecificFundamentalTypesCheck.cpp - clang-tidy ---------------===//
+//===--- AvoidPlatformSpecificFundamentalTypesCheck.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.
@@ -31,8 +32,9 @@ AST_MATCHER_P(clang::TypeLoc, hasType,
} // namespace
-AvoidPlatformSpecificFundamentalTypesCheck::AvoidPlatformSpecificFundamentalTypesCheck(
- StringRef Name, ClangTidyContext *Context)
+AvoidPlatformSpecificFundamentalTypesCheck::
+ AvoidPlatformSpecificFundamentalTypesCheck(StringRef Name,
+ ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {}
bool AvoidPlatformSpecificFundamentalTypesCheck::isFundamentalIntegerType(
@@ -59,7 +61,8 @@ bool AvoidPlatformSpecificFundamentalTypesCheck::isFundamentalIntegerType(
}
}
-bool AvoidPlatformSpecificFundamentalTypesCheck::isSemanticType(const Type *T) const {
+bool AvoidPlatformSpecificFundamentalTypesCheck::isSemanticType(
+ const Type *T) const {
if (!T->isBuiltinType())
return false;
@@ -84,35 +87,24 @@ bool AvoidPlatformSpecificFundamentalTypesCheck::isSemanticType(const Type *T) c
}
}
-void AvoidPlatformSpecificFundamentalTypesCheck::registerMatchers(MatchFinder *Finder) {
+void AvoidPlatformSpecificFundamentalTypesCheck::registerMatchers(
+ MatchFinder *Finder) {
// Match variable declarations with fundamental integer types
- Finder->addMatcher(
- varDecl().bind("var_decl"),
- this);
+ Finder->addMatcher(varDecl().bind("var_decl"), this);
// Match function declarations with fundamental integer return types
- Finder->addMatcher(
- functionDecl().bind("func_decl"),
- this);
+ Finder->addMatcher(functionDecl().bind("func_decl"), this);
// Match function parameters with fundamental integer types
- Finder->addMatcher(
- parmVarDecl().bind("param_decl"),
- this);
+ Finder->addMatcher(parmVarDecl().bind("param_decl"), this);
// Match field declarations with fundamental integer types
- Finder->addMatcher(
- fieldDecl().bind("field_decl"),
- this);
+ Finder->addMatcher(fieldDecl().bind("field_decl"), this);
// Match typedef declarations to check their underlying types
- Finder->addMatcher(
- typedefDecl().bind("typedef_decl"),
- this);
+ Finder->addMatcher(typedefDecl().bind("typedef_decl"), this);
- Finder->addMatcher(
- typeAliasDecl().bind("alias_decl"),
- this);
+ Finder->addMatcher(typeAliasDecl().bind("alias_decl"), this);
}
void AvoidPlatformSpecificFundamentalTypesCheck::check(
@@ -125,11 +117,13 @@ void AvoidPlatformSpecificFundamentalTypesCheck::check(
Loc = VD->getLocation();
QT = VD->getType();
DeclType = "variable";
- } else if (const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("func_decl")) {
+ } else if (const auto *FD =
+ Result.Nodes.getNodeAs<FunctionDecl>("func_decl")) {
Loc = FD->getLocation();
QT = FD->getReturnType();
DeclType = "function return type";
- } else if (const auto *PD = Result.Nodes.getNodeAs<ParmVarDecl>("param_decl")) {
+ } else if (const auto *PD =
+ Result.Nodes.getNodeAs<ParmVarDecl>("param_decl")) {
Loc = PD->getLocation();
QT = PD->getType();
DeclType = "function parameter";
@@ -137,11 +131,13 @@ void AvoidPlatformSpecificFundamentalTypesCheck::check(
Loc = FD->getLocation();
QT = FD->getType();
DeclType = "field";
- } else if (const auto *TD = Result.Nodes.getNodeAs<TypedefDecl>("typedef_decl")) {
+ } else if (const auto *TD =
+ Result.Nodes.getNodeAs<TypedefDecl>("typedef_decl")) {
Loc = TD->getLocation();
QT = TD->getUnderlyingType();
DeclType = "typedef";
- } else if (const auto *AD = Result.Nodes.getNodeAs<TypeAliasDecl>("alias_decl")) {
+ } else if (const auto *AD =
+ Result.Nodes.getNodeAs<TypeAliasDecl>("alias_decl")) {
Loc = AD->getLocation();
QT = AD->getUnderlyingType();
DeclType = "type alias";
diff --git a/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h
index 0b5c8053b5bfe..7c446328c8ea0 100644
--- a/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h
+++ b/clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h
@@ -1,4 +1,5 @@
-//===--- AvoidPlatformSpecificFundamentalTypesCheck.h - clang-tidy -------*- C++ -*-===//
+//===--- AvoidPlatformSpecificFundamentalTypesCheck.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.
@@ -13,7 +14,8 @@
namespace clang::tidy::portability {
-/// Find fundamental integer types and recommend using typedefs or fixed-width types.
+/// Find fundamental integer types and recommend using typedefs or fixed-width
+/// types.
///
/// Detects fundamental integer types (int, short, long, long long, and their
/// unsigned variants) and warns against their use due to platform-dependent
@@ -24,7 +26,8 @@ namespace clang::tidy::portability {
/// http://clang.llvm.org/extra/clang-tidy/checks/portability/avoid-platform-specific-fundamental-types.html
class AvoidPlatformSpecificFundamentalTypesCheck : public ClangTidyCheck {
public:
- AvoidPlatformSpecificFundamentalTypesCheck(StringRef Name, ClangTidyContext *Context);
+ AvoidPlatformSpecificFundamentalTypesCheck(StringRef Name,
+ ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
More information about the cfe-commits
mailing list