extra/doxygen/AbseilTidyModule_8cpp_source.html

//===------- AbseilTidyModule.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 "CleanupCtadCheck.h"

#include "DurationAdditionCheck.h"

#include "DurationComparisonCheck.h"

#include "DurationConversionCastCheck.h"

#include "DurationDivisionCheck.h"

#include "DurationFactoryFloatCheck.h"

#include "DurationFactoryScaleCheck.h"

#include "DurationSubtractionCheck.h"

#include "DurationUnnecessaryConversionCheck.h"

#include "FasterStrsplitDelimiterCheck.h"

#include "NoInternalDependenciesCheck.h"

#include "NoNamespaceCheck.h"

#include "RedundantStrcatCallsCheck.h"

#include "StrCatAppendCheck.h"

#include "StringFindStartswithCheck.h"

#include "StringFindStrContainsCheck.h"

#include "TimeComparisonCheck.h"

#include "TimeSubtractionCheck.h"

#include "UpgradeDurationConversionsCheck.h"


namespace clang::tidy {

namespace abseil {


class AbseilModule : public ClangTidyModule {

public:

  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {

    CheckFactories.registerCheck<CleanupCtadCheck>("abseil-cleanup-ctad");

    CheckFactories.registerCheck<DurationAdditionCheck>(

        "abseil-duration-addition");

    CheckFactories.registerCheck<DurationComparisonCheck>(

        "abseil-duration-comparison");

    CheckFactories.registerCheck<DurationConversionCastCheck>(

        "abseil-duration-conversion-cast");

    CheckFactories.registerCheck<DurationDivisionCheck>(

        "abseil-duration-division");

    CheckFactories.registerCheck<DurationFactoryFloatCheck>(

        "abseil-duration-factory-float");

    CheckFactories.registerCheck<DurationFactoryScaleCheck>(

        "abseil-duration-factory-scale");

    CheckFactories.registerCheck<DurationSubtractionCheck>(

        "abseil-duration-subtraction");

    CheckFactories.registerCheck<DurationUnnecessaryConversionCheck>(

        "abseil-duration-unnecessary-conversion");

    CheckFactories.registerCheck<FasterStrsplitDelimiterCheck>(

        "abseil-faster-strsplit-delimiter");

    CheckFactories.registerCheck<NoInternalDependenciesCheck>(

        "abseil-no-internal-dependencies");

    CheckFactories.registerCheck<NoNamespaceCheck>("abseil-no-namespace");

    CheckFactories.registerCheck<RedundantStrcatCallsCheck>(

        "abseil-redundant-strcat-calls");

    CheckFactories.registerCheck<StrCatAppendCheck>(

        "abseil-str-cat-append");

    CheckFactories.registerCheck<StringFindStartswithCheck>(

        "abseil-string-find-startswith");

    CheckFactories.registerCheck<StringFindStrContainsCheck>(

        "abseil-string-find-str-contains");

    CheckFactories.registerCheck<TimeComparisonCheck>(

        "abseil-time-comparison");

    CheckFactories.registerCheck<TimeSubtractionCheck>(

        "abseil-time-subtraction");

    CheckFactories.registerCheck<UpgradeDurationConversionsCheck>(

        "abseil-upgrade-duration-conversions");

  }

};


// Register the AbseilModule using this statically initialized variable.

static ClangTidyModuleRegistry::Add<AbseilModule> X("abseil-module",

                                                    "Add Abseil checks.");


} // namespace abseil


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

// and thus register the AbseilModule.

volatile int AbseilModuleAnchorSource = 0;


} // namespace clang::tidy

CleanupCtadCheck.h

DurationAdditionCheck.h

DurationComparisonCheck.h

DurationConversionCastCheck.h

DurationDivisionCheck.h

DurationFactoryFloatCheck.h

DurationFactoryScaleCheck.h

DurationSubtractionCheck.h

DurationUnnecessaryConversionCheck.h

FasterStrsplitDelimiterCheck.h

X
int X
Definition: LSPBinderTests.cpp:26

NoInternalDependenciesCheck.h

NoNamespaceCheck.h

RedundantStrcatCallsCheck.h

StrCatAppendCheck.h

StringFindStartswithCheck.h

StringFindStrContainsCheck.h

TimeComparisonCheck.h

TimeSubtractionCheck.h

UpgradeDurationConversionsCheck.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::abseil::AbseilModule
Definition: AbseilTidyModule.cpp:35

clang::tidy::abseil::AbseilModule::addCheckFactories
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override
Implement this function in order to register all CheckFactories belonging to this module.
Definition: AbseilTidyModule.cpp:37

clang::tidy::abseil::CleanupCtadCheck
Suggests switching the initialization pattern of absl::Cleanup instances from the factory function to...
Definition: CleanupCtadCheck.h:22

clang::tidy::abseil::DurationAdditionCheck
Checks for cases where addition should be performed in the absl::Time domain.
Definition: DurationAdditionCheck.h:21

clang::tidy::abseil::DurationComparisonCheck
Prefer comparison in the absl::Duration domain instead of the numeric domain.
Definition: DurationComparisonCheck.h:21

clang::tidy::abseil::DurationConversionCastCheck
Checks for casts of absl::Duration conversion functions, and recommends the right conversion function...
Definition: DurationConversionCastCheck.h:21

clang::tidy::abseil::DurationDivisionCheck
Definition: DurationDivisionCheck.h:21

clang::tidy::abseil::DurationFactoryFloatCheck
This check finds cases where Duration factories are being called with floating point arguments,...
Definition: DurationFactoryFloatCheck.h:23

clang::tidy::abseil::DurationFactoryScaleCheck
This check finds cases where the incorrect Duration factory function is being used by looking for sca...
Definition: DurationFactoryScaleCheck.h:23

clang::tidy::abseil::DurationSubtractionCheck
Checks for cases where subtraction should be performed in the absl::Duration domain.
Definition: DurationSubtractionCheck.h:21

clang::tidy::abseil::DurationUnnecessaryConversionCheck
Finds and fixes cases where absl::Duration values are being converted to numeric types and back again...
Definition: DurationUnnecessaryConversionCheck.h:21

clang::tidy::abseil::FasterStrsplitDelimiterCheck
Finds instances of absl::StrSplit() or absl::MaxSplits() where the delimiter is a single character st...
Definition: FasterStrsplitDelimiterCheck.h:21

clang::tidy::abseil::NoInternalDependenciesCheck
Finds instances where the user depends on internal details and warns them against doing so.
Definition: NoInternalDependenciesCheck.h:21

clang::tidy::abseil::NoNamespaceCheck
This check ensures users don't open namespace absl, as that violates Abseil's compatibility guideline...
Definition: NoNamespaceCheck.h:21

clang::tidy::abseil::RedundantStrcatCallsCheck
Flags redundant calls to absl::StrCat when the result is being passed to another call of absl::StrCat...
Definition: RedundantStrcatCallsCheck.h:24

clang::tidy::abseil::StrCatAppendCheck
Flags uses of absl::StrCat to append to a string.
Definition: StrCatAppendCheck.h:21

clang::tidy::abseil::StringFindStartswithCheck
Definition: StringFindStartswithCheck.h:24

clang::tidy::abseil::StringFindStrContainsCheck
Finds s.find(...) == string::npos comparisons (for various string-like types) and suggests replacing ...
Definition: StringFindStrContainsCheck.h:22

clang::tidy::abseil::TimeComparisonCheck
Prefer comparison in the absl::Time domain instead of the numeric domain.
Definition: TimeComparisonCheck.h:21

clang::tidy::abseil::TimeSubtractionCheck
Finds and fixes absl::Time subtraction expressions to do subtraction in the time domain instead of th...
Definition: TimeSubtractionCheck.h:21

clang::tidy::abseil::UpgradeDurationConversionsCheck
Finds deprecated uses of absl::Duration arithmetic operators and factories.
Definition: UpgradeDurationConversionsCheck.h:23

clang::tidy
Definition: AbseilTidyModule.cpp:32

clang::tidy::AbseilModuleAnchorSource
volatile int AbseilModuleAnchorSource
Definition: AbseilTidyModule.cpp:85