| Cclang::clangd::Anchor | |
| Cllvm::Annotations | |
| Cclang::clangd::Annotations | Same as llvm::Annotations, but adjusts functions to LSP-specific types for positions and ranges |
| Cclang::clangd::ApplyWorkspaceEditParams | |
| Cclang::clangd::ApplyWorkspaceEditResponse | |
| Cclang::clangd::ArgStripper | |
| Cclang::pp_trace::Argument | |
| Cclang::clangd::ASTAction | |
| Cclang::clangd::TUScheduler::ASTCache | An LRU cache of idle ASTs |
| CASTConsumer | |
| CCollectEntitiesConsumer | |
| CCompileCheckConsumer | |
| CCoverageCheckerConsumer | |
| Cclang::doc::MapASTVisitor | |
| Cclang::ASTFrontendAction | |
| Cclang::find_all_symbols::FindAllSymbolsAction | |
| Cclang::move::ClangMoveAction | |
| Cclang::clangd::FeatureModule::ASTListener | Extension point that allows modules to observe and modify an AST build |
| Cclang::clangd::ASTNode | Simplified description of a clang AST node |
| Cclang::clangd::ASTParams | Payload for textDocument/ast request |
| Cclang::clangd::ASTRetentionPolicy | Configuration of the AST retention policy |
| Cclang::clangd::ASTSignals | Signals derived from a valid AST of a file |
| Cclang::clangd::AsyncTaskRunner | Runs tasks on separate (detached) threads and wait for all tasks to finish |
| Cclang::clangd::BackgroundIndexRebuilder | |
| Cclang::clangd::BackgroundIndexStorage | |
| Cclang::clangd::MemoryShardStorage | |
| Cclang::clangd::BackgroundQueue | |
| Cclang::doc::BitCodeConstants | |
| CBlock | |
| Cclang::CodeBlock | |
| Cclang::Ruler | |
| Cclang::clangd::markup::Block | Holds text and knows how to lay it out |
| Cclang::clangd::markup::Paragraph | Represents parts of the markup that can contain strings, like inline code, code block or plain text |
| Cclang::doc::BlockIdToIndexFunctor | |
| Cllvm::yaml::BlockScalarTraits< MultiLineString > | |
| Cclang::tidy::utils::BraceInsertionHints | A provider of fix-it hints to insert opening and closing braces |
| Cclang::clangd::DirectoryBasedGlobalCompilationDatabase::BroadcastThread | |
| Cclang::clangd::TUStatus::BuildDetails | |
| Cclang::clangd::RefSlab::Builder | RefSlab::Builder is a mutable container that can 'freeze' to RefSlab |
| Cclang::clangd::RelationSlab::Builder | RelationSlab::Builder is a mutable container that can 'freeze' to RelationSlab |
| Cclang::clangd::SymbolSlab::Builder | SymbolSlab::Builder is a mutable container that can 'freeze' to SymbolSlab |
| Cclang::pp_trace::CallbackCall | This class represents one callback call by name and an array of arguments |
| Cclang::clangd::ClangdServer::Callbacks | Interface with hooks for users of ClangdServer to be notified of events |
| Cclang::clangd::ClangdLSPServer | This class exposes ClangdServer's capabilities via Language Server Protocol |
| Cclang::clangd::CallHierarchyIncomingCall | Represents an incoming call, e.g. a caller of a method or constructor |
| Cclang::clangd::CallHierarchyIncomingCallsParams | The parameter of a callHierarchy/incomingCalls request |
| Cclang::clangd::CallHierarchyItem | Represents programming constructs like functions or constructors in the context of call hierarchy |
| Cclang::clangd::CallHierarchyOutgoingCall | Represents an outgoing call, e.g |
| Cclang::clangd::CallHierarchyOutgoingCallsParams | The parameter of a callHierarchy/outgoingCalls request |
| Cclang::clangd::LSPClient::CallResult | |
| Cclang::clangd::CancelState | |
| Cclang::clangd::CanonicalIncludes | Maps a definition location onto an #include file, based on a set of filename rules |
| Cclang::clangd::CapturedASTCtx | The captured AST context |
| Cclang::clangd::config::CapturedDiags | |
| Cclang::clangd::Config::CDBSearchSpec | |
| Cclang::clangd::ChangeAnnotation | |
| Cclang::clangd::CheapUnresolvedName | |
| Cclang::tidy::performance::UnnecessaryCopyInitializationCheck::CheckContext | |
| Cclang::tidy::bugprone::UnsafeFunctionsCheck::CheckedFunction | |
| Cclang::tidy::ChecksAndOptions | |
| Cclang::clangd::dex::Chunk | NOTE: This is an implementation detail |
| Cclang::clangd::riff::Chunk | |
| Cclang::clangd::ClangdCompileCommand | Clangd extension that's used in the 'compilationDatabaseChanges' in workspace/didChangeConfiguration to record updates to the in-memory compilation database |
| Cclang::clangd::ClangdDiagnosticOptions | |
| Cclang::doc::ClangDocBitcodeReader | |
| Cclang::doc::ClangDocBitcodeWriter | |
| Cclang::doc::ClangDocContext | |
| Cclang::clangd::ClangdServer | Manages a collection of source files and derived data (ASTs, indexes), and provides language-aware features such as code completion |
| Cclang::move::ClangMoveContext | |
| Cclang::tidy::ClangTidyASTConsumerFactory | |
| Cclang::clangd::config::Fragment::DiagnosticsBlock::ClangTidyBlock | Controls how clang-tidy will run over the code base |
| CClangTidyCheck | |
| Cclang::tidy::RenamerClangTidyCheck | Base class for clang-tidy checks that want to flag declarations and/or macros for renaming based on customizable criteria |
| Cclang::tidy::bugprone::ReservedIdentifierCheck | Checks for usages of identifiers reserved for use by the implementation |
| Cclang::tidy::readability::IdentifierNamingCheck | Checks for identifiers naming style mismatch |
| Cclang::tidy::abseil::DurationAdditionCheck | Checks for cases where addition should be performed in the absl::Time domain |
| Cclang::tidy::abseil::DurationComparisonCheck | Prefer comparison in the absl::Duration domain instead of the numeric domain |
| Cclang::tidy::abseil::DurationConversionCastCheck | Checks for casts of absl::Duration conversion functions, and recommends the right conversion function instead |
| Cclang::tidy::abseil::DurationDivisionCheck | |
| Cclang::tidy::abseil::DurationFactoryFloatCheck | This check finds cases where Duration factories are being called with floating point arguments, but could be called using integer arguments |
| Cclang::tidy::abseil::DurationFactoryScaleCheck | This check finds cases where the incorrect Duration factory function is being used by looking for scaling constants inside the factory argument and suggesting a more appropriate factory |
| Cclang::tidy::abseil::DurationSubtractionCheck | Checks for cases where subtraction should be performed in the absl::Duration domain |
| Cclang::tidy::abseil::DurationUnnecessaryConversionCheck | Finds and fixes cases where absl::Duration values are being converted to numeric types and back again |
| Cclang::tidy::abseil::FasterStrsplitDelimiterCheck | Finds instances of absl::StrSplit() or absl::MaxSplits() where the delimiter is a single character string literal and replaces it with a character |
| Cclang::tidy::abseil::NoInternalDependenciesCheck | Finds instances where the user depends on internal details and warns them against doing so |
| Cclang::tidy::abseil::NoNamespaceCheck | This check ensures users don't open namespace absl, as that violates Abseil's compatibility guidelines |
| Cclang::tidy::abseil::RedundantStrcatCallsCheck | Flags redundant calls to absl::StrCat when the result is being passed to another call of absl::StrCat/absl::StrAppend |
| Cclang::tidy::abseil::StrCatAppendCheck | Flags uses of absl::StrCat to append to a string |
| Cclang::tidy::abseil::StringFindStartswithCheck | |
| Cclang::tidy::abseil::TimeComparisonCheck | Prefer comparison in the absl::Time domain instead of the numeric domain |
| Cclang::tidy::abseil::TimeSubtractionCheck | Finds and fixes absl::Time subtraction expressions to do subtraction in the time domain instead of the numeric domain |
| Cclang::tidy::abseil::UncheckedStatusOrAccessCheck | |
| Cclang::tidy::abseil::UpgradeDurationConversionsCheck | Finds deprecated uses of absl::Duration arithmetic operators and factories |
| Cclang::tidy::altera::IdDependentBackwardBranchCheck | Finds ID-dependent variables and fields used within loops, and warns of their usage |
| Cclang::tidy::altera::KernelNameRestrictionCheck | Finds kernel files and include directives whose filename is kernel.cl, Verilog.cl, or VHDL.cl |
| Cclang::tidy::altera::SingleWorkItemBarrierCheck | Detects OpenCL kernel functions that call a barrier but do not call an ID-function function |
| Cclang::tidy::altera::StructPackAlignCheck | Finds structs that are inefficiently packed or aligned, and recommends packing and/or aligning of said structs as needed |
| Cclang::tidy::altera::UnrollLoopsCheck | Finds inner loops that have not been unrolled, as well as fully unrolled loops with unknown loop bounds or a large number of iterations |
| Cclang::tidy::android::CloexecCheck | The base class for all close-on-exec checks in Android module |
| Cclang::tidy::android::CloexecAccept4Check | Finds code that uses accept4() without using the SOCK_CLOEXEC flag |
| Cclang::tidy::android::CloexecAcceptCheck | Accept() is better to be replaced by accept4() |
| Cclang::tidy::android::CloexecCreatCheck | Creat() is better to be replaced by open() |
| Cclang::tidy::android::CloexecDupCheck | Dup() is better to be replaced by fcntl(), which has close-on-exec flag |
| Cclang::tidy::android::CloexecEpollCreate1Check | Finds code that uses epoll_create1() without using the EPOLL_CLOEXEC flag |
| Cclang::tidy::android::CloexecEpollCreateCheck | Epoll_create() is better to be replaced by epoll_create1() |
| Cclang::tidy::android::CloexecFopenCheck | Fopen() is suggested to include "e" in their mode string; like "re" would be better than "r" |
| Cclang::tidy::android::CloexecInotifyInit1Check | Finds code that uses inotify_init1() without using the IN_CLOEXEC flag |
| Cclang::tidy::android::CloexecInotifyInitCheck | Inotify_init() is better to be replaced by inotify_init1() |
| Cclang::tidy::android::CloexecMemfdCreateCheck | Finds code that uses memfd_create() without using the MFD_CLOEXEC flag |
| Cclang::tidy::android::CloexecOpenCheck | Finds code that opens file without using the O_CLOEXEC flag |
| Cclang::tidy::android::CloexecPipe2Check | Finds code that uses pipe2() without using the O_CLOEXEC flag |
| Cclang::tidy::android::CloexecPipeCheck | Suggests to replace calls to pipe() with calls to pipe2() |
| Cclang::tidy::android::CloexecSocketCheck | Finds code that uses socket() without using the SOCK_CLOEXEC flag |
| Cclang::tidy::android::ComparisonInTempFailureRetryCheck | Attempts to catch calls to TEMP_FAILURE_RETRY with a top-level comparison operation, like TEMP_FAILURE_RETRY(read(...) != N) |
| Cclang::tidy::boost::UseToStringCheck | Finds calls to boost::lexical_cast<std::string> and / boost::lexical_cast<std::wstring> and replaces them with / std::to_string and std::to_wstring calls |
| Cclang::tidy::bugprone::ArgumentCommentCheck | |
| Cclang::tidy::bugprone::AssertSideEffectCheck | Finds assert() with side effect |
| Cclang::tidy::bugprone::AssignmentInIfConditionCheck | Catches assignments within the condition clause of an if statement |
| Cclang::tidy::bugprone::BadSignalToKillThreadCheck | Finds pthread_kill function calls when thread is terminated by / SIGTERM signal |
| Cclang::tidy::bugprone::BitwisePointerCastCheck | Warns about code that tries to cast between pointers by means of std::bit_cast or memcpy |
| Cclang::tidy::bugprone::BoolPointerImplicitConversionCheck | Checks for conditions based on implicit conversion from a bool pointer to bool |
| Cclang::tidy::bugprone::BranchCloneCheck | A check for detecting if/else if/else chains where two or more branches are Type I clones of each other (that is, they contain identical code), for detecting switch statements where two or more consecutive branches are Type I clones of each other, and for detecting conditional operators where the true and false expressions are Type I clones of each other |
| Cclang::tidy::bugprone::CapturingThisInMemberVariableCheck | Finds lambda captures that capture the this pointer and store it as class members without handle the copy and move constructors and the assignments |
| Cclang::tidy::bugprone::CastingThroughVoidCheck | Detects unsafe or redundant two-step casting operations involving void* |
| Cclang::tidy::bugprone::ChainedComparisonCheck | Check detects chained comparison operators that can lead to unintended behavior or logical errors |
| Cclang::tidy::bugprone::CommandProcessorCheck | Execution of a command processor can lead to security vulnerabilities, and is generally not required |
| Cclang::tidy::bugprone::ComparePointerToMemberVirtualFunctionCheck | Detects unspecified behavior about equality comparison between pointer to member virtual function and anything other than null-pointer-constant |
| Cclang::tidy::bugprone::CopyConstructorInitCheck | Finds copy constructors where the ctor don't call the copy constructor of the base class |
| Cclang::tidy::bugprone::CopyConstructorMutatesArgumentCheck | Finds assignments to the copied object and its direct or indirect members in copy constructors and copy assignment operators |
| Cclang::tidy::bugprone::CrtpConstructorAccessibilityCheck | Detects error-prone Curiously Recurring Template Pattern usage, when the CRTP can be constructed outside itself and the derived class |
| Cclang::tidy::bugprone::DanglingHandleCheck | Detect dangling references in value handlers like std::string_view |
| Cclang::tidy::bugprone::DefaultOperatorNewOnOveralignedTypeCheck | Checks if an object of type with extended alignment is allocated by using the default operator new |
| Cclang::tidy::bugprone::DerivedMethodShadowingBaseMethodCheck | Checks that a derived class does not define the same (non virtual) method as a base class |
| Cclang::tidy::bugprone::DynamicStaticInitializersCheck | Finds dynamically initialized static variables in header files |
| Cclang::tidy::bugprone::EasilySwappableParametersCheck | Finds function definitions where parameters of convertible types follow each other directly, making call sites prone to calling the function with swapped (or badly ordered) arguments |
| Cclang::tidy::bugprone::EmptyCatchCheck | Detects and suggests addressing issues with empty catch statements |
| Cclang::tidy::bugprone::ExceptionCopyConstructorThrowsCheck | Checks whether a thrown object is nothrow copy constructible |
| Cclang::tidy::bugprone::ExceptionEscapeCheck | Finds functions which should not throw exceptions: Destructors, move constructors, move assignment operators, the main() function, swap() functions, functions marked with throw() or noexcept and functions given as option to the checker |
| Cclang::tidy::bugprone::FloatLoopCounterCheck | This check diagnoses when the loop induction expression of a for loop has floating-point type |
| Cclang::tidy::bugprone::FoldInitTypeCheck | Find and flag invalid initializer values in folds, e.g |
| Cclang::tidy::bugprone::ForwardDeclarationNamespaceCheck | Checks if an unused forward declaration is in a wrong namespace |
| Cclang::tidy::bugprone::ForwardingReferenceOverloadCheck | The checker looks for constructors that can act as copy or move constructors through their forwarding reference parameters |
| Cclang::tidy::bugprone::ImplicitWideningOfMultiplicationResultCheck | Diagnoses instances of an implicit widening of multiplication result |
| Cclang::tidy::bugprone::InaccurateEraseCheck | Checks for inaccurate use of the erase() method |
| Cclang::tidy::bugprone::IncDecInConditionsCheck | Detects when a variable is both incremented/decremented and referenced inside a complex condition and suggests moving them outside to avoid ambiguity in the variable's value |
| Cclang::tidy::bugprone::IncorrectEnableIfCheck | Detects incorrect usages of std::enable_if that don't name the nested / type type |
| Cclang::tidy::bugprone::IncorrectEnableSharedFromThisCheck | Detect classes or structs that do not publicly inherit from std::enable_shared_from_this, because unintended behavior will / otherwise occur when calling shared_from_this |
| Cclang::tidy::bugprone::IncorrectRoundingsCheck | Checks the usage of patterns known to produce incorrect rounding |
| Cclang::tidy::bugprone::InfiniteLoopCheck | Finds obvious infinite loops (loops where the condition variable is not changed at all) |
| Cclang::tidy::bugprone::IntegerDivisionCheck | Finds cases where integer division in a floating point context is likely to cause unintended loss of precision |
| Cclang::tidy::bugprone::InvalidEnumDefaultInitializationCheck | Detects default initialization (to 0) of variables with enum type where the enum has no enumerator with value of 0 |
| Cclang::tidy::bugprone::LambdaFunctionNameCheck | Detect when func or FUNCTION is being used from within a lambda |
| Cclang::tidy::bugprone::MacroParenthesesCheck | Finds macros that can have unexpected behaviour due to missing parentheses |
| Cclang::tidy::bugprone::MacroRepeatedSideEffectsCheck | Checks for repeated argument with side effects in macros |
| Cclang::tidy::bugprone::MisleadingSetterOfReferenceCheck | Emits a warning when a setter-like function that has a pointer parameter is used to set value of a field with reference type |
| Cclang::tidy::bugprone::MisplacedOperatorInStrlenInAllocCheck | Finds cases where 1 is added to the string in the argument to a function / in the strlen() family instead of the result and value is used as an argument to a memory allocation function |
| Cclang::tidy::bugprone::MisplacedPointerArithmeticInAllocCheck | Finds cases where an integer is added to or subracted from the result of a memory allocation function instead of its argument |
| Cclang::tidy::bugprone::MisplacedWideningCastCheck | Find casts of calculation results to bigger type |
| Cclang::tidy::bugprone::MoveForwardingReferenceCheck | The check warns if std::move is applied to a forwarding reference (i.e |
| Cclang::tidy::bugprone::MultiLevelImplicitPointerConversionCheck | Detects implicit conversions between pointers of different levels of indirection |
| Cclang::tidy::bugprone::MultipleNewInOneExpressionCheck | For the user-facing documentation see: https://clang.llvm.org/extra/clang-tidy/checks/bugprone/multiple-new-in-one-expression.html |
| Cclang::tidy::bugprone::MultipleStatementMacroCheck | Detect multiple statement macros that are used in unbraced conditionals |
| Cclang::tidy::bugprone::NarrowingConversionsCheck | Checks for narrowing conversions, e.g: int i = 0; i += 0.1; |
| Cclang::tidy::bugprone::NoEscapeCheck | Block arguments in dispatch_async() and dispatch_after() are guaranteed to escape |
| Cclang::tidy::bugprone::NonZeroEnumToBoolConversionCheck | Detect implicit and explicit casts of enum type into bool where enum type doesn't have a zero-value enumerator |
| Cclang::tidy::bugprone::NondeterministicPointerIterationOrderCheck | Finds nondeterministic usages of pointers in unordered containers |
| Cclang::tidy::bugprone::NotNullTerminatedResultCheck | Finds function calls where it is possible to cause a not null-terminated result |
| Cclang::tidy::bugprone::OptionalValueConversionCheck | Detects potentially unintentional and redundant conversions where a value is extracted from an optional-like type and then used to create a new instance of the same optional-like type |
| Cclang::tidy::bugprone::ParentVirtualCallCheck | Finds calls to grand..-parent virtual methods instead of parent's |
| Cclang::tidy::bugprone::PointerArithmeticOnPolymorphicObjectCheck | Finds pointer arithmetic performed on classes that contain a virtual function |
| Cclang::tidy::bugprone::PosixReturnCheck | |
| Cclang::tidy::bugprone::RandomGeneratorSeedCheck | Random number generator must be seeded properly |
| Cclang::tidy::bugprone::RawMemoryCallOnNonTrivialTypeCheck | Flags use of the C standard library functions 'memset', 'memcpy' and 'memcmp' and similar derivatives on non-trivial types |
| Cclang::tidy::bugprone::RedundantBranchConditionCheck | Finds condition variables in nested if statements that were also checked in the outer if statement and were not changed |
| Cclang::tidy::bugprone::ReturnConstRefFromParameterCheck | Detects return statements that return a constant reference parameter as constant reference |
| Cclang::tidy::bugprone::SignalHandlerCheck | Checker for signal handler functions |
| Cclang::tidy::bugprone::SignedCharMisuseCheck | Finds those signed char -> integer conversions which might indicate a / programming error |
| Cclang::tidy::bugprone::SizeofContainerCheck | Find usages of sizeof on expressions of STL container types |
| Cclang::tidy::bugprone::SizeofExpressionCheck | Find suspicious usages of sizeof expressions |
| Cclang::tidy::bugprone::SmartPtrArrayMismatchCheck | Find constructions of smart (unique or shared) pointers where the pointer is declared with non-array target type and an array (created with a new-expression) is passed to it |
| Cclang::tidy::bugprone::SharedPtrArrayMismatchCheck | Find std::shared_ptr<T>(new T[...]), replace it (if applicable) with std::shared_ptr<T[]>(new T[...]) |
| Cclang::tidy::bugprone::UniquePtrArrayMismatchCheck | Finds initializations of C++ unique pointers to non-array type that are initialized with an array |
| Cclang::tidy::bugprone::SpuriouslyWakeUpFunctionsCheck | Finds cnd_wait, cnd_timedwait, wait, wait_for, or / wait_until function calls when the function is not invoked from a loop that checks whether a condition predicate holds or the function has a condition parameter |
| Cclang::tidy::bugprone::StandaloneEmptyCheck | Checks for ignored calls to empty() on a range and suggests clear() as an alternative if it is an existing member function |
| Cclang::tidy::bugprone::StdNamespaceModificationCheck | Modification of the std or posix namespace can result in undefined behavior |
| Cclang::tidy::bugprone::StringConstructorCheck | Finds suspicious string constructor and check their parameters |
| Cclang::tidy::bugprone::StringIntegerAssignmentCheck | Finds instances where an integer is assigned to a string |
| Cclang::tidy::bugprone::StringLiteralWithEmbeddedNulCheck | Find suspicious string literals with embedded NUL characters |
| Cclang::tidy::bugprone::SuspiciousEnumUsageCheck | The checker detects various cases when an enum is probably misused (as a bitmask) |
| Cclang::tidy::bugprone::SuspiciousIncludeCheck | Warns on inclusion of files whose names suggest that they're implementation files, instead of headers |
| Cclang::tidy::bugprone::SuspiciousMemoryComparisonCheck | Finds potentially incorrect calls to memcmp() based on properties of the arguments |
| Cclang::tidy::bugprone::SuspiciousMemsetUsageCheck | Finds memset calls with potential mistakes in their arguments |
| Cclang::tidy::bugprone::SuspiciousMissingCommaCheck | This check finds string literals which are probably concatenated accidentally |
| Cclang::tidy::bugprone::SuspiciousReallocUsageCheck | Finds usages of realloc where the return value is assigned to the same variable as passed to the first argument |
| Cclang::tidy::bugprone::SuspiciousSemicolonCheck | This check finds semicolon that modifies the meaning of the program unintendedly |
| Cclang::tidy::bugprone::SuspiciousStringCompareCheck | Find suspicious calls to string compare functions |
| Cclang::tidy::bugprone::SuspiciousStringviewDataUsageCheck | Identifies suspicious usages of std::string_view::data() that could lead to reading out-of-bounds data due to inadequate or incorrect string null termination |
| Cclang::tidy::bugprone::SwappedArgumentsCheck | Finds potentially swapped arguments by looking at implicit conversions |
| Cclang::tidy::bugprone::SwitchMissingDefaultCaseCheck | Ensures that switch statements without default cases are flagged, focuses only on covering cases with non-enums where the compiler may not issue warnings |
| Cclang::tidy::bugprone::TaggedUnionMemberCountCheck | Gives warnings for tagged unions, where the number of tags is different from the number of data members inside the union |
| Cclang::tidy::bugprone::TerminatingContinueCheck | Checks if a 'continue' statement terminates the loop (i.e |
| Cclang::tidy::bugprone::ThrowKeywordMissingCheck | Emits a warning about temporary objects whose type is (or is derived from) a class that has 'EXCEPTION', 'Exception' or 'exception' in its name |
| Cclang::tidy::bugprone::ThrowingStaticInitializationCheck | Checks whether the constructor for a static or thread_local object will throw |
| Cclang::tidy::bugprone::TooSmallLoopVariableCheck | This check gives a warning if a loop variable has a too small type which might not be able to represent all values which are part of the whole range in which the loop iterates |
| Cclang::tidy::bugprone::UncheckedOptionalAccessCheck | Warns when the code is unwrapping a std::optional<T>, absl::optional<T>, or base::std::optional<T> object without assuring that it contains a value |
| Cclang::tidy::bugprone::UncheckedStringToNumberConversionCheck | Guards against use of string conversion functions that do not have reasonable error handling for conversion errors |
| Cclang::tidy::bugprone::UndefinedMemoryManipulationCheck | Finds calls of memory manipulation functions memset(), memcpy() and / memmove() on non-TriviallyCopyable objects resulting in undefined behavior |
| Cclang::tidy::bugprone::UndelegatedConstructorCheck | Finds creation of temporary objects in constructors that look like a function call to another constructor of the same class |
| Cclang::tidy::bugprone::UnhandledExceptionAtNewCheck | Finds calls to 'new' that may throw unhandled exception at allocation failure |
| Cclang::tidy::bugprone::UnhandledSelfAssignmentCheck | Finds user-defined copy assignment operators which do not protect the code against self-assignment either by checking self-assignment explicitly or using the copy-and-swap or the copy-and-move method |
| Cclang::tidy::bugprone::UnintendedCharOstreamOutputCheck | Finds unintended character output from unsigned char and signed char to an ostream |
| Cclang::tidy::bugprone::UnsafeFunctionsCheck | Checks for functions that have safer, more secure replacements available, or are considered deprecated due to design flaws |
| Cclang::tidy::bugprone::UnusedLocalNonTrivialVariableCheck | Warns when a local non trivial variable is unused within a function |
| Cclang::tidy::bugprone::UnusedRaiiCheck | Finds temporaries that look like RAII objects |
| Cclang::tidy::bugprone::UnusedReturnValueCheck | Detects function calls where the return value is unused |
| Cclang::tidy::hicpp::IgnoredRemoveResultCheck | Ensure that the result of std::remove, std::remove_if and std::unique are not ignored according to rule 17.5.1 |
| Cclang::tidy::bugprone::UseAfterMoveCheck | The check warns if an object is used after it has been moved, without an intervening reinitialization |
| Cclang::tidy::bugprone::VirtualNearMissCheck | Checks for near miss of virtual methods |
| Cclang::tidy::concurrency::MtUnsafeCheck | Checks that non-thread-safe functions are not used |
| Cclang::tidy::concurrency::ThreadCanceltypeAsynchronousCheck | Finds pthread_setcanceltype function calls where a thread's cancellation type is set to asynchronous |
| Cclang::tidy::cppcoreguidelines::AvoidCapturingLambdaCoroutinesCheck | Flags C++20 coroutine lambdas with non-empty capture lists that may cause use-after-free errors and suggests avoiding captures or ensuring the lambda closure object has a guaranteed lifetime |
| Cclang::tidy::cppcoreguidelines::AvoidConstOrRefDataMembersCheck | Const-qualified or reference data members in classes should be avoided, as they make the class non-copy-assignable |
| Cclang::tidy::cppcoreguidelines::AvoidDoWhileCheck | Do-while loops are less readable than plan while loops, and can lead to subtle bugs |
| Cclang::tidy::cppcoreguidelines::AvoidGotoCheck | The usage of goto for control flow is error prone and should be replaced with looping constructs |
| Cclang::tidy::cppcoreguidelines::AvoidNonConstGlobalVariablesCheck | Non-const global variables hide dependencies and make the dependencies subject to unpredictable changes |
| Cclang::tidy::cppcoreguidelines::AvoidReferenceCoroutineParametersCheck | Warns on coroutines that accept reference parameters |
| Cclang::tidy::cppcoreguidelines::InitVariablesCheck | Find uninitialized local variables |
| Cclang::tidy::cppcoreguidelines::InterfacesGlobalInitCheck | Flags possible initialization order issues of static variables |
| Cclang::tidy::cppcoreguidelines::MacroUsageCheck | Find macro usage that is considered problematic because better language constructs exist for the task |
| Cclang::tidy::cppcoreguidelines::MisleadingCaptureDefaultByValueCheck | Warns when lambda specify a by-value capture default and capture this |
| Cclang::tidy::cppcoreguidelines::MissingStdForwardCheck | Warns when a function accepting a forwarding reference does anything besides forwarding (with std::forward) the parameter in the body of the function |
| Cclang::tidy::cppcoreguidelines::NoMallocCheck | This checker is concerned with C-style memory management and suggest modern alternatives to it |
| Cclang::tidy::cppcoreguidelines::NoSuspendWithLockCheck | Flag coroutines that suspend while any lock guard is alive |
| Cclang::tidy::cppcoreguidelines::OwningMemoryCheck | Checks for common use cases for gsl::owner and enforces the unique owner nature of it whenever possible |
| Cclang::tidy::cppcoreguidelines::PreferMemberInitializerCheck | Finds member initializations in the constructor body which can be placed into the initialization list instead |
| Cclang::tidy::cppcoreguidelines::ProBoundsArrayToPointerDecayCheck | This check flags all array to pointer decays |
| Cclang::tidy::cppcoreguidelines::ProBoundsAvoidUncheckedContainerAccessCheck | Flags calls to operator[] in STL containers and suggests replacing it with safe alternatives |
| Cclang::tidy::cppcoreguidelines::ProBoundsConstantArrayIndexCheck | This checks that all array subscriptions on static arrays and std::arrays have a constant index and are within bounds |
| Cclang::tidy::cppcoreguidelines::ProBoundsPointerArithmeticCheck | Flags all kinds of pointer arithmetic that have result of pointer type, i.e |
| Cclang::tidy::cppcoreguidelines::ProTypeConstCastCheck | Imposes limitations on the use of const_cast within C++ code |
| Cclang::tidy::cppcoreguidelines::ProTypeCstyleCastCheck | This check flags all use of C-style casts that perform a static_cast downcast, const_cast, or reinterpret_cast |
| Cclang::tidy::cppcoreguidelines::ProTypeMemberInitCheck | Implements C++ Core Guidelines Type.6 |
| Cclang::tidy::cppcoreguidelines::ProTypeReinterpretCastCheck | Flags all occurrences of reinterpret_cast |
| Cclang::tidy::cppcoreguidelines::ProTypeStaticCastDowncastCheck | Checks for usages of static_cast, where a base class is downcasted to a derived class |
| Cclang::tidy::cppcoreguidelines::ProTypeUnionAccessCheck | This check flags all access to members of unions |
| Cclang::tidy::cppcoreguidelines::ProTypeVarargCheck | This check flags all calls to c-style variadic functions and all use of va_arg |
| Cclang::tidy::cppcoreguidelines::RvalueReferenceParamNotMovedCheck | Warns when an rvalue reference function parameter is never moved within the function body |
| Cclang::tidy::cppcoreguidelines::SlicingCheck | Flags slicing (incomplete copying of an object's state) of member variables or vtable |
| Cclang::tidy::cppcoreguidelines::SpecialMemberFunctionsCheck | Checks for classes where some, but not all, of the special member functions are defined |
| Cclang::tidy::cppcoreguidelines::UseEnumClassCheck | Finds unscoped (non-class) enum declarations and suggests using enum class instead |
| Cclang::tidy::cppcoreguidelines::VirtualClassDestructorCheck | Finds base classes whose destructor is neither public and virtual nor protected and non-virtual |
| Cclang::tidy::custom::QueryCheck | Implement of Clang-Query based check |
| Cclang::tidy::darwin::AvoidSpinlockCheck | Finds usages of OSSpinlock, which is deprecated due to potential livelock problems |
| Cclang::tidy::darwin::DispatchOnceNonstaticCheck | Finds variables of type dispatch_once_t that do not have static or global storage duration, as required by the libdispatch documentation |
| Cclang::tidy::fuchsia::DefaultArgumentsCallsCheck | Default arguments are not allowed in called functions |
| Cclang::tidy::fuchsia::DefaultArgumentsDeclarationsCheck | Default parameters are not allowed in declared functions |
| Cclang::tidy::fuchsia::OverloadedOperatorCheck | Overloading operators is disallowed by the Fuchsia coding standard |
| Cclang::tidy::fuchsia::StaticallyConstructedObjectsCheck | Constructing global, non-trivial objects with static storage is disallowed, unless the object is statically initialized with a constexpr constructor or has no explicit constructor |
| Cclang::tidy::fuchsia::TemporaryObjectsCheck | Construction of specific temporary objects in the Zircon kernel is discouraged |
| Cclang::tidy::fuchsia::TrailingReturnCheck | Functions that have trailing returns are disallowed, except for those using decltype specifiers and lambda with otherwise unutterable return types |
| Cclang::tidy::fuchsia::VirtualInheritanceCheck | Defining classes with virtual inheritance is disallowed |
| Cclang::tidy::google::DefaultArgumentsCheck | Checks that default parameters are not given for virtual methods |
| Cclang::tidy::google::ExplicitConstructorCheck | Checks that all single-argument constructors are explicit |
| Cclang::tidy::google::UpgradeGoogletestCaseCheck | Finds uses of deprecated Googletest APIs with names containing "case" and replaces them with equivalent names containing "suite" |
| Cclang::tidy::google::build::ExplicitMakePairCheck | Check that make_pair's template arguments are deduced |
| Cclang::tidy::google::build::UnnamedNamespaceInHeaderCheck | Finds anonymous namespaces in headers |
| Cclang::tidy::google::build::UsingNamespaceDirectiveCheck | Finds using namespace directives |
| Cclang::tidy::google::objc::AvoidNSObjectNewCheck | This check finds Objective-C code that uses +new to create object instances, or overrides +new in classes |
| Cclang::tidy::google::objc::AvoidThrowingObjCExceptionCheck | The check is to find usage of |
| Cclang::tidy::google::objc::FunctionNamingCheck | Finds function names that do not conform to the recommendations of the Google Objective-C Style Guide |
| Cclang::tidy::google::objc::GlobalVariableDeclarationCheck | The check for Objective-C global variables and constants naming convention |
| Cclang::tidy::google::readability::AvoidUnderscoreInGoogletestNameCheck | For the user-facing documentation see: https://clang.llvm.org/extra/clang-tidy/checks/google/readability-avoid-underscore-in-googletest-name.html |
| Cclang::tidy::google::readability::GlobalNamesInHeadersCheck | Flag global namespace pollution in header files |
| Cclang::tidy::google::readability::TodoCommentCheck | Finds TODO comments without a username or bug number |
| Cclang::tidy::google::runtime::IntegerTypesCheck | Finds uses of short, long and long long and suggest replacing them with u?intXX(_t)? |
| Cclang::tidy::google::runtime::OverloadedUnaryAndCheck | Finds overloads of unary operator & |
| Cclang::tidy::google::runtime::RuntimeFloatCheck | Finds usages of long double and suggests against their use due to lack of portability |
| Cclang::tidy::hicpp::ExceptionBaseclassCheck | Check for thrown exceptions and enforce they are all derived from std::exception |
| Cclang::tidy::hicpp::MultiwayPathsCoveredCheck | Find occasions where not all codepaths are explicitly covered in code |
| Cclang::tidy::hicpp::NoAssemblerCheck | Find assembler statements |
| Cclang::tidy::hicpp::SignedBitwiseCheck | This check implements the rule 5.6.1 of the HICPP Standard, which disallows bitwise operations on signed integer types |
| Cclang::tidy::linuxkernel::MustCheckErrsCheck | Checks Linux kernel code to see if it uses the results from the functions in linux/err.h |
| Cclang::tidy::llvm_check::IncludeOrderCheck | Checks the correct order of #includes |
| Cclang::tidy::llvm_check::PreferIsaOrDynCastInConditionalsCheck | Looks at conditionals and finds and replaces cases of cast<>, which will / assert rather than return a null pointer, and dyn_cast<> where / the return value is not captured |
| Cclang::tidy::llvm_check::PreferRegisterOverUnsignedCheck | Historically, LLVM has used unsigned to represent registers |
| Cclang::tidy::llvm_check::PreferStaticOverAnonymousNamespaceCheck | Finds function and variable declarations inside anonymous namespace and suggests replacing them with static declarations |
| Cclang::tidy::llvm_check::TwineLocalCheck | Looks for local Twine variables which are prone to use after frees and should be generally avoided |
| Cclang::tidy::llvm_libc::CalleeNamespaceCheck | Checks all calls resolve to functions within __llvm_libc namespace |
| Cclang::tidy::llvm_libc::ImplementationInNamespaceCheck | Checks all llvm-libc implementation is within the correct namespace |
| Cclang::tidy::llvm_libc::InlineFunctionDeclCheck | Checks that explicitly and implicitly inline functions in headers files are tagged with the LIBC_INLINE macro |
| Cclang::tidy::misc::ConfusableIdentifierCheck | Finds symbol which have confusable identifiers, i.e |
| Cclang::tidy::misc::ConstCorrectnessCheck | This check warns on variables which could be declared const but are not |
| Cclang::tidy::misc::CoroutineHostileRAIICheck | Detects when objects of certain hostile RAII types persists across suspension points in a coroutine |
| Cclang::tidy::misc::DefinitionsInHeadersCheck | Finds non-extern non-inline function and variable definitions in header files, which can lead to potential ODR violations |
| Cclang::tidy::misc::HeaderIncludeCycleCheck | Check detects cyclic #include dependencies between user-defined headers |
| Cclang::tidy::misc::IncludeCleanerCheck | Checks for unused and missing includes |
| Cclang::tidy::misc::MisleadingBidirectionalCheck | Warns about unterminated bidirectional unicode sequence |
| Cclang::tidy::misc::MisleadingIdentifierCheck | Finds identifiers that contain Unicode characters with right-to-left direction, which can be confusing as they may change the understanding of a whole statement line |
| Cclang::tidy::misc::MisplacedConstCheck | This check diagnoses when a const qualifier is applied to a typedef to a pointer type rather than to the pointee |
| Cclang::tidy::misc::MultipleInheritanceCheck | Multiple implementation inheritance is discouraged |
| Cclang::tidy::misc::NewDeleteOverloadsCheck | |
| Cclang::tidy::misc::NoRecursionCheck | Finds strongly connected functions (by analyzing call graph for SCC's that are loops), diagnoses each function in the cycle, and displays one example of possible call graph loop (recursion) |
| Cclang::tidy::misc::NonCopyableObjectsCheck | Flags dereferences and non-pointer declarations of objects that are not meant to be passed by value, such as C FILE objects |
| Cclang::tidy::misc::NonPrivateMemberVariablesInClassesCheck | This checker finds classes that not only contain the data (non-static member variables), but also have logic (non-static member functions), and diagnoses all member variables that have any other scope other than private |
| Cclang::tidy::misc::OverrideWithDifferentVisibilityCheck | Finds virtual function overrides with different visibility than the function in the base class |
| Cclang::tidy::misc::PredictableRandCheck | Pseudorandom number generators are not genuinely random |
| Cclang::tidy::misc::RedundantExpressionCheck | The checker detects expressions that are redundant, because they contain ineffective, useless parts |
| Cclang::tidy::misc::StaticAssertCheck | Replaces assert() with static_assert() if the condition is evaluatable at compile time |
| Cclang::tidy::misc::ThrowByValueCatchByReferenceCheck | Checks for locations that do not throw by value |
| Cclang::tidy::misc::UnconventionalAssignOperatorCheck | Finds declarations of assignment operators with the wrong return and/or argument types and definitions with good return type but wrong return statements |
| Cclang::tidy::misc::UniqueptrResetReleaseCheck | Find and replace unique_ptr::reset(release()) with std::move() |
| Cclang::tidy::misc::UnusedAliasDeclsCheck | Finds unused namespace alias declarations |
| Cclang::tidy::misc::UnusedParametersCheck | Finds unused parameters and fixes them, so that -Wunused-parameter can be turned on |
| Cclang::tidy::misc::UnusedUsingDeclsCheck | Finds unused using declarations |
| Cclang::tidy::misc::UseAnonymousNamespaceCheck | Warns when using 'static' functions or variables at global scope, and suggests moving them to an anonymous namespace |
| Cclang::tidy::misc::UseInternalLinkageCheck | Detects variables and functions that can be marked as static or moved into an anonymous namespace to enforce internal linkage |
| Cclang::tidy::modernize::AvoidBindCheck | Replace simple uses of std::bind with a lambda |
| Cclang::tidy::modernize::AvoidCArraysCheck | Find C-style array types and recommend to use std::array<> / std::vector<> |
| Cclang::tidy::modernize::AvoidCStyleCastCheck | Finds usages of C-style casts |
| Cclang::tidy::modernize::AvoidSetjmpLongjmpCheck | Guards against use of setjmp/longjmp in C++ code |
| Cclang::tidy::modernize::AvoidVariadicFunctionsCheck | Find all function definitions of C-style variadic functions |
| Cclang::tidy::modernize::ConcatNestedNamespacesCheck | |
| Cclang::tidy::modernize::DeprecatedHeadersCheck | This check replaces deprecated C library headers with their C++ STL alternatives |
| Cclang::tidy::modernize::DeprecatedIosBaseAliasesCheck | This check warns the uses of the deprecated member types of std::ios_base and replaces those that have a non-deprecated equivalent |
| Cclang::tidy::modernize::LoopConvertCheck | |
| Cclang::tidy::modernize::MacroToEnumCheck | Replaces groups of related macros with an unscoped anonymous enum |
| Cclang::tidy::modernize::MakeSmartPtrCheck | Base class for MakeSharedCheck and MakeUniqueCheck |
| Cclang::tidy::modernize::MakeSharedCheck | Replace the pattern: |
| Cclang::tidy::modernize::MakeUniqueCheck | Replace the pattern: |
| Cclang::tidy::modernize::MinMaxUseInitializerListCheck | Replaces nested std::min and std::max calls with an initializer list where applicable |
| Cclang::tidy::modernize::PassByValueCheck | |
| Cclang::tidy::modernize::RawStringLiteralCheck | This check replaces string literals with escaped characters to raw string literals |
| Cclang::tidy::modernize::RedundantVoidArgCheck | Find and remove redundant void argument lists |
| Cclang::tidy::modernize::ReplaceAutoPtrCheck | Transforms the deprecated std::auto_ptr into the C++11 std::unique_ptr |
| Cclang::tidy::modernize::ReplaceDisallowCopyAndAssignMacroCheck | This check finds macro expansions of DISALLOW_COPY_AND_ASSIGN(Type) and replaces them with a deleted copy constructor and a deleted assignment operator |
| Cclang::tidy::modernize::ReplaceRandomShuffleCheck | Std::random_shuffle will be removed as of C++17 |
| Cclang::tidy::modernize::ReturnBracedInitListCheck | Use a braced init list for return statements rather than unnecessary repeating the return type name |
| Cclang::tidy::modernize::ShrinkToFitCheck | Replace copy and swap tricks on shrinkable containers with the shrink_to_fit() method call |
| Cclang::tidy::modernize::TypeTraitsCheck | Converts standard library type traits of the form traits<...>::type and traits<...>::value into traits_t<...> and traits_v<...> respectively |
| Cclang::tidy::modernize::UnaryStaticAssertCheck | Replaces a static_assert declaration with an empty message with the unary version |
| Cclang::tidy::modernize::UseAutoCheck | |
| Cclang::tidy::modernize::UseBoolLiteralsCheck | Finds integer literals which are cast to bool |
| Cclang::tidy::modernize::UseConstraintsCheck | Replace enable_if with C++20 requires clauses |
| Cclang::tidy::modernize::UseDefaultMemberInitCheck | Convert a default constructor's member initializers into default member initializers |
| Cclang::tidy::modernize::UseDesignatedInitializersCheck | Finds initializer lists for aggregate type that could be written as designated initializers instead |
| Cclang::tidy::modernize::UseEmplaceCheck | This check looks for cases when inserting new element into std::vector but the element is constructed temporarily |
| Cclang::tidy::modernize::UseEqualsDefaultCheck | Replace default bodies of special member functions with '= default;' |
| Cclang::tidy::modernize::UseEqualsDeleteCheck | Identifies unimplemented private special member functions, and recommends using = delete for them |
| Cclang::tidy::modernize::UseIntegerSignComparisonCheck | Replace comparisons between signed and unsigned integers with their safe C++20 std::cmp_* alternative, if available |
| Cclang::tidy::modernize::UseNodiscardCheck | Add [[nodiscard]] to non-void const-member functions with no arguments or pass-by-value or pass by const-reference arguments |
| Cclang::tidy::modernize::UseNoexceptCheck | Replace dynamic exception specifications, with noexcept (or user-defined macro) or noexcept(false) |
| Cclang::tidy::modernize::UseNullptrCheck | |
| Cclang::tidy::modernize::UseOverrideCheck | Use C++11's override and remove virtual where applicable |
| Cclang::tidy::modernize::UseScopedLockCheck | Finds uses of std::lock_guard and suggests replacing them with C++17's / alternative std::scoped_lock |
| Cclang::tidy::modernize::UseStartsEndsWithCheck | Checks for common roundabout ways to express starts_with and / ends_with and suggests replacing with the simpler method when it is / available |
| Cclang::tidy::modernize::UseStdFormatCheck | Converts calls to absl::StrFormat, or other functions via configuration options, to C++20's std::format, or another function via a configuration option, modifying the format string appropriately and removing now-unnecessary calls to std::string::c_str() and std::string::data() |
| Cclang::tidy::modernize::UseStdNumbersCheck | Finds constants and function calls to math functions that can be replaced with c++20's mathematical constants from the numbers header and offers fix-it hints |
| Cclang::tidy::modernize::UseStdPrintCheck | Convert calls to printf-like functions to std::print and std::println |
| Cclang::tidy::modernize::UseTrailingReturnTypeCheck | Rewrites function signatures to use a trailing return type |
| Cclang::tidy::modernize::UseTransparentFunctorsCheck | Prefer using transparent functors to non-transparent ones |
| Cclang::tidy::modernize::UseUncaughtExceptionsCheck | This check will warn on calls to std::uncaught_exception and replace them with calls to std::uncaught_exceptions, since std::uncaught_exception was deprecated in C++17 |
| Cclang::tidy::modernize::UseUsingCheck | Check finds typedefs and replaces it with usings |
| Cclang::tidy::mpi::BufferDerefCheck | This check verifies if a buffer passed to an MPI (Message Passing Interface) function is sufficiently dereferenced |
| Cclang::tidy::mpi::TypeMismatchCheck | This check verifies if buffer type and MPI (Message Passing Interface) datatype pairs match |
| Cclang::tidy::objc::AssertEqualsCheck | Warns if XCTAssertEqual() or XCTAssertNotEqual() is used with at least one operands of type NSString* |
| Cclang::tidy::objc::AvoidNSErrorInitCheck | Finds usages of -[NSError init] |
| Cclang::tidy::objc::DeallocInCategoryCheck | Finds implementations of -dealloc in Objective-C categories |
| Cclang::tidy::objc::ForbiddenSubclassingCheck | Finds Objective-C classes which have a superclass which is documented to not support subclassing |
| Cclang::tidy::objc::MissingHashCheck | Finds Objective-C implementations that implement -isEqual: without also appropriately implementing -hash |
| Cclang::tidy::objc::NSDateFormatterCheck | Checks the string pattern used as a date format specifier and reports warnings if it contains any incorrect sub-pattern |
| Cclang::tidy::objc::NSInvocationArgumentLifetimeCheck | Finds calls to NSInvocation methods under ARC that don't have proper argument object lifetimes |
| Cclang::tidy::objc::PropertyDeclarationCheck | |
| Cclang::tidy::objc::SuperSelfCheck | Finds invocations of -self on super instances in initializers of subclasses of NSObject and recommends calling a superclass initializer instead |
| Cclang::tidy::openmp::ExceptionEscapeCheck | Analyzes OpenMP Structured Blocks and checks that no exception escapes out of the Structured Block it was thrown in |
| Cclang::tidy::openmp::UseDefaultNoneCheck | Finds OpenMP directives that are allowed to contain a default clause, / but either don't specify it or the clause is specified but with the kind / other than none, and suggests to use the default(none) clause |
| Cclang::tidy::performance::AvoidEndlCheck | ClangTidyCheck Checks to flag for uses of 'std::endl' on streams and suggests using the newline character '"\n"' instead |
| Cclang::tidy::performance::EnumSizeCheck | Finds enum type definitions that could use smaller integral type as a base |
| Cclang::tidy::performance::FasterStringFindCheck | Optimize calls to std::string::find() and friends when the needle passed is a single character string literal |
| Cclang::tidy::performance::ForRangeCopyCheck | A check that detects copied loop variables and suggests using const references |
| Cclang::tidy::performance::ImplicitConversionInLoopCheck | |
| Cclang::tidy::performance::InefficientAlgorithmCheck | Warns on inefficient use of STL algorithms on associative containers |
| Cclang::tidy::performance::InefficientStringConcatenationCheck | This check is to warn about the performance overhead arising from concatenating strings, using the operator+, instead of operator+= |
| Cclang::tidy::performance::InefficientVectorOperationCheck | Finds possible inefficient std::vector operations (e.g |
| Cclang::tidy::performance::MoveConstArgCheck | Find casts of calculation results to bigger type |
| Cclang::tidy::performance::MoveConstructorInitCheck | The check flags user-defined move constructors that have a ctor-initializer initializing a member or base class through a copy constructor instead of a move constructor |
| Cclang::tidy::performance::NoAutomaticMoveCheck | Finds local variables that cannot be automatically moved due to constness |
| Cclang::tidy::performance::NoIntToPtrCheck | Diagnoses every integer to pointer cast |
| Cclang::tidy::performance::NoexceptFunctionBaseCheck | Generic check which checks if the bound function decl is marked with noexcept or noexcept(expr) where expr evaluates to false |
| Cclang::tidy::performance::NoexceptDestructorCheck | The check flags destructors not marked with noexcept or marked with noexcept(expr) where expr evaluates to false (but is not a false literal itself) |
| Cclang::tidy::performance::NoexceptMoveConstructorCheck | The check flags user-defined move constructors and assignment operators not marked with noexcept or marked with noexcept(expr) where expr evaluates to false (but is not a false literal itself) |
| Cclang::tidy::performance::NoexceptSwapCheck | The check flags swap functions not marked with noexcept or marked with noexcept(expr) where expr evaluates to false (but is not a false literal itself) |
| Cclang::tidy::performance::TriviallyDestructibleCheck | A check that finds classes that would be trivial if not for the defaulted destructors declared out-of-line: struct A: TrivialClass { ~A(); TrivialClass trivial_fields; }; A::~A() = default; |
| Cclang::tidy::performance::TypePromotionInMathFnCheck | Finds calls to C math library functions with implicit float to double promotions |
| Cclang::tidy::performance::UnnecessaryCopyInitializationCheck | |
| Cclang::tidy::performance::UnnecessaryValueParamCheck | A check that flags value parameters of expensive to copy types that can safely be converted to const references |
| Cclang::tidy::portability::AvoidPragmaOnceCheck | Finds uses of #pragma once and suggests replacing them with standard / include guards (#ifndef/#define/#endif) for improved portability |
| Cclang::tidy::portability::RestrictSystemIncludesCheck | Checks for allowed includes and suggests removal of any others |
| Cclang::tidy::llvm_libc::RestrictSystemLibcHeadersCheck | Warns of accidental inclusions of system libc headers that aren't compiler provided |
| Cclang::tidy::portability::SIMDIntrinsicsCheck | Find SIMD intrinsics calls and suggest std::experimental::simd alternatives |
| Cclang::tidy::portability::StdAllocatorConstCheck | Report use of std::vector<const T> (and similar containers of const / elements) |
| Cclang::tidy::portability::TemplateVirtualMemberFunctionCheck | Upon instantiating a template class, non-virtual member functions don't have to be instantiated unless they are used |
| Cclang::tidy::readability::AmbiguousSmartptrResetCallCheck | Finds potentially erroneous calls to 'reset' method on smart pointers when the pointee type also has a 'reset' method |
| Cclang::tidy::readability::AvoidConstParamsInDeclsCheck | |
| Cclang::tidy::readability::AvoidNestedConditionalOperatorCheck | Identifies instances of nested conditional operators in the code |
| Cclang::tidy::readability::AvoidReturnWithVoidValueCheck | Finds return statements with void values used within functions with void result types |
| Cclang::tidy::readability::AvoidUnconditionalPreprocessorIfCheck | Finds code blocks that are constantly enabled or disabled in preprocessor directives by analyzing #if conditions, such as #if 0 and #if 1, etc |
| Cclang::tidy::readability::BracesAroundStatementsCheck | Checks that bodies of if statements and loops (for, range-for, do-while, and while) are inside braces |
| Cclang::tidy::readability::ConstReturnTypeCheck | For any function whose return type is const-qualified, suggests removal of the const qualifier from that return type |
| Cclang::tidy::readability::ContainerContainsCheck | Finds usages of container.count() and container.find() == container.end() which should be replaced by a call to the container.contains() method |
| Cclang::tidy::readability::ContainerDataPointerCheck | Checks whether a call to operator[] and & can be replaced with a call to data() |
| Cclang::tidy::readability::ContainerSizeEmptyCheck | Checks whether a call to the size()/length() method can be replaced with a call to empty() |
| Cclang::tidy::readability::ConvertMemberFunctionsToStaticCheck | This check finds C++ class methods than can be made static because they don't use the 'this' pointer |
| Cclang::tidy::readability::DeleteNullPointerCheck | Check whether the 'if' statement is unnecessary before calling 'delete' on a pointer |
| Cclang::tidy::readability::DuplicateIncludeCheck | Find and remove duplicate #include directives |
| Cclang::tidy::readability::ElseAfterReturnCheck | Flags the usages of else after return |
| Cclang::tidy::readability::EnumInitialValueCheck | Enforces consistent style for enumerators' initialization, covering three styles: none, first only, or all initialized explicitly |
| Cclang::tidy::readability::FunctionCognitiveComplexityCheck | Checks function Cognitive Complexity metric |
| Cclang::tidy::readability::FunctionSizeCheck | Checks for large functions based on various metrics |
| Cclang::tidy::readability::IdentifierLengthCheck | Warns about identifiers names whose length is too short |
| Cclang::tidy::readability::ImplicitBoolConversionCheck | Checks for use of implicit bool conversions in expressions |
| Cclang::tidy::readability::InconsistentDeclarationParameterNameCheck | Checks for declarations of functions which differ in parameter names |
| Cclang::tidy::readability::IsolateDeclarationCheck | This check diagnoses all DeclStmt's declaring more than one variable and tries to refactor the code to one statement per declaration |
| Cclang::tidy::readability::MagicNumbersCheck | Detects magic numbers, integer and floating point literals embedded in code |
| Cclang::tidy::readability::MakeMemberFunctionConstCheck | Finds non-static member functions that can be made 'const' |
| Cclang::tidy::readability::MathMissingParenthesesCheck | Check for mising parantheses in mathematical expressions that involve operators of different priorities |
| Cclang::tidy::readability::MisleadingIndentationCheck | Checks the code for dangling else, and possible misleading indentations due to missing braces |
| Cclang::tidy::readability::MisplacedArrayIndexCheck | Warn about unusual array index syntax (index[array] instead of array[index]) |
| Cclang::tidy::readability::NamedParameterCheck | Find functions with unnamed arguments |
| Cclang::tidy::readability::NamespaceCommentCheck | Checks that long namespaces have a closing comment |
| Cclang::tidy::readability::NonConstParameterCheck | Warn when a pointer function parameter can be const |
| Cclang::tidy::readability::OperatorsRepresentationCheck | Enforces consistent token representation for invoked binary, unary and overloaded operators in C++ code |
| Cclang::tidy::readability::QualifiedAutoCheck | Finds variables declared as auto that could be declared as: 'auto*' or 'const auto *' and reference variables declared as: 'const auto &' |
| Cclang::tidy::readability::RedundantAccessSpecifiersCheck | Detects redundant access specifiers inside classes, structs, and unions |
| Cclang::tidy::readability::RedundantCastingCheck | Detects explicit type casting operations that involve the same source and destination types, and subsequently recommend their removal |
| Cclang::tidy::readability::RedundantControlFlowCheck | Eliminates redundant return statements at the end of a function that returns void |
| Cclang::tidy::readability::RedundantDeclarationCheck | Find redundant variable declarations |
| Cclang::tidy::readability::RedundantFunctionPtrDereferenceCheck | Eliminate redundant dereferences of a function pointer |
| Cclang::tidy::readability::RedundantInlineSpecifierCheck | Detects redundant inline specifiers on function and variable declarations |
| Cclang::tidy::readability::RedundantMemberInitCheck | Finds member initializations that are unnecessary because the same default constructor would be called if they were not present |
| Cclang::tidy::readability::RedundantParenthesesCheck | Detect redundant parentheses |
| Cclang::tidy::readability::RedundantPreprocessorCheck | This check flags redundant preprocessor directives: nested directives with the same condition |
| Cclang::tidy::readability::RedundantSmartptrGetCheck | Find and remove redundant calls to smart pointer's .get() method |
| Cclang::tidy::readability::RedundantStringCStrCheck | Finds unnecessary calls to std::string::c_str() |
| Cclang::tidy::readability::RedundantStringInitCheck | Finds unnecessary string initializations |
| Cclang::tidy::readability::RedundantTypenameCheck | Finds redundant uses of the typename keyword |
| Cclang::tidy::readability::ReferenceToConstructedTemporaryCheck | Detects C++ code where a reference variable is used to extend the lifetime of a temporary object that has just been constructed |
| Cclang::tidy::readability::SimplifyBooleanExprCheck | Looks for boolean expressions involving boolean constants and simplifies them to use the appropriate boolean expression directly |
| Cclang::tidy::readability::SimplifySubscriptExprCheck | Simplifies subscript expressions |
| Cclang::tidy::readability::StaticAccessedThroughInstanceCheck | Checks for member expressions that access static members through instances and replaces them with uses of the appropriate qualified-id |
| Cclang::tidy::readability::StaticDefinitionInAnonymousNamespaceCheck | Finds static function and variable definitions in anonymous namespace |
| Cclang::tidy::readability::StringCompareCheck | This check flags all calls compare when used to check for string equality or inequality |
| Cclang::tidy::readability::SuspiciousCallArgumentCheck | Finds function calls where the arguments passed are provided out of order, based on the difference between the argument name and the parameter names of the function |
| Cclang::tidy::readability::UniqueptrDeleteReleaseCheck | Flags statements of the form delete <unique_ptr expr>.release(); and / replaces them with: <unique_ptr expr> = nullptr; |
| Cclang::tidy::readability::UppercaseLiteralSuffixCheck | Detects when the integral literal or floating point literal has non-uppercase suffix, and suggests to make the suffix uppercase |
| Cclang::tidy::readability::UseAnyOfAllOfCheck | Finds ranged-based for loops that can be replaced by a call to std::any_of or std::all_of |
| Cclang::tidy::readability::UseConcisePreprocessorDirectivesCheck | Finds uses of #if that can be simplified to #ifdef or #ifndef / and, since C23 and C++23, uses of #elif that can be simplified to / #elifdef or #elifndef |
| Cclang::tidy::readability::UseStdMinMaxCheck | Replaces certain conditional statements with equivalent calls to std::min or std::max |
| Cclang::tidy::utils::HeaderGuardCheck | Finds and fixes header guards |
| Cclang::tidy::llvm_check::LLVMHeaderGuardCheck | Finds and fixes header guards that do not adhere to LLVM style |
| Cclang::tidy::utils::TransformerClangTidyCheck | A base class for defining a ClangTidy check based on a RewriteRule |
| Cclang::tidy::abseil::CleanupCtadCheck | Suggests switching the initialization pattern of absl::Cleanup instances from the factory function to class template argument deduction (CTAD), in C++17 and higher |
| Cclang::tidy::abseil::StringFindStrContainsCheck | Finds s.find(...) == string::npos comparisons (for various string-like types) and suggests replacing with absl::StrContains |
| Cclang::tidy::bugprone::StringviewNullptrCheck | Checks for various ways that the const CharT* constructor of std::basic_string_view can be passed a null argument and replaces them with the default constructor in most cases |
| Cclang::tidy::llvm_check::UseNewMlirOpBuilderCheck | Checks for uses of MLIR's old/to be deprecated OpBuilder::create<T> form and suggests using T::create instead |
| Cclang::tidy::utils::UseRangesCheck | Base class for handling converting std iterator algorithms to a range equivalent |
| Cclang::tidy::boost::UseRangesCheck | Detects calls to standard library iterator algorithms that could be replaced with a boost ranges version instead |
| Cclang::tidy::llvm_check::UseRangesCheck | Finds calls to STL iterator algorithms that can be replaced with LLVM range-based algorithms from llvm/ADT/STLExtras.h |
| Cclang::tidy::modernize::UseRangesCheck | Detects calls to standard library iterator algorithms that could be replaced with a ranges version instead |
| Cclang::tidy::ClangTidyCheckFactories | A collection of ClangTidyCheckFactory instances |
| Cclang::tidy::ClangTidyContext | Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context |
| Cclang::tidy::ClangTidyGlobalOptions | Global options |
| Cclang::tidy::ClangTidyModule | A clang-tidy module groups a number of ClangTidyChecks and gives them a prefixed name |
| Cclang::tidy::ClangTidyOptions | Contains options for clang-tidy |
| CClangTidyOptions | Contains options for clang-tidy |
| Cclang::tidy::ClangTidyOptionsProvider | Abstract interface for retrieving various ClangTidy options |
| Cclang::tidy::DefaultOptionsProvider | Implementation of the ClangTidyOptionsProvider interface, which returns the same options for all files |
| Cclang::tidy::FileOptionsBaseProvider | |
| Cclang::tidy::ConfigOptionsProvider | Implementation of ClangTidyOptions interface, which is used for '-config' command-line option |
| Cclang::tidy::FileOptionsProvider | Implementation of the ClangTidyOptionsProvider interface, which tries to find a configuration file in the closest parent directory of each source file |
| Cclang::tidy::ClangTidyProfiling | |
| Crun-clang-tidy.ClangTidyResult | |
| Cclang::tidy::ClangTidyStats | Contains displayed and ignored diagnostic counters for a ClangTidy run |
| Cclang::tidy::ClangTidyOptions::ClangTidyValue | Helper structure for storing option value with priority of the value |
| CClangTidyOptions::ClangTidyValue | Helper structure for storing option value with priority of the value |
| Cclang::tidy::modernize::ClassifiedToken | |
| Cclang::clangd::ClientCapabilities | |
| Cclang::clangd::CodeAction | A code action represents a change that can be performed in code, e.g |
| Cclang::clangd::CodeActionContext | |
| Cclang::clangd::ClangdServer::CodeActionInputs | |
| Cclang::clangd::CodeActionParams | |
| Cclang::clangd::ClangdServer::CodeActionResult | |
| Cclang::clangd::CodeCompleteOptions | |
| Cclang::clangd::CodeDescription | Structure to capture a description for an error code |
| Cclang::clangd::CommandMangler | |
| Cclang::CommentHandler | |
| Cclang::find_all_symbols::PragmaCommentHandler | PragmaCommentHandler parses pragma comment on include files to determine when we should include a different header from the header that directly defines a symbol |
| Cclang::tidy::google::readability::TodoCommentCheck::TodoCommentHandler | |
| CCommentHandler | |
| Cclang::tidy::misc::MisleadingBidirectionalCheck::MisleadingBidirectionalHandler | |
| Cclang::doc::CommentInfo | |
| Cclang::clangd::config::Fragment::CompileFlagsBlock | Conditions in the CompileFlags block affect how a file is parsed |
| Cclang::clangd::config::Fragment::CompletionBlock | Describes code completion preferences |
| Cclang::clangd::CompletionContext | |
| Cclang::clangd::CompletionItem | |
| Cclang::clangd::CompletionItemLabelDetails | Additional details for a completion item label |
| Cclang::clangd::CompletionList | Represents a collection of completion items to be presented in the editor |
| Cclang::clangd::CompletionPrefix | |
| Cclang::tidy::modernize::Confidence | A class to encapsulate lowering of the tool's confidence level |
| Cclang::clangd::Config | Settings that express user/project preferences and control clangd behavior |
| Cclang::tidy::utils::FormatStringConverter::Configuration | |
| Cclang::clangd::ConfigurationSettings | Clangd extension: parameters configurable at any time, via the workspace/didChangeConfiguration notification |
| Ccomments::ConstCommentVisitor | |
| Cclang::clangd::BlockCommentToMarkupDocument | |
| Cclang::clangd::ParagraphToMarkupDocument | |
| Cclang::clangd::ParagraphToString | |
| Cclang::clangd::SymbolDocCommentVisitor | |
| CConstCommentVisitor | |
| Cclang::doc::serialize::ClangDocCommentVisitor | |
| Cclang::doc::ConstraintInfo | |
| Cclang::clangd::ContainedRefsRequest | |
| Cclang::clangd::ContainedRefsResult | |
| Cclang::clangd::Context | A context is an immutable container for per-request data that must be propagated through layers that don't care about it |
| Cclang::clangd::dex::Corpus | |
| CModularize::CoverageChecker | Module map checker class |
| CCompletionModelCodegen.CppClass | |
| Cclang::tidy::ClangTidyOptions::CustomCheckDiag | |
| CClangTidyOptions::CustomCheckDiag | |
| Cclang::tidy::ClangTidyOptions::CustomCheckValue | |
| CClangTidyOptions::CustomCheckValue | |
| Cclang::clangd::Deadline | A point in time we can wait for |
| Cclang::clangd::DebouncePolicy | Clangd may wait after an update to see if another one comes along |
| Cclang::clangd::DecisionForestScores | Same semantics as CodeComplete::Score |
| Cclang::move::DeclarationReporter::Declaration | |
| Cclang::move::DeclarationReporter | |
| Cclang::clangd::DeclRelationSet | |
| Cclang::clangd::DefinedMacro | |
| Cllvm::DenseMapInfo< clang::clangd::Config::ExternalIndexSpec > | |
| Cllvm::DenseMapInfo< clang::clangd::dex::Token > | |
| Cllvm::DenseMapInfo< clang::clangd::dex::Trigram > | |
| Cllvm::DenseMapInfo< clang::clangd::IncludeStructure::HeaderID > | |
| Cllvm::DenseMapInfo< clang::clangd::Range > | |
| Cllvm::DenseMapInfo< clang::clangd::RefSlab::Builder::Entry > | |
| Cllvm::DenseMapInfo< clang::clangd::SymbolID > | |
| Cllvm::DenseMapInfo< clang::tidy::cppcoreguidelines::SpecialMemberFunctionsCheck::ClassDefId > | Specialization of DenseMapInfo to allow ClassDefId objects in DenseMaps FIXME: Move this to the corresponding cpp file as is done for clang-tidy/readability/IdentifierNamingCheck.cpp |
| Cllvm::DenseMapInfo< clang::tidy::RenamerClangTidyCheck::NamingCheckId > | Specialization of DenseMapInfo to allow NamingCheckId objects in DenseMaps |
| Cllvm::DenseMapInfo< DriverArgs > | |
| Cclang::clangd::SymbolRelevanceSignals::DerivedSignals | Set of derived signals computed by calculateDerivedSignals() |
| Cclang::reorder_fields::Designator | Represents a part of a designation in a C99/C++20 designated initializer |
| Cclang::reorder_fields::Designators | List of designators |
| Cclang::clangd::config::CapturedDiags::Diag | |
| Cclang::clangd::DiagBase | Contains basic information about a diagnostic |
| Cclang::clangd::Diag | A top-level diagnostic that may have Notes and Fixes |
| Cclang::clangd::Note | Represents a note for the diagnostic |
| Cclang::tidy::RenamerClangTidyCheck::DiagInfo | Represents customized diagnostic text and how arguments should be applied |
| Cclang::clangd::Diagnostic | |
| Ctooling::Diagnostic | |
| Cclang::tidy::ClangTidyError | A detected error complete with information to display diagnostic and automatic fix |
| CDiagnosticConsumer | |
| Cclang::clangd::IgnoreDiagnostics | |
| Cclang::clangd::StoreDiags | StoreDiags collects the diagnostics that can later be reported by clangd |
| Cclang::tidy::ClangTidyDiagnosticConsumer | A diagnostic consumer that turns each Diagnostic into a SourceManager-independent ClangTidyError |
| Cclang::clangd::DiagnosticRelatedInformation | Represents a related message and source code location for a diagnostic |
| Cclang::clangd::config::Fragment::DiagnosticsBlock | Controls behavior of diagnostics (errors and warnings) |
| Cclang::clangd::ClangdServer::DiagRef | |
| Cclang::clangd::DidChangeConfigurationParams | |
| Cclang::clangd::DidChangeTextDocumentParams | |
| Cclang::clangd::DidChangeWatchedFilesParams | |
| Cclang::clangd::DidCloseTextDocumentParams | |
| Cclang::clangd::DidOpenTextDocumentParams | |
| Cclang::clangd::DidSaveTextDocumentParams | |
| Cclang::clangd::DirectoryBasedGlobalCompilationDatabase::DirectoryCache | |
| Cclang::clangd::config::Fragment::DocumentationBlock | Configures documentation style and behaviour |
| Cclang::clangd::DocumentFormattingParams | |
| Cclang::clangd::DocumentHighlight | A document highlight is a range inside a text document which deserves special attention |
| Cclang::clangd::DocumentLink | A range in a text document that links to an internal or external resource, like another text document or a web site |
| Cclang::clangd::DocumentLinkParams | Parameters for the document link request |
| Cclang::clangd::DocumentOnTypeFormattingParams | |
| Cclang::clangd::DocumentRangeFormattingParams | |
| Cclang::clangd::DocumentRangesFormattingParams | |
| Cclang::clangd::DocumentSymbol | Represents programming constructs like variables, classes, interfaces etc |
| Cclang::clangd::DocumentSymbolParams | |
| Cclang::clangd::DraftStore::Draft | |
| Cclang::clangd::DraftStore | A thread-safe container for files opened in a workspace, addressed by filenames |
| Cclang::clangd::Edit | A set of edits generated for a single file |
| Cclang::clangd::Tweak::Effect | |
| Cclang::clangd::EligibleRegion | Represents locations that can accept a definition |
| CEntry | |
| Cclang::doc::EnumValueInfo | |
| Cllvm::ErrorInfo | |
| Cclang::clangd::CancelledError | Conventional error when no result is returned due to cancellation |
| Cclang::clangd::LSPError | |
| Cclang::clangd::Event< T > | An Event<T> allows events of type T to be broadcast to listeners |
| Cclang::clangd::trace::EventTracer | A consumer of trace events and measurements |
| Cclang::clangd::trace::TestTracer | A RAII Tracer that can be used by tests |
| Cclang::tidy::utils::ExceptionAnalyzer | This class analysis if a FunctionDecl can in principle throw an exception, either directly or indirectly |
| Cclang::tidy::utils::ExceptionAnalyzer::ExceptionInfo | Bundle the gathered information about an entity like a function regarding it's exception behaviour |
| Cclang::tidy::utils::ExceptionSpecAnalyzer | This class analysis if a FunctionDecl has been declared implicitly through defaulting or explicitly as throwing or not and evaluates noexcept expressions if needed |
| Cclang::clangd::ExecuteCommandParams | |
| Cclang::clangd::Command | |
| Cclang::tidy::utils::ExprSequence | Provides information about the evaluation order of (sub-)expressions within a CFGBlock |
| Cclang::clangd::config::Fragment::IndexBlock::ExternalBlock | An external index uses data source outside of clangd itself |
| Cclang::clangd::Config::ExternalIndexSpec | Describes an external index configuration |
| Cclang::ExternalSemaSource | |
| Cclang::include_fixer::IncludeFixerSemaSource | Handles callbacks from sema, does the include lookup and turns it into an IncludeFixerContext |
| CExternalSemaSource | |
| Cclang::clangd::IncludeFixer::UnresolvedNameRecorder | |
| Cclang::clangd::FeatureModule::Facilities | Shared server facilities needed by the module to get its work done |
| Cclang::tidy::RenamerClangTidyCheck::FailureInfo | Information describing a failed check |
| Cclang::clangd::FeatureModule | A FeatureModule contributes a vertical feature to clangd |
| Cclang::clangd::FeatureModuleSet | A FeatureModuleSet is a collection of feature modules installed in clangd |
| Cclang::clangd::riff::File | |
| Cclang::clangd::FileCache | Base class for threadsafe cache of data read from a file on disk |
| Cclang::clangd::config::FileConfigCache | |
| Cclang::clangd::TUScheduler::FileData | |
| Cclang::clangd::FileDistance | |
| Cclang::clangd::FileDistanceOptions | |
| Cclang::clangd::FileEvent | |
| Cclang::tidy::FileFilter | Contains a list of line ranges in a single file |
| CFileFilter | Contains a list of line ranges in a single file |
| Cclang::tooling::ExpandModularHeadersPPCallbacks::FileRecorder | |
| Cclang::clangd::FileShardedIndex | Takes slabs coming from a TU (multiple files) and shards them per declaration location |
| Cclang::clangd::TUScheduler::FileStats | |
| Cclang::clangd::FileStatus | Clangd extension: indicates the current state of the file in clangd, sent from server via the textDocument/clangd.fileStatus notification |
| Cclang::tidy::readability::IdentifierNamingCheck::FileStyle | |
| Cclang::clangd::FileSymbols | A container of slabs associated with a key |
| Cclang::clangd::DirectoryBasedGlobalCompilationDatabase::BroadcastThread::Filter | |
| Cclang::clangd::Fix | Represents a single fix-it that editor can apply to fix the error |
| Cclang::clangd::FoldingRange | Stores information about a region of code that can be folded |
| Cclang::clangd::FoldingRangeParams | |
| CFoo | |
| CBar | |
| Cllvm::format_provider< clang::clangd::Position > | |
| Cclang::analyze_format_string::FormatStringHandler | |
| Cclang::tidy::utils::FormatStringConverter | Convert a printf-style format string to a std::formatter-style one, and prepare any casts that are required to wrap the arguments to retain printf compatibility |
| Cclang::clangd::config::Fragment | A chunk of configuration obtained from a config file, LSP, or elsewhere |
| CFrontendActionFactory | |
| CCompileCheckFrontendActionFactory | |
| CCoverageCheckerFrontendActionFactory | |
| CModularizeFrontendActionFactory | |
| Ctooling::FrontendActionFactory | |
| Cclang::doc::MapperActionFactory | |
| Cclang::find_all_symbols::FindAllSymbolsActionFactory | |
| Cclang::move::ClangMoveActionFactory | |
| Cclang::clangd::FuzzyFindRequest | |
| Cclang::clangd::FuzzyMatcher | |
| Cclang::doc::Generator | |
| Cclang::doc::JSONGenerator | |
| Cclang::doc::MDGenerator | Generator for Markdown documentation |
| Cclang::doc::MustacheGenerator | |
| Cclang::doc::HTMLGenerator | |
| Cclang::doc::YAMLGenerator | Generator for YAML documentation |
| Cclang::clangd::GlobalCompilationDatabase | Provides compilation arguments used for parsing C and C++ files |
| Cclang::clangd::DelegatingCDB | |
| Cclang::clangd::OverlayCDB | Wraps another compilation database, and supports overriding the commands using an in-memory mapping |
| Cclang::clangd::DirectoryBasedGlobalCompilationDatabase | Gets compile args from tooling::CompilationDatabases built for parent directories |
| Cclang::clangd::MockCompilationDatabase | |
| Cclang::tidy::GlobList | Read-only set of strings represented as a list of positive and negative globs |
| Cclang::tidy::CachedGlobList | A GlobList that caches search results, so that search is performed only once for the same query |
| CHeaderEntry | |
| Cclang::clangd::HeaderFile | Represents a header file to be #include'd |
| Cclang::clangd::SymbolCollector::HeaderFileURICache | |
| Cclang::clangd::TUScheduler::HeaderIncluderCache | A map from header files to an opened "proxy" file that includes them |
| Cclang::include_fixer::IncludeFixerContext::HeaderInfo | |
| CIncludeFixerContext::HeaderInfo | |
| Cclang::find_all_symbols::HeaderMapCollector | HeaderMappCollector collects all remapping header files |
| Cclang::move::HelperDeclRefGraph | |
| Cclang::clangd::HighlightingToken | |
| Cclang::clangd::Hover | |
| Cclang::clangd::config::Fragment::HoverBlock | Describes hover preferences |
| Cclang::clangd::HoverInfo | Contains detailed information about a Symbol |
| Cclang::tidy::readability::IdentifierNamingCheck::HungarianNotation | |
| Cclang::tidy::readability::IdentifierNamingCheck::HungarianNotationOption | |
| Cclang::clangd::config::Fragment::IfBlock | Conditions in the If block restrict when a Fragment applies |
| Cclang::tidy::NoLintDirectiveHandler::Impl | |
| Cclang::clangd::InactiveRegionsParams | Parameters for the inactive regions (server-side) push notification |
| Cclang::clangd::IncludeCleanerFindings | |
| Cclang::clangd::IncludeFixer | Attempts to recover from error diagnostics by suggesting include insertion fixes |
| Cclang::include_fixer::IncludeFixerContext | A context for a file being processed |
| CIncludeFixerContext | A context for a file being processed |
| Cclang::clangd::IncludeGraphNode | |
| Cllvm::yaml::IncludeGraphNode | |
| Cclang::clangd::Symbol::IncludeHeaderWithReferences | |
| Cllvm::yaml::Symbol::IncludeHeaderWithReferences | |
| Cclang::clangd::IncludeInserter | |
| Cclang::tidy::modernize::DeprecatedHeadersCheck::IncludeMarker | |
| Cclang::clangd::config::Fragment::DiagnosticsBlock::IncludesBlock | Controls IncludeCleaner diagnostics |
| Cclang::clangd::IncludeStructure | |
| Cclang::clangd::Inclusion | |
| Cclang::clangd::config::Fragment::IndexBlock | Controls how clangd understands code outside the current file |
| Cindex::IndexDataConsumer | |
| Cclang::clangd::SymbolCollector | Collect declarations (symbols) from an AST |
| Cclang::tidy::utils::UseRangesCheck::Indexes | |
| Cclang::clangd::IndexFileIn | |
| Cclang::clangd::IndexFileOut | |
| Cclang::doc::Info | A base struct for Infos |
| Cclang::doc::NamespaceInfo | |
| Cclang::doc::SymbolInfo | |
| Cclang::doc::ConceptInfo | |
| Cclang::doc::EnumInfo | |
| Cclang::doc::FriendInfo | |
| Cclang::doc::FunctionInfo | |
| Cclang::doc::RecordInfo | |
| Cclang::doc::BaseRecordInfo | |
| Cclang::doc::TypedefInfo | |
| Cclang::doc::VarInfo | |
| Cclang::clangd::InitializationOptions | Clangd extension: parameters configurable at initialize time |
| Cclang::clangd::InitializeParams | |
| Cclang::clangd::InlayHint | Inlay hint information |
| Cclang::clangd::InlayHintLabelPart | An inlay hint label part allows for interactive and composite labels of inlay hints |
| Cclang::clangd::InlayHintOptions | |
| Cclang::clangd::config::Fragment::InlayHintsBlock | Configures labels shown inline with the code |
| Cclang::clangd::InlayHintsParams | A parameter literal used in inlay hint requests |
| Cclang::clangd::InputsAndAST | |
| Cclang::clangd::InputsAndPreamble | |
| Cclang::tidy::modernize::IntegralLiteralExpressionMatcher | |
| Cclang::clangd::dex::Iterator | Iterator is the interface for Query Tree node |
| Cclang::clangd::Key< Type > | Values in a Context are indexed by typed keys |
| Cclang::query::QueryParser::LexOrCompleteWord< T > | |
| Cclang::clangd::LoadedShard | Represents a shard loaded from storage, stores contents in Shard and metadata about the source file that generated this shard |
| Cclang::clangd::DirectoryBasedGlobalCompilationDatabase::DirectoryCache::CachedFile::LoadResult | |
| Cclang::clangd::config::Located< T > | An entity written in config along, with its optional location in the file |
| Cclang::clangd::LocatedSymbol | |
| Cclang::clangd::Location | |
| Cclang::clangd::ReferenceLocation | Extends Locations returned by textDocument/references with extra info |
| Cclang::doc::Location | |
| CLocation | |
| Cclang::clangd::Logger | Interface to allow custom logging in clangd |
| Cclang::clangd::StreamLogger | |
| Cclang::clangd::LoggingSession | Only one LoggingSession can be active at a time |
| Cclang::clangd::LookupRequest | |
| Cclang::clangd::LSPBinder | LSPBinder collects a table of functions that handle LSP calls |
| Cclang::clangd::LSPClient | |
| Cclang::clangd::MacroOccurrence | |
| Cclang::clangd::MainFileMacros | |
| Cstd::map | |
| CEntityMap | |
| Cllvm::yaml::MappingTraits< BaseRecordInfo > | |
| Cllvm::yaml::MappingTraits< ClangTidyOptions > | |
| Cllvm::yaml::MappingTraits< ClangTidyOptions::CustomCheckDiag > | |
| Cllvm::yaml::MappingTraits< ClangTidyOptions::CustomCheckValue > | |
| Cllvm::yaml::MappingTraits< ClangTidyOptions::StringPair > | |
| Cllvm::yaml::MappingTraits< CommentInfo > | |
| Cllvm::yaml::MappingTraits< CompileCommandYAML > | |
| Cllvm::yaml::MappingTraits< EnumInfo > | |
| Cllvm::yaml::MappingTraits< EnumValueInfo > | |
| Cllvm::yaml::MappingTraits< FieldTypeInfo > | |
| Cllvm::yaml::MappingTraits< FileFilter > | |
| Cllvm::yaml::MappingTraits< FunctionInfo > | |
| Cllvm::yaml::MappingTraits< IncludeFixerContext > | |
| Cllvm::yaml::MappingTraits< IncludeFixerContext::HeaderInfo > | |
| Cllvm::yaml::MappingTraits< IncludeFixerContext::QuerySymbolInfo > | |
| Cllvm::yaml::MappingTraits< IncludeGraphNode > | |
| Cllvm::yaml::MappingTraits< Location > | |
| Cllvm::yaml::MappingTraits< MemberTypeInfo > | |
| Cllvm::yaml::MappingTraits< NamespaceInfo > | |
| Cllvm::yaml::MappingTraits< RecordInfo > | |
| Cllvm::yaml::MappingTraits< Ref > | |
| Cllvm::yaml::MappingTraits< RefBundle > | |
| Cllvm::yaml::MappingTraits< Reference > | |
| Cllvm::yaml::MappingTraits< Relation > | |
| Cllvm::yaml::MappingTraits< std::unique_ptr< CommentInfo > > | |
| Cllvm::yaml::MappingTraits< Symbol > | |
| Cllvm::yaml::MappingTraits< SymbolAndSignals > | |
| Cllvm::yaml::MappingTraits< SymbolID > | |
| Cllvm::yaml::MappingTraits< SymbolInfo > | |
| Cllvm::yaml::MappingTraits< SymbolInfo::Context > | |
| Cllvm::yaml::MappingTraits< SymbolLocation > | |
| Cllvm::yaml::MappingTraits< TemplateInfo > | |
| Cllvm::yaml::MappingTraits< TemplateParamInfo > | |
| Cllvm::yaml::MappingTraits< TemplateSpecializationInfo > | |
| Cllvm::yaml::MappingTraits< tooling::Range > | |
| Cllvm::yaml::MappingTraits< TypedefInfo > | |
| Cllvm::yaml::MappingTraits< TypeInfo > | |
| Cllvm::yaml::MappingTraits< VariantEntry > | |
| Cllvm::yaml::MappingTraits< YIncludeHeaderWithReferences > | |
| Cllvm::yaml::MappingTraits< YPosition > | |
| Cclang::clangd::MarkupContent | |
| Cclang::clangd::remote::Marshaller | A notable exception is URI translation |
| Cast_matchers::MatchFinder::MatchCallback | |
| Cclang::find_all_symbols::FindAllSymbols | FindAllSymbols collects all classes, free standing functions and global variables with some extra information such as the path of the header file, the namespaces they are contained in, the type of variables and the parameter types of functions |
| Cclang::move::ClangMoveTool | |
| Cclang::move::HelperDeclRGBuilder | |
| Cast_matchers::internal::MatcherInterface | |
| Cclang::tidy::matchers::MatchesAnyListedNameMatcher | |
| Cclang::tidy::matchers::MatchesAnyListedTypeNameMatcher | |
| Ctesting::MatcherInterface | |
| Cclang::clangd::SubsequenceMatcher< T > | |
| Cclang::clangd::Memoize< Container > | Memoize is a cache to store and reuse computation results based on a key |
| Cclang::clangd::MemoryTree | A tree that can be used to represent memory usage of nested components while preserving the hierarchy |
| Cclang::clangd::Transport::MessageHandler | |
| Cclang::clangd::ClangdLSPServer::MessageHandler | |
| Cclang::clangd::trace::Metric | Represents measurements of clangd events, e.g |
| Cclang::clangd::MissingIncludeDiagInfo | |
| CModularize::ModularizeUtilities | Modularize utilities class |
| Cclang::clangd::ModulesBuilder | This class handles building module files for a given source file |
| Cclang::clangd::ModulesBuilder::ModulesBuilderImpl | |
| Cclang::move::MoveDefinitionSpec | |
| Cclang::doc::MustacheTemplateFile | |
| CNamedTuple | |
| Ccheck_alphabetical_order.BulletBlocks | |
| Ccheck_alphabetical_order.ScannedBlocks | |
| Cclang::tidy::matchers::MatchesAnyListedNameMatcher::NameMatcher | |
| Cclang::tidy::utils::NamespaceAliaser | |
| Cclang::tidy::RenamerClangTidyCheck::NamingCheckFailure | Holds an identifier name check failure, tracking the kind of the identifier, its possible fixup and the starting locations of all the identifier usages |
| Cclang::tidy::readability::IdentifierNamingCheck::NamingStyle | |
| Cclang::clangd::SelectionTree::Node | |
| Cclang::tidy::readability::SimplifyBooleanExprCheck::Visitor::NodeAndBool< Node > | |
| Cclang::tidy::NoLintDirectiveHandler | This class is used to locate NOLINT comments in the file being analyzed, to decide whether a diagnostic should be suppressed |
| Cclang::clangd::NoParams | |
| Cllvm::yaml::NormalizedFileDigest | |
| Cllvm::yaml::NormalizedFileURI | |
| Cllvm::yaml::NormalizedIncludeHeaders | |
| Cllvm::yaml::NormalizedPosition | |
| Cllvm::yaml::MappingTraits< tooling::Range >::NormalizedRange | |
| Cllvm::yaml::NormalizedRefKind | |
| Cllvm::yaml::NormalizedSourceFlag | |
| Cllvm::yaml::NormalizedSymbolFlag | |
| Cllvm::yaml::NormalizedSymbolID | |
| Cllvm::yaml::NormalizedSymbolRole | |
| Cclang::tidy::matchers::NotIdenticalStatementsPredicate | |
| Cclang::clangd::Notification | A threadsafe flag that is initially clear |
| Cclang::clangd::OpaqueType | A representation of a type that can be computed based on clang AST and compared for equality |
| Cclang::tidy::OptionEnumMapping< T > | This class should be specialized by any enum type that needs to be converted to and from an llvm::StringRef |
| Cclang::tidy::OptionEnumMapping< bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind > | |
| Cclang::tidy::OptionEnumMapping< concurrency::MtUnsafeCheck::FunctionSet > | |
| Cclang::tidy::OptionEnumMapping< cppcoreguidelines::ProBoundsAvoidUncheckedContainerAccessCheck::FixModes > | |
| Cclang::tidy::OptionEnumMapping< google::readability::StyleKind > | |
| Cclang::tidy::OptionEnumMapping< misc::OverrideWithDifferentVisibilityCheck::ChangeKind > | |
| Cclang::tidy::OptionEnumMapping< misc::UseInternalLinkageCheck::FixModeKind > | |
| Cclang::tidy::OptionEnumMapping< modernize::Confidence::Level > | |
| Cclang::tidy::OptionEnumMapping< modernize::UseTrailingReturnTypeCheck::TransformLambda > | |
| Cclang::tidy::OptionEnumMapping< modernize::VariableNamer::NamingStyle > | |
| Cclang::tidy::OptionEnumMapping< readability::IdentifierNamingCheck::CaseType > | |
| Cclang::tidy::OptionEnumMapping< readability::IdentifierNamingCheck::HungarianPrefixType > | |
| COptionEnumMapping< utils::IncludeSorter::IncludeStyle > | |
| Cclang::clangd::BackgroundIndex::Options | |
| Cclang::clangd::ClangdServer::Options | |
| Cclang::clangd::ClangdLSPServer::Options | |
| Cclang::clangd::DirectoryBasedGlobalCompilationDatabase::Options | |
| Cclang::clangd::SymbolCollector::Options | |
| Cclang::clangd::TUScheduler::Options | |
| Cclang::tidy::FileOptionsBaseProvider::OptionsCache | |
| CParagraph | |
| Cclang::Heading | |
| Cclang::clangd::HoverInfo::Param | Represents parameters of a function, a template or a macro |
| Cclang::clangd::ParameterInformation | A single parameter of a particular signature |
| Cclang::clangd::config::Params | Describes the context used to evaluate configuration fragments |
| Cclang::clangd::ParsedAST | Stores and provides access to parsed AST |
| Cclang::clangd::ParseInputs | Information required to run clang, e.g. to parse AST or do code completion |
| Cclang::clangd::ParseOptions | |
| Cclang::clangd::ParsingCallbacks | |
| Cclang::clangd::HoverInfo::PassType | |
| Cclang::clangd::PathMapping | PathMappings are a collection of paired client and server paths |
| Cclang::clangd::PeriodicThrottler | Used to guard an operation that should run at most every N seconds |
| CPluginASTAction | |
| Cclang::include_fixer::ClangIncludeFixerPluginAction | The core include fixer plugin action |
| Cclang::clangd::PolySubsequenceMatcher< M > | |
| Cclang::clangd::Position | |
| Cclang::clangd::SymbolLocation::Position | |
| Cllvm::yaml::SymbolLocation::Position | |
| Cclang::clangd::dex::PostingList | PostingList is the storage of DocIDs which can be inserted to the Query Tree as a leaf by constructing Iterator over the PostingList object |
| Cclang::PPCallbacks | |
| Cclang::find_all_symbols::FindAllMacros | A preprocessor that collects all macro symbols |
| Cclang::pp_trace::PPCallbacksTracker | This class overrides the PPCallbacks class for tracking preprocessor activity by means of its callback functions |
| Cclang::tidy::modernize::MacroToEnumCallbacks | |
| Cclang::tidy::portability::RestrictedIncludesPPCallbacks | |
| Cclang::tidy::utils::IncludeInserterCallback | |
| Cclang::tooling::ExpandModularHeadersPPCallbacks | Handles PPCallbacks and re-runs preprocessing of the whole translation unit with modules disabled |
| CPPCallbacks | |
| CCoverageCheckerCallbacks | |
| Cclang::clangd::CollectMainFileMacros | Collects macro references (e.g |
| Cclang::clangd::CollectPragmaMarks | |
| Cclang::clangd::IncludeStructure::RecordHeaders | |
| Cclang::clangd::PragmaMark | Represents a #pragma mark in the main file |
| Cclang::clangd::PragmaRegionFinder | |
| Cclang::clangd::PreambleBuildStats | Timings and statistics from the premble build |
| Cclang::clangd::PreambleData | The parsed preamble and associated data |
| Cclang::clangd::PreambleFileStatusCache | Records status information for files open()ed or stat()ed during preamble build (except for the main file), so we can avoid stat()s on the underlying FS when reusing the preamble |
| Cclang::clangd::PreamblePatch | Stores information required to parse a TU using a (possibly stale) Baseline preamble |
| Cclang::clangd::PreambleThrottler | PreambleThrottler controls which preambles can build at any given time |
| Cclang::clangd::PrepareRenameResult | |
| CModularize::PreprocessorTracker | Preprocessor tracker for modularize |
| Cclang::clangd::PrerequisiteModules | Store all the needed module files information to parse a single source file |
| Cclang::clangd::HoverInfo::PrintedType | Contains pretty-printed type and desugared type |
| Cclang::clangd::ProgressParams< T > | |
| Cclang::clangd::ProjectInfo | |
| Cclang::clangd::ProjectModules | An interface to query the modules information in the project |
| Cclang::clangd::ScanningAllProjectModules | TODO: The existing ScanningAllProjectModules is not efficient |
| Cclang::clangd::config::Provider | A source of configuration fragments |
| Cclang::clangd::PublishDiagnosticsParams | |
| Cclang::query::QueryParser | |
| Cclang::query::QuerySession | Represents the state for a particular clang-query session |
| Cclang::include_fixer::IncludeFixerContext::QuerySymbolInfo | |
| CIncludeFixerContext::QuerySymbolInfo | |
| Cclang::clangd::ClangdServer::CodeActionResult::QuickFix | |
| Cclang::clangd::Range | |
| Cclang::clangd::Token::Range | A half-open range of tokens within a stream |
| Cclang::clangd::LSPBinder::RawHandlers | |
| Cclang::clangd::LSPBinder::RawOutgoing | |
| Cclang::clangd::ClangdLSPServer | This class exposes ClangdServer's capabilities via Language Server Protocol |
| Cclang::doc::RecordIdDsc | |
| Cclang::doc::RecordIdToIndexFunctor | |
| Cclang::RecursiveASTVisitor | |
| Cclang::doc::MapASTVisitor | |
| Cclang::tidy::misc::UnusedParametersCheck::IndexerVisitor | |
| Cclang::tidy::modernize::ComponentFinderASTVisitor | Class used to find the variables and member expressions on which an arbitrary expression depends |
| Cclang::tidy::modernize::DeclFinderASTVisitor | Class used to determine if any declarations used in a Stmt would conflict with a particular identifier |
| Cclang::tidy::modernize::DependencyFinderASTVisitor | Class used to determine if an expression is dependent on a variable declared inside of the loop where it would be used |
| Cclang::tidy::modernize::ForLoopIndexUseVisitor | Discover usages of expressions consisting of index or iterator access |
| Cclang::tidy::modernize::StmtAncestorASTVisitor | Class used build the reverse AST properties needed to detect name conflicts and free variables |
| Cclang::tidy::readability::SimplifyBooleanExprCheck::Visitor | |
| CRecursiveASTVisitor | |
| CCollectEntitiesVisitor | |
| CCompileCheckVisitor | |
| Cclang::clangd::Ref | Represents a symbol occurrence in the source file |
| Cllvm::yaml::Ref | Represents a symbol occurrence in the source file |
| Cllvm::RefCountedBase | |
| Cclang::query::Query | |
| Cclang::query::FileQuery | |
| Cclang::query::HelpQuery | Query for "help" |
| Cclang::query::InvalidQuery | Any query which resulted in a parse error. The error message is in ErrStr |
| Cclang::query::LetQuery | |
| Cclang::query::MatchQuery | Query for "match MATCHER" |
| Cclang::query::NoOpQuery | No-op query (i.e. a blank line) |
| Cclang::query::QuitQuery | Query for "quit" |
| Cclang::query::SetExclusiveOutputQuery | |
| Cclang::query::SetNonExclusiveOutputQuery | |
| Cclang::query::DisableOutputQuery | |
| Cclang::query::EnableOutputQuery | |
| Cclang::query::SetQuery< T > | Query for "set VAR VALUE" |
| Cclang::tidy::utils::UseRangesCheck::Replacer | |
| Cclang::clangd::ReferencesResult::Reference | |
| Cclang::doc::Reference | |
| Cclang::doc::Index | |
| Cclang::clangd::ReferenceContext | |
| Cclang::clangd::ReferenceLoc | Information about a reference written in the source code, independent of the actual AST node that this reference lives in |
| Cclang::clangd::ReferencesResult | |
| Cclang::clangd::RefSlab | An efficient structure of storing large set of symbol references in memory |
| Cclang::clangd::RefsRequest | |
| Cclang::clangd::Relation | Represents a relation between two symbols |
| Cllvm::yaml::Relation | Represents a relation between two symbols |
| Cclang::clangd::RelationSlab | |
| Cclang::clangd::RelationsRequest | |
| Cclang::clangd::ClangdServer::CodeActionResult::Rename | |
| Cclang::clangd::RenameInputs | |
| Cclang::clangd::RenameOptions | |
| Cclang::clangd::RenameParams | |
| Cclang::clangd::RenameResult | |
| Cclang::clangd::RenameSymbolName | A name of a symbol that should be renamed |
| Cclang::reorder_fields::ReorderedStruct | |
| Cclang::reorder_fields::ReorderFieldsAction | |
| Cclang::clangd::TypeHierarchyItem::ResolveParams | Used to resolve a client provided item back |
| Cclang::clangd::ResolveTypeHierarchyItemParams | Parameters for the typeHierarchy/resolve request |
| Cclang::tidy::utils::UseRangesCheck::ReverseIteratorDescriptor | |
| Cllvm::yaml::ScalarBitSetTraits< clang::clangd::Symbol::IncludeDirective > | |
| Cllvm::yaml::ScalarEnumerationTraits< clang::AccessSpecifier > | |
| Cllvm::yaml::ScalarEnumerationTraits< clang::DiagnosticIDs::Level > | |
| Cllvm::yaml::ScalarEnumerationTraits< clang::doc::CommentKind > | |
| Cllvm::yaml::ScalarEnumerationTraits< clang::TagTypeKind > | |
| Cllvm::yaml::ScalarEnumerationTraits< ContextType > | |
| Cllvm::yaml::ScalarEnumerationTraits< InfoType > | |
| Cllvm::yaml::ScalarEnumerationTraits< SymbolKind > | |
| Cllvm::yaml::ScalarEnumerationTraits< SymbolLanguage > | |
| Cllvm::yaml::ScalarTraits< SmallString< U > > | |
| Cllvm::yaml::ScalarTraits< std::array< unsigned char, 20 > > | |
| Cclang::doc::ScopeChildren | |
| Cclang::clangd::ScopeDistance | Support lookups like FileDistance, but the lookup keys are symbol scopes |
| Cclang::clangd::Tweak::Selection | Input to prepare and apply tweaks |
| Cclang::clangd::SelectionRange | |
| Cclang::clangd::SelectionRangeParams | |
| Cclang::clangd::SelectionTree | |
| Cclang::clangd::SemanticToken | Specifies a single semantic token in the document |
| Cclang::clangd::SemanticTokens | A versioned set of tokens |
| Cclang::clangd::config::Fragment::SemanticTokensBlock | Configures semantic tokens that are produced by clangd |
| Cclang::clangd::SemanticTokensDeltaParams | Body of textDocument/semanticTokens/full/delta request |
| Cclang::clangd::SemanticTokensEdit | Describes a replacement of a contiguous range of semanticTokens |
| Cclang::clangd::SemanticTokensOrDelta | This models LSP SemanticTokensDelta | SemanticTokens, which is the result of textDocument/semanticTokens/full/delta |
| Cclang::clangd::SemanticTokensParams | Body of textDocument/semanticTokens/full request |
| Cclang::clangd::Semaphore | Limits the number of threads that can acquire the lock at the same time |
| Cllvm::yaml::SequenceElementTraits< ClangTidyOptions::CustomCheckDiag > | |
| Cllvm::yaml::SequenceElementTraits< ClangTidyOptions::CustomCheckValue > | |
| Cllvm::yaml::SequenceTraits< FileFilter::LineRange > | |
| Cclang::clangd::trace::Session | Sets up a global EventTracer that consumes events produced by Span and trace::log |
| Cclang::query::SetQueryKind< T > | |
| Cclang::query::SetQueryKind< bool > | |
| Cclang::query::SetQueryKind< OutputKind > | |
| Cclang::query::SetQueryKind< TraversalKind > | |
| Cclang::clangd::ShowMessageParams | The show message notification is sent from a server to a client to ask the client to display a particular message in the user interface |
| Cclang::find_all_symbols::SymbolInfo::Signals | |
| Cclang::include_fixer::SymbolInfo::Signals | |
| CSymbolInfo::Signals | |
| Cclang::clangd::SignatureHelp | Represents the signature of a callable |
| Cclang::clangd::SignatureInformation | Represents the signature of something callable |
| Cclang::clangd::SignatureQualitySignals | |
| Cclang::tidy::bugprone::filter::SimilarlyUsedParameterPairSuppressor | Helper class that is used to detect if two parameters of the same function are used in a similar fashion, to suppress the result |
| Cllvm::SmallVector | |
| Cclang::tidy::modernize::NS | |
| Cllvm::SmallVectorImpl< T > | |
| Cclang::clangd::config::Fragment::SourceInfo | These fields are not part of the user-specified configuration, but instead are populated by the parser to describe the configuration source |
| Cclang::clangd::SourceParams | |
| Cclang::tidy::bugprone::LambdaFunctionNameCheck::SourceRangeLessThan | |
| Cclang::clangd::trace::Span | Records an event whose duration is the lifetime of the Span object |
| Cclang::tidy::cppcoreguidelines::SpecialMemberFunctionsCheck::SpecialMemberFunctionData | |
| Cclang::clangd::SpelledWord | |
| Cclang::clangd::BackgroundQueue::Stats | |
| Cclang::clangd::StdLibLocation | |
| Cclang::clangd::StdLibSet | |
| Cclang::tidy::utils::StmtToBlockMap | Maps Stmts to the CFGBlock that contains them |
| Cclang::tidy::ClangTidyProfiling::StorageParams | |
| Cclang::clangd::config::Fragment::StyleBlock | |
| Cclang::clangd::Event< T >::Subscription | |
| Cclang::clangd::Symbol | The class presents a C++ symbol, e.g |
| Cllvm::yaml::Symbol | The class presents a C++ symbol, e.g |
| Cclang::find_all_symbols::SymbolAndSignals | |
| Cclang::include_fixer::SymbolAndSignals | |
| CSymbolAndSignals | |
| Cclang::clangd::SymbolDetails | Represents information about identifier |
| Cclang::clangd::SymbolID | |
| Cllvm::yaml::SymbolID | |
| Cclang::clangd::SymbolInclude | A header and directives as stored in a Symbol |
| Cclang::clangd::SymbolIndex | Interface for symbol indexes that can be used for searching or matching symbols among a set of symbols based on names or unique IDs |
| Cclang::clangd::MemIndex | MemIndex is a naive in-memory index suitable for a small set of symbols |
| Cclang::clangd::MergedIndex | |
| Cclang::clangd::FileIndex | This manages symbols from files and an in-memory index on all symbols |
| Cclang::clangd::SwapIndex | |
| Cclang::clangd::BackgroundIndex | |
| Cclang::clangd::dex::Dex | In-memory Dex trigram-based index implementation |
| Cclang::include_fixer::SymbolIndex | This class provides an interface for finding all SymbolInfos corresponding to a symbol name from a symbol database |
| Cclang::include_fixer::FuzzySymbolIndex | |
| Cclang::include_fixer::InMemorySymbolIndex | Xref database with fixed content |
| Cclang::include_fixer::YamlSymbolIndex | Yaml format database |
| Cclang::include_fixer::SymbolIndexManager | This class provides an interface for finding the header files corresponding to an identifier in the source code from multiple symbol databases |
| Cclang::find_all_symbols::SymbolInfo | Describes a named symbol from a header |
| Cclang::include_fixer::SymbolInfo | Describes a named symbol from a header |
| CSymbolInfo | Describes a named symbol from a header |
| Cclang::clangd::SymbolInformation | Represents information about programming constructs like variables, classes, interfaces etc |
| Cclang::clangd::SymbolLocation | |
| Cllvm::yaml::SymbolLocation | |
| Cclang::clangd::SymbolQualitySignals | Attributes of a symbol that affect how much we like it |
| Cclang::clangd::SymbolRange | Represents a symbol range where the symbol can potentially have multiple tokens |
| Cclang::clangd::SymbolRelevanceSignals | Attributes of a symbol-query pair that affect how much we like it |
| Cclang::find_all_symbols::SymbolReporter | An interface for classes that collect symbols |
| Cclang::find_all_symbols::YamlReporter | |
| Cclang::clangd::SymbolSlab | An immutable symbol container that stores a set of symbols |
| CSyntaxOnlyAction | |
| CCollectEntitiesAction | |
| CCompileCheckAction | |
| CCoverageCheckerAction | |
| Cclang::clangd::BackgroundQueue::Task | A work item on the thread pool's queue |
| Cclang::doc::TemplateInfo | |
| Cclang::doc::TemplateParamInfo | |
| Cclang::doc::TemplateSpecializationInfo | |
| Ctesting::Test | |
| Cclang::clangd::BackgroundIndexRebuilderTest | |
| Cclang::clangd::BackgroundIndexTest | |
| Cclang::clangd::DirectoryBasedGlobalCompilationDatabaseCacheTest | |
| Cclang::clangd::ThreadingTest | |
| Cclang::clangd::TweakTest | |
| Cclang::clangd::TweakWorkspaceTest | |
| Cunittest.TestCase | |
| Ccheck_alphabetical_order_test.TestAlphabeticalOrderCheck | |
| Cclang::clangd::TestTU | |
| Cclang::clangd::TestWorkspace | |
| Cclang::clangd::TextDocumentContentChangeEvent | |
| Cclang::clangd::TextDocumentEdit | |
| Cclang::clangd::TextDocumentIdentifier | |
| Cclang::clangd::VersionedTextDocumentIdentifier | |
| Cclang::clangd::TextDocumentItem | |
| Cclang::clangd::TextDocumentPositionParams | |
| Cclang::clangd::CallHierarchyPrepareParams | The parameter of a textDocument/prepareCallHierarchy request |
| Cclang::clangd::CompletionParams | |
| Cclang::clangd::ReferenceParams | |
| Cclang::clangd::TypeHierarchyPrepareParams | The type hierarchy params is an extension of the TextDocumentPositionsParams with optional properties which can be used to eagerly resolve the item when requesting from the server |
| Cclang::clangd::TextEdit | |
| Cclang::clangd::ThreadCrashReporter | Allows setting per-thread abort/kill signal callbacks, to print additional information about the crash depending on which thread got signalled |
| Cclang::clangd::ThreadsafeFS | Wrapper for vfs::FileSystem for use in multithreaded programs like clangd |
| Cclang::clangd::MockFS | |
| Cclang::clangd::RealThreadsafeFS | |
| Cclang::tidy::utils::ExceptionAnalyzer::ExceptionInfo::ThrowInfo | Holds information about where an exception is thrown |
| Cclang::clangd::dex::Token | A Token represents an attribute of a symbol, such as a particular trigram present in the name (used for fuzzy search) |
| Cclang::clangd::Token | A single C++ or preprocessor token |
| Cclang::clangd::TokenStream | A complete sequence of Tokens representing a source file |
| Cclang::tooling::ToolAction | |
| Cclang::include_fixer::IncludeFixerActionFactory | |
| Cclang::clangd::TopN< T, Compare > | TopN<T> is a lossy container that preserves only the "best" N elements |
| Cclang::clangd::Transport | |
| Cclang::clangd::LSPClient::TransportImpl | |
| Cclang::clangd::TraverseHeadersToo | |
| Cclang::clangd::dex::Trigram | |
| Cclang::clangd::TUScheduler | Handles running tasks for ClangdServer and managing the resources (e.g., preambles and ASTs) for opened files |
| Cclang::clangd::TUStatus | |
| Cclang::tidy::modernize::TUTrackingInfo | |
| Cclang::clangd::Tweak | An interface base for small context-sensitive refactoring actions |
| Cclang::clangd::TweakArgs | Arguments for the 'applyTweak' command |
| Cclang::clangd::ClangdServer::TweakRef | |
| Cclang::clangd::TweakResult | |
| Cclang::clangd::TypeHierarchyItem | |
| Cclang::doc::TypeInfo | |
| Cclang::doc::FieldTypeInfo | |
| Cclang::doc::MemberTypeInfo | |
| Cclang::clangd::LSPBinder::UntypedOutgoingMethod | |
| Cclang::clangd::LSPBinder::UntypedOutgoingNotification | |
| Cclang::clangd::URI | A URI describes the location of a source file |
| Cclang::clangd::URIDistance | |
| Cclang::clangd::URIForFile | |
| Cclang::clangd::URIScheme | URIScheme is an extension point for teaching clangd to recognize a custom URI scheme |
| Cclang::clangd::TestScheme | Unittest: is a scheme that refers to files relative to testRoot() |
| Cclang::clangd::TestScheme | Unittest: is a scheme that refers to files relative to testRoot() |
| Cclang::tidy::modernize::Usage | The information needed to describe a valid convertible usage of an array index or iterator |
| Cclang::tidy::utils::UsingInserter | |
| Cclang::tidy::modernize::VariableNamer | Create names for generated variables within a particular statement |
| Cclang::clangd::WithContext | WithContext replaces Context::current() with a provided scope |
| Cclang::clangd::WithContextValue | WithContextValue extends Context::current() with a single value |
| Cclang::clangd::WorkDoneProgressBegin | To start progress reporting a $/progress notification with the following payload must be sent |
| Cclang::clangd::WorkDoneProgressCreateParams | |
| Cclang::clangd::WorkDoneProgressEnd | Signals the end of progress reporting |
| Cclang::clangd::WorkDoneProgressReport | Reporting progress is done using the following payload |
| Cclang::clangd::WorkspaceEdit | The edit should either provide changes or documentChanges |
| Cclang::clangd::WorkspaceSymbolParams | The parameters of a Workspace Symbol Request |
1.14.0