Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123456]
| Nclang | ===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===// |
| Nclangd | FIXME: Skip testing on windows temporarily due to the different escaping code mode |
| Nconfig | |
| CCapturedDiags | |
| CDiag | |
| CFileConfigCache | |
| CFragment | A chunk of configuration obtained from a config file, LSP, or elsewhere |
| CCompileFlagsBlock | Conditions in the CompileFlags block affect how a file is parsed |
| CCompletionBlock | Describes code completion preferences |
| CDiagnosticsBlock | Controls behavior of diagnostics (errors and warnings) |
| CClangTidyBlock | Controls how clang-tidy will run over the code base |
| CIncludesBlock | Controls IncludeCleaner diagnostics |
| CDocumentationBlock | Configures documentation style and behaviour |
| CHoverBlock | Describes hover preferences |
| CIfBlock | Conditions in the If block restrict when a Fragment applies |
| CIndexBlock | Controls how clangd understands code outside the current file |
| CExternalBlock | An external index uses data source outside of clangd itself |
| CInlayHintsBlock | Configures labels shown inline with the code |
| CSemanticTokensBlock | Configures semantic tokens that are produced by clangd |
| CSourceInfo | These fields are not part of the user-specified configuration, but instead are populated by the parser to describe the configuration source |
| CStyleBlock | |
| CLocated | An entity written in config along, with its optional location in the file |
| CParams | Describes the context used to evaluate configuration fragments |
| CProvider | A source of configuration fragments |
| Ndex | |
| CChunk | NOTE: This is an implementation detail |
| CCorpus | |
| CDex | In-memory Dex trigram-based index implementation |
| CIterator | Iterator is the interface for Query Tree node |
| CPostingList | PostingList is the storage of DocIDs which can be inserted to the Query Tree as a leaf by constructing Iterator over the PostingList object |
| CToken | A Token represents an attribute of a symbol, such as a particular trigram present in the name (used for fuzzy search) |
| CTrigram | |
| Nmarkup | |
| CBlock | Holds text and knows how to lay it out |
| CParagraph | Represents parts of the markup that can contain strings, like inline code, code block or plain text |
| Nremote | |
| CMarshaller | A notable exception is URI translation |
| Nriff | |
| CChunk | |
| CFile | |
| Ntrace | |
| CEventTracer | A consumer of trace events and measurements |
| CMetric | Represents measurements of clangd events, e.g |
| CSession | 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 |
| CTestTracer | A RAII Tracer that can be used by tests |
| CAnchor | |
| CAnnotations | Same as llvm::Annotations, but adjusts functions to LSP-specific types for positions and ranges |
| CApplyWorkspaceEditParams | |
| CApplyWorkspaceEditResponse | |
| CArgStripper | |
| CASTAction | |
| CASTNode | Simplified description of a clang AST node |
| CASTParams | Payload for textDocument/ast request |
| CASTRetentionPolicy | Configuration of the AST retention policy |
| CASTSignals | Signals derived from a valid AST of a file |
| CAsyncTaskRunner | Runs tasks on separate (detached) threads and wait for all tasks to finish |
| CBackgroundIndex | |
| COptions | |
| CBackgroundIndexRebuilder | |
| CBackgroundIndexRebuilderTest | |
| CBackgroundIndexStorage | |
| CBackgroundIndexTest | |
| CBackgroundQueue | |
| CStats | |
| CTask | A work item on the thread pool's queue |
| CBlockCommentToMarkupDocument | |
| CCallHierarchyIncomingCall | Represents an incoming call, e.g. a caller of a method or constructor |
| CCallHierarchyIncomingCallsParams | The parameter of a callHierarchy/incomingCalls request |
| CCallHierarchyItem | Represents programming constructs like functions or constructors in the context of call hierarchy |
| CCallHierarchyOutgoingCall | Represents an outgoing call, e.g |
| CCallHierarchyOutgoingCallsParams | The parameter of a callHierarchy/outgoingCalls request |
| CCallHierarchyPrepareParams | The parameter of a textDocument/prepareCallHierarchy request |
| CCancelledError | Conventional error when no result is returned due to cancellation |
| CCancelState | |
| CCanonicalIncludes | Maps a definition location onto an #include file, based on a set of filename rules |
| CCapturedASTCtx | The captured AST context |
| CChangeAnnotation | |
| CCheapUnresolvedName | |
| CClangdCompileCommand | Clangd extension that's used in the 'compilationDatabaseChanges' in workspace/didChangeConfiguration to record updates to the in-memory compilation database |
| CClangdDiagnosticOptions | |
| CClangdLSPServer | This class exposes ClangdServer's capabilities via Language Server Protocol |
| CMessageHandler | |
| COptions | |
| CClangdServer | Manages a collection of source files and derived data (ASTs, indexes), and provides language-aware features such as code completion |
| CCallbacks | Interface with hooks for users of ClangdServer to be notified of events |
| CCodeActionInputs | |
| CCodeActionResult | |
| CQuickFix | |
| CRename | |
| CDiagRef | |
| COptions | |
| CTweakRef | |
| CClientCapabilities | |
| CCodeAction | A code action represents a change that can be performed in code, e.g |
| CCodeActionContext | |
| CCodeActionParams | |
| CCodeCompleteOptions | |
| CCodeDescription | Structure to capture a description for an error code |
| CCollectMainFileMacros | Collects macro references (e.g |
| CCollectPragmaMarks | |
| CCommand | |
| CCommandMangler | |
| CCompletionContext | |
| CCompletionItem | |
| CCompletionItemLabelDetails | Additional details for a completion item label |
| CCompletionList | Represents a collection of completion items to be presented in the editor |
| CCompletionParams | |
| CCompletionPrefix | |
| CConfig | Settings that express user/project preferences and control clangd behavior |
| CCDBSearchSpec | |
| CExternalIndexSpec | Describes an external index configuration |
| CConfigurationSettings | Clangd extension: parameters configurable at any time, via the workspace/didChangeConfiguration notification |
| CContainedRefsRequest | |
| CContainedRefsResult | |
| CContext | A context is an immutable container for per-request data that must be propagated through layers that don't care about it |
| CDeadline | A point in time we can wait for |
| CDebouncePolicy | Clangd may wait after an update to see if another one comes along |
| CDecisionForestScores | Same semantics as CodeComplete::Score |
| CDeclRelationSet | |
| CDefinedMacro | |
| CDelegatingCDB | |
| CDiag | A top-level diagnostic that may have Notes and Fixes |
| CDiagBase | Contains basic information about a diagnostic |
| CDiagnostic | |
| CDiagnosticRelatedInformation | Represents a related message and source code location for a diagnostic |
| CDidChangeConfigurationParams | |
| CDidChangeTextDocumentParams | |
| CDidChangeWatchedFilesParams | |
| CDidCloseTextDocumentParams | |
| CDidOpenTextDocumentParams | |
| CDidSaveTextDocumentParams | |
| CDirectoryBasedGlobalCompilationDatabase | Gets compile args from tooling::CompilationDatabases built for parent directories |
| CBroadcastThread | |
| CFilter | |
| CDirectoryCache | |
| COptions | |
| CDirectoryBasedGlobalCompilationDatabaseCacheTest | |
| CDocumentFormattingParams | |
| CDocumentHighlight | A document highlight is a range inside a text document which deserves special attention |
| CDocumentLink | A range in a text document that links to an internal or external resource, like another text document or a web site |
| CDocumentLinkParams | Parameters for the document link request |
| CDocumentOnTypeFormattingParams | |
| CDocumentRangeFormattingParams | |
| CDocumentRangesFormattingParams | |
| CDocumentSymbol | Represents programming constructs like variables, classes, interfaces etc |
| CDocumentSymbolParams | |
| CDraftStore | A thread-safe container for files opened in a workspace, addressed by filenames |
| CDraft | |
| CEdit | A set of edits generated for a single file |
| CEligibleRegion | Represents locations that can accept a definition |
| CEvent | An Event<T> allows events of type T to be broadcast to listeners |
| CSubscription | |
| CExecuteCommandParams | |
| CFeatureModule | A FeatureModule contributes a vertical feature to clangd |
| CASTListener | Extension point that allows modules to observe and modify an AST build |
| CFacilities | Shared server facilities needed by the module to get its work done |
| CFeatureModuleSet | A FeatureModuleSet is a collection of feature modules installed in clangd |
| CFileCache | Base class for threadsafe cache of data read from a file on disk |
| CFileDistance | |
| CFileDistanceOptions | |
| CFileEvent | |
| CFileIndex | This manages symbols from files and an in-memory index on all symbols |
| CFileShardedIndex | Takes slabs coming from a TU (multiple files) and shards them per declaration location |
| CFileStatus | Clangd extension: indicates the current state of the file in clangd, sent from server via the textDocument/clangd.fileStatus notification |
| CFileSymbols | A container of slabs associated with a key |
| CFix | Represents a single fix-it that editor can apply to fix the error |
| CFoldingRange | Stores information about a region of code that can be folded |
| CFoldingRangeParams | |
| CFuzzyFindRequest | |
| CFuzzyMatcher | |
| CGlobalCompilationDatabase | Provides compilation arguments used for parsing C and C++ files |
| CHeaderFile | Represents a header file to be #include'd |
| CHighlightingToken | |
| CHover | |
| CHoverInfo | Contains detailed information about a Symbol |
| CParam | Represents parameters of a function, a template or a macro |
| CPassType | |
| CPrintedType | Contains pretty-printed type and desugared type |
| CIgnoreDiagnostics | |
| CInactiveRegionsParams | Parameters for the inactive regions (server-side) push notification |
| CIncludeCleanerFindings | |
| CIncludeFixer | Attempts to recover from error diagnostics by suggesting include insertion fixes |
| CUnresolvedNameRecorder | |
| CIncludeGraphNode | |
| CIncludeInserter | |
| CIncludeStructure | |
| CRecordHeaders | |
| CInclusion | |
| CIndexFileIn | |
| CIndexFileOut | |
| CInitializationOptions | Clangd extension: parameters configurable at initialize time |
| CInitializeParams | |
| CInlayHint | Inlay hint information |
| CInlayHintLabelPart | An inlay hint label part allows for interactive and composite labels of inlay hints |
| CInlayHintOptions | |
| CInlayHintsParams | A parameter literal used in inlay hint requests |
| CInputsAndAST | |
| CInputsAndPreamble | |
| CKey | Values in a Context are indexed by typed keys |
| CLoadedShard | Represents a shard loaded from storage, stores contents in Shard and metadata about the source file that generated this shard |
| CLocatedSymbol | |
| CLocation | |
| CLogger | Interface to allow custom logging in clangd |
| CLoggingSession | Only one LoggingSession can be active at a time |
| CLookupRequest | |
| CLSPBinder | LSPBinder collects a table of functions that handle LSP calls |
| CRawHandlers | |
| CRawOutgoing | |
| CUntypedOutgoingMethod | |
| CUntypedOutgoingNotification | |
| CLSPClient | |
| CCallResult | |
| CTransportImpl | |
| CLSPError | |
| CMacroOccurrence | |
| CMainFileMacros | |
| CMarkupContent | |
| CMemIndex | MemIndex is a naive in-memory index suitable for a small set of symbols |
| CMemoize | Memoize is a cache to store and reuse computation results based on a key |
| CMemoryShardStorage | |
| CMemoryTree | A tree that can be used to represent memory usage of nested components while preserving the hierarchy |
| CMergedIndex | |
| CMissingIncludeDiagInfo | |
| CMockCompilationDatabase | |
| CMockFS | |
| CModulesBuilder | This class handles building module files for a given source file |
| CModulesBuilderImpl | |
| CNoParams | |
| CNote | Represents a note for the diagnostic |
| CNotification | A threadsafe flag that is initially clear |
| COpaqueType | A representation of a type that can be computed based on clang AST and compared for equality |
| COverlayCDB | Wraps another compilation database, and supports overriding the commands using an in-memory mapping |
| CParagraphToMarkupDocument | |
| CParagraphToString | |
| CParameterInformation | A single parameter of a particular signature |
| CParsedAST | Stores and provides access to parsed AST |
| CParseInputs | Information required to run clang, e.g. to parse AST or do code completion |
| CParseOptions | |
| CParsingCallbacks | |
| CPathMapping | PathMappings are a collection of paired client and server paths |
| CPeriodicThrottler | Used to guard an operation that should run at most every N seconds |
| CPolySubsequenceMatcher | |
| CPosition | |
| CPragmaMark | Represents a #pragma mark in the main file |
| CPreambleBuildStats | Timings and statistics from the premble build |
| CPreambleData | The parsed preamble and associated data |
| CPreambleFileStatusCache | 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 |
| CPreamblePatch | Stores information required to parse a TU using a (possibly stale) Baseline preamble |
| CPreambleThrottler | PreambleThrottler controls which preambles can build at any given time |
| CPrepareRenameResult | |
| CPrerequisiteModules | Store all the needed module files information to parse a single source file |
| CProgressParams | |
| CProjectInfo | |
| CProjectModules | An interface to query the modules information in the project |
| CPublishDiagnosticsParams | |
| CRange | |
| CRealThreadsafeFS | |
| CRef | Represents a symbol occurrence in the source file |
| CReferenceContext | |
| CReferenceLoc | Information about a reference written in the source code, independent of the actual AST node that this reference lives in |
| CReferenceLocation | Extends Locations returned by textDocument/references with extra info |
| CReferenceParams | |
| CReferencesResult | |
| CReference | |
| CRefSlab | An efficient structure of storing large set of symbol references in memory |
| CBuilder | RefSlab::Builder is a mutable container that can 'freeze' to RefSlab |
| CRefsRequest | |
| CRelation | Represents a relation between two symbols |
| CRelationSlab | |
| CBuilder | RelationSlab::Builder is a mutable container that can 'freeze' to RelationSlab |
| CRelationsRequest | |
| CRenameInputs | |
| CRenameOptions | |
| CRenameParams | |
| CRenameResult | |
| CRenameSymbolName | A name of a symbol that should be renamed |
| CResolveTypeHierarchyItemParams | Parameters for the typeHierarchy/resolve request |
| CScanningAllProjectModules | TODO: The existing ScanningAllProjectModules is not efficient |
| CScopeDistance | Support lookups like FileDistance, but the lookup keys are symbol scopes |
| CSelectionRange | |
| CSelectionRangeParams | |
| CSelectionTree | |
| CNode | |
| CSemanticToken | Specifies a single semantic token in the document |
| CSemanticTokens | A versioned set of tokens |
| CSemanticTokensDeltaParams | Body of textDocument/semanticTokens/full/delta request |
| CSemanticTokensEdit | Describes a replacement of a contiguous range of semanticTokens |
| CSemanticTokensOrDelta | This models LSP SemanticTokensDelta | SemanticTokens, which is the result of textDocument/semanticTokens/full/delta |
| CSemanticTokensParams | Body of textDocument/semanticTokens/full request |
| CSemaphore | Limits the number of threads that can acquire the lock at the same time |
| CShowMessageParams | 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 |
| CSignatureHelp | Represents the signature of a callable |
| CSignatureInformation | Represents the signature of something callable |
| CSignatureQualitySignals | |
| CSourceParams | |
| CSpelledWord | |
| CStdLibLocation | |
| CStdLibSet | |
| CStoreDiags | StoreDiags collects the diagnostics that can later be reported by clangd |
| CStreamLogger | |
| CSubsequenceMatcher | |
| CSwapIndex | |
| CSymbol | The class presents a C++ symbol, e.g |
| CIncludeHeaderWithReferences | |
| CSymbolCollector | Collect declarations (symbols) from an AST |
| CHeaderFileURICache | |
| COptions | |
| CSymbolDetails | Represents information about identifier |
| CSymbolDocCommentVisitor | |
| CSymbolID | |
| CSymbolInclude | A header and directives as stored in a Symbol |
| CSymbolIndex | Interface for symbol indexes that can be used for searching or matching symbols among a set of symbols based on names or unique IDs |
| CSymbolInformation | Represents information about programming constructs like variables, classes, interfaces etc |
| CSymbolLocation | |
| CPosition | |
| CSymbolQualitySignals | Attributes of a symbol that affect how much we like it |
| CSymbolRange | Represents a symbol range where the symbol can potentially have multiple tokens |
| CSymbolRelevanceSignals | Attributes of a symbol-query pair that affect how much we like it |
| CDerivedSignals | Set of derived signals computed by calculateDerivedSignals() |
| CSymbolSlab | An immutable symbol container that stores a set of symbols |
| CBuilder | SymbolSlab::Builder is a mutable container that can 'freeze' to SymbolSlab |
| CTestScheme | Unittest: is a scheme that refers to files relative to testRoot() |
| CTestTU | |
| CTestWorkspace | |
| CTextDocumentContentChangeEvent | |
| CTextDocumentEdit | |
| CTextDocumentIdentifier | |
| CTextDocumentItem | |
| CTextDocumentPositionParams | |
| CTextEdit | |
| CThreadCrashReporter | Allows setting per-thread abort/kill signal callbacks, to print additional information about the crash depending on which thread got signalled |
| CThreadingTest | |
| CThreadsafeFS | Wrapper for vfs::FileSystem for use in multithreaded programs like clangd |
| CToken | A single C++ or preprocessor token |
| CRange | A half-open range of tokens within a stream |
| CTokenStream | A complete sequence of Tokens representing a source file |
| CTopN | TopN<T> is a lossy container that preserves only the "best" N elements |
| CTransport | |
| CMessageHandler | |
| CTraverseHeadersToo | |
| CTUScheduler | Handles running tasks for ClangdServer and managing the resources (e.g., preambles and ASTs) for opened files |
| CASTCache | An LRU cache of idle ASTs |
| CFileData | |
| CFileStats | |
| CHeaderIncluderCache | A map from header files to an opened "proxy" file that includes them |
| COptions | |
| CTUStatus | |
| CBuildDetails | |
| CTweak | An interface base for small context-sensitive refactoring actions |
| CEffect | |
| CSelection | Input to prepare and apply tweaks |
| CTweakArgs | Arguments for the 'applyTweak' command |
| CTweakTest | |
| CTypeHierarchyItem | |
| CResolveParams | Used to resolve a client provided item back |
| CTypeHierarchyPrepareParams | 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 |
| CURIDistance | |
| CURIForFile | |
| CURIScheme | URIScheme is an extension point for teaching clangd to recognize a custom URI scheme |
| CVersionedTextDocumentIdentifier | |
| CWithContext | WithContext replaces Context::current() with a provided scope |
| CWithContextValue | WithContextValue extends Context::current() with a single value |
| CWorkDoneProgressBegin | To start progress reporting a $/progress notification with the following payload must be sent |
| CWorkDoneProgressCreateParams | |
| CWorkDoneProgressEnd | Signals the end of progress reporting |
| CWorkDoneProgressReport | Reporting progress is done using the following payload |
| CWorkspaceEdit | The edit should either provide changes or documentChanges |
| CWorkspaceSymbolParams | The parameters of a Workspace Symbol Request |
| Ndoc | |
| Nserialize | |
| CClangDocCommentVisitor | |
| CBaseRecordInfo | |
| CBitCodeConstants | |
| CBlockIdToIndexFunctor | |
| CClangDocBitcodeReader | |
| CClangDocBitcodeWriter | |
| CClangDocContext | |
| CCommentInfo | |
| CConceptInfo | |
| CConstraintInfo | |
| CEnumInfo | |
| CEnumValueInfo | |
| CFieldTypeInfo | |
| CFriendInfo | |
| CFunctionInfo | |
| CGenerator | |
| CHTMLGenerator | Generator for HTML documentation |
| CIndex | |
| CInfo | A base struct for Infos |
| CJSONGenerator | |
| CLocation | |
| CMapASTVisitor | |
| CMapperActionFactory | |
| CMDGenerator | Generator for Markdown documentation |
| CMemberTypeInfo | |
| CMustacheHTMLGenerator | |
| CMustacheTemplateFile | |
| CNamespaceInfo | |
| CRecordIdDsc | |
| CRecordIdToIndexFunctor | |
| CRecordInfo | |
| CReference | |
| CScopeChildren | |
| CSymbolInfo | |
| CTemplateInfo | |
| CTemplateParamInfo | |
| CTemplateSpecializationInfo | |
| CTypedefInfo | |
| CTypeInfo | |
| CVarInfo | |
| CYAMLGenerator | Generator for YAML documentation |
| Nfind_all_symbols | |
| CFindAllMacros | A preprocessor that collects all macro symbols |
| CFindAllSymbols | 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 |
| CFindAllSymbolsAction | |
| CFindAllSymbolsActionFactory | |
| CHeaderMapCollector | HeaderMappCollector collects all remapping header files |
| CPragmaCommentHandler | PragmaCommentHandler parses pragma comment on include files to determine when we should include a different header from the header that directly defines a symbol |
| CSymbolAndSignals | |
| CSymbolInfo | Describes a named symbol from a header |
| CSignals | |
| CSymbolReporter | An interface for classes that collect symbols |
| CYamlReporter | |
| Ninclude_fixer | |
| CClangIncludeFixerPluginAction | The core include fixer plugin action |
| CFuzzySymbolIndex | |
| CIncludeFixerActionFactory | |
| CIncludeFixerContext | A context for a file being processed |
| CHeaderInfo | |
| CQuerySymbolInfo | |
| CIncludeFixerSemaSource | Handles callbacks from sema, does the include lookup and turns it into an IncludeFixerContext |
| CInMemorySymbolIndex | Xref database with fixed content |
| CSymbolAndSignals | |
| CSymbolIndex | This class provides an interface for finding all SymbolInfos corresponding to a symbol name from a symbol database |
| CSymbolIndexManager | This class provides an interface for finding the header files corresponding to an identifier in the source code from multiple symbol databases |
| CSymbolInfo | Describes a named symbol from a header |
| CSignals | |
| CYamlSymbolIndex | Yaml format database |
| Nmove | |
| CClangMoveAction | |
| CClangMoveActionFactory | |
| CClangMoveContext | |
| CClangMoveTool | |
| CDeclarationReporter | |
| CDeclaration | |
| CHelperDeclRefGraph | |
| CHelperDeclRGBuilder | |
| CMoveDefinitionSpec | |
| Npp_trace | |
| CArgument | |
| CCallbackCall | This class represents one callback call by name and an array of arguments |
| CPPCallbacksTracker | This class overrides the PPCallbacks class for tracking preprocessor activity by means of its callback functions |
| Nquery | |
| CDisableOutputQuery | |
| CEnableOutputQuery | |
| CFileQuery | |
| CHelpQuery | Query for "help" |
| CInvalidQuery | Any query which resulted in a parse error. The error message is in ErrStr |
| CLetQuery | |
| CMatchQuery | Query for "match MATCHER" |
| CNoOpQuery | No-op query (i.e. a blank line) |
| CQuery | |
| CQueryParser | |
| CLexOrCompleteWord | |
| CQuerySession | Represents the state for a particular clang-query session |
| CQuitQuery | Query for "quit" |
| CSetExclusiveOutputQuery | |
| CSetNonExclusiveOutputQuery | |
| CSetQuery | Query for "set VAR VALUE" |
| CSetQueryKind | |
| CSetQueryKind< bool > | |
| CSetQueryKind< OutputKind > | |
| CSetQueryKind< TraversalKind > | |
| Nreorder_fields | |
| CDesignator | Represents a part of a designation in a C99/C++20 designated initializer |
| CDesignators | List of designators |
| CReorderedStruct | |
| CReorderFieldsAction | |
| Ntidy | |
| Nabseil | |
| CAbseilModule | |
| CCleanupCtadCheck | Suggests switching the initialization pattern of absl::Cleanup instances from the factory function to class template argument deduction (CTAD), in C++17 and higher |
| CDurationAdditionCheck | Checks for cases where addition should be performed in the absl::Time domain |
| CDurationComparisonCheck | Prefer comparison in the absl::Duration domain instead of the numeric domain |
| CDurationConversionCastCheck | Checks for casts of absl::Duration conversion functions, and recommends the right conversion function instead |
| CDurationDivisionCheck | |
| CDurationFactoryFloatCheck | This check finds cases where Duration factories are being called with floating point arguments, but could be called using integer arguments |
| CDurationFactoryScaleCheck | 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 |
| CDurationScale2IndexFunctor | |
| CDurationSubtractionCheck | 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 |
| CFasterStrsplitDelimiterCheck | Finds instances of absl::StrSplit() or absl::MaxSplits() where the delimiter is a single character string literal and replaces it with a character |
| CNoInternalDependenciesCheck | Finds instances where the user depends on internal details and warns them against doing so |
| CNoNamespaceCheck | This check ensures users don't open namespace absl, as that violates Abseil's compatibility guidelines |
| CRedundantStrcatCallsCheck | Flags redundant calls to absl::StrCat when the result is being passed to another call of absl::StrCat/absl::StrAppend |
| CStrCatAppendCheck | Flags uses of absl::StrCat to append to a string |
| CStringFindStartswithCheck | |
| CStringFindStrContainsCheck | Finds s.find(...) == string::npos comparisons (for various string-like types) and suggests replacing with absl::StrContains |
| CTimeComparisonCheck | Prefer comparison in the absl::Time domain instead of the numeric domain |
| CTimeSubtractionCheck | 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 |
| Naltera | |
| CAlteraModule | |
| CIdDependentBackwardBranchCheck | Finds ID-dependent variables and fields used within loops, and warns of their usage |
| CKernelNameRestrictionCheck | Finds kernel files and include directives whose filename is kernel.cl, Verilog.cl, or VHDL.cl |
| CSingleWorkItemBarrierCheck | Detects OpenCL kernel functions that call a barrier but do not call an ID-function function |
| CStructPackAlignCheck | Finds structs that are inefficiently packed or aligned, and recommends packing and/or aligning of said structs as needed |
| CUnrollLoopsCheck | Finds inner loops that have not been unrolled, as well as fully unrolled loops with unknown loop bounds or a large number of iterations |
| Nandroid | |
| CAndroidModule | This module is for Android specific checks |
| CCloexecAccept4Check | Finds code that uses accept4() without using the SOCK_CLOEXEC flag |
| CCloexecAcceptCheck | Accept() is better to be replaced by accept4() |
| CCloexecCheck | The base class for all close-on-exec checks in Android module |
| CCloexecCreatCheck | Creat() is better to be replaced by open() |
| CCloexecDupCheck | Dup() is better to be replaced by fcntl(), which has close-on-exec flag |
| CCloexecEpollCreate1Check | Finds code that uses epoll_create1() without using the EPOLL_CLOEXEC flag |
| CCloexecEpollCreateCheck | Epoll_create() is better to be replaced by epoll_create1() |
| CCloexecFopenCheck | Fopen() is suggested to include "e" in their mode string; like "re" would be better than "r" |
| CCloexecInotifyInit1Check | Finds code that uses inotify_init1() without using the IN_CLOEXEC flag |
| CCloexecInotifyInitCheck | Inotify_init() is better to be replaced by inotify_init1() |
| CCloexecMemfdCreateCheck | Finds code that uses memfd_create() without using the MFD_CLOEXEC flag |
| CCloexecOpenCheck | Finds code that opens file without using the O_CLOEXEC flag |
| CCloexecPipe2Check | Finds code that uses pipe2() without using the O_CLOEXEC flag |
| CCloexecPipeCheck | Suggests to replace calls to pipe() with calls to pipe2() |
| CCloexecSocketCheck | 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) |
| Nboost | |
| CBoostModule | |
| CUseRangesCheck | Detects calls to standard library iterator algorithms that could be replaced with a boost ranges version instead |
| CUseToStringCheck | 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 |
| Nbugprone | |
| Nfilter | |
| Nrelatedness_heuristic | This namespace contains the implementations for the suppression of diagnostics from similarly-used ("related") parameters |
| CAccessedSameMemberOf | Implements the heuristic that marks two parameters related if the same member is accessed (referred to) inside the current function's body |
| CAppearsInSameExpr | Implements the heuristic that marks two parameters related if there is a usage for both in the same strict expression subtree |
| CPassedToSameFunction | 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 |
| CReturned | 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 |
| Nmodel | |
| CConversionSequence | 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 |
| CMixableParameterRange | |
| CMixData | Contains the metadata for the mixability result between two types, independently of which parameters they were calculated from |
| CArgumentCommentCheck | |
| CAssertSideEffectCheck | Finds assert() with side effect |
| CAssignmentInIfConditionCheck | Catches assignments within the condition clause of an if statement |
| CBadSignalToKillThreadCheck | Finds pthread_kill function calls when thread is terminated by / SIGTERM signal |
| CBitwisePointerCastCheck | 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 |
| CBranchCloneCheck | 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 |
| CBugproneModule | |
| 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 |
| CCastingThroughVoidCheck | Detects unsafe or redundant two-step casting operations involving void* |
| CChainedComparisonCheck | Check detects chained comparison operators that can lead to unintended behavior or logical errors |
| CCharExpressionDetector | |
| CComparePointerToMemberVirtualFunctionCheck | Detects unspecified behavior about equality comparison between pointer to member virtual function and anything other than null-pointer-constant |
| CCopyConstructorInitCheck | Finds copy constructors where the ctor don't call the copy constructor of the base class |
| CCrtpConstructorAccessibilityCheck | Detects error-prone Curiously Recurring Template Pattern usage, when the CRTP can be constructed outside itself and the derived class |
| CDanglingHandleCheck | Detect dangling references in value handlers like std::string_view |
| 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 |
| CEmptyCatchCheck | Detects and suggests addressing issues with empty catch statements |
| CExceptionEscapeCheck | 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 |
| CFoldInitTypeCheck | 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 |
| CInaccurateEraseCheck | Checks for inaccurate use of the erase() method |
| CIncDecInConditionsCheck | 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 |
| CIncorrectEnableIfCheck | 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 |
| CIncorrectRoundingsCheck | Checks the usage of patterns known to produce incorrect rounding |
| CInfiniteLoopCheck | Finds obvious infinite loops (loops where the condition variable is not changed at all) |
| CIntegerDivisionCheck | 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 |
| CLambdaFunctionNameCheck | Detect when func or FUNCTION is being used from within a lambda |
| CSourceRangeLessThan | |
| CMacroParenthesesCheck | 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 |
| CMisplacedWideningCastCheck | Find casts of calculation results to bigger type |
| CMoveForwardingReferenceCheck | 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: http://clang.llvm.org/extra/clang-tidy/checks/bugprone/multiple-new-in-one-expression.html |
| CMultipleStatementMacroCheck | Detect multiple statement macros that are used in unbraced conditionals |
| CNarrowingConversionsCheck | Checks for narrowing conversions, e.g: int i = 0; i += 0.1; |
| CNoEscapeCheck | 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 |
| CNotNullTerminatedResultCheck | Finds function calls where it is possible to cause a not null-terminated result |
| COptionalValueConversionCheck | 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 |
| CParentVirtualCallCheck | Finds calls to grand..-parent virtual methods instead of parent's |
| CPointerArithmeticOnPolymorphicObjectCheck | Finds pointer arithmetic performed on classes that contain a virtual function |
| CPosixReturnCheck | |
| CRedundantBranchConditionCheck | Finds condition variables in nested if statements that were also checked in the outer if statement and were not changed |
| CReservedIdentifierCheck | Checks for usages of identifiers reserved for use by the implementation |
| CReturnConstRefFromParameterCheck | Detects return statements that return a constant reference parameter as constant reference |
| CSharedPtrArrayMismatchCheck | Find std::shared_ptr<T>(new T[...]), replace it (if applicable) with std::shared_ptr<T[]>(new T[...]) |
| CSignalHandlerCheck | Checker for signal handler functions |
| CSignedCharMisuseCheck | Finds those signed char -> integer conversions which might indicate a / programming error |
| CSizeofContainerCheck | Find usages of sizeof on expressions of STL container types |
| CSizeofExpressionCheck | Find suspicious usages of sizeof expressions |
| CSmartPtrArrayMismatchCheck | 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 |
| CStandaloneEmptyCheck | Checks for ignored calls to empty() on a range and suggests clear() as an alternative if it is an existing member function |
| CStringConstructorCheck | Finds suspicious string constructor and check their parameters |
| CStringIntegerAssignmentCheck | Finds instances where an integer is assigned to a string |
| CStringLiteralWithEmbeddedNulCheck | Find suspicious string literals with embedded NUL characters |
| CStringviewNullptrCheck | 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 |
| CSuspiciousEnumUsageCheck | The checker detects various cases when an enum is probably misused (as a bitmask) |
| CSuspiciousIncludeCheck | 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 |
| CSuspiciousMemsetUsageCheck | Finds memset calls with potential mistakes in their arguments |
| CSuspiciousMissingCommaCheck | This check finds string literals which are probably concatenated accidentally |
| CSuspiciousReallocUsageCheck | Finds usages of realloc where the return value is assigned to the same variable as passed to the first argument |
| CSuspiciousSemicolonCheck | This check finds semicolon that modifies the meaning of the program unintendedly |
| CSuspiciousStringCompareCheck | 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 |
| CSwappedArgumentsCheck | 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 |
| CTaggedUnionMemberCountCheck | Gives warnings for tagged unions, where the number of tags is different from the number of data members inside the union |
| CTerminatingContinueCheck | Checks if a 'continue' statement terminates the loop (i.e |
| CThrowKeywordMissingCheck | Emits a warning about temporary objects whose type is (or is derived from) a class that has 'EXCEPTION', 'Exception' or 'exception' in its name |
| CTooSmallLoopVariableCheck | 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 |
| CUncheckedOptionalAccessCheck | 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 |
| 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 |
| CUndelegatedConstructorCheck | Finds creation of temporary objects in constructors that look like a function call to another constructor of the same class |
| CUnhandledExceptionAtNewCheck | Finds calls to 'new' that may throw unhandled exception at allocation failure |
| CUnhandledSelfAssignmentCheck | 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 |
| CUniquePtrArrayMismatchCheck | Finds initializations of C++ unique pointers to non-array type that are initialized with an array |
| CUnsafeFunctionsCheck | Checks for functions that have safer, more secure replacements available, or are considered deprecated due to design flaws |
| CCheckedFunction | |
| CUnusedLocalNonTrivialVariableCheck | Warns when a local non trivial variable is unused within a function |
| CUnusedRaiiCheck | Finds temporaries that look like RAII objects |
| CUnusedReturnValueCheck | Detects function calls where the return value is unused |
| CUseAfterMoveCheck | The check warns if an object is used after it has been moved, without an intervening reinitialization |
| CValueRange | Stores a min and a max value which describe an interval |
| CVirtualNearMissCheck | Checks for near miss of virtual methods |
| Ncert | |
| CCERTModule | |
| CCommandProcessorCheck | Execution of a command processor can lead to security vulnerabilities, and is generally not required |
| CDefaultOperatorNewAlignmentCheck | Checks if an object of type with extended alignment is allocated by using the default operator new |
| CDontModifyStdNamespaceCheck | Modification of the std or posix namespace can result in undefined behavior |
| CFloatLoopCounter | This check diagnoses when the loop induction expression of a for loop has floating-point type |
| CLimitedRandomnessCheck | Pseudorandom number generators are not genuinely random |
| CMutatingCopyCheck | Finds assignments to the copied object and its direct or indirect members in copy constructors and copy assignment operators |
| CNonTrivialTypesLibcMemoryCallsCheck | Flags use of the C standard library functions 'memset', 'memcpy' and 'memcmp' and similar derivatives on non-trivial types |
| CProperlySeededRandomGeneratorCheck | Random number generator must be seeded properly |
| CSetLongJmpCheck | Guards against use of setjmp/longjmp in C++ code |
| CStaticObjectExceptionCheck | Checks whether the constructor for a static or thread_local object will throw |
| CThrownExceptionTypeCheck | Checks whether a thrown object is nothrow copy constructible |
| CVariadicFunctionDefCheck | Guards against any C-style variadic function definitions (not declarations) |
| Nconcurrency | |
| CConcurrencyModule | |
| CMtUnsafeCheck | 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 |
| Ncppcoreguidelines | |
| CAssignmentPair | |
| 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 |
| CAvoidDoWhileCheck | Do-while loops are less readable than plan while loops, and can lead to subtle bugs |
| CAvoidGotoCheck | 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 |
| CCppCoreGuidelinesModule | A module containing checks of the C++ Core Guidelines |
| CInitVariablesCheck | Find uninitialized local variables |
| CInterfacesGlobalInitCheck | Flags possible initialization order issues of static variables |
| CMacroUsageCheck | 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 |
| CMissingStdForwardCheck | Warns when a function accepting a forwarding reference does anything besides forwarding (with std::forward) the parameter in the body of the function |
| CNoMallocCheck | This checker is concerned with C-style memory management and suggest modern alternatives to it |
| CNoSuspendWithLockCheck | Flag coroutines that suspend while any lock guard is alive |
| COwningMemoryCheck | Checks for common use cases for gsl::owner and enforces the unique owner nature of it whenever possible |
| CPreferMemberInitializerCheck | 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 |
| CProBoundsAvoidUncheckedContainerAccess | 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 |
| CProTypeConstCastCheck | Imposes limitations on the use of const_cast within C++ code |
| CProTypeCstyleCastCheck | This check flags all use of C-style casts that perform a static_cast downcast, const_cast, or reinterpret_cast |
| CProTypeMemberInitCheck | Implements C++ Core Guidelines Type.6 |
| CProTypeReinterpretCastCheck | Flags all occurrences of reinterpret_cast |
| CProTypeStaticCastDowncastCheck | Checks for usages of static_cast, where a base class is downcasted to a derived class |
| CProTypeUnionAccessCheck | This check flags all access to members of unions |
| CProTypeVarargCheck | 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 |
| CSlicingCheck | Flags slicing (incomplete copying of an object's state) of member variables or vtable |
| CSpecialMemberFunctionsCheck | Checks for classes where some, but not all, of the special member functions are defined |
| CSpecialMemberFunctionData | |
| CUseEnumClassCheck | Finds unscoped (non-class) enum declarations and suggests using enum class instead |
| CVirtualClassDestructorCheck | Finds base classes whose destructor is neither public and virtual nor protected and non-virtual |
| Ndarwin | |
| CAvoidSpinlockCheck | Finds usages of OSSpinlock, which is deprecated due to potential livelock problems |
| CDarwinModule | |
| CDispatchOnceNonstaticCheck | Finds variables of type dispatch_once_t that do not have static or global storage duration, as required by the libdispatch documentation |
| Nfuchsia | |
| CDefaultArgumentsCallsCheck | Default arguments are not allowed in called functions |
| CDefaultArgumentsDeclarationsCheck | Default parameters are not allowed in declared functions |
| CFuchsiaModule | This module is for Fuchsia-specific checks |
| CMultipleInheritanceCheck | Multiple implementation inheritance is discouraged |
| COverloadedOperatorCheck | 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 |
| CTrailingReturnCheck | Functions that have trailing returns are disallowed, except for those using decltype specifiers and lambda with otherwise unutterable return types |
| CVirtualInheritanceCheck | Defining classes with virtual inheritance is disallowed |
| Ngoogle | |
| Nbuild | |
| CExplicitMakePairCheck | Check that make_pair's template arguments are deduced |
| CUnnamedNamespaceInHeaderCheck | Finds anonymous namespaces in headers |
| CUsingNamespaceDirectiveCheck | Finds using namespace directives |
| Nobjc | |
| CAvoidNSObjectNewCheck | 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 |
| CFunctionNamingCheck | 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 |
| Nreadability | |
| CAvoidCStyleCastsCheck | Finds usages of C-style casts |
| CAvoidUnderscoreInGoogletestNameCheck | For the user-facing documentation see: http://clang.llvm.org/extra/clang-tidy/checks/google/readability-avoid-underscore-in-googletest-name.html |
| CGlobalNamesInHeadersCheck | Flag global namespace pollution in header files |
| CTodoCommentCheck | Finds TODO comments without a username or bug number |
| CTodoCommentHandler | |
| Nruntime | |
| CIntegerTypesCheck | Finds uses of short, long and long long and suggest replacing them with u?intXX(_t)? |
| COverloadedUnaryAndCheck | Finds overloads of unary operator & |
| CDefaultArgumentsCheck | Checks that default parameters are not given for virtual methods |
| CExplicitConstructorCheck | Checks that all single-argument constructors are explicit |
| CGoogleModule | |
| CUpgradeGoogletestCaseCheck | Finds uses of deprecated Googletest APIs with names containing "case" and replaces them with equivalent names containing "suite" |
| Nhicpp | |
| CExceptionBaseclassCheck | Check for thrown exceptions and enforce they are all derived from std::exception |
| CHICPPModule | |
| CIgnoredRemoveResultCheck | Ensure that the result of std::remove, std::remove_if and std::unique are not ignored according to rule 17.5.1 |
| CMultiwayPathsCoveredCheck | Find occasions where not all codepaths are explicitly covered in code |
| CNoAssemblerCheck | Find assembler statements |
| CSignedBitwiseCheck | This check implements the rule 5.6.1 of the HICPP Standard, which disallows bitwise operations on signed integer types |
| Nlinuxkernel | |
| CLinuxKernelModule | This module is for checks specific to the Linux kernel |
| CMustCheckErrsCheck | Checks Linux kernel code to see if it uses the results from the functions in linux/err.h |
| Nllvm_check | |
| CIncludeOrderCheck | Checks the correct order of #includes |
| CLLVMHeaderGuardCheck | Finds and fixes header guards that do not adhere to LLVM style |
| CLLVMModule | |
| 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 |
| CTwineLocalCheck | Looks for local Twine variables which are prone to use after frees and should be generally avoided |
| CUseNewMlirOpBuilderCheck | Checks for uses of MLIR's old/to be deprecated OpBuilder::create<T> form and suggests using T::create instead |
| CUseRangesCheck | Finds calls to STL iterator algorithms that can be replaced with LLVM range-based algorithms from llvm/ADT/STLExtras.h |
| Nllvm_libc | |
| CCalleeNamespaceCheck | Checks all calls resolve to functions within __llvm_libc namespace |
| CImplementationInNamespaceCheck | Checks all llvm-libc implementation is within the correct namespace |
| CInlineFunctionDeclCheck | Checks that explicitly and implicitly inline functions in headers files are tagged with the LIBC_INLINE macro |
| CLLVMLibcModule | |
| CRestrictSystemLibcHeadersCheck | Warns of accidental inclusions of system libc headers that aren't compiler provided |
| Nmatchers | |
| CMatchesAnyListedNameMatcher | |
| CNameMatcher | |
| CMatchesAnyListedTypeNameMatcher | |
| CNotIdenticalStatementsPredicate | |
| Nmisc | |
| CConfusableIdentifierCheck | Finds symbol which have confusable identifiers, i.e |
| CConstCorrectnessCheck | This check warns on variables which could be declared const but are not |
| CCoroutineHostileRAIICheck | Detects when objects of certain hostile RAII types persists across suspension points in a coroutine |
| CDefinitionsInHeadersCheck | Finds non-extern non-inline function and variable definitions in header files, which can lead to potential ODR violations |
| CHeaderIncludeCycleCheck | Check detects cyclic #include dependencies between user-defined headers |
| CIncludeCleanerCheck | Checks for unused and missing includes |
| CMiscModule | |
| CMisleadingBidirectionalCheck | |
| CMisleadingBidirectionalHandler | |
| CMisleadingIdentifierCheck | |
| CMisplacedConstCheck | This check diagnoses when a const qualifier is applied to a typedef to a pointer type rather than to the pointee |
| CNewDeleteOverloadsCheck | |
| CNonCopyableObjectsCheck | The check 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 |
| CNoRecursionCheck | 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 |
| CRedundantExpressionCheck | The checker detects expressions that are redundant, because they contain ineffective, useless parts |
| CStaticAssertCheck | 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 |
| CUniqueptrResetReleaseCheck | Find and replace unique_ptr::reset(release()) with std::move() |
| CUnusedAliasDeclsCheck | Finds unused namespace alias declarations |
| CUnusedParametersCheck | Finds unused parameters and fixes them, so that -Wunused-parameter can be turned on |
| CIndexerVisitor | |
| CUnusedUsingDeclsCheck | Finds unused using declarations |
| CUseAnonymousNamespaceCheck | Warns when using 'static' functions or variables at global scope, and suggests moving them to an anonymous namespace |
| CUseInternalLinkageCheck | Detects variables and functions that can be marked as static or moved into an anonymous namespace to enforce internal linkage |
| Nmodernize | |
| CAvoidBindCheck | Replace simple uses of std::bind with a lambda |
| CAvoidCArraysCheck | Find C-style array types and recommend to use std::array<> / std::vector<> |
| CClassifiedToken | |
| CComponentFinderASTVisitor | Class used to find the variables and member expressions on which an arbitrary expression depends |
| CConcatNestedNamespacesCheck | |
| CConfidence | A class to encapsulate lowering of the tool's confidence level |
| CContainerCall | |
| CDeclFinderASTVisitor | Class used to determine if any declarations used in a Stmt would conflict with a particular identifier |
| CDependencyFinderASTVisitor | Class used to determine if an expression is dependent on a variable declared inside of the loop where it would be used |
| CDeprecatedHeadersCheck | This check replaces deprecated C library headers with their C++ STL alternatives |
| CIncludeMarker | |
| CDeprecatedIosBaseAliasesCheck | This check warns the uses of the deprecated member types of std::ios_base and replaces those that have a non-deprecated equivalent |
| CEnableIfData | |
| CForLoopIndexUseVisitor | Discover usages of expressions consisting of index or iterator access |
| CIntegralLiteralExpressionMatcher | |
| CLoopConvertCheck | |
| CMacroToEnumCallbacks | |
| CMacroToEnumCheck | Replaces groups of related macros with an unscoped anonymous enum |
| CMakeSharedCheck | Replace the pattern: |
| CMakeSmartPtrCheck | Base class for MakeSharedCheck and MakeUniqueCheck |
| CMakeUniqueCheck | Replace the pattern: |
| CMinMaxUseInitializerListCheck | Replaces nested std::min and std::max calls with an initializer list where applicable |
| CModernizeModule | |
| CNS | |
| CPassByValueCheck | |
| CRawStringLiteralCheck | This check replaces string literals with escaped characters to raw string literals |
| CRedundantVoidArgCheck | Find and remove redundant void argument lists |
| CReplaceAutoPtrCheck | 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 |
| CReplaceRandomShuffleCheck | Std::random_shuffle will be removed as of C++17 |
| CReturnBracedInitListCheck | Use a braced init list for return statements rather than unnecessary repeating the return type name |
| CShrinkToFitCheck | Replace copy and swap tricks on shrinkable containers with the shrink_to_fit() method call |
| CStmtAncestorASTVisitor | Class used build the reverse AST properties needed to detect name conflicts and free variables |
| CTUTrackingInfo | |
| CTypeTraitsCheck | Converts standard library type traits of the form traits<...>::type and traits<...>::value into traits_t<...> and traits_v<...> respectively |
| CUnaryStaticAssertCheck | Replaces a static_assert declaration with an empty message with the unary version |
| CUsage | The information needed to describe a valid convertible usage of an array index or iterator |
| CUseAutoCheck | |
| CUseBoolLiteralsCheck | Finds integer literals which are cast to bool |
| CUseConstraintsCheck | Replace enable_if with C++20 requires clauses |
| CUseDefaultMemberInitCheck | 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 |
| CUseEmplaceCheck | This check looks for cases when inserting new element into std::vector but the element is constructed temporarily |
| CUseEqualsDefaultCheck | Replace default bodies of special member functions with '= default;' |
| CUseEqualsDeleteCheck | 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 |
| CUseNodiscardCheck | Add [[nodiscard]] to non-void const-member functions with no arguments or pass-by-value or pass by const-reference arguments |
| CUseNoexceptCheck | Replace dynamic exception specifications, with noexcept (or user-defined macro) or noexcept(false) |
| CUseNullptrCheck | |
| CUseOverrideCheck | Use C++11's override and remove virtual where applicable |
| CUseRangesCheck | Detects calls to standard library iterator algorithms that could be replaced with a ranges version instead |
| CUseScopedLockCheck | Finds uses of std::lock_guard and suggests replacing them with C++17's / alternative std::scoped_lock |
| CUseStartsEndsWithCheck | Checks for common roundabout ways to express starts_with and / ends_with and suggests replacing with the simpler method when it is / available |
| CUseStdFormatCheck | 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() |
| CUseStdNumbersCheck | 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 |
| CUseStdPrintCheck | Convert calls to printf-like functions to std::print and std::println |
| CUseTrailingReturnTypeCheck | Rewrites function signatures to use a trailing return type |
| CUseTransparentFunctorsCheck | Prefer using transparent functors to non-transparent ones |
| CUseUncaughtExceptionsCheck | 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 |
| CUseUsingCheck | Check finds typedefs and replaces it with usings |
| CVariableNamer | Create names for generated variables within a particular statement |
| Nmpi | |
| CBufferDerefCheck | This check verifies if a buffer passed to an MPI (Message Passing Interface) function is sufficiently dereferenced |
| CMPIModule | |
| CTypeMismatchCheck | This check verifies if buffer type and MPI (Message Passing Interface) datatype pairs match |
| Nobjc | |
| CAssertEquals | Warn if XCTAssertEqual() or XCTAssertNotEqual() is used with at least one operands of type NSString* |
| CAvoidNSErrorInitCheck | Finds usages of -[NSError init] |
| CDeallocInCategoryCheck | Finds implementations of -dealloc in Objective-C categories |
| CForbiddenSubclassingCheck | Finds Objective-C classes which have a superclass which is documented to not support subclassing |
| CMissingHashCheck | Finds Objective-C implementations that implement -isEqual: without also appropriately implementing -hash |
| CNSDateFormatterCheck | 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 |
| CObjCModule | |
| CPropertyDeclarationCheck | |
| CSuperSelfCheck | Finds invocations of -self on super instances in initializers of subclasses of NSObject and recommends calling a superclass initializer instead |
| Nopenmp | |
| CExceptionEscapeCheck | Analyzes OpenMP Structured Blocks and checks that no exception escapes out of the Structured Block it was thrown in |
| COpenMPModule | This module is for OpenMP-specific checks |
| CUseDefaultNoneCheck | 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 |
| Nperformance | |
| CAvoidEndlCheck | ClangTidyCheck Checks to flag for uses of 'std::endl' on streams and suggests using the newline character '"\n"' instead |
| CEnumSizeCheck | Finds enum type definitions that could use smaller integral type as a base |
| CFasterStringFindCheck | Optimize calls to std::string::find() and friends when the needle passed is a single character string literal |
| CForRangeCopyCheck | A check that detects copied loop variables and suggests using const references |
| CImplicitConversionInLoopCheck | |
| CInefficientAlgorithmCheck | 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 |
| CMoveConstArgCheck | Find casts of calculation results to bigger type |
| CMoveConstructorInitCheck | 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 |
| CNoAutomaticMoveCheck | Finds local variables that cannot be automatically moved due to constness |
| CNoexceptDestructorCheck | 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) |
| CNoexceptFunctionBaseCheck | Generic check which checks if the bound function decl is marked with noexcept or noexcept(expr) where expr evaluates to false |
| CNoexceptMoveConstructorCheck | 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) |
| CNoexceptSwapCheck | 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) |
| CNoIntToPtrCheck | Diagnoses every integer to pointer cast |
| CPerformanceModule | |
| CTriviallyDestructibleCheck | 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; |
| CTypePromotionInMathFnCheck | Finds calls to C math library functions with implicit float to double promotions |
| CUnnecessaryCopyInitialization | |
| CCheckContext | |
| CUnnecessaryValueParamCheck | A check that flags value parameters of expensive to copy types that can safely be converted to const references |
| Nportability | |
| CAvoidPragmaOnceCheck | Finds uses of #pragma once and suggests replacing them with standard / include guards (#ifndef/#define/#endif) for improved portability |
| CPortabilityModule | |
| CPragmaOnceCallbacks | |
| CRestrictedIncludesPPCallbacks | |
| CRestrictSystemIncludesCheck | Checks for allowed includes and suggests removal of any others |
| CSIMDIntrinsicsCheck | Find SIMD intrinsics calls and suggest std::experimental::simd alternatives |
| CStdAllocatorConstCheck | Report use of std::vector<const T> (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 |
| Nreadability | |
| CAmbiguousSmartptrResetCallCheck | Finds potentially erroneous calls to 'reset' method on smart pointers when the pointee type also has a 'reset' method |
| CAvoidConstParamsInDecls | |
| 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 |
| CBracesAroundStatementsCheck | Checks that bodies of if statements and loops (for, range-for, do-while, and while) are inside braces |
| CConstReturnTypeCheck | For any function whose return type is const-qualified, suggests removal of the const qualifier from that return type |
| CContainerContainsCheck | Finds usages of container.count() and container.find() == container.end() which should be replaced by a call to the container.contains() method |
| CContainerDataPointerCheck | Checks whether a call to operator[] and & can be replaced with a call to data() |
| CContainerSizeEmptyCheck | Checks whether a call to the size()/length() method can be replaced with a call to empty() |
| CConvertMemberFunctionsToStatic | This check finds C++ class methods than can be made static because they don't use the 'this' pointer |
| CDeleteNullPointerCheck | Check whether the 'if' statement is unnecessary before calling 'delete' on a pointer |
| CDuplicateIncludeCheck | Find and remove duplicate #include directives |
| CElseAfterReturnCheck | Flags the usages of else after return |
| CEnumInitialValueCheck | Enforces consistent style for enumerators' initialization, covering three styles: none, first only, or all initialized explicitly |
| CFunctionCognitiveComplexityCheck | Checks function Cognitive Complexity metric |
| CFunctionSizeCheck | Checks for large functions based on various metrics |
| CIdentifierLengthCheck | Warns about identifiers names whose length is too short |
| CIdentifierNamingCheck | Checks for identifiers naming style mismatch |
| CFileStyle | |
| CHungarianNotation | |
| CHungarianNotationOption | |
| CNamingStyle | |
| CImplicitBoolConversionCheck | Checks for use of implicit bool conversions in expressions |
| CInconsistentDeclarationParameterNameCheck | Checks for declarations of functions which differ in parameter names |
| CIsolateDeclarationCheck | This check diagnoses all DeclStmt's declaring more than one variable and tries to refactor the code to one statement per declaration |
| CMagicNumbersCheck | Detects magic numbers, integer and floating point literals embedded in code |
| CMakeMemberFunctionConstCheck | Finds non-static member functions that can be made 'const' |
| CMathMissingParenthesesCheck | Check for mising parantheses in mathematical expressions that involve operators of different priorities |
| CMisleadingIndentationCheck | Checks the code for dangling else, and possible misleading indentations due to missing braces |
| CMisplacedArrayIndexCheck | Warn about unusual array index syntax (index[array] instead of array[index]) |
| CNamedParameterCheck | Find functions with unnamed arguments |
| CNamespaceCommentCheck | Checks that long namespaces have a closing comment |
| CNonConstParameterCheck | Warn when a pointer function parameter can be const |
| COperatorsRepresentationCheck | Enforces consistent token representation for invoked binary, unary and overloaded operators in C++ code |
| CQualifiedAutoCheck | Finds variables declared as auto that could be declared as: 'auto*' or 'const auto *' and reference variables declared as: 'const auto &' |
| CReadabilityModule | |
| CRedundantAccessSpecifiersCheck | Detects redundant access specifiers inside classes, structs, and unions |
| CRedundantCastingCheck | Detects explicit type casting operations that involve the same source and destination types, and subsequently recommend their removal |
| CRedundantControlFlowCheck | Eliminates redundant return statements at the end of a function that returns void |
| CRedundantDeclarationCheck | Find redundant variable declarations |
| CRedundantFunctionPtrDereferenceCheck | Eliminate redundant dereferences of a function pointer |
| CRedundantInlineSpecifierCheck | Detects redundant inline specifiers on function and variable declarations |
| CRedundantMemberInitCheck | Finds member initializations that are unnecessary because the same default constructor would be called if they were not present |
| CRedundantPreprocessorCheck | This check flags redundant preprocessor directives: nested directives with the same condition |
| CRedundantSmartptrGetCheck | Find and remove redundant calls to smart pointer's .get() method |
| CRedundantStringCStrCheck | Finds unnecessary calls to std::string::c_str() |
| CRedundantStringInitCheck | Finds unnecessary string initializations |
| CReferenceToConstructedTemporaryCheck | Detects C++ code where a reference variable is used to extend the lifetime of a temporary object that has just been constructed |
| CSimplifyBooleanExprCheck | Looks for boolean expressions involving boolean constants and simplifies them to use the appropriate boolean expression directly |
| CVisitor | |
| CNodeAndBool | |
| CSimplifySubscriptExprCheck | 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 |
| CStringCompareCheck | This check flags all calls compare when used to check for string equality or inequality |
| CSuspiciousCallArgumentCheck | 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 |
| CUniqueptrDeleteReleaseCheck | Flags statements of the form delete <unique_ptr expr>.release(); and / replaces them with: <unique_ptr expr> = nullptr; |
| CUppercaseLiteralSuffixCheck | Detects when the integral literal or floating point literal has non-uppercase suffix, and suggests to make the suffix uppercase |
| CUseAnyOfAllOfCheck | 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 |
| CUseStdMinMaxCheck | Replaces certain conditional statements with equivalent calls to std::min or std::max |
| Nutils | |
| CBraceInsertionHints | A provider of fix-it hints to insert opening and closing braces |
| CExceptionAnalyzer | This class analysis if a FunctionDecl can in principle throw an exception, either directly or indirectly |
| CExceptionInfo | Bundle the gathered information about an entity like a function regarding it's exception behaviour |
| CThrowInfo | Holds information about where an exception is thrown |
| CExceptionSpecAnalyzer | This class analysis if a FunctionDecl has been declared implicitly through defaulting or explicitly as throwing or not and evaluates noexcept expressions if needed |
| CExprSequence | Provides information about the evaluation order of (sub-)expressions within a CFGBlock |
| CFormatStringConverter | 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 |
| CConfiguration | |
| CHeaderGuardCheck | Finds and fixes header guards |
| CIncludeInserterCallback | |
| CNamespaceAliaser | |
| CStmtToBlockMap | Maps Stmts to the CFGBlock that contains them |
| CTransformerClangTidyCheck | A base class for defining a ClangTidy check based on a RewriteRule |
| CUseRangesCheck | Base class for handling converting std iterator algorithms to a range equivalent |
| CIndexes | |
| CReplacer | |
| CReverseIteratorDescriptor | |
| CUsingInserter | |
| Nzircon | |
| CTemporaryObjectsCheck | Construction of specific temporary objects in the Zircon kernel is discouraged |
| CZirconModule | This module is for Zircon-specific checks |
| CCachedGlobList | A GlobList that caches search results, so that search is performed only once for the same query |
| CChecksAndOptions | |
| CClangTidyASTConsumerFactory | |
| CClangTidyCheckFactories | A collection of ClangTidyCheckFactory instances |
| CClangTidyContext | Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context |
| CClangTidyDiagnosticConsumer | A diagnostic consumer that turns each Diagnostic into a SourceManager-independent ClangTidyError |
| CClangTidyError | A detected error complete with information to display diagnostic and automatic fix |
| CClangTidyGlobalOptions | Global options |
| CClangTidyModule | A clang-tidy module groups a number of ClangTidyChecks and gives them a prefixed name |
| CClangTidyOptions | Contains options for clang-tidy |
| CClangTidyValue | Helper structure for storing option value with priority of the value |
| CClangTidyOptionsProvider | Abstract interface for retrieving various ClangTidy options |
| CClangTidyPluginAction | The core clang tidy plugin action |
| CClangTidyProfiling | |
| CStorageParams | |
| CClangTidyStats | Contains displayed and ignored diagnostic counters for a ClangTidy run |
| CConfigOptionsProvider | Implementation of ClangTidyOptions interface, which is used for '-config' command-line option |
| CDefaultOptionsProvider | Implementation of the ClangTidyOptionsProvider interface, which returns the same options for all files |
| CFileFilter | Contains a list of line ranges in a single file |
| CFileOptionsBaseProvider | |
| COptionsCache | |
| CFileOptionsProvider | Implementation of the ClangTidyOptionsProvider interface, which tries to find a configuration file in the closest parent directory of each source file |
| CGlobList | Read-only set of strings represented as a list of positive and negative globs |
| CNoLintDirectiveHandler | This class is used to locate NOLINT comments in the file being analyzed, to decide whether a diagnostic should be suppressed |
| CImpl | |
| COptionEnumMapping | 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::ProBoundsAvoidUncheckedContainerAccess::FixModes > | |
| 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 > | |
| CRenamerClangTidyCheck | Base class for clang-tidy checks that want to flag declarations and/or macros for renaming based on customizable criteria |
| CDiagInfo | Represents customized diagnostic text and how arguments should be applied |
| CFailureInfo | Information describing a failed check |
| CNamingCheckFailure | Holds an identifier name check failure, tracking the kind of the identifier, its possible fixup and the starting locations of all the identifier usages |
| Ntooling | |
| CExpandModularHeadersPPCallbacks | Handles PPCallbacks and re-runs preprocessing of the whole translation unit with modules disabled |
| CFileRecorder | |
| CCodeBlock | |
| CHeading | |
| CRuler | |
| NCompletionModelCodegen | |
| CCppClass | |
| Nllvm | Some operations such as code completion produce a set of candidates |
| Nyaml | |
| CChecksVariant | |
| CIncludeGraphNode | |
| CMappingTraits< BaseRecordInfo > | |
| CMappingTraits< ClangTidyOptions > | |
| CMappingTraits< ClangTidyOptions::StringPair > | |
| CMappingTraits< CommentInfo > | |
| CMappingTraits< CompileCommandYAML > | |
| CMappingTraits< EnumInfo > | |
| CMappingTraits< EnumValueInfo > | |
| CMappingTraits< FieldTypeInfo > | |
| CMappingTraits< FileFilter > | |
| CMappingTraits< FunctionInfo > | |
| CMappingTraits< IncludeFixerContext > | |
| CMappingTraits< IncludeFixerContext::HeaderInfo > | |
| CMappingTraits< IncludeFixerContext::QuerySymbolInfo > | |
| CMappingTraits< IncludeGraphNode > | |
| CMappingTraits< Location > | |
| CMappingTraits< MemberTypeInfo > | |
| CMappingTraits< NamespaceInfo > | |
| CMappingTraits< RecordInfo > | |
| CMappingTraits< Ref > | |
| CMappingTraits< RefBundle > | |
| CMappingTraits< Reference > | |
| CMappingTraits< Relation > | |
| CMappingTraits< std::unique_ptr< CommentInfo > > | |
| CMappingTraits< Symbol > | |
| CMappingTraits< SymbolAndSignals > | |
| CMappingTraits< SymbolID > | |
| CMappingTraits< SymbolInfo > | |
| CMappingTraits< SymbolInfo::Context > | |
| CMappingTraits< SymbolLocation > | |
| CMappingTraits< TemplateInfo > | |
| CMappingTraits< TemplateParamInfo > | |
| CMappingTraits< TemplateSpecializationInfo > | |
| CMappingTraits< tooling::Range > | |
| CNormalizedRange | |
| CMappingTraits< TypedefInfo > | |
| CMappingTraits< TypeInfo > | |
| CMappingTraits< VariantEntry > | |
| CMappingTraits< YIncludeHeaderWithReferences > | |
| CMappingTraits< YPosition > | |
| CNOptionMap | |
| CNormalizedFileDigest | |
| CNormalizedFileURI | |
| CNormalizedIncludeHeaders | |
| CNormalizedPosition | |
| CNormalizedRefKind | |
| CNormalizedSourceFlag | |
| CNormalizedSymbolFlag | |
| CNormalizedSymbolID | |
| CNormalizedSymbolRole | |
| CRef | Represents a symbol occurrence in the source file |
| CRelation | Represents a relation between two symbols |
| CScalarBitSetTraits< clang::clangd::Symbol::IncludeDirective > | |
| CScalarEnumerationTraits< clang::AccessSpecifier > | |
| CScalarEnumerationTraits< clang::doc::CommentKind > | |
| CScalarEnumerationTraits< clang::TagTypeKind > | |
| CScalarEnumerationTraits< ContextType > | |
| CScalarEnumerationTraits< InfoType > | |
| CScalarEnumerationTraits< SymbolKind > | |
| CScalarEnumerationTraits< SymbolLanguage > | |
| CScalarTraits< SmallString< U > > | |
| CScalarTraits< std::array< unsigned char, 20 > > | |
| CSequenceTraits< FileFilter::LineRange > | |
| CSymbol | The class presents a C++ symbol, e.g |
| CIncludeHeaderWithReferences | |
| CSymbolID | |
| CSymbolLocation | |
| CPosition | |
| 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 |
| CDenseMapInfo< DriverArgs > | |
| Cformat_provider< clang::clangd::Position > | |
| CSmallVectorImpl | |
| NModularize | |
| CCoverageChecker | Module map checker class |
| CModularizeUtilities | Modularize utilities class |
| CPreprocessorTracker | Preprocessor tracker for modularize |
| Nrun-clang-tidy | |
| CClangTidyResult | |
| CASTConsumer | |
| CBar | |
| CBlock | |
| CClangTidyCheck | |
| CClangTidyOptions | Contains options for clang-tidy |
| CClangTidyValue | Helper structure for storing option value with priority of the value |
| CCollectEntitiesAction | |
| CCollectEntitiesConsumer | |
| CCollectEntitiesVisitor | |
| CCommentHandler | |
| CCompileCheckAction | |
| CCompileCheckConsumer | |
| CCompileCheckFrontendActionFactory | |
| CCompileCheckVisitor | |
| CConstCommentVisitor | |
| CCoverageCheckerAction | |
| CCoverageCheckerCallbacks | |
| CCoverageCheckerConsumer | |
| CCoverageCheckerFrontendActionFactory | |
| CDiagnosticConsumer | |
| CEntityMap | |
| CEntry | |
| CExternalSemaSource | |
| CFileFilter | Contains a list of line ranges in a single file |
| CFoo | |
| CFrontendActionFactory | |
| CHeaderEntry | |
| CIncludeFixerContext | A context for a file being processed |
| CHeaderInfo | |
| CQuerySymbolInfo | |
| CLocation | |
| CModularizeFrontendActionFactory | |
| CMultiplexConsumer | |
| COptionEnumMapping< utils::IncludeSorter::IncludeStyle > | |
| CParagraph | |
| CPluginASTAction | |
| CPPCallbacks | |
| CRecursiveASTVisitor | |
| CSymbolAndSignals | |
| CSymbolInfo | Describes a named symbol from a header |
| CSignals | |
| CSyntaxOnlyAction | |
| CTemplate |
Generated on for clang-tools by
1.14.0