Other renaming for portability change

Author: jj-marr

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

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

clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.cpp

@@ -1,19 +1,19 @@
-//===--- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

clang-tools-extra/clang-tidy/portability/AvoidPlatformSpecificFundamentalTypesCheck.h

@@ -1,17 +1,17 @@
-//===--- 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.
 // 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
+#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

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

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

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>`,

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.