Test typedefs properly

Author: jj-marr

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
+} // namespace clang::tidy::modernize

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
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDFUNDAMENTALINTEGERTYPESCHECK_H

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,11 +128,14 @@ 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) {}
 
 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]
-}
+}