clang-tools: Class List (original) (raw)
Ncheck_alphabetical_order_test
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
FIXME: Skip testing on windows temporarily due to the different escaping code mode
CDiag
A chunk of configuration obtained from a config file, LSP, or elsewhere
Conditions in the CompileFlags block affect how a file is parsed
Describes code completion preferences
Controls behavior of diagnostics (errors and warnings)
Controls how clang-tidy will run over the code base
Controls IncludeCleaner diagnostics
Configures documentation style and behaviour
Describes hover preferences
Conditions in the If block restrict when a Fragment applies
Controls how clangd understands code outside the current file
An external index uses data source outside of clangd itself
Configures labels shown inline with the code
Configures semantic tokens that are produced by clangd
These fields are not part of the user-specified configuration, but instead are populated by the parser to describe the configuration source
An entity written in config along, with its optional location in the file
Describes the context used to evaluate configuration fragments
A source of configuration fragments
Ndex
NOTE: This is an implementation detail
CDex
In-memory Dex trigram-based index implementation
Iterator is the interface for Query Tree node
PostingList is the storage of DocIDs which can be inserted to the Query Tree as a leaf by constructing Iterator over the PostingList object
A Token represents an attribute of a symbol, such as a particular trigram present in the name (used for fuzzy search)
Holds text and knows how to lay it out
Represents parts of the markup that can contain strings, like inline code, code block or plain text
A notable exception is URI translation
Nriff
CFile
A consumer of trace events and measurements
Represents measurements of clangd events, e.g
Sets up a global EventTracer that consumes events produced by Span and trace::log
CSpan
Records an event whose duration is the lifetime of the Span object
A RAII Tracer that can be used by tests
Same as llvm::Annotations, but adjusts functions to LSP-specific types for positions and ranges
Simplified description of a clang AST node
Payload for textDocument/ast request
Configuration of the AST retention policy
Signals derived from a valid AST of a file
Runs tasks on separate (detached) threads and wait for all tasks to finish
CTask
A work item on the thread pool's queue
Represents an incoming call, e.g. a caller of a method or constructor
CCallHierarchyIncomingCallsParams
The parameter of a callHierarchy/incomingCalls request
Represents programming constructs like functions or constructors in the context of call hierarchy
Represents an outgoing call, e.g
CCallHierarchyOutgoingCallsParams
The parameter of a callHierarchy/outgoingCalls request
The parameter of a textDocument/prepareCallHierarchy request
Conventional error when no result is returned due to cancellation
Maps a definition location onto an #include file, based on a set of filename rules
The captured AST context
Clangd extension that's used in the 'compilationDatabaseChanges' in workspace/didChangeConfiguration to record updates to the in-memory compilation database
This class exposes ClangdServer's capabilities via Language Server Protocol
Manages a collection of source files and derived data (ASTs, indexes), and provides language-aware features such as code completion
Interface with hooks for users of ClangdServer to be notified of events
A code action represents a change that can be performed in code, e.g
Structure to capture a description for an error code
Collects macro references (e.g
Additional details for a completion item label
Represents a collection of completion items to be presented in the editor
Settings that express user/project preferences and control clangd behavior
Describes an external index configuration
Clangd extension: parameters configurable at any time, via the workspace/didChangeConfiguration notification
A context is an immutable container for per-request data that must be propagated through layers that don't care about it
A point in time we can wait for
Clangd may wait after an update to see if another one comes along
Same semantics as CodeComplete::Score
CDiag
A top-level diagnostic that may have Notes and Fixes
Contains basic information about a diagnostic
Represents a related message and source code location for a diagnostic
CDirectoryBasedGlobalCompilationDatabase
Gets compile args from tooling::CompilationDatabases built for parent directories
CDirectoryBasedGlobalCompilationDatabaseCacheTest
A document highlight is a range inside a text document which deserves special attention
A range in a text document that links to an internal or external resource, like another text document or a web site
Parameters for the document link request
CDocumentOnTypeFormattingParams
CDocumentRangeFormattingParams
CDocumentRangesFormattingParams
Represents programming constructs like variables, classes, interfaces etc
A thread-safe container for files opened in a workspace, addressed by filenames
CEdit
A set of edits generated for a single file
Represents locations that can accept a definition
An Event allows events of type T to be broadcast to listeners
A FeatureModule contributes a vertical feature to clangd
Extension point that allows modules to observe and modify an AST build
Shared server facilities needed by the module to get its work done
A FeatureModuleSet is a collection of feature modules installed in clangd
Base class for threadsafe cache of data read from a file on disk
This manages symbols from files and an in-memory index on all symbols
Takes slabs coming from a TU (multiple files) and shards them per declaration location
Clangd extension: indicates the current state of the file in clangd, sent from server via the textDocument/clangd.fileStatus notification
A container of slabs associated with a key
CFix
Represents a single fix-it that editor can apply to fix the error
Stores information about a region of code that can be folded
Provides compilation arguments used for parsing C and C++ files
Represents a header file to be #include'd
Contains detailed information about a Symbol
Represents parameters of a function, a template or a macro
Contains pretty-printed type and desugared type
Parameters for the inactive regions (server-side) push notification
Attempts to recover from error diagnostics by suggesting include insertion fixes
Clangd extension: parameters configurable at initialize time
Inlay hint information
An inlay hint label part allows for interactive and composite labels of inlay hints
A parameter literal used in inlay hint requests
CKey
Values in a Context are indexed by typed keys
Represents a shard loaded from storage, stores contents in Shard and metadata about the source file that generated this shard
Interface to allow custom logging in clangd
Only one LoggingSession can be active at a time
LSPBinder collects a table of functions that handle LSP calls
MemIndex is a naive in-memory index suitable for a small set of symbols
Memoize is a cache to store and reuse computation results based on a key
A tree that can be used to represent memory usage of nested components while preserving the hierarchy
This class handles building module files for a given source file
CNote
Represents a note for the diagnostic
A threadsafe flag that is initially clear
A representation of a type that can be computed based on clang AST and compared for equality
Wraps another compilation database, and supports overriding the commands using an in-memory mapping
A single parameter of a particular signature
Stores and provides access to parsed AST
Information required to run clang, e.g. to parse AST or do code completion
PathMappings are a collection of paired client and server paths
Used to guard an operation that should run at most every N seconds
Represents a #pragma mark in the main file
Timings and statistics from the premble build
The parsed preamble and associated data
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
Stores information required to parse a TU using a (possibly stale) Baseline preamble
PreambleThrottler controls which preambles can build at any given time
Store all the needed module files information to parse a single source file
An interface to query the modules information in the project
CRef
Represents a symbol occurrence in the source file
Information about a reference written in the source code, independent of the actual AST node that this reference lives in
Extends Locations returned by textDocument/references with extra info
An efficient structure of storing large set of symbol references in memory
RefSlab::Builder is a mutable container that can 'freeze' to RefSlab
Represents a relation between two symbols
RelationSlab::Builder is a mutable container that can 'freeze' to RelationSlab
A name of a symbol that should be renamed
CResolveTypeHierarchyItemParams
Parameters for the typeHierarchy/resolve request
TODO: The existing ScanningAllProjectModules is not efficient
Support lookups like FileDistance, but the lookup keys are symbol scopes
CNode
Specifies a single semantic token in the document
A versioned set of tokens
Body of textDocument/semanticTokens/full/delta request
Describes a replacement of a contiguous range of semanticTokens
This models LSP SemanticTokensDelta | SemanticTokens, which is the result of textDocument/semanticTokens/full/delta
Body of textDocument/semanticTokens/full request
Limits the number of threads that can acquire the lock at the same time
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
Represents the signature of a callable
Represents the signature of something callable
StoreDiags collects the diagnostics that can later be reported by clangd
The class presents a C++ symbol, e.g
Collect declarations (symbols) from an AST
Represents information about identifier
A header and directives as stored in a Symbol
Interface for symbol indexes that can be used for searching or matching symbols among a set of symbols based on names or unique IDs
Represents information about programming constructs like variables, classes, interfaces etc
Attributes of a symbol that affect how much we like it
Represents a symbol range where the symbol can potentially have multiple tokens
Attributes of a symbol-query pair that affect how much we like it
Set of derived signals computed by calculateDerivedSignals()
An immutable symbol container that stores a set of symbols
SymbolSlab::Builder is a mutable container that can 'freeze' to SymbolSlab
Unittest: is a scheme that refers to files relative to testRoot()
CTextDocumentContentChangeEvent
Allows setting per-thread abort/kill signal callbacks, to print additional information about the crash depending on which thread got signalled
Wrapper for vfs::FileSystem for use in multithreaded programs like clangd
A single C++ or preprocessor token
A half-open range of tokens within a stream
A complete sequence of Tokens representing a source file
CTopN
TopN is a lossy container that preserves only the "best" N elements
Handles running tasks for ClangdServer and managing the resources (e.g., preambles and ASTs) for opened files
An LRU cache of idle ASTs
A map from header files to an opened "proxy" file that includes them
An interface base for small context-sensitive refactoring actions
Input to prepare and apply tweaks
Arguments for the 'applyTweak' command
Used to resolve a client provided item back
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
CURI
A URI describes the location of a source file
URIScheme is an extension point for teaching clangd to recognize a custom URI scheme
CVersionedTextDocumentIdentifier
WithContext replaces Context::current() with a provided scope
WithContextValue extends Context::current() with a single value
To start progress reporting a $/progress notification with the following payload must be sent
Signals the end of progress reporting
Reporting progress is done using the following payload
The edit should either provide changes or documentChanges
The parameters of a Workspace Symbol Request
Ndoc
CInfo
A base struct for Infos
Generator for Markdown documentation
Generator for YAML documentation
A preprocessor that collects all macro symbols
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
HeaderMappCollector collects all remapping header files
PragmaCommentHandler parses pragma comment on include files to determine when we should include a different header from the header that directly defines a symbol
Describes a named symbol from a header
An interface for classes that collect symbols
CClangIncludeFixerPluginAction
The core include fixer plugin action
A context for a file being processed
Handles callbacks from sema, does the include lookup and turns it into an IncludeFixerContext
Xref database with fixed content
This class provides an interface for finding all SymbolInfos corresponding to a symbol name from a symbol database
This class provides an interface for finding the header files corresponding to an identifier in the source code from multiple symbol databases
Describes a named symbol from a header
Yaml format database
Nmove
This class represents one callback call by name and an array of arguments
This class overrides the PPCallbacks class for tracking preprocessor activity by means of its callback functions
Query for "help"
Any query which resulted in a parse error. The error message is in ErrStr
Query for "match MATCHER"
No-op query (i.e. a blank line)
Represents the state for a particular clang-query session
Query for "quit"
Query for "set VAR VALUE"
CSetQueryKind< TraversalKind >
Represents a part of a designation in a C99/C++20 designated initializer
List of designators
Ntidy
Suggests switching the initialization pattern of absl::Cleanup instances from the factory function to class template argument deduction (CTAD), in C++17 and higher
Checks for cases where addition should be performed in the absl::Time domain
Prefer comparison in the absl::Duration domain instead of the numeric domain
Checks for casts of absl::Duration conversion functions, and recommends the right conversion function instead
This check finds cases where Duration factories are being called with floating point arguments, but could be called using integer arguments
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
Checks for cases where subtraction should be performed in the absl::Duration domain
CDurationUnnecessaryConversionCheck
Finds and fixes cases where absl::Duration values are being converted to numeric types and back again
Finds instances of absl::StrSplit() or absl::MaxSplits() where the delimiter is a single character string literal and replaces it with a character
Finds instances where the user depends on internal details and warns them against doing so
This check ensures users don't open namespace absl, as that violates Abseil's compatibility guidelines
Flags redundant calls to absl::StrCat when the result is being passed to another call of absl::StrCat/absl::StrAppend
Flags uses of absl::StrCat to append to a string
Finds s.find(...) == string::npos comparisons (for various string-like types) and suggests replacing with absl::StrContains
Prefer comparison in the absl::Time domain instead of the numeric domain
Finds and fixes absl::Time subtraction expressions to do subtraction in the time domain instead of the numeric domain
CUpgradeDurationConversionsCheck
Finds deprecated uses of absl::Duration arithmetic operators and factories
CIdDependentBackwardBranchCheck
Finds ID-dependent variables and fields used within loops, and warns of their usage
Finds kernel files and include directives whose filename is kernel.cl, Verilog.cl, or VHDL.cl
Detects OpenCL kernel functions that call a barrier but do not call an ID-function function
Finds structs that are inefficiently packed or aligned, and recommends packing and/or aligning of said structs as needed
Finds inner loops that have not been unrolled, as well as fully unrolled loops with unknown loop bounds or a large number of iterations
This module is for Android specific checks
Finds code that uses accept4() without using the SOCK_CLOEXEC flag
Accept() is better to be replaced by accept4()
The base class for all close-on-exec checks in Android module
Creat() is better to be replaced by open()
Dup() is better to be replaced by fcntl(), which has close-on-exec flag
Finds code that uses epoll_create1() without using the EPOLL_CLOEXEC flag
Epoll_create() is better to be replaced by epoll_create1()
Fopen() is suggested to include "e" in their mode string; like "re" would be better than "r"
Finds code that uses inotify_init1() without using the IN_CLOEXEC flag
Inotify_init() is better to be replaced by inotify_init1()
Finds code that uses memfd_create() without using the MFD_CLOEXEC flag
Finds code that opens file without using the O_CLOEXEC flag
Finds code that uses pipe2() without using the O_CLOEXEC flag
Suggests to replace calls to pipe() with calls to pipe2()
Finds code that uses socket() without using the SOCK_CLOEXEC flag
CComparisonInTempFailureRetryCheck
Attempts to catch calls to TEMP_FAILURE_RETRY with a top-level comparison operation, like TEMP_FAILURE_RETRY(read(...) != N)
Detects calls to standard library iterator algorithms that could be replaced with a boost ranges version instead
Finds calls to boost::lexical_caststd::string and / boost::lexical_caststd::wstring and replaces them with / std::to_string and std::to_wstring calls
This namespace contains the implementations for the suppression of diagnostics from similarly-used ("related") parameters
Implements the heuristic that marks two parameters related if the same member is accessed (referred to) inside the current function's body
Implements the heuristic that marks two parameters related if there is a usage for both in the same strict expression subtree
Implements the heuristic that marks two parameters related if there are two separate calls to the same function (overload) and the parameters are passed to the same index in both calls, i.e f(a, b) and f(a, c) passes b and c to the same index (2) of f(), marking them related
Implements the heuristic that marks two parameters related if different ReturnStmts return them from the function
CSimilarlyUsedParameterPairSuppressor
Helper class that is used to detect if two parameters of the same function are used in a similar fashion, to suppress the result
The results of the steps of an Implicit Conversion Sequence is saved in an instance of this record
CUserDefinedConversionOperator
CUserDefinedConvertingConstructor
CMix
A named tuple that contains the information for a mix between two concrete parameters
Contains the metadata for the mixability result between two types, independently of which parameters they were calculated from
Finds assert() with side effect
Catches assignments within the condition clause of an if statement
Finds pthread_kill function calls when thread is terminated by / SIGTERM signal
Warns about code that tries to cast between pointers by means of std::bit_cast or memcpy
CBoolPointerImplicitConversionCheck
Checks for conditions based on implicit conversion from a bool pointer to bool
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
CCapturingThisInMemberVariableCheck
Finds lambda captures that capture the this pointer and store it as class members without handle the copy and move constructors and the assignments
Detects unsafe or redundant two-step casting operations involving void*
Check detects chained comparison operators that can lead to unintended behavior or logical errors
Execution of a command processor can lead to security vulnerabilities, and is generally not required
CComparePointerToMemberVirtualFunctionCheck
Detects unspecified behavior about equality comparison between pointer to member virtual function and anything other than null-pointer-constant
Finds copy constructors where the ctor don't call the copy constructor of the base class
CCopyConstructorMutatesArgumentCheck
Finds assignments to the copied object and its direct or indirect members in copy constructors and copy assignment operators
CCrtpConstructorAccessibilityCheck
Detects error-prone Curiously Recurring Template Pattern usage, when the CRTP can be constructed outside itself and the derived class
Detect dangling references in value handlers like std::string_view
CDefaultOperatorNewOnOveralignedTypeCheck
Checks if an object of type with extended alignment is allocated by using the default operator new
CDerivedMethodShadowingBaseMethodCheck
Checks that a derived class does not define the same (non virtual) method as a base class
CDynamicStaticInitializersCheck
Finds dynamically initialized static variables in header files
CEasilySwappableParametersCheck
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
Detects and suggests addressing issues with empty catch statements
CExceptionCopyConstructorThrowsCheck
Checks whether a thrown object is nothrow copy constructible
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
This check diagnoses when the loop induction expression of a for loop has floating-point type
Find and flag invalid initializer values in folds, e.g
CForwardDeclarationNamespaceCheck
Checks if an unused forward declaration is in a wrong namespace
CForwardingReferenceOverloadCheck
The checker looks for constructors that can act as copy or move constructors through their forwarding reference parameters
CImplicitWideningOfMultiplicationResultCheck
Diagnoses instances of an implicit widening of multiplication result
Checks for inaccurate use of the erase() method
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
Detects incorrect usages of std::enable_if that don't name the nested / type type
CIncorrectEnableSharedFromThisCheck
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
Checks the usage of patterns known to produce incorrect rounding
Finds obvious infinite loops (loops where the condition variable is not changed at all)
Finds cases where integer division in a floating point context is likely to cause unintended loss of precision
CInvalidEnumDefaultInitializationCheck
Detects default initialization (to 0) of variables with enum type where the enum has no enumerator with value of 0
Detect when func or FUNCTION is being used from within a lambda
Finds macros that can have unexpected behaviour due to missing parentheses
CMacroRepeatedSideEffectsCheck
Checks for repeated argument with side effects in macros
CMisleadingSetterOfReferenceCheck
Emits a warning when a setter-like function that has a pointer parameter is used to set value of a field with reference type
CMisplacedOperatorInStrlenInAllocCheck
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
CMisplacedPointerArithmeticInAllocCheck
Finds cases where an integer is added to or subracted from the result of a memory allocation function instead of its argument
Find casts of calculation results to bigger type
The check warns if std::move is applied to a forwarding reference (i.e
CMultiLevelImplicitPointerConversionCheck
Detects implicit conversions between pointers of different levels of indirection
CMultipleNewInOneExpressionCheck
For the user-facing documentation see: https://clang.llvm.org/extra/clang-tidy/checks/bugprone/multiple-new-in-one-expression.html
Detect multiple statement macros that are used in unbraced conditionals
Checks for narrowing conversions, e.g: int i = 0; i += 0.1;
Block arguments in dispatch_async() and dispatch_after() are guaranteed to escape
CNondeterministicPointerIterationOrderCheck
Finds nondeterministic usages of pointers in unordered containers
CNonZeroEnumToBoolConversionCheck
Detect implicit and explicit casts of enum type into bool where enum type doesn't have a zero-value enumerator
Finds function calls where it is possible to cause a not null-terminated result
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
Finds calls to grand..-parent virtual methods instead of parent's
CPointerArithmeticOnPolymorphicObjectCheck
Finds pointer arithmetic performed on classes that contain a virtual function
Random number generator must be seeded properly
CRawMemoryCallOnNonTrivialTypeCheck
Flags use of the C standard library functions 'memset', 'memcpy' and 'memcmp' and similar derivatives on non-trivial types
CRedundantBranchConditionCheck
Finds condition variables in nested if statements that were also checked in the outer if statement and were not changed
Checks for usages of identifiers reserved for use by the implementation
CReturnConstRefFromParameterCheck
Detects return statements that return a constant reference parameter as constant reference
Find std::shared_ptr(new T[...]), replace it (if applicable) with std::shared_ptr<T[]>(new T[...])
Checker for signal handler functions
Finds those signed char -> integer conversions which might indicate a / programming error
Find usages of sizeof on expressions of STL container types
Find suspicious usages of sizeof expressions
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
CSpuriouslyWakeUpFunctionsCheck
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
Checks for ignored calls to empty() on a range and suggests clear() as an alternative if it is an existing member function
CStdNamespaceModificationCheck
Modification of the std or posix namespace can result in undefined behavior
Finds suspicious string constructor and check their parameters
Finds instances where an integer is assigned to a string
CStringLiteralWithEmbeddedNulCheck
Find suspicious string literals with embedded NUL characters
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
The checker detects various cases when an enum is probably misused (as a bitmask)
Warns on inclusion of files whose names suggest that they're implementation files, instead of headers
CSuspiciousMemoryComparisonCheck
Finds potentially incorrect calls to memcmp() based on properties of the arguments
Finds memset calls with potential mistakes in their arguments
This check finds string literals which are probably concatenated accidentally
Finds usages of realloc where the return value is assigned to the same variable as passed to the first argument
This check finds semicolon that modifies the meaning of the program unintendedly
Find suspicious calls to string compare functions
CSuspiciousStringviewDataUsageCheck
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
Finds potentially swapped arguments by looking at implicit conversions
CSwitchMissingDefaultCaseCheck
Ensures that switch statements without default cases are flagged, focuses only on covering cases with non-enums where the compiler may not issue warnings
Gives warnings for tagged unions, where the number of tags is different from the number of data members inside the union
Checks if a 'continue' statement terminates the loop (i.e
CThrowingStaticInitializationCheck
Checks whether the constructor for a static or thread_local object will throw
Emits a warning about temporary objects whose type is (or is derived from) a class that has 'EXCEPTION', 'Exception' or 'exception' in its name
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
Warns when the code is unwrapping a std::optional, absl::optional, or base::std::optional object without assuring that it contains a value
CUncheckedStringToNumberConversionCheck
Guards against use of string conversion functions that do not have reasonable error handling for conversion errors
CUndefinedMemoryManipulationCheck
Finds calls of memory manipulation functions memset(), memcpy() and / memmove() on non-TriviallyCopyable objects resulting in undefined behavior
Finds creation of temporary objects in constructors that look like a function call to another constructor of the same class
Finds calls to 'new' that may throw unhandled exception at allocation failure
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
CUnintendedCharOstreamOutputCheck
Finds unintended character output from unsigned char and signed char to an ostream
Finds initializations of C++ unique pointers to non-array type that are initialized with an array
Checks for functions that have safer, more secure replacements available, or are considered deprecated due to design flaws
CUnusedLocalNonTrivialVariableCheck
Warns when a local non trivial variable is unused within a function
Finds temporaries that look like RAII objects
Detects function calls where the return value is unused
The check warns if an object is used after it has been moved, without an intervening reinitialization
Stores a min and a max value which describe an interval
Checks for near miss of virtual methods
Ncert
Checks that non-thread-safe functions are not used
CThreadCanceltypeAsynchronousCheck
Finds pthread_setcanceltype function calls where a thread's cancellation type is set to asynchronous
CAvoidCapturingLambdaCoroutinesCheck
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
CAvoidConstOrRefDataMembersCheck
Const-qualified or reference data members in classes should be avoided, as they make the class non-copy-assignable
Do-while loops are less readable than plan while loops, and can lead to subtle bugs
The usage of goto for control flow is error prone and should be replaced with looping constructs
CAvoidNonConstGlobalVariablesCheck
Non-const global variables hide dependencies and make the dependencies subject to unpredictable changes
CAvoidReferenceCoroutineParametersCheck
Warns on coroutines that accept reference parameters
A module containing checks of the C++ Core Guidelines
Find uninitialized local variables
Flags possible initialization order issues of static variables
Find macro usage that is considered problematic because better language constructs exist for the task
CMisleadingCaptureDefaultByValueCheck
Warns when lambda specify a by-value capture default and capture this
Warns when a function accepting a forwarding reference does anything besides forwarding (with std::forward) the parameter in the body of the function
This checker is concerned with C-style memory management and suggest modern alternatives to it
Flag coroutines that suspend while any lock guard is alive
Checks for common use cases for gsl::owner and enforces the unique owner nature of it whenever possible
Finds member initializations in the constructor body which can be placed into the initialization list instead
CProBoundsArrayToPointerDecayCheck
This check flags all array to pointer decays
CProBoundsAvoidUncheckedContainerAccessCheck
Flags calls to operator[] in STL containers and suggests replacing it with safe alternatives
CProBoundsConstantArrayIndexCheck
This checks that all array subscriptions on static arrays and std::arrays have a constant index and are within bounds
CProBoundsPointerArithmeticCheck
Flags all kinds of pointer arithmetic that have result of pointer type, i.e
Imposes limitations on the use of const_cast within C++ code
This check flags all use of C-style casts that perform a static_cast downcast, const_cast, or reinterpret_cast
Implements C++ Core Guidelines Type.6
Flags all occurrences of reinterpret_cast
CProTypeStaticCastDowncastCheck
Checks for usages of static_cast, where a base class is downcasted to a derived class
This check flags all access to members of unions
This check flags all calls to c-style variadic functions and all use of va_arg
CRvalueReferenceParamNotMovedCheck
Warns when an rvalue reference function parameter is never moved within the function body
Flags slicing (incomplete copying of an object's state) of member variables or vtable
Checks for classes where some, but not all, of the special member functions are defined
Finds unscoped (non-class) enum declarations and suggests using enum class instead
Finds base classes whose destructor is neither public and virtual nor protected and non-virtual
CCustomChecksRegisterInitializer
Implement of Clang-Query based check
Finds usages of OSSpinlock, which is deprecated due to potential livelock problems
Finds variables of type dispatch_once_t that do not have static or global storage duration, as required by the libdispatch documentation
Default arguments are not allowed in called functions
CDefaultArgumentsDeclarationsCheck
Default parameters are not allowed in declared functions
This module is for Fuchsia-specific checks
Overloading operators is disallowed by the Fuchsia coding standard
CStaticallyConstructedObjectsCheck
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
Construction of specific temporary objects in the Zircon kernel is discouraged
Functions that have trailing returns are disallowed, except for those using decltype specifiers and lambda with otherwise unutterable return types
Defining classes with virtual inheritance is disallowed
Check that make_pair's template arguments are deduced
CUnnamedNamespaceInHeaderCheck
Finds anonymous namespaces in headers
Finds using namespace directives
Nobjc
This check finds Objective-C code that uses +new to create object instances, or overrides +new in classes
CAvoidThrowingObjCExceptionCheck
The check is to find usage of
Finds function names that do not conform to the recommendations of the Google Objective-C Style Guide
CGlobalVariableDeclarationCheck
The check for Objective-C global variables and constants naming convention
CAvoidUnderscoreInGoogletestNameCheck
For the user-facing documentation see: https://clang.llvm.org/extra/clang-tidy/checks/google/readability-avoid-underscore-in-googletest-name.html
Flag global namespace pollution in header files
Finds TODO comments without a username or bug number
Finds uses of short, long and long long and suggest replacing them with u?intXX(_t)?
Finds overloads of unary operator &
Finds usages of long double and suggests against their use due to lack of portability
Checks that default parameters are not given for virtual methods
Checks that all single-argument constructors are explicit
Finds uses of deprecated Googletest APIs with names containing "case" and replaces them with equivalent names containing "suite"
Check for thrown exceptions and enforce they are all derived from std::exception
Ensure that the result of std::remove, std::remove_if and std::unique are not ignored according to rule 17.5.1
Find occasions where not all codepaths are explicitly covered in code
Find assembler statements
This check implements the rule 5.6.1 of the HICPP Standard, which disallows bitwise operations on signed integer types
This module is for checks specific to the Linux kernel
Checks Linux kernel code to see if it uses the results from the functions in linux/err.h
Checks the correct order of #includes
Finds and fixes header guards that do not adhere to LLVM style
CPreferIsaOrDynCastInConditionalsCheck
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
CPreferRegisterOverUnsignedCheck
Historically, LLVM has used unsigned to represent registers
CPreferStaticOverAnonymousNamespaceCheck
Finds function and variable declarations inside anonymous namespace and suggests replacing them with static declarations
Looks for local Twine variables which are prone to use after frees and should be generally avoided
Checks for uses of MLIR's old/to be deprecated OpBuilder::create form and suggests using T::create instead
Finds calls to STL iterator algorithms that can be replaced with LLVM range-based algorithms from llvm/ADT/STLExtras.h
Checks all calls resolve to functions within __llvm_libc namespace
CImplementationInNamespaceCheck
Checks all llvm-libc implementation is within the correct namespace
Checks that explicitly and implicitly inline functions in headers files are tagged with the LIBC_INLINE macro
CRestrictSystemLibcHeadersCheck
Warns of accidental inclusions of system libc headers that aren't compiler provided
CMatchesAnyListedTypeNameMatcher
CNotIdenticalStatementsPredicate
Nmisc
Finds symbol which have confusable identifiers, i.e
This check warns on variables which could be declared const but are not
Detects when objects of certain hostile RAII types persists across suspension points in a coroutine
Finds non-extern non-inline function and variable definitions in header files, which can lead to potential ODR violations
Check detects cyclic #include dependencies between user-defined headers
Checks for unused and missing includes
Warns about unterminated bidirectional unicode sequence
CMisleadingBidirectionalHandler
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
This check diagnoses when a const qualifier is applied to a typedef to a pointer type rather than to the pointee
Multiple implementation inheritance is discouraged
Flags dereferences and non-pointer declarations of objects that are not meant to be passed by value, such as C FILE objects
CNonPrivateMemberVariablesInClassesCheck
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
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)
COverrideWithDifferentVisibilityCheck
Finds virtual function overrides with different visibility than the function in the base class
Pseudorandom number generators are not genuinely random
The checker detects expressions that are redundant, because they contain ineffective, useless parts
Replaces assert() with static_assert() if the condition is evaluatable at compile time
CThrowByValueCatchByReferenceCheck
Checks for locations that do not throw by value
CUnconventionalAssignOperatorCheck
Finds declarations of assignment operators with the wrong return and/or argument types and definitions with good return type but wrong return statements
Find and replace unique_ptr::reset(release()) with std::move()
Finds unused namespace alias declarations
Finds unused parameters and fixes them, so that -Wunused-parameter can be turned on
Finds unused using declarations
Warns when using 'static' functions or variables at global scope, and suggests moving them to an anonymous namespace
Detects variables and functions that can be marked as static or moved into an anonymous namespace to enforce internal linkage
Replace simple uses of std::bind with a lambda
Find C-style array types and recommend to use std::array<> / std::vector<>
Finds usages of C-style casts
Guards against use of setjmp/longjmp in C++ code
Find all function definitions of C-style variadic functions
Class used to find the variables and member expressions on which an arbitrary expression depends
A class to encapsulate lowering of the tool's confidence level
Class used to determine if any declarations used in a Stmt would conflict with a particular identifier
Class used to determine if an expression is dependent on a variable declared inside of the loop where it would be used
This check replaces deprecated C library headers with their C++ STL alternatives
CDeprecatedIosBaseAliasesCheck
This check warns the uses of the deprecated member types of std::ios_base and replaces those that have a non-deprecated equivalent
Discover usages of expressions consisting of index or iterator access
CIntegralLiteralExpressionMatcher
Replaces groups of related macros with an unscoped anonymous enum
Replace the pattern:
Base class for MakeSharedCheck and MakeUniqueCheck
Replace the pattern:
CMinMaxUseInitializerListCheck
Replaces nested std::min and std::max calls with an initializer list where applicable
CNS
This check replaces string literals with escaped characters to raw string literals
Find and remove redundant void argument lists
Transforms the deprecated std::auto_ptr into the C++11 std::unique_ptr
CReplaceDisallowCopyAndAssignMacroCheck
This check finds macro expansions of DISALLOW_COPY_AND_ASSIGN(Type) and replaces them with a deleted copy constructor and a deleted assignment operator
Std::random_shuffle will be removed as of C++17
Use a braced init list for return statements rather than unnecessary repeating the return type name
Replace copy and swap tricks on shrinkable containers with the shrink_to_fit() method call
Class used build the reverse AST properties needed to detect name conflicts and free variables
Converts standard library type traits of the form traits<...>::type and traits<...>::value into traits_t<...> and traits_v<...> respectively
Replaces a static_assert declaration with an empty message with the unary version
The information needed to describe a valid convertible usage of an array index or iterator
Finds integer literals which are cast to bool
Replace enable_if with C++20 requires clauses
Convert a default constructor's member initializers into default member initializers
CUseDesignatedInitializersCheck
Finds initializer lists for aggregate type that could be written as designated initializers instead
This check looks for cases when inserting new element into std::vector but the element is constructed temporarily
Replace default bodies of special member functions with '= default;'
Identifies unimplemented private special member functions, and recommends using = delete for them
CUseIntegerSignComparisonCheck
Replace comparisons between signed and unsigned integers with their safe C++20 std::cmp_* alternative, if available
Add [[nodiscard]] to non-void const-member functions with no arguments or pass-by-value or pass by const-reference arguments
Replace dynamic exception specifications, with noexcept (or user-defined macro) or noexcept(false)
Use C++11's override and remove virtual where applicable
Detects calls to standard library iterator algorithms that could be replaced with a ranges version instead
Finds uses of std::lock_guard and suggests replacing them with C++17's / alternative std::scoped_lock
Checks for common roundabout ways to express starts_with and / ends_with and suggests replacing with the simpler method when it is / available
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:🧵:c_str() and std:🧵:data()
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
Convert calls to printf-like functions to std::print and std::println
Rewrites function signatures to use a trailing return type
Prefer using transparent functors to non-transparent ones
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
Check finds typedefs and replaces it with usings
Create names for generated variables within a particular statement
Nmpi
This check verifies if a buffer passed to an MPI (Message Passing Interface) function is sufficiently dereferenced
This check verifies if buffer type and MPI (Message Passing Interface) datatype pairs match
Nobjc
Warns if XCTAssertEqual() or XCTAssertNotEqual() is used with at least one operands of type NSString*
Finds usages of -[NSError init]
Finds implementations of -dealloc in Objective-C categories
Finds Objective-C classes which have a superclass which is documented to not support subclassing
Finds Objective-C implementations that implement -isEqual: without also appropriately implementing -hash
Checks the string pattern used as a date format specifier and reports warnings if it contains any incorrect sub-pattern
CNSInvocationArgumentLifetimeCheck
Finds calls to NSInvocation methods under ARC that don't have proper argument object lifetimes
Finds invocations of -self on super instances in initializers of subclasses of NSObject and recommends calling a superclass initializer instead
Analyzes OpenMP Structured Blocks and checks that no exception escapes out of the Structured Block it was thrown in
This module is for OpenMP-specific checks
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
ClangTidyCheck Checks to flag for uses of 'std::endl' on streams and suggests using the newline character '"\n"' instead
Finds enum type definitions that could use smaller integral type as a base
Optimize calls to std:🧵:find() and friends when the needle passed is a single character string literal
A check that detects copied loop variables and suggests using const references
CImplicitConversionInLoopCheck
Warns on inefficient use of STL algorithms on associative containers
CInefficientStringConcatenationCheck
This check is to warn about the performance overhead arising from concatenating strings, using the operator+, instead of operator+=
CInefficientVectorOperationCheck
Finds possible inefficient std::vector operations (e.g
Find casts of calculation results to bigger type
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
Finds local variables that cannot be automatically moved due to constness
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)
Generic check which checks if the bound function decl is marked with noexcept or noexcept(expr) where expr evaluates to false
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)
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)
Diagnoses every integer to pointer cast
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;
Finds calls to C math library functions with implicit float to double promotions
CUnnecessaryCopyInitializationCheck
A check that flags value parameters of expensive to copy types that can safely be converted to const references
Finds uses of #pragma once and suggests replacing them with standard / include guards (#ifndef/#define/#endif) for improved portability
CRestrictedIncludesPPCallbacks
Checks for allowed includes and suggests removal of any others
Find SIMD intrinsics calls and suggest std::experimental::simd alternatives
Report use of std::vector (and similar containers of const / elements)
CTemplateVirtualMemberFunctionCheck
Upon instantiating a template class, non-virtual member functions don't have to be instantiated unless they are used
CAmbiguousSmartptrResetCallCheck
Finds potentially erroneous calls to 'reset' method on smart pointers when the pointee type also has a 'reset' method
CAvoidNestedConditionalOperatorCheck
Identifies instances of nested conditional operators in the code
CAvoidReturnWithVoidValueCheck
Finds return statements with void values used within functions with void result types
CAvoidUnconditionalPreprocessorIfCheck
Finds code blocks that are constantly enabled or disabled in preprocessor directives by analyzing #if conditions, such as #if 0 and #if 1, etc
Checks that bodies of if statements and loops (for, range-for, do-while, and while) are inside braces
For any function whose return type is const-qualified, suggests removal of the const qualifier from that return type
Finds usages of container.count() and container.find() == container.end() which should be replaced by a call to the container.contains() method
Checks whether a call to operator[] and & can be replaced with a call to data()
Checks whether a call to the size()/length() method can be replaced with a call to empty()
CConvertMemberFunctionsToStaticCheck
This check finds C++ class methods than can be made static because they don't use the 'this' pointer
Check whether the 'if' statement is unnecessary before calling 'delete' on a pointer
Find and remove duplicate #include directives
Flags the usages of else after return
Enforces consistent style for enumerators' initialization, covering three styles: none, first only, or all initialized explicitly
CFunctionCognitiveComplexityCheck
Checks function Cognitive Complexity metric
Checks for large functions based on various metrics
Warns about identifiers names whose length is too short
Checks for identifiers naming style mismatch
Checks for use of implicit bool conversions in expressions
CInconsistentDeclarationParameterNameCheck
Checks for declarations of functions which differ in parameter names
This check diagnoses all DeclStmt's declaring more than one variable and tries to refactor the code to one statement per declaration
Detects magic numbers, integer and floating point literals embedded in code
Finds non-static member functions that can be made 'const'
Check for mising parantheses in mathematical expressions that involve operators of different priorities
Checks the code for dangling else, and possible misleading indentations due to missing braces
Warn about unusual array index syntax (index[array] instead of array[index])
Find functions with unnamed arguments
Checks that long namespaces have a closing comment
Warn when a pointer function parameter can be const
Enforces consistent token representation for invoked binary, unary and overloaded operators in C++ code
Finds variables declared as auto that could be declared as: 'auto*' or 'const auto *' and reference variables declared as: 'const auto &'
CRedundantAccessSpecifiersCheck
Detects redundant access specifiers inside classes, structs, and unions
Detects explicit type casting operations that involve the same source and destination types, and subsequently recommend their removal
Eliminates redundant return statements at the end of a function that returns void
Find redundant variable declarations
CRedundantFunctionPtrDereferenceCheck
Eliminate redundant dereferences of a function pointer
CRedundantInlineSpecifierCheck
Detects redundant inline specifiers on function and variable declarations
Finds member initializations that are unnecessary because the same default constructor would be called if they were not present
Detect redundant parentheses
This check flags redundant preprocessor directives: nested directives with the same condition
Find and remove redundant calls to smart pointer's .get() method
Finds unnecessary calls to std:🧵:c_str()
Finds unnecessary string initializations
Finds redundant uses of the typename keyword
CReferenceToConstructedTemporaryCheck
Detects C++ code where a reference variable is used to extend the lifetime of a temporary object that has just been constructed
Looks for boolean expressions involving boolean constants and simplifies them to use the appropriate boolean expression directly
Simplifies subscript expressions
CStaticAccessedThroughInstanceCheck
Checks for member expressions that access static members through instances and replaces them with uses of the appropriate qualified-id
CStaticDefinitionInAnonymousNamespaceCheck
Finds static function and variable definitions in anonymous namespace
This check flags all calls compare when used to check for string equality or inequality
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
Flags statements of the form delete <unique_ptr expr>.release(); and / replaces them with: <unique_ptr expr> = nullptr;
Detects when the integral literal or floating point literal has non-uppercase suffix, and suggests to make the suffix uppercase
Finds ranged-based for loops that can be replaced by a call to std::any_of or std::all_of
CUseConcisePreprocessorDirectivesCheck
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
Replaces certain conditional statements with equivalent calls to std::min or std::max
A provider of fix-it hints to insert opening and closing braces
This class analysis if a FunctionDecl can in principle throw an exception, either directly or indirectly
Bundle the gathered information about an entity like a function regarding it's exception behaviour
Holds information about where an exception is thrown
This class analysis if a FunctionDecl has been declared implicitly through defaulting or explicitly as throwing or not and evaluates noexcept expressions if needed
Provides information about the evaluation order of (sub-)expressions within a CFGBlock
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
Finds and fixes header guards
Maps Stmts to the CFGBlock that contains them
A base class for defining a ClangTidy check based on a RewriteRule
Base class for handling converting std iterator algorithms to a range equivalent
This module is for Zircon-specific checks
A [GlobList](classclang%5F1%5F1tidy%5F1%5F1GlobList.html "Read-only set of strings represented as a list of positive and negative globs.") that caches search results, so that search is performed only once for the same query
A collection of ClangTidyCheckFactory instances
Every [ClangTidyCheck](classClangTidyCheck.html) reports errors through a DiagnosticsEngine provided by this context
A diagnostic consumer that turns each Diagnostic into a SourceManager-independent [ClangTidyError](structclang%5F1%5F1tidy%5F1%5F1ClangTidyError.html "A detected error complete with information to display diagnostic and automatic fix.")
A detected error complete with information to display diagnostic and automatic fix
Global options
A clang-tidy module groups a number of ClangTidyChecks and gives them a prefixed name
Contains options for clang-tidy
Helper structure for storing option value with priority of the value
Abstract interface for retrieving various ClangTidy options
The core clang tidy plugin action
Contains displayed and ignored diagnostic counters for a ClangTidy run
Implementation of ClangTidyOptions interface, which is used for '-config' command-line option
Implementation of the [ClangTidyOptionsProvider](classclang%5F1%5F1tidy%5F1%5F1ClangTidyOptionsProvider.html "Abstract interface for retrieving various ClangTidy options.") interface, which returns the same options for all files
Contains a list of line ranges in a single file
Implementation of the [ClangTidyOptionsProvider](classclang%5F1%5F1tidy%5F1%5F1ClangTidyOptionsProvider.html "Abstract interface for retrieving various ClangTidy options.") interface, which tries to find a configuration file in the closest parent directory of each source file
Read-only set of strings represented as a list of positive and negative globs
This class is used to locate NOLINT comments in the file being analyzed, to decide whether a diagnostic should be suppressed
CImpl
This class should be specialized by any enum type that needs to be converted to and from an llvm::StringRef
COptionEnumMapping< bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind >
COptionEnumMapping< concurrency::MtUnsafeCheck::FunctionSet >
COptionEnumMapping< cppcoreguidelines::ProBoundsAvoidUncheckedContainerAccessCheck::FixModes >
COptionEnumMapping< google::readability::StyleKind >
COptionEnumMapping< misc::OverrideWithDifferentVisibilityCheck::ChangeKind >
COptionEnumMapping< misc::UseInternalLinkageCheck::FixModeKind >
COptionEnumMapping< modernize::Confidence::Level >
COptionEnumMapping< modernize::UseTrailingReturnTypeCheck::TransformLambda >
COptionEnumMapping< modernize::VariableNamer::NamingStyle >
COptionEnumMapping< readability::IdentifierNamingCheck::CaseType >
COptionEnumMapping< readability::IdentifierNamingCheck::HungarianPrefixType >
Base class for clang-tidy checks that want to flag declarations and/or macros for renaming based on customizable criteria
Represents customized diagnostic text and how arguments should be applied
Information describing a failed check
Holds an identifier name check failure, tracking the kind of the identifier, its possible fixup and the starting locations of all the identifier usages
CExpandModularHeadersPPCallbacks
Handles PPCallbacks and re-runs preprocessing of the whole translation unit with modules disabled
Nllvm
Some operations such as code completion produce a set of candidates
Nyaml
CBlockScalarTraits< MultiLineString >
CMappingTraits< BaseRecordInfo >
CMappingTraits< ClangTidyOptions >
CMappingTraits< ClangTidyOptions::CustomCheckDiag >
CMappingTraits< ClangTidyOptions::CustomCheckValue >
CMappingTraits< ClangTidyOptions::StringPair >
CMappingTraits< CompileCommandYAML >
CMappingTraits< EnumValueInfo >
CMappingTraits< FieldTypeInfo >
CMappingTraits< FunctionInfo >
CMappingTraits< IncludeFixerContext >
CMappingTraits< IncludeFixerContext::HeaderInfo >
CMappingTraits< IncludeFixerContext::QuerySymbolInfo >
CMappingTraits< IncludeGraphNode >
CMappingTraits< MemberTypeInfo >
CMappingTraits< NamespaceInfo >
CMappingTraits< std::unique_ptr< CommentInfo > >
CMappingTraits< SymbolAndSignals >
CMappingTraits< SymbolInfo::Context >
CMappingTraits< SymbolLocation >
CMappingTraits< TemplateInfo >
CMappingTraits< TemplateParamInfo >
CMappingTraits< TemplateSpecializationInfo >
CMappingTraits< tooling::Range >
CMappingTraits< VariantEntry >
CMappingTraits< YIncludeHeaderWithReferences >
CRef
Represents a symbol occurrence in the source file
Represents a relation between two symbols
CScalarBitSetTraits< clang::clangd::Symbol::IncludeDirective >
CScalarEnumerationTraits< clang::AccessSpecifier >
CScalarEnumerationTraits< clang::DiagnosticIDs::Level >
CScalarEnumerationTraits< clang::doc::CommentKind >
CScalarEnumerationTraits< clang::TagTypeKind >
CScalarEnumerationTraits< ContextType >
CScalarEnumerationTraits< InfoType >
CScalarEnumerationTraits< SymbolKind >
CScalarEnumerationTraits< SymbolLanguage >
CScalarTraits< SmallString< U > >
CScalarTraits< std::array< unsigned char, 20 > >
CSequenceElementTraits< ClangTidyOptions::CustomCheckDiag >
CSequenceElementTraits< ClangTidyOptions::CustomCheckValue >
CSequenceTraits< FileFilter::LineRange >
The class presents a C++ symbol, e.g
CDenseMapInfo< clang::clangd::Config::ExternalIndexSpec >
CDenseMapInfo< clang::clangd::dex::Token >
CDenseMapInfo< clang::clangd::dex::Trigram >
CDenseMapInfo< clang::clangd::IncludeStructure::HeaderID >
CDenseMapInfo< clang::clangd::Range >
CDenseMapInfo< clang::clangd::RefSlab::Builder::Entry >
CDenseMapInfo< clang::clangd::SymbolID >
CDenseMapInfo< 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
CDenseMapInfo< clang::tidy::RenamerClangTidyCheck::NamingCheckId >
Specialization of DenseMapInfo to allow NamingCheckId objects in DenseMaps
Cformat_provider< clang::clangd::Position >
Module map checker class
Modularize utilities class
Preprocessor tracker for modularize
CBar
Contains options for clang-tidy
Helper structure for storing option value with priority of the value
CCompileCheckFrontendActionFactory
CCoverageCheckerFrontendActionFactory
Contains a list of line ranges in a single file
CFoo
A context for a file being processed
CModularizeFrontendActionFactory
COptionEnumMapping< utils::IncludeSorter::IncludeStyle >
Describes a named symbol from a header