extra/doxygen/ModernizeTidyModule_8cpp_source.html

//===--- ModernizeTidyModule.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 "../ClangTidy.h"

#include "../ClangTidyModule.h"

#include "../ClangTidyModuleRegistry.h"

#include "AvoidBindCheck.h"

#include "AvoidCArraysCheck.h"

#include "ConcatNestedNamespacesCheck.h"

#include "DeprecatedHeadersCheck.h"

#include "DeprecatedIosBaseAliasesCheck.h"

#include "LoopConvertCheck.h"

#include "MacroToEnumCheck.h"

#include "MakeSharedCheck.h"

#include "MakeUniqueCheck.h"

#include "MinMaxUseInitializerListCheck.h"

#include "PassByValueCheck.h"

#include "RawStringLiteralCheck.h"

#include "RedundantVoidArgCheck.h"

#include "ReplaceAutoPtrCheck.h"

#include "ReplaceDisallowCopyAndAssignMacroCheck.h"

#include "ReplaceRandomShuffleCheck.h"

#include "ReturnBracedInitListCheck.h"

#include "ShrinkToFitCheck.h"

#include "TypeTraitsCheck.h"

#include "UnaryStaticAssertCheck.h"

#include "UseAutoCheck.h"

#include "UseBoolLiteralsCheck.h"

#include "UseConstraintsCheck.h"

#include "UseDefaultMemberInitCheck.h"

#include "UseDesignatedInitializersCheck.h"

#include "UseEmplaceCheck.h"

#include "UseEqualsDefaultCheck.h"

#include "UseEqualsDeleteCheck.h"

#include "UseNodiscardCheck.h"

#include "UseNoexceptCheck.h"

#include "UseNullptrCheck.h"

#include "UseOverrideCheck.h"

#include "UseRangesCheck.h"

#include "UseStartsEndsWithCheck.h"

#include "UseStdFormatCheck.h"

#include "UseStdNumbersCheck.h"

#include "UseStdPrintCheck.h"

#include "UseTrailingReturnTypeCheck.h"

#include "UseTransparentFunctorsCheck.h"

#include "UseUncaughtExceptionsCheck.h"

#include "UseUsingCheck.h"


using namespace clang::ast_matchers;


namespace clang::tidy {

namespace modernize {


class ModernizeModule : public ClangTidyModule {

public:

  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {

    CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");

    CheckFactories.registerCheck<AvoidCArraysCheck>("modernize-avoid-c-arrays");

    CheckFactories.registerCheck<ConcatNestedNamespacesCheck>(

        "modernize-concat-nested-namespaces");

    CheckFactories.registerCheck<DeprecatedHeadersCheck>(

        "modernize-deprecated-headers");

    CheckFactories.registerCheck<DeprecatedIosBaseAliasesCheck>(

        "modernize-deprecated-ios-base-aliases");

    CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");

    CheckFactories.registerCheck<MacroToEnumCheck>("modernize-macro-to-enum");

    CheckFactories.registerCheck<MakeSharedCheck>("modernize-make-shared");

    CheckFactories.registerCheck<MakeUniqueCheck>("modernize-make-unique");

    CheckFactories.registerCheck<MinMaxUseInitializerListCheck>(

        "modernize-min-max-use-initializer-list");

    CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");

    CheckFactories.registerCheck<UseDesignatedInitializersCheck>(

        "modernize-use-designated-initializers");

    CheckFactories.registerCheck<UseRangesCheck>("modernize-use-ranges");

    CheckFactories.registerCheck<UseStartsEndsWithCheck>(

        "modernize-use-starts-ends-with");

    CheckFactories.registerCheck<UseStdFormatCheck>("modernize-use-std-format");

    CheckFactories.registerCheck<UseStdNumbersCheck>(

        "modernize-use-std-numbers");

    CheckFactories.registerCheck<UseStdPrintCheck>("modernize-use-std-print");

    CheckFactories.registerCheck<RawStringLiteralCheck>(

        "modernize-raw-string-literal");

    CheckFactories.registerCheck<RedundantVoidArgCheck>(

        "modernize-redundant-void-arg");

    CheckFactories.registerCheck<ReplaceAutoPtrCheck>(

        "modernize-replace-auto-ptr");

    CheckFactories.registerCheck<ReplaceDisallowCopyAndAssignMacroCheck>(

        "modernize-replace-disallow-copy-and-assign-macro");

    CheckFactories.registerCheck<ReplaceRandomShuffleCheck>(

        "modernize-replace-random-shuffle");

    CheckFactories.registerCheck<ReturnBracedInitListCheck>(

        "modernize-return-braced-init-list");

    CheckFactories.registerCheck<ShrinkToFitCheck>("modernize-shrink-to-fit");

    CheckFactories.registerCheck<TypeTraitsCheck>("modernize-type-traits");

    CheckFactories.registerCheck<UnaryStaticAssertCheck>(

        "modernize-unary-static-assert");

    CheckFactories.registerCheck<UseAutoCheck>("modernize-use-auto");

    CheckFactories.registerCheck<UseBoolLiteralsCheck>(

        "modernize-use-bool-literals");

    CheckFactories.registerCheck<UseConstraintsCheck>(

        "modernize-use-constraints");

    CheckFactories.registerCheck<UseDefaultMemberInitCheck>(

        "modernize-use-default-member-init");

    CheckFactories.registerCheck<UseEmplaceCheck>("modernize-use-emplace");

    CheckFactories.registerCheck<UseEqualsDefaultCheck>("modernize-use-equals-default");

    CheckFactories.registerCheck<UseEqualsDeleteCheck>(

        "modernize-use-equals-delete");

    CheckFactories.registerCheck<UseNodiscardCheck>(

        "modernize-use-nodiscard");

    CheckFactories.registerCheck<UseNoexceptCheck>("modernize-use-noexcept");

    CheckFactories.registerCheck<UseNullptrCheck>("modernize-use-nullptr");

    CheckFactories.registerCheck<UseOverrideCheck>("modernize-use-override");

    CheckFactories.registerCheck<UseTrailingReturnTypeCheck>(

        "modernize-use-trailing-return-type");

    CheckFactories.registerCheck<UseTransparentFunctorsCheck>(

        "modernize-use-transparent-functors");

    CheckFactories.registerCheck<UseUncaughtExceptionsCheck>(

        "modernize-use-uncaught-exceptions");

    CheckFactories.registerCheck<UseUsingCheck>("modernize-use-using");

  }

};


// Register the ModernizeTidyModule using this statically initialized variable.

static ClangTidyModuleRegistry::Add<ModernizeModule> X("modernize-module",

                                                       "Add modernize checks.");


} // namespace modernize


// This anchor is used to force the linker to link in the generated object file

// and thus register the ModernizeModule.

volatile int ModernizeModuleAnchorSource = 0;


} // namespace clang::tidy

AvoidBindCheck.h

AvoidCArraysCheck.h

ConcatNestedNamespacesCheck.h

DeprecatedHeadersCheck.h

DeprecatedIosBaseAliasesCheck.h

X
int X
Definition: LSPBinderTests.cpp:26

LoopConvertCheck.h

MacroToEnumCheck.h

MakeSharedCheck.h

MakeUniqueCheck.h

MinMaxUseInitializerListCheck.h

PassByValueCheck.h

RawStringLiteralCheck.h

RedundantVoidArgCheck.h

ReplaceAutoPtrCheck.h

ReplaceDisallowCopyAndAssignMacroCheck.h

ReplaceRandomShuffleCheck.h

ReturnBracedInitListCheck.h

ShrinkToFitCheck.h

TypeTraitsCheck.h

UnaryStaticAssertCheck.h

UseAutoCheck.h

UseBoolLiteralsCheck.h

UseConstraintsCheck.h

UseDefaultMemberInitCheck.h

UseDesignatedInitializersCheck.h

UseEmplaceCheck.h

UseEqualsDefaultCheck.h

UseEqualsDeleteCheck.h

UseNodiscardCheck.h

UseNoexceptCheck.h

UseNullptrCheck.h

UseOverrideCheck.h

UseStartsEndsWithCheck.h

UseStdFormatCheck.h

UseStdNumbersCheck.h

UseStdPrintCheck.h

UseTrailingReturnTypeCheck.h

UseTransparentFunctorsCheck.h

UseUncaughtExceptionsCheck.h

UseUsingCheck.h

clang::tidy::ClangTidyCheckFactories
A collection of ClangTidyCheckFactory instances.
Definition: ClangTidyModule.h:27

clang::tidy::ClangTidyCheckFactories::registerCheck
void registerCheck(llvm::StringRef CheckName)
Registers the CheckType with the name Name.
Definition: ClangTidyModule.h:58

clang::tidy::ClangTidyModule
A clang-tidy module groups a number of ClangTidyChecks and gives them a prefixed name.
Definition: ClangTidyModule.h:84

clang::tidy::modernize::AvoidBindCheck
Replace simple uses of std::bind with a lambda.
Definition: AvoidBindCheck.h:22

clang::tidy::modernize::AvoidCArraysCheck
Find C-style array types and recommend to use std::array<> / std::vector<>.
Definition: AvoidCArraysCheck.h:20

clang::tidy::modernize::ConcatNestedNamespacesCheck
Definition: ConcatNestedNamespacesCheck.h:33

clang::tidy::modernize::DeprecatedHeadersCheck
This check replaces deprecated C library headers with their C++ STL alternatives.
Definition: DeprecatedHeadersCheck.h:33

clang::tidy::modernize::DeprecatedIosBaseAliasesCheck
This check warns the uses of the deprecated member types of std::ios_base and replaces those that hav...
Definition: DeprecatedIosBaseAliasesCheck.h:21

clang::tidy::modernize::LoopConvertCheck
Definition: LoopConvertCheck.h:18

clang::tidy::modernize::MacroToEnumCheck
Replaces groups of related macros with an unscoped anonymous enum.
Definition: MacroToEnumCheck.h:22

clang::tidy::modernize::MakeSharedCheck
Replace the pattern:
Definition: MakeSharedCheck.h:28

clang::tidy::modernize::MakeUniqueCheck
Replace the pattern:
Definition: MakeUniqueCheck.h:25

clang::tidy::modernize::MinMaxUseInitializerListCheck
Replaces nested std::min and std::max calls with an initializer list where applicable.
Definition: MinMaxUseInitializerListCheck.h:31

clang::tidy::modernize::ModernizeModule
Definition: ModernizeTidyModule.cpp:59

clang::tidy::modernize::ModernizeModule::addCheckFactories
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override
Implement this function in order to register all CheckFactories belonging to this module.
Definition: ModernizeTidyModule.cpp:61

clang::tidy::modernize::PassByValueCheck
Definition: PassByValueCheck.h:19

clang::tidy::modernize::RawStringLiteralCheck
This check replaces string literals with escaped characters to raw string literals.
Definition: RawStringLiteralCheck.h:24

clang::tidy::modernize::RedundantVoidArgCheck
Find and remove redundant void argument lists.
Definition: RedundantVoidArgCheck.h:29

clang::tidy::modernize::ReplaceAutoPtrCheck
Transforms the deprecated std::auto_ptr into the C++11 std::unique_ptr.
Definition: ReplaceAutoPtrCheck.h:41

clang::tidy::modernize::ReplaceDisallowCopyAndAssignMacroCheck
This check finds macro expansions of DISALLOW_COPY_AND_ASSIGN(Type) and replaces them with a deleted ...
Definition: ReplaceDisallowCopyAndAssignMacroCheck.h:39

clang::tidy::modernize::ReplaceRandomShuffleCheck
std::random_shuffle will be removed as of C++17.
Definition: ReplaceRandomShuffleCheck.h:22

clang::tidy::modernize::ReturnBracedInitListCheck
Use a braced init list for return statements rather than unnecessary repeating the return type name.
Definition: ReturnBracedInitListCheck.h:21

clang::tidy::modernize::ShrinkToFitCheck
Replace copy and swap tricks on shrinkable containers with the shrink_to_fit() method call.
Definition: ShrinkToFitCheck.h:22

clang::tidy::modernize::TypeTraitsCheck
Converts standard library type traits of the form traits<...>::type and traits<......
Definition: TypeTraitsCheck.h:21

clang::tidy::modernize::UnaryStaticAssertCheck
Replaces a static_assert declaration with an empty message with the unary version.
Definition: UnaryStaticAssertCheck.h:21

clang::tidy::modernize::UseAutoCheck
Definition: UseAutoCheck.h:16

clang::tidy::modernize::UseBoolLiteralsCheck
Finds integer literals which are cast to bool.
Definition: UseBoolLiteralsCheck.h:20

clang::tidy::modernize::UseConstraintsCheck
Replace enable_if with C++20 requires clauses.
Definition: UseConstraintsCheck.h:20

clang::tidy::modernize::UseDefaultMemberInitCheck
Convert a default constructor's member initializers into default member initializers.
Definition: UseDefaultMemberInitCheck.h:22

clang::tidy::modernize::UseDesignatedInitializersCheck
Finds initializer lists for aggregate type that could be written as designated initializers instead.
Definition: UseDesignatedInitializersCheck.h:21

clang::tidy::modernize::UseEmplaceCheck
This check looks for cases when inserting new element into std::vector but the element is constructed...
Definition: UseEmplaceCheck.h:25

clang::tidy::modernize::UseEqualsDefaultCheck
Replace default bodies of special member functions with '= default;'.
Definition: UseEqualsDefaultCheck.h:35

clang::tidy::modernize::UseEqualsDeleteCheck
Identifies unimplemented private special member functions, and recommends using = delete for them.
Definition: UseEqualsDeleteCheck.h:22

clang::tidy::modernize::UseNodiscardCheck
Add [[nodiscard]] to non-void const-member functions with no arguments or pass-by-value or pass by co...
Definition: UseNodiscardCheck.h:32

clang::tidy::modernize::UseNoexceptCheck
Replace dynamic exception specifications, with noexcept (or user-defined macro) or noexcept(false).
Definition: UseNoexceptCheck.h:30

clang::tidy::modernize::UseNullptrCheck
Definition: UseNullptrCheck.h:16

clang::tidy::modernize::UseOverrideCheck
Use C++11's override and remove virtual where applicable.
Definition: UseOverrideCheck.h:17

clang::tidy::modernize::UseRangesCheck
Detects calls to standard library iterator algorithms that could be replaced with a ranges version in...
Definition: modernize/UseRangesCheck.h:21

clang::tidy::modernize::UseStartsEndsWithCheck
Checks for common roundabout ways to express starts_with and ends_with and suggests replacing with st...
Definition: UseStartsEndsWithCheck.h:23

clang::tidy::modernize::UseStdFormatCheck
Converts calls to absl::StrFormat, or other functions via configuration options, to C++20's std::form...
Definition: UseStdFormatCheck.h:24

clang::tidy::modernize::UseStdNumbersCheck
Finds constants and function calls to math functions that can be replaced with c++20's mathematical c...
Definition: UseStdNumbersCheck.h:25

clang::tidy::modernize::UseStdPrintCheck
Convert calls to printf-like functions to std::print and std::println.
Definition: UseStdPrintCheck.h:20

clang::tidy::modernize::UseTrailingReturnTypeCheck
Rewrites function signatures to use a trailing return type.
Definition: UseTrailingReturnTypeCheck.h:28

clang::tidy::modernize::UseTransparentFunctorsCheck
Prefer using transparent functors to non-transparent ones.
Definition: UseTransparentFunctorsCheck.h:20

clang::tidy::modernize::UseUncaughtExceptionsCheck
This check will warn on calls to std::uncaught_exception and replace them with calls to std::uncaught...
Definition: UseUncaughtExceptionsCheck.h:22

clang::tidy::modernize::UseUsingCheck
Check finds typedefs and replaces it with usings.
Definition: UseUsingCheck.h:20

clang::ast_matchers
Definition: AbseilMatcher.h:13

clang::tidy
Definition: AbseilTidyModule.cpp:32

clang::tidy::ModernizeModuleAnchorSource
volatile int ModernizeModuleAnchorSource
Definition: ModernizeTidyModule.cpp:136

UseRangesCheck.h