| ►Nclang | |
| ►Nanalyze_format_string | Common components of both fprintf and fscanf format strings |
| CArgType | |
| CConversionSpecifier | |
| CFormatSpecifier | |
| CFormatStringHandler | |
| CLengthModifier | Represents the length modifier in a format string in scanf/printf |
| COptionalAmount | |
| COptionalFlag | Class representing optional flags with location and representation information |
| CSpecifierResult | |
| ►Nanalyze_os_log | |
| COSLogBufferItem | An OSLogBufferItem represents a single item in the data written by a call to os_log() or os_trace() |
| COSLogBufferLayout | |
| ►Nanalyze_printf | Pieces specific to fprintf format strings |
| CPrintfConversionSpecifier | |
| CPrintfSpecifier | |
| ►Nanalyze_scanf | Pieces specific to fscanf format strings |
| CScanfConversionSpecifier | |
| CScanfSpecifier | |
| ►Napi_notes | |
| CAPINotesManager | The API notes manager helps find API notes associated with declarations |
| ►CAPINotesReader | A class that reads API notes data from a binary file that was written by the APINotesWriter |
| CImplementation | |
| CVersionedInfo | Captures the completed versioned information for a particular part of API notes, including both unversioned API notes and each versioned API note for that particular entity |
| ►CAPINotesWriter | |
| CImplementation | |
| CCommonEntityInfo | Describes API notes data for any entity |
| CCommonTypeInfo | Describes API notes for types |
| CContext | |
| CContextID | Opaque context ID used to refer to an Objective-C class or protocol or a C++ namespace |
| CContextTableKey | A stored Objective-C or C++ context, represented by the ID of its parent context, the kind of this context (Objective-C class / C++ namespace / etc), and the ID of this context |
| CEnumConstantInfo | Describes API notes data for an enumerator |
| CFunctionInfo | API notes for a function or method |
| CGlobalFunctionInfo | Describes API notes data for a global function |
| CGlobalVariableInfo | Describes API notes data for a global variable |
| CObjCContextInfo | Describes API notes data for an Objective-C class or protocol |
| CObjCMethodInfo | Describes API notes data for an Objective-C method |
| CObjCPropertyInfo | Describes API notes data for an Objective-C property |
| CObjCSelectorRef | A temporary reference to an Objective-C selector, suitable for referencing selector data on the stack |
| CParamInfo | Describes a function or method parameter |
| CStoredObjCSelector | A stored Objective-C selector |
| CTagInfo | Describes API notes data for a tag |
| CTypedefInfo | Describes API notes data for a typedef |
| CVariableInfo | API notes for a variable/property |
| ►Narcmt | |
| ►Ntrans | |
| CASTTraverser | |
| CBlockObjCVariableTraverser | |
| CBodyContext | |
| CBodyTransform | |
| CGCAttrsTraverser | |
| CGCCollectableCallsTraverser | |
| ►CMigrationContext | |
| CGCAttrOccurrence | |
| CObjCImplementationContext | |
| CPropertyRewriteTraverser | |
| CProtectedScopeTraverser | |
| CCapturedDiagList | |
| CCheckAction | |
| CFileRemapper | |
| CMigrateAction | |
| CMigrateSourceAction | |
| CMigrationPass | |
| ►CMigrationProcess | |
| CRewriteListener | |
| CModifyAction | |
| CObjCMigrateAction | Migrates to modern ObjC syntax |
| CTransaction | |
| ►CTransformActions | |
| CRewriteReceiver | |
| ►Nast_matchers | |
| ►Ndynamic | |
| ►Ninternal | |
| CAdaptativeOverloadCollector | Helper class used to collect all the possible overloads of an argument adaptative matcher function |
| CArgTypeTraits | Helper template class to just from argument type to the right is/get functions in VariantValue |
| CArgTypeTraits< ast_matchers::internal::Matcher< T > > | |
| CArgTypeTraits< attr::Kind > | |
| CArgTypeTraits< bool > | |
| CArgTypeTraits< CastKind > | |
| CArgTypeTraits< const T & > | |
| CArgTypeTraits< double > | |
| CArgTypeTraits< llvm::Regex::RegexFlags > | |
| CArgTypeTraits< OpenMPClauseKind > | |
| CArgTypeTraits< std::string > | |
| CArgTypeTraits< StringRef > | |
| CArgTypeTraits< UnaryExprOrTypeTrait > | |
| CArgTypeTraits< unsigned > | |
| CBuildReturnTypeVector | |
| CBuildReturnTypeVector< ast_matchers::internal::BindableMatcher< T > > | |
| CBuildReturnTypeVector< ast_matchers::internal::Matcher< T > > | |
| CDynCastAllOfMatcherDescriptor | Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers |
| CFixedArgCountMatcherDescriptor | Simple callback implementation |
| CMapAnyOfBuilderDescriptor | |
| CMapAnyOfMatcherDescriptor | |
| CMatcherDescriptor | Matcher descriptor interface |
| CMatcherDescriptorPtr | A smart (owning) pointer for MatcherDescriptor |
| COverloadedMatcherDescriptor | MatcherDescriptor that wraps multiple "overloads" of the same matcher |
| CRegexMatcherDescriptor | |
| CVariadicFuncMatcherDescriptor | Matcher descriptor for variadic functions |
| CVariadicOperatorMatcherDescriptor | Variadic operator marshaller function |
| CArgKind | Kind identifier |
| ►CDiagnostics | Helper class to manage error messages |
| CArgStream | Helper stream class |
| CContext | Class defining a parser context |
| CContextFrame | Information stored for one frame of the context |
| ►CErrorContent | Information stored for each error found |
| CMessage | |
| COverloadContext | Context for overloaded matcher construction |
| CMatcherCompletion | |
| ►CParser | Matcher expression parser |
| CCodeTokenizer | Simple tokenizer for the parser |
| CRegistrySema | Sema implementation that uses the matcher registry to process the tokens |
| CScopedContextEntry | |
| CSema | Interface to connect the parser with the registry and more |
| CTokenInfo | Simple structure to hold information for one token from the parser |
| CParserValue | A VariantValue instance annotated with its parser context |
| CRegistry | |
| CSourceLocation | |
| CSourceRange | |
| ►CVariantMatcher | A variant matcher object |
| CPolymorphicPayload | |
| CSinglePayload | |
| CVariadicOpPayload | |
| CVariantValue | Variant value class |
| ►Ninternal | |
| CCollectMatchesCallback | |
| CBoundNodes | Maps string IDs to AST nodes matched by parts of a matcher |
| CMatchDescendantVisitor | |
| ►CMatchFinder | A class to allow finding matches over the Clang AST |
| CMatchCallback | Called when the Match registered for it was successfully found in the AST |
| CMatchersByType | For each Matcher<> a MatchCallback that will be called when it matches |
| ►CMatchFinderOptions | |
| CProfiling | |
| CMatchResult | Contains all information for a given match |
| CParsingDoneTestCallback | Called when parsing is finished. Intended for testing only |
| ►Nattrvisitor | |
| CBase | A simple visitor class that helps create attribute visitors |
| ►NBuiltin | |
| CContext | Holds information about both target-independent and target-specific builtins, allowing easy queries by clients |
| CInfo | |
| CTargetFeatures | TargetFeatures - This class is used to check whether the builtin function has the required tagert specific features |
| ►NCodeGen | |
| ►Nswiftcall | |
| CSwiftAggLowering | |
| CABIArgInfo | ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to or returned from a function |
| CABIInfo | ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions |
| CAddress | An aligned address |
| CAggValueSlot | An aggregate value slot |
| CApplyDebugLocation | A scoped helper to set the current debug location to the specified location or preferred location of the specified Expr |
| CApplyInlineDebugLocation | A scoped helper to set the current debug location to an inlined location |
| CBlockByrefHelpers | A pair of helper functions for a __block variable |
| CBlockByrefInfo | Information about the layout of a __block variable |
| CBlockFieldFlags | |
| CBlockFlags | |
| CBranchFixup | A branch fixup |
| CCallArg | |
| ►CCallArgList | CallArgList - Type for representing both the value and type of arguments in a call |
| CCallArgCleanup | |
| CWriteback | |
| CCatchRetScope | |
| CCatchTypeInfo | The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler, so we use this wrapper |
| CCGBitFieldInfo | Structure with information about how a bitfield should be accessed |
| ►CCGBlockInfo | CGBlockInfo - Information to generate a block literal |
| CCapture | |
| CCGBuilderInserter | This is an IRBuilder insertion helper that forwards to CodeGenFunction::InsertHelper, which adds necessary metadata to instructions |
| CCGBuilderTy | |
| CCGCallee | All available information about a concrete callee |
| CCGCalleeInfo | Abstract information about a function or function prototype |
| CCGCoroData | |
| ►CCGCUDARuntime | |
| CDeviceVarFlags | |
| ►CCGCXXABI | Implements C++ ABI-specific code generation functions |
| CAddedStructorArgCounts | Similar to AddedStructorArgs, but only notes the number of additional arguments |
| ►CAddedStructorArgs | Additional implicit arguments to add to the beginning (Prefix) and end (Suffix) of a constructor / destructor arg list |
| CArg | |
| CCGDebugInfo | This class gathers all debug information during compilation and is responsible for emitting to llvm globals or pass directly to the backend |
| CCGFunctionInfo | CGFunctionInfo - Class to encapsulate the information about a function definition |
| CCGFunctionInfoArgInfo | |
| ►CCGHLSLRuntime | |
| CBuffer | |
| CBufferResBinding | |
| ►CCGObjCRuntime | Implements runtime-specific code generation functions |
| CMessageSendInfo | |
| ►CCGOpenCLRuntime | |
| CEnqueuedBlockInfo | Structure for enqueued block information |
| ►CCGOpenMPRuntime | |
| CDebugLocThreadIdTy | Stores debug location and ThreadID for the function |
| CDisableAutoDeclareTargetRAII | Allows to disable automatic handling of functions used in target regions as those marked as omp declare target |
| CDispatchRTInput | Struct with the values to be passed to the dispatch runtime function |
| CLastprivateConditionalData | Maps the expression for the lastprivate variable to the global copy used to store new value because original variables are not mapped in inner parallel regions |
| CLastprivateConditionalRAII | Manages list of lastprivate conditional decls for the specified directive |
| CNontemporalDeclsRAII | Manages list of nontemporal decls for the specified directive |
| CReductionOptionsTy | |
| CStaticRTInput | Struct with the values to be passed to the static runtime function |
| CTargetDataInfo | Struct that keeps all the relevant information that should be kept throughout a 'target data' region |
| CTaskResultTy | |
| CUntiedTaskLocalDeclsRAII | Manages list of nontemporal decls for the specified directive |
| CCGOpenMPRuntimeGPU | |
| CCGOpenMPSIMDRuntime | Class supports emissionof SIMD-only code |
| CCGRecordLayout | CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM types |
| ►CCodeGenFunction | CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code |
| CAbstractCallee | An abstract representation of regular/ObjC call/message targets |
| CArrayInitLoopExprScope | The scope of an ArrayInitLoopExpr |
| CAutoVarEmission | |
| CCallLifetimeEnd | |
| CCGCapturedStmtInfo | API for captured statement code generation |
| CCGCapturedStmtRAII | RAII for correct setting/restoring of CapturedStmtInfo |
| CCGCoroInfo | |
| CCGFPOptionsRAII | |
| CConditionalEvaluation | An object to manage conditionally-evaluated expressions |
| CConstantEmission | |
| CCXXDefaultArgExprScope | |
| CCXXDefaultInitExprScope | The scope of a CXXDefaultInitExpr |
| CFieldConstructionScope | A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr |
| CFinallyInfo | A class controlling the emission of a finally block |
| CInlinedInheritingConstructorScope | |
| CJumpDest | A jump destination is an abstract label, branching to which may require a jump out through normal cleanups |
| CLexicalScope | |
| CLifetimeExtendedCleanupHeader | Header for data within LifetimeExtendedCleanupStack |
| ►CMultiVersionResolverOption | |
| CConds | |
| ►COMPBuilderCBHelpers | |
| CInlinedRegionBodyRAII | RAII for preserving necessary info during inlined region body codegen |
| COMPAllocateCleanupTy | Cleanup action for allocate support |
| COutlinedRegionBodyRAII | RAII for preserving necessary info during Outlined region body codegen |
| COMPCancelStackRAII | Controls insertion of cancellation exit blocks in worksharing constructs |
| COMPLocalDeclMapRAII | Save/restore original map of previously emitted local vars in case when we need to duplicate emission of the same code several times in the same function for OpenMP code |
| COMPMapVars | The class used to assign some variables some temporarily addresses |
| COMPPrivateScope | The scope used to remap some variables as private in the OpenMP loop body (or other captured region emitted without outlining), and to restore old vars back on exit |
| COMPTargetDataInfo | |
| COpaqueValueMapping | An RAII object to set (and then clear) a mapping for an OpaqueValueExpr |
| COpaqueValueMappingData | A non-RAII class containing all the information about a bound opaque value |
| CParamValue | |
| CParentLoopDirectiveForScanRegion | Manages parent directive for scan directives |
| CPeepholeProtection | An object which temporarily prevents a value from being destroyed by aggressive peephole optimizations that assume that all uses of a value have been realized in the IR |
| CPrototypeWrapper | |
| CRunCleanupsScope | Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited |
| CSanitizerScope | RAII object to set/unset CodeGenFunction::IsSanitizerScope |
| CStmtExprEvaluation | An RAII object to record that we're evaluating a statement expression |
| CVlaSizePair | |
| CVPtr | Struct with all information about dynamic [sub]class needed to set vptr |
| ►CCodeGenModule | This class organizes the cross-function state that is used while generating LLVM code |
| CStructor | |
| CCodeGenPGO | Per-function PGO state |
| CCodeGenTBAA | CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LLVM types |
| CCodeGenTypeCache | This structure provides a set of types that are commonly used during IR emission |
| CCodeGenTypes | This class organizes the cross-module state that is used while lowering AST types to LLVM types |
| CCodeGenVTables | |
| CConstantAddress | A specialization of Address that requires the address to be an LLVM Constant |
| ►CConstantAggregateBuilderBase | A concrete base class for struct and array aggregate initializer builders |
| CPlaceholderPosition | An opaque class to hold the abstract position of a placeholder |
| CConstantAggregateBuilderTemplateBase | |
| CConstantArrayBuilder | A helper class of ConstantInitBuilder, used for building constant array initializers |
| CConstantArrayBuilderTemplateBase | |
| CConstantEmitter | |
| CConstantInitBuilder | The standard implementation of ConstantInitBuilder used in Clang |
| CConstantInitBuilderBase | A convenience builder class for complex constant initializers, especially for anonymous global structures used by various language runtimes |
| CConstantInitBuilderTemplateBase | A template class designed to allow other frontends to easily customize the builder classes used by ConstantInitBuilder, and thus to extend the API to work with the abstractions they prefer |
| CConstantInitBuilderTraits | |
| CConstantInitFuture | A "future" for a completed constant initializer, which can be passed around independently of any sub-builders (but not the original parent) |
| CConstantStructBuilder | A helper class of ConstantInitBuilder, used for building constant struct initializers |
| CConstantStructBuilderTemplateBase | A template class designed to allow other frontends to easily customize the builder classes used by ConstantInitBuilder, and thus to extend the API to work with the abstractions they prefer |
| CCoverageMappingGen | Organizes the per-function state that is used while generating code coverage mapping data |
| CCoverageMappingModuleGen | Organizes the cross-function state that is used while generating code coverage mapping data |
| CDefaultABIInfo | DefaultABIInfo - The default implementation for ABI specific details |
| CDominatingLLVMValue | Helper class with most of the code for saving a value for a conditional expression cleanup |
| CDominatingPointer | |
| CDominatingPointer< T, false > | |
| CDominatingPointer< T, true > | A partial specialization of DominatingValue for llvm::Values that might be llvm::Instructions |
| CDominatingValue | A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function |
| ►CDominatingValue< Address > | A specialization of DominatingValue for Address |
| Csaved_type | |
| ►CDominatingValue< RValue > | A specialization of DominatingValue for RValue |
| Csaved_type | |
| CDominatingValue< T * > | |
| ►CEHCatchScope | A scope which attempts to handle some, possibly all, types of exceptions |
| CHandler | |
| CEHCleanupScope | A cleanup scope which generates the cleanup blocks lazily |
| CEHFilterScope | An exceptions scope which filters exceptions thrown through it |
| CEHPersonality | The exceptions personality for a function |
| ►CEHScope | A protected scope for zero-cost EH handling |
| CCatchBitFields | |
| CCleanupBitFields | |
| CFilterBitFields | |
| ►CEHScopeStack | A stack of scopes which respond to exceptions, including cleanups and catch blocks |
| ►CCleanup | Information for lazily generating a cleanup |
| CFlags | Generation flags |
| CConditionalCleanup | ConditionalCleanup stores the saved form of its parameters, then restores them and performs the cleanup |
| Citerator | A non-stable pointer into the scope stack |
| Cstable_iterator | A saved depth on the scope stack |
| CEHTerminateScope | An exceptions scope which calls std::terminate if any exception reaches it |
| CFunctionArgList | FunctionArgList - Type for representing both the decl and type of parameters to a function |
| CImplicitCXXConstructorArgs | Additional implicit arguments to add to a constructor argument list |
| CInstrProfStats | This class records statistics on instrumentation based profiling |
| CInvariantValue | |
| CLoopAttributes | Attributes that may be specified on loops |
| CLoopInfo | Information used when generating a structured loop |
| CLoopInfoStack | A stack of loop information corresponding to loop nesting levels |
| CLValue | LValue - This represents an lvalue references |
| CLValueBaseInfo | |
| CObjCEntrypoints | |
| ►COMPTaskDataTy | |
| CDependData | |
| COrderGlobalInitsOrStermFinalizers | |
| CPrePostActionTy | A basic class for pre|post-action for advanced codegen sequence for OpenMP region |
| CReductionCodeGen | Class intended to support codegen of all kind of the reduction clauses |
| CRegionCodeGenTy | Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possible pre|post-actions in codegen |
| CRequiredArgs | A class for recording the number of arguments that a function signature requires |
| CReturnValueSlot | ReturnValueSlot - Contains the address where the return value of a function can be stored, and whether the address is volatile or not |
| CRValue | RValue - This trivial value class is used to represent the result of an expression that is evaluated |
| CSanitizerMetadata | |
| CSwiftABIInfo | Target specific hooks for defining how a type should be passed or returned from functions with one of the Swift calling conventions |
| ►CTargetCodeGenInfo | TargetCodeGenInfo - This class organizes various target-specific codegeneration issues, like target-specific attributes, builtins and so on |
| CTargetOpenCLBlockHelper | Interface class for filling custom fields of a block literal for OpenCL |
| CTBAAAccessInfo | |
| CVarBypassDetector | The class detects jumps which bypass local variables declaration: goto L; int a; L: |
| ►Ncomments | |
| CBlockCommandComment | A command that has zero or more word-like arguments (number of word-like arguments depends on command name) and a paragraph as an argument (e |
| CBlockContentComment | Block content (contains inline content) |
| CBriefParser | A very simple comment parser that extracts "a brief description" |
| CCommandInfo | Information about a single command |
| CCommandTraits | This class provides information about commands that can be used in comments |
| ►CComment | Any part of the comment |
| CArgument | |
| CBlockCommandCommentBitfields | |
| CCommentBitfields | |
| CHTMLStartTagCommentBitfields | |
| CHTMLTagCommentBitfields | |
| CInlineCommandCommentBitfields | |
| CInlineContentCommentBitfields | |
| CParagraphCommentBitfields | |
| CParamCommandCommentBitfields | |
| CTextCommentBitfields | |
| CCommentVisitor | |
| CCommentVisitorBase | |
| CConstCommentVisitor | |
| CDeclInfo | Information about the declaration, useful to clients of FullComment |
| CFullComment | A full comment attached to a declaration, contains block content |
| CHTMLEndTagComment | A closing HTML tag |
| ►CHTMLStartTagComment | An opening HTML tag with attributes |
| CAttribute | |
| CHTMLTagComment | Abstract class for opening and closing HTML tags |
| CInlineCommandComment | A command with word-like arguments that is considered inline content |
| CInlineContentComment | Inline content (contained within a block) |
| CLexer | Comment lexer |
| CParagraphComment | A single paragraph that contains inline content |
| CParamCommandComment | Doxygen \param command |
| CParser | Doxygen comment parser |
| CSema | |
| CTextComment | Plain text |
| CTextTokenRetokenizer | Re-lexes a sequence of tok::text tokens |
| CToken | Comment token |
| CTParamCommandComment | Doxygen \tparam command, describes a template parameter |
| CVerbatimBlockComment | A verbatim block command (e |
| CVerbatimBlockLineComment | A line of text contained in a verbatim block |
| CVerbatimLineComment | A verbatim line command |
| ►Nconcepts | |
| ►CExprRequirement | A requires-expression requirement which queries the validity and properties of an expression ('simple' and 'compound' requirements) |
| CReturnTypeRequirement | |
| CNestedRequirement | A requires-expression requirement which is satisfied when a general constraint expression is satisfied ('nested' requirements) |
| ►CRequirement | A static requirement that can be used in a requires-expression to check properties of types and expression |
| CSubstitutionDiagnostic | |
| CTypeRequirement | A requires-expression requirement which queries the existence of a type name or type template specialization ('type' requirements) |
| ►Nconsumed | |
| CConsumedAnalyzer | A class that handles the analysis of uniqueness violations |
| CConsumedBlockInfo | |
| CConsumedStateMap | |
| CConsumedStmtVisitor | |
| CConsumedWarningsHandlerBase | |
| CPropagationInfo | |
| ►Ncross_tu | |
| CCrossTranslationUnitContext | This class is used for tools that requires cross translation unit capability |
| CIndexError | |
| ►Ndataflow | Dataflow Directional Tag Classes |
| CArena | The Arena owns the objects that model data within an analysis |
| CASTMatchSwitchBuilder | Collects cases of a "match switch": a collection of matchers paired with callbacks, which together define a switch that can be applied to a node whose type derives from BaseT |
| CAtomicBoolValue | Models an atomic boolean |
| Cbackward_analysis_tag | |
| CBoolValue | Models a boolean |
| CCFGMatchSwitchBuilder | Collects cases of a "match switch": a collection of matchers paired with callbacks, which together define a switch that can be applied to an AST node contained in a CFG element |
| CChromiumCheckModel | Models the behavior of Chromium's CHECK, DCHECK, etc |
| CCNFFormula | A boolean formula in conjunctive normal form |
| CCNFFormulaBuilder | Applies simplifications while building up a BooleanFormula |
| CContextSensitiveOptions | |
| CControlFlowContext | Holds CFG and other derived context that is needed to perform dataflow analysis |
| CDataflowAnalysis | Base class template for dataflow analyses built on a single lattice type |
| ►CDataflowAnalysisContext | Owns objects that encompass the state of a program and stores context that is used during dataflow analysis |
| COptions | |
| CDataflowAnalysisOptions | |
| CDataflowAnalysisState | |
| CDataflowModel | Abstract base class for dataflow "models": reusable analysis components that model a particular aspect of program semantics in the Environment |
| ►CEnvironment | Holds the state of the program (store and heap) at a given program point |
| CValueModel | Supplements Environment with non-standard comparison and join operations |
| CFormula | |
| CFormulaBoolValue | Models a compound boolean formula |
| Cforward_analysis_tag | |
| CIntegerValue | Models an integer |
| CLogger | A logger is notified as the analysis progresses |
| CMapLattice | A lattice that maps keys to individual lattice elements |
| CNoopAnalysis | |
| CNoopLattice | Trivial lattice for dataflow analysis with exactly one element |
| CPointerValue | Models a symbolic pointer. Specifically, any value of type T* |
| CRecordStorageLocation | A storage location for a record (struct, class, or union) |
| CRecordValue | Models a value of struct or class type |
| CScalarStorageLocation | A storage location that is not subdivided further for the purposes of abstract interpretation |
| CSimplifyConstraintsInfo | Information on the way a set of constraints was simplified |
| ►CSolver | An interface for a SAT solver that can be used by dataflow analyses |
| CResult | |
| CStmtToEnvMap | Maps statements to the environments of basic blocks that contain them |
| CStorageLocation | Base class for elements of the local variable store and of the heap |
| CTopBoolValue | A TopBoolValue represents a boolean that is explicitly unconstrained |
| CTransferState | A common form of state shared between the cases of a transfer function |
| CTransferStateForDiagnostics | A read-only version of TransferState |
| CTypeErasedDataflowAnalysis | Type-erased base class for dataflow analyses built on a single lattice type |
| CTypeErasedDataflowAnalysisState | Type-erased model of the program at a given program point |
| CTypeErasedLattice | Type-erased lattice element container |
| CUncheckedOptionalAccessDiagnoser | |
| CUncheckedOptionalAccessModel | Dataflow analysis that models whether optionals hold values or not |
| CUncheckedOptionalAccessModelOptions | |
| CValue | Base class for all values computed by abstract interpretation |
| CWatchedLiteralsSolver | A SAT solver that is an implementation of Algorithm D from Knuth's The Art of Computer Programming Volume 4: Satisfiability, Fascicle 6 |
| CWatchedLiteralsSolverImpl | |
| ►Ndeclvisitor | |
| CBase | A simple visitor class that helps create declaration visitors |
| ►Ndependency_directives_scan | |
| CDirective | Represents a directive that's lexed as part of the dependency directives scanning |
| CToken | Token lexed as part of dependency directive scanning |
| ►Ndetail | |
| CAvailabilityData | Describes the trailing object for Availability attribute in ParsedAttr |
| CCXXDeductionGuideNameExtra | Contains extra information for the name of a C++ deduction guide |
| CCXXLiteralOperatorIdName | Contains the actual identifier that makes up the name of a C++ literal operator |
| CCXXOperatorIdName | Contains extra information for the name of an overloaded operator in C++, such as "operator+ |
| CCXXSpecialNameExtra | CXXSpecialNameExtra records the type associated with one of the "special" kinds of declaration names in C++, e.g., constructors, destructors, and conversion functions |
| CDeclarationNameExtra | DeclarationNameExtra is used as a base of various uncommon special names |
| Chas_same_member_pointer_type | |
| Chas_same_member_pointer_type< R(T::*)(P...), R(U::*)(P...)> | |
| CMacroExpansionRangeRecorder | |
| CPropertyData | |
| CSarifArtifact | Since every clang artifact MUST have a location (there being no nested artifacts), the creation method SarifArtifact::create requires a SarifArtifactLocation object |
| CSarifArtifactLocation | |
| CSearchDirIteratorImpl | Forward iterator over the search directories of HeaderSearch |
| CTypeTagForDatatypeData | |
| ►Ndiag | |
| CCustomDiagInfo | |
| ►Ndiff | |
| ►CASTDiff | |
| CImpl | |
| CComparisonOptions | |
| CNode | Represents a Clang AST node, alongside some additional information |
| CNodeId | Within a tree, this identifies a node by its preorder offset |
| CSNodeId | Identifies a node in a subtree by its postorder offset, starting at 1 |
| CSubtree | |
| ►CSyntaxTree | SyntaxTree objects represent subtrees of the AST |
| CImpl | Represents the AST of a TranslationUnit |
| CZhangShashaMatcher | Implementation of Zhang and Shasha's Algorithm for tree edit distance |
| ►Ndriver | |
| ►Ntoolchains | |
| CAIX | |
| CAMDGPUOpenMPToolChain | |
| ►CAMDGPUToolChain | |
| CParsedTargetIDType | The struct type returned by getParsedTargetID |
| CAVRToolChain | |
| CBareMetal | |
| CCrossWindowsToolChain | |
| CCSKYToolChain | |
| CCudaToolChain | |
| CDarwin | Darwin - The base Darwin tool chain |
| CDarwinClang | DarwinClang - The Darwin toolchain used by Clang |
| CDragonFly | |
| CFreeBSD | |
| CFuchsia | |
| CGeneric_ELF | |
| ►CGeneric_GCC | Generic_GCC - A tool chain using the 'gcc' command to perform all subcommands; this relies on gcc translating the majority of command line options |
| CGCCInstallationDetector | This is a class to find a viable GCC installation for Clang to use |
| CGCCVersion | Struct to store and manipulate GCC versions |
| CHaiku | |
| CHexagonToolChain | |
| CHIPAMDToolChain | |
| CHIPSPVToolChain | |
| CHLSLToolChain | |
| CHurd | |
| CLanaiToolChain | |
| CLinux | |
| CMachO | |
| CMinGW | |
| CMipsLLVMToolChain | |
| CMSP430ToolChain | |
| CMSVCToolChain | |
| CNaClToolChain | |
| CNetBSD | |
| CNVPTXToolChain | |
| COHOS | |
| COpenBSD | |
| CPPCFreeBSDToolChain | |
| CPPCLinuxToolChain | |
| CPS4CPU | |
| CPS4PS5Base | |
| CPS5CPU | |
| CRISCVToolChain | |
| CROCMToolChain | |
| CSolaris | |
| CSPIRVToolChain | |
| CTCELEToolChain | Toolchain for little endian TCE cores |
| CTCEToolChain | TCEToolChain - A tool chain using the llvm bitcode tools to perform all subcommands |
| CVEToolChain | |
| CWebAssembly | |
| CXCoreToolChain | |
| CZOS | |
| ►Ntools | |
| ►Naix | Directly call system default assembler and linker |
| CAssembler | |
| CLinker | |
| ►NAMDGCN | |
| CLinker | |
| ►Namdgpu | |
| CLinker | |
| ►NAVR | |
| CLinker | |
| ►Nbaremetal | |
| CLinker | |
| CStaticLibTool | |
| ►NCrossWindows | |
| CAssembler | |
| CLinker | |
| ►NCSKY | |
| CLinker | |
| ►Ndarwin | |
| CAssembler | |
| CDsymutil | |
| CLinker | |
| CLipo | |
| CMachOTool | |
| CStaticLibTool | |
| CVerifyDebug | |
| ►Ndragonfly | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| ►Nfreebsd | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| ►Nfuchsia | |
| CLinker | |
| CStaticLibTool | |
| ►Ngcc | Gcc - Generic GCC tool implementations |
| CCommon | |
| CCompiler | |
| CLinker | |
| CPreprocessor | |
| ►Ngnutools | Directly call GNU Binutils' assembler and linker |
| CAssembler | |
| CLinker | |
| CStaticLibTool | |
| ►Nhaiku | Directly call GNU Binutils assembler and linker |
| CLinker | |
| ►Nhexagon | |
| CAssembler | |
| CLinker | |
| ►NHIPSPV | |
| CLinker | |
| ►Nhlsl | |
| CValidator | |
| ►Nifstool | |
| CMerger | |
| ►NMinGW | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| ►Nmsp430 | |
| CLinker | |
| ►Nnacltools | |
| CAssemblerARM | |
| CLinker | |
| ►Nnetbsd | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| ►NNVPTX | |
| CAssembler | |
| CFatBinary | |
| CLinker | |
| ►Nopenbsd | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| ►NPScpu | |
| CAssembler | |
| CLinker | |
| ►NRISCV | |
| CLinker | |
| ►Nsolaris | Directly call Solaris assembler and linker |
| CAssembler | |
| CLinker | |
| ►NSPIRV | |
| CLinker | |
| CTranslator | |
| ►Nvisualstudio | Visual studio tools |
| CLinker | |
| ►Nwasm | |
| CLinker | |
| ►NXCore | |
| CAssembler | |
| CLinker | |
| ►Nzos | Directly call system default assembler and linker |
| CAssembler | |
| CLinker | |
| CClang | Clang compiler tool |
| CClangAs | Clang integrated assembler tool |
| CFlang | Flang compiler tool |
| CLinkerWrapper | Linker wrapper tool |
| COffloadBundler | Offload bundler tool |
| COffloadPackager | Offload binary tool |
| CAction | Action - Represent an abstract compilation step to perform |
| CAnalyzeJobAction | |
| CAssembleJobAction | |
| CBackendJobAction | |
| CBinaryAnalyzeJobAction | |
| CBindArchAction | |
| CCC1Command | Use the CC1 tool callback when available, to avoid creating a new process |
| CCommand | Command - An executable path/name and argument vector to execute |
| CCompilation | Compilation - A set of tasks to perform for a single driver invocation |
| CCompileJobAction | |
| CCrashReportInfo | |
| CCudaInstallationDetector | A class to find a viable CUDA installation |
| CDetectedMultilibs | |
| CDeviceLibABIVersion | ABI version of device library |
| CDistro | Distro - Helper class for detecting and classifying Linux distributions |
| ►CDriver | Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like command line arguments |
| CCompilationDiagnosticReport | Contains the files in the compilation diagnostic report generated by generateCompilationDiagnostics |
| CDsymutilJobAction | |
| CExtractAPIJobAction | |
| CIfsMergeJobAction | |
| CInputAction | |
| CInputInfo | InputInfo - Wrapper for information about an input source |
| CJobAction | |
| CJobList | JobList - A sequence of jobs to perform |
| CLinkerWrapperJobAction | |
| CLinkJobAction | |
| CLipoJobAction | |
| CMigrateJobAction | |
| CMultilib | This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag |
| CMultilibBuilder | This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag |
| ►CMultilibSet | See also MultilibSetBuilder for combining multilibs into a set |
| CFlagMatcher | Uses regular expressions to simplify flags used for multilib selection |
| CMultilibSetBuilder | This class can be used to create a MultilibSet, and contains helper functions to add combinations of multilibs before creating a MultilibSet instance with makeMultilibSet() |
| ►COffloadAction | An offload action combines host or/and device actions according to the programming model implementation needs and propagates the offloading kind to its dependences |
| CDeviceDependences | Type used to communicate device actions |
| CHostDependence | Type used to communicate host actions |
| COffloadBundlingJobAction | |
| COffloadPackagerJobAction | |
| ►COffloadUnbundlingJobAction | |
| CDependentActionInfo | Type that provides information about the actions that depend on this unbundling action |
| CParsedClangName | Helper structure used to pass information extracted from clang executable name such as i686-linux-android-g++ |
| CPrecompileJobAction | |
| CPreprocessJobAction | |
| CRegisterEffectiveTriple | Set a ToolChain's effective triple |
| CResponseFileSupport | |
| CRocmInstallationDetector | A class to find a viable ROCM installation TODO: Generalize to handle libclc |
| CSanitizerArgs | |
| CStaticLibJobAction | |
| CTool | Tool - Information on a specific compilation tool |
| ►CToolChain | ToolChain - Access to tools for a single platform |
| CBitCodeLibraryInfo | |
| CVerifyDebugInfoJobAction | |
| CVerifyJobAction | |
| CVerifyPCHJobAction | |
| CXRayArgs | |
| ►Nedit | |
| ►CCommit | |
| CEdit | |
| CEditedSource | |
| CEditsReceiver | |
| CFileOffset | |
| ►Nento | |
| ►Nbugreporter | |
| CExpressionHandler | Handles expressions during the tracking |
| CStoreHandler | Handles stores during the tracking |
| CStoreInfo | Describes an event when the value got stored into a memory region |
| ►CTracker | A generalized component for tracking expressions, values, and stores |
| CResult | Describes a tracking result with the most basic information of what was actually done (or not done) |
| CTrackingBugReporterVisitor | Visitor that tracks expressions and values |
| CTrackingOptions | Defines a set of options altering tracking behavior |
| ►Ncheck | |
| CASTCodeBody | |
| CASTDecl | |
| CBeginFunction | |
| CBind | |
| CBranchCondition | |
| CConstPointerEscape | |
| CDeadSymbols | |
| CEndAnalysis | |
| CEndFunction | |
| CEndOfTranslationUnit | |
| CEvent | |
| CLiveSymbols | |
| CLocation | |
| CNewAllocator | |
| CObjCMessageNil | |
| CPointerEscape | |
| CPostCall | |
| CPostObjCMessage | |
| CPostStmt | |
| CPreCall | |
| CPreObjCMessage | |
| CPreStmt | |
| CRegionChanges | |
| ►Nchecker_registry | |
| CFullNameLT | |
| ►Neval | |
| CAssume | |
| CCall | |
| ►Niterator | |
| CContainerData | |
| CContainerMap | |
| CIteratorPosition | |
| CIteratorRegionMap | |
| CIteratorSymbolMap | |
| ►Nloc | |
| CConcreteInt | |
| CGotoLabel | |
| CMemRegionVal | |
| ►Nmpi | |
| CMPIBugReporter | |
| CMPIChecker | |
| CMPIFunctionClassifier | |
| CRequest | |
| CRequestMap | |
| ►Nnonloc | |
| CCompoundVal | |
| CConcreteInt | Value representing integer constant |
| CLazyCompoundVal | |
| CLocAsInteger | |
| CPointerToMember | Value representing pointer-to-member |
| CSymbolVal | Represents symbolic expression that isn't a location |
| ►Nretaincountchecker | |
| CRefCountBug | |
| CRefCountReport | |
| CRefCountReportVisitor | |
| CRefLeakReport | |
| CRefLeakReportVisitor | |
| CRefVal | Metadata on reference |
| CRetainCountChecker | |
| ►NsummMgr | |
| CSummaryKey | |
| CAllocaRegion | AllocaRegion - A region that represents an untyped blob of bytes created by a call to 'alloca' |
| CAnalysisAction | |
| CAnalysisASTConsumer | |
| CAnalysisManager | |
| CAnyCXXConstructorCall | Represents any constructor invocation |
| CAnyFunctionCall | Represents a call to any sort of function that might have a FunctionDecl |
| CAPSIntType | A record of the "type" of an APSInt, used for conversions |
| CArgEffect | An ArgEffect summarizes the retain count behavior on an argument or receiver to a function or method |
| CBasicBugReport | |
| CBasicValueFactory | |
| CBinarySymExpr | Represents a symbolic expression involving a binary operator |
| CBinarySymExprImpl | Template implementation for all binary symbolic expressions |
| CBlockCall | Represents a call to a block |
| CBlockCodeRegion | BlockCodeRegion - A region that represents code texts of blocks (closures) |
| ►CBlockCounter | An abstract data type used to count the number of times a given block has been visited along a path analyzed by CoreEngine |
| CFactory | |
| ►CBlockDataRegion | BlockDataRegion - A region that represents a block instance |
| Creferenced_vars_iterator | |
| CBranchNodeBuilder | BranchNodeBuilder is responsible for constructing the nodes corresponding to the two branches of the if statement - true and false |
| CBugReport | This class provides an interface through which checkers can create individual bug reports |
| CBugReportEquivClass | |
| CBugReporter | BugReporter is a utility class for generating PathDiagnostics for analysis |
| CBugReporterContext | |
| CBugReporterData | |
| CBugReporterVisitor | BugReporterVisitors are used to add custom diagnostics along a path |
| CBugType | |
| CCallDescription | This class represents a description of a function call using the number of arguments and the name of the function |
| CCallDescriptionMap | An immutable map from CallDescriptions to arbitrary data |
| CCallDescriptionSet | An immutable set of CallDescriptions |
| CCallEvent | Represents an abstract call to a function or method along a particular path |
| CCallEventManager | Manages the lifetime of CallEvent objects |
| CCallEventRef | |
| CChecker | |
| CChecker< CHECK1 > | |
| CCheckerBase | |
| CCheckerContext | |
| CCheckerDocumentation | This checker documents the callback functions checkers can use to implement the custom handling of the specific events during path exploration as well as reporting bugs |
| CCheckerFn | |
| CCheckerFn< RET(Ps...)> | |
| CCheckerInfo | Specifies a checker |
| CCheckerManager | |
| CCheckerNameRef | This wrapper is used to ensure that only StringRefs originating from the CheckerRegistry are used as check names |
| CCheckerProgramPointTag | Tag that can use a checker name as a message provider (see SimpleProgramPointTag) |
| CCheckerRegistry | Manages a set of available checkers for running a static analysis |
| CCheckerRegistryData | |
| CCmdLineOption | Specifies a command line option |
| CCodeSpaceRegion | CodeSpaceRegion - The memory space that holds the executable code of functions and blocks |
| CCodeTextRegion | |
| CCompoundLiteralRegion | CompoundLiteralRegion - A memory region representing a compound literal |
| CCompoundValData | |
| CConditionBRVisitor | Visitor that tries to report interesting diagnostics from conditions |
| CConditionTruthVal | |
| ►CConstraintManager | |
| CAssumeStackTy | A helper class to simulate the call stack of nested assume calls |
| CCoreEngine | CoreEngine - Implements the core logic of the graph-reachability analysis |
| CCXXAllocatorCall | Represents the memory allocation call in a C++ new-expression |
| CCXXBaseObjectRegion | |
| CCXXConstructorCall | Represents a call to a C++ constructor |
| CCXXDeallocatorCall | Represents the memory deallocation call in a C++ delete-expression |
| CCXXDerivedObjectRegion | |
| CCXXDestructorCall | Represents an implicit call to a C++ destructor |
| CCXXInheritedConstructorCall | Represents a call to a C++ inherited constructor |
| CCXXInstanceCall | Represents a non-static C++ member function call, no matter how it is written |
| CCXXLifetimeExtendedObjectRegion | |
| CCXXMemberCall | Represents a non-static C++ member function call |
| CCXXMemberOperatorCall | Represents a C++ overloaded operator call where the operator is implemented as a non-static member function |
| CCXXTempObjectRegion | |
| CCXXThisRegion | CXXThisRegion - Represents the region for the implicit 'this' parameter in a call to a C++ method |
| ►CDataTag | The tag that carries some information with it |
| CFactory | |
| CDeclRegion | |
| CDefaultProgramStatePartialTraitImpl | |
| CDefinedOrUnknownSVal | |
| CDefinedSVal | |
| CDynamicCastInfo | |
| CDynamicTypeInfo | Stores the currently inferred strictest bound on the runtime type of a region in a given state along the analysis path |
| CElementRegion | ElementRegion is used to represent both array elements and casts |
| CEnvironment | An immutable map from EnvironemntEntries to SVals |
| CEnvironmentEntry | An entry in the environment consists of a Stmt and an LocationContext |
| CEnvironmentManager | |
| CEvalCallOptions | Hints for figuring out of a call should be inlined during evalCall() |
| CEventDispatcher | |
| CExplodedGraph | |
| CExplodedNode | |
| CExplodedNodeSet | |
| CExprEngine | |
| CFalsePositiveRefutationBRVisitor | The bug visitor will walk all the nodes in a path and collect all the constraints |
| CFieldChainInfo | Represents a field chain |
| CFieldNode | A lightweight polymorphic wrapper around FieldRegion * |
| CFieldRegion | |
| CFindUninitializedFields | Searches for and stores uninitialized fields in a non-union object |
| CFullSValVisitor | FullSValVisitor - a convenient mixed visitor for all three: SVal, SymExpr and MemRegion subclasses |
| CFunctionCodeRegion | FunctionCodeRegion - A region that represents code texts of function |
| CFunctionSummariesTy | |
| CGlobalImmutableSpaceRegion | The region containing globals which are considered not to be modified or point to data which could be modified as a result of a function call (system or internal) |
| CGlobalInternalSpaceRegion | The region containing globals which can be modified by calls to "internally" defined functions - (for now just) functions other then system calls |
| CGlobalsSpaceRegion | |
| CGlobalSystemSpaceRegion | The region containing globals which are defined in system/external headers and are considered modifiable by system calls (ex: errno) |
| CHeapSpaceRegion | |
| CImplicitNullDerefEvent | We dereferenced a location that may be null |
| ►CIndirectGotoNodeBuilder | |
| Citerator | |
| CKnownSVal | Represents an SVal that is guaranteed to not be UnknownVal |
| CLazyCompoundValData | |
| CLikelyFalsePositiveSuppressionBRVisitor | Suppress reports that might lead to known false positives |
| CLoc | |
| CMemRegion | MemRegion - The root abstract class for all memory regions |
| CMemRegionManager | |
| CMemRegionVisitor | MemRegionVisitor - this class implements a simple visitor for MemRegion subclasses |
| CMemSpaceRegion | MemSpaceRegion - A memory region that represents a "memory space"; for example, the set of global variables, the stack frame, etc |
| CModelConsumer | ASTConsumer to consume model files' AST |
| CModelInjector | |
| CNilReceiverBRVisitor | Prints path notes when a message is sent to a nil receiver |
| CNodeBuilder | This is the simplest builder which generates nodes in the ExplodedGraph |
| CNodeBuilderContext | |
| CNodeBuilderWithSinks | This node builder keeps track of the generated sink nodes |
| CNonLoc | |
| CNonParamVarRegion | |
| CNonStaticGlobalSpaceRegion | The region for all the non-static global variables |
| CNoStateChangeFuncVisitor | Put a diagnostic on return statement (or on } in its absence) of all inlined functions for which some property remained unchanged |
| CNoteTag | The tag upon which the TagVisitor reacts |
| CObjCIvarRegion | |
| CObjCMethodCall | Represents any expression that calls an Objective-C method |
| CObjCStringRegion | The region associated with an ObjCStringLiteral |
| CObjCSummaryCache | |
| CObjCSummaryKey | A key identifying a summary |
| COperatorKind | |
| CPackageInfo | Specifies a package |
| CParamVarRegion | ParamVarRegion - Represents a region for paremters |
| CParseModelFileAction | Frontend action to parse model files |
| CPathDiagnostic | PathDiagnostic - PathDiagnostic objects represent a single path-sensitive diagnostic |
| CPathDiagnosticCallPiece | |
| ►CPathDiagnosticConsumer | |
| CFilesMade | |
| CPDFileEntry | |
| CPathDiagnosticConsumerOptions | These options tweak the behavior of path diangostic consumers |
| CPathDiagnosticControlFlowPiece | |
| CPathDiagnosticEventPiece | |
| CPathDiagnosticLocation | |
| CPathDiagnosticLocationPair | |
| CPathDiagnosticMacroPiece | |
| CPathDiagnosticNotePiece | |
| CPathDiagnosticPiece | |
| CPathDiagnosticPopUpPiece | |
| CPathDiagnosticRange | |
| CPathDiagnosticSpotPiece | |
| CPathPieces | |
| CPathSensitiveBugReport | |
| CPathSensitiveBugReporter | GRBugReporter is used for generating path-sensitive reports |
| CPointerToMemberData | |
| CPrettyStackTraceLocationContext | While alive, includes the current analysis stack in a crash trace |
| CProgramState | ProgramState - This class encapsulates: |
| CProgramStateManager | |
| CProgramStatePartialTrait | |
| CProgramStatePartialTrait< llvm::ImmutableList< T > > | |
| CProgramStatePartialTrait< llvm::ImmutableMap< Key, Data, Info > > | |
| CProgramStatePartialTrait< llvm::ImmutableSet< Key, Info > > | |
| CProgramStatePartialTrait< T *, void > | |
| CProgramStatePartialTrait< T, std::enable_if_t< std::is_enum< T >::value > > | |
| CProgramStatePartialTrait< T, std::enable_if_t< std::is_integral< T >::value > > | |
| CProgramStateTrait | |
| CProgramStateTrait< iterator::ContainerMap > | |
| CProgramStateTrait< iterator::IteratorRegionMap > | |
| CProgramStateTrait< iterator::IteratorSymbolMap > | |
| CProgramStateTrait< mpi::RequestMap > | |
| CProgramStateTrait< ReplayWithoutInlining > | |
| CRange | A Range represents the closed range [from, to] |
| CRangedConstraintManager | |
| ►CRangeSet | Persistent set of non-overlapping ranges |
| CFactory | |
| CRegionAndSymbolInvalidationTraits | Information about invalidation for a particular region/symbol |
| CRegionOffset | Represent a region's offset within the top level base region |
| CRegionRawOffset | |
| CReplayWithoutInlining | Traits for storing the call processing policy inside GDM |
| CRetainSummary | Summary for a function with respect to ownership changes |
| CRetainSummaryManager | |
| CRetainSummaryTemplate | |
| CRetEffect | RetEffect summarizes a call's retain/release behavior with respect to its return value |
| CRuntimeDefinition | Defines the runtime definition of the called function |
| CScanReachableSymbols | A utility class that visits the reachable symbols using a custom SymbolVisitor |
| CSimpleConstraintManager | |
| CSimpleFunctionCall | Represents a C function or static C++ member function call |
| CSMTConstraintManager | |
| CSMTConv | |
| CStackArgumentsSpaceRegion | |
| CStackHintGenerator | Interface for classes constructing Stack hints |
| CStackHintGeneratorForSymbol | Constructs a Stack hint for the given symbol |
| CStackLocalsSpaceRegion | |
| CStackSpaceRegion | |
| CStaticGlobalSpaceRegion | The region of the static variables within the current CodeTextRegion scope |
| CStmtNodeBuilder | This builder class is useful for generating nodes that resulted from visiting a statement |
| ►CStoreManager | |
| CBindingsHandler | |
| CFindUniqueBinding | |
| CStoreRef | |
| CStringRegion | StringRegion - Region associated with a StringLiteral |
| CSubRegion | SubRegion - A region that subsets another larger region |
| CSummaryManager | |
| CSummaryManagerImpl | |
| CSuppressInlineDefensiveChecksVisitor | |
| CSVal | SVal - This represents a symbolic expression, which can be either an L-value or an R-value |
| CSValBuilder | |
| CSValExplainer | |
| CSValVisitor | SValVisitor - this class implements a simple visitor for SVal subclasses |
| ►CSwitchNodeBuilder | |
| Citerator | |
| CSymbolCast | Represents a cast expression |
| CSymbolConjured | A symbol representing the result of an expression in the case when we do not know anything about what the expression is |
| CSymbolData | A symbol representing data which can be stored in a memory location (region) |
| CSymbolDerived | A symbol representing the value of a MemRegion whose parent region has symbolic value |
| CSymbolExtent | SymbolExtent - Represents the extent (size in bytes) of a bounded region |
| CSymbolicRegion | SymbolicRegion - A special, "non-concrete" region |
| CSymbolManager | |
| CSymbolMetadata | SymbolMetadata - Represents path-dependent metadata about a specific region |
| CSymbolReaper | A class responsible for cleaning up unused symbols |
| CSymbolRegionValue | A symbol representing the value stored at a MemRegion |
| CSymbolVisitor | |
| ►CSymExpr | Symbolic value |
| Csymbol_iterator | Iterator over symbols that the current symbol depends on |
| CSymExprVisitor | SymExprVisitor - this class implements a simple visitor for SymExpr subclasses |
| CTagVisitor | The visitor detects NoteTags and displays the event notes they contain |
| CTrackConstraintBRVisitor | |
| CTypedRegion | TypedRegion - An abstract class representing regions that are typed |
| CTypedValueRegion | TypedValueRegion - An abstract class representing regions having a typed value |
| CUnarySymExpr | Represents a symbolic expression involving a unary operator |
| CUndefinedVal | |
| CUndefOrNullArgVisitor | When a region containing undefined value or '0' value is passed as an argument in a call, marks the call as interesting |
| CUninitObjCheckerOptions | |
| CUnknownSpaceRegion | |
| CUnknownVal | |
| CVarRegion | |
| CWorkList | |
| CWorkListUnit | |
| ►Nextractapi | |
| ►Nimpl | |
| CExtractAPIVisitorBase | |
| CAccessControl | |
| CAPIIgnoresList | A type that provides access to a new line separated list of symbol names to ignore when extracting API information |
| ►CAPIRecord | The base representation of an API record. Holds common symbol information |
| CHierarchyInformation | Stores information about the context of the declaration of this API |
| CAPISet | APISet holds the set of API records collected from given inputs |
| CAPISetVisitor | The base interface of visitors for API information |
| CAvailabilityInfo | Stores availability attributes of a symbol in a given domain |
| CAvailabilitySet | |
| CClassTemplatePartialSpecializationRecord | |
| CClassTemplateRecord | |
| CClassTemplateSpecializationRecord | |
| CConceptRecord | |
| CCXXClassRecord | |
| CCXXConstructorRecord | |
| CCXXDestructorRecord | |
| CCXXFieldRecord | |
| CCXXFieldTemplateRecord | |
| CCXXInstanceMethodRecord | |
| CCXXMethodRecord | |
| CCXXMethodTemplateRecord | |
| CCXXMethodTemplateSpecializationRecord | |
| CCXXStaticMethodRecord | |
| ►CDeclarationFragments | DeclarationFragments is a vector of tagged important parts of a symbol's declaration |
| CFragment | Fragment holds information of a single fragment |
| CDeclarationFragmentsBuilder | A factory class to build DeclarationFragments for different kinds of Decl |
| CEnumConstantRecord | This holds information associated with enum constants |
| CEnumRecord | This holds information associated with enums |
| CExtractAPIVisitor | The RecursiveASTVisitor to traverse symbol declarations and collect API information |
| ►CFunctionSignature | Store function signature information with DeclarationFragments of the return type and parameters |
| CParameter | Parameter holds the name and DeclarationFragments of a single parameter |
| CGlobalFunctionRecord | This holds information associated with global functions |
| CGlobalFunctionTemplateRecord | |
| CGlobalFunctionTemplateSpecializationRecord | |
| CGlobalVariableRecord | This holds information associated with global functions |
| CGlobalVariableTemplatePartialSpecializationRecord | |
| CGlobalVariableTemplateRecord | |
| CGlobalVariableTemplateSpecializationRecord | |
| Chas_access | |
| Chas_access< ClassTemplatePartialSpecializationRecord > | |
| Chas_access< ClassTemplateRecord > | |
| Chas_access< ClassTemplateSpecializationRecord > | |
| Chas_access< CXXClassRecord > | |
| Chas_access< CXXFieldRecord > | |
| Chas_access< CXXFieldTemplateRecord > | |
| Chas_access< CXXInstanceMethodRecord > | |
| Chas_access< CXXMethodTemplateRecord > | |
| Chas_access< CXXMethodTemplateSpecializationRecord > | |
| Chas_access< CXXStaticMethodRecord > | |
| Chas_function_signature | Check if a record type has a function signature mixin |
| Chas_function_signature< CXXInstanceMethodRecord > | |
| Chas_function_signature< CXXMethodTemplateRecord > | |
| Chas_function_signature< CXXMethodTemplateSpecializationRecord > | |
| Chas_function_signature< CXXStaticMethodRecord > | |
| Chas_function_signature< GlobalFunctionRecord > | |
| Chas_function_signature< GlobalFunctionTemplateRecord > | |
| Chas_function_signature< GlobalFunctionTemplateSpecializationRecord > | |
| Chas_function_signature< ObjCClassMethodRecord > | |
| Chas_function_signature< ObjCInstanceMethodRecord > | |
| Chas_function_signature< ObjCMethodRecord > | |
| Chas_template | |
| Chas_template< ClassTemplatePartialSpecializationRecord > | |
| Chas_template< ClassTemplateRecord > | |
| Chas_template< ConceptRecord > | |
| Chas_template< CXXFieldTemplateRecord > | |
| Chas_template< CXXMethodTemplateRecord > | |
| Chas_template< GlobalFunctionTemplateRecord > | |
| Chas_template< GlobalVariableTemplatePartialSpecializationRecord > | |
| Chas_template< GlobalVariableTemplateRecord > | |
| CIgnoresFileNotFound | |
| CMacroDefinitionRecord | This holds information associated with macro definitions |
| CNamespaceRecord | |
| CObjCCategoryRecord | This holds information associated with Objective-C categories |
| CObjCClassMethodRecord | |
| CObjCClassPropertyRecord | |
| CObjCContainerRecord | The base representation of an Objective-C container record |
| CObjCInstanceMethodRecord | |
| CObjCInstancePropertyRecord | |
| CObjCInstanceVariableRecord | This holds information associated with Objective-C instance variables |
| CObjCInterfaceRecord | This holds information associated with Objective-C interfaces/classes |
| CObjCMethodRecord | This holds information associated with Objective-C methods |
| CObjCPropertyRecord | This holds information associated with Objective-C properties |
| CObjCProtocolRecord | This holds information associated with Objective-C protocols |
| CStaticFieldRecord | |
| CStructFieldRecord | This holds information associated with struct fields |
| CStructRecord | This holds information associated with structs |
| CSymbolGraphSerializer | The visitor that organizes API information in the Symbol Graph format |
| CSymbolGraphSerializerOption | Common options to customize the visitor output |
| CSymbolReference | This represents a reference to another symbol that might come from external sources |
| CTemplate | |
| CTypedefRecord | This holds information associated with typedefs |
| CTypedefUnderlyingTypeResolver | |
| ►NFileMgr | |
| CMapEntryOptionalStorage | Customized storage for refs derived from map entires in FileManager, using the private optional_none_tag to keep it to the size of a single pointer |
| ►Nformat | |
| CAdditionalKeywords | Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's lexer |
| CAffectedRangeManager | |
| CAnnotatedLine | |
| CBreakableBlockComment | |
| CBreakableComment | |
| CBreakableLineCommentSection | |
| CBreakableStringLiteral | |
| CBreakableStringLiteralUsingOperators | |
| CBreakableToken | Base class for tokens / ranges of tokens that can allow breaking within the tokens - for example, to avoid whitespace beyond the column limit, or to reflow text |
| CCommaSeparatedList | |
| CCompoundStatementIndenter | |
| CContinuationIndenter | |
| CDefinitionBlockSeparator | |
| CEnvironment | |
| CFatalDiagnosticConsumer | |
| ►CFormatStyle | The FormatStyle is used to configure the formatting to follow specific guidelines |
| CAlignConsecutiveStyle | Alignment options |
| CBraceWrappingFlags | Precise control over the wrapping of braces |
| CFormatStyleSet | |
| CIntegerLiteralSeparatorStyle | Separator format of integer literals of different bases |
| CRawStringFormat | See documentation of RawStringFormats |
| CShortCaseStatementsAlignmentStyle | Alignment options |
| CSpaceBeforeParensCustom | Precise control over the spacing before parentheses |
| CSpacesInLineComment | If true, spaces may be inserted into C style casts |
| CSpacesInParensCustom | Precise control over the spacing in parentheses |
| CTrailingCommentsAlignmentStyle | Alignment options |
| CFormattingAttemptStatus | Represents the status of a formatting attempt |
| CFormatToken | A wrapper around a Token storing information about the whitespace characters preceding it |
| CFormatTokenLexer | |
| CFormatTokenSource | |
| CIndexedTokenSource | |
| CIntegerLiteralSeparatorFixer | |
| CJavaScriptImportSorter | |
| CJsImportedSymbol | |
| CJsModuleReference | |
| CLeftRightQualifierAlignmentFixer | |
| CLineState | The current state when indenting a unwrapped line |
| CMacroCallReconstructor | Converts a sequence of UnwrappedLines containing expanded macros into a single UnwrappedLine containing the macro calls |
| ►CMacroExpander | Takes a set of macro definitions as strings and allows expanding calls to those macros |
| CDefinition | |
| CDefinitionParser | |
| CMacroExpansion | Contains information on the token's role in a macro expansion |
| CNamespaceEndCommentsFixer | |
| CObjCPropertyAttributeOrderFixer | |
| CObjCPropertyEntry | |
| CParenState | |
| CParseErrorCategory | |
| CRawStringFormatStyleManager | |
| CScopedLineState | |
| CScopedMacroState | |
| CTokenAnalyzer | |
| CTokenAnnotator | Determines extra information about the tokens comprising an UnwrappedLine |
| CTokenRole | |
| CUnwrappedLine | An unwrapped line is a sequence of Token, that we would like to put on a single line if there was no column limit |
| CUnwrappedLineConsumer | Interface for users of the UnwrappedLineParser to receive the parsed lines |
| CUnwrappedLineFormatter | |
| CUnwrappedLineNode | |
| CUnwrappedLineParser | |
| CUsingDeclarationsSorter | |
| ►CWhitespaceManager | Manages the whitespaces around tokens and their replacements |
| ►CChange | Represents a change before a token, a break inside a token, or the layout of an unchanged token (or whitespace within) |
| CIsBeforeInFile | Functor to sort changes in original source order |
| ►Nindex | |
| CCommentToXMLConverter | |
| CDeclOccurrence | |
| CFileIndexRecord | Stores the declaration occurrences seen in a particular source or header file of a translation unit |
| ►CIndexDataConsumer | |
| CASTNodeInfo | |
| CIndexingContext | |
| CIndexingOptions | |
| ►CPathPool | Pool of filesystem paths backed by a StringPool |
| CDirPath | |
| CFilePath | |
| CSerializablePathCollection | Stores file paths and produces serialization-friendly representation |
| ►CStringPool | Pool of strings |
| CStringOffsetSize | |
| CSymbolInfo | |
| CSymbolRelation | Represents a relation to another symbol for a symbol occurrence |
| ►Ninternal | |
| CCFGIntervalNode | |
| ►Ninterp | |
| CArrayIndexScope | |
| CAutoScope | Like a regular LocalScope, except that the destructors of all local variables are automatically emitted when the AutoScope is destroyed |
| CBlock | A memory block, either on the stack or in the heap |
| CBlockScope | Scope for storage declared in a compound statement |
| CBoolean | Wrapper around boolean types |
| CByteCodeEmitter | An emitter which links the program to bytecode for later use |
| CByteCodeExprGen | Compilation context for expressions |
| CByteCodeGenError | Error thrown by the compiler |
| CByteCodeStmtGen | Compilation context for statements |
| CCodePtr | Pointer into the code segment |
| CContext | Holds all information required to evaluate constexpr code in a module |
| CDeadBlock | Descriptor for a dead block |
| CDeclScope | Scope used to handle temporaries in toplevel variable declarations |
| ►CDescriptor | Describes a memory block created by an allocation site |
| CUnknownSize | Token to denote structures of unknown size |
| CDestructorScope | Emits the destructors of the variables of |
| CEvalEmitter | An emitter which evaluates opcodes as they are emitted |
| CExprScope | Expression scope which tracks potentially lifetime extended temporaries which are hoisted to the parent scope on exit |
| CFloating | |
| CFrame | Base class for stack frames, shared between VM and walker |
| CFunction | Bytecode function |
| CFunctionPointer | |
| CInitMap | Bitfield tracking the initialisation status of elements of primitive arrays |
| CInlineDescriptor | Inline descriptor embedded in structures and arrays |
| CIntegral | Wrapper around numeric types |
| CIntegralAP | |
| CInterpFrame | Frame storing local variables |
| CInterpStack | Stack frame storing temporaries and parameters |
| CInterpState | Interpreter context |
| CLabelScope | Scope managing label targets |
| CLocalScope | Generic scope for local variables |
| CLoopScope | Sets the context for break/continue statements |
| COptionScope | Scope used to handle initialization methods |
| CParamOffset | |
| CPointer | A pointer to a memory block, live or dead |
| CPrimConv | Mapping from primitive types to their representation |
| CPrimConv< PT_Bool > | |
| CPrimConv< PT_Float > | |
| CPrimConv< PT_FnPtr > | |
| CPrimConv< PT_IntAP > | |
| CPrimConv< PT_IntAPS > | |
| CPrimConv< PT_Ptr > | |
| CPrimConv< PT_Sint16 > | |
| CPrimConv< PT_Sint32 > | |
| CPrimConv< PT_Sint64 > | |
| CPrimConv< PT_Sint8 > | |
| CPrimConv< PT_Uint16 > | |
| CPrimConv< PT_Uint32 > | |
| CPrimConv< PT_Uint64 > | |
| CPrimConv< PT_Uint8 > | |
| ►CProgram | The program contains and links the bytecode for all functions |
| CDeclScope | Context to manage declaration lifetimes |
| ►CRecord | Structure/Class descriptor |
| CBase | Describes a base class |
| CField | Describes a record field |
| CRecordScope | |
| CRepr | |
| CRepr< 16, false > | |
| CRepr< 16, true > | |
| CRepr< 32, false > | |
| CRepr< 32, true > | |
| CRepr< 64, false > | |
| CRepr< 64, true > | |
| CRepr< 8, false > | |
| CRepr< 8, true > | |
| ►CScope | Describes a scope block |
| CLocal | Information about a local's storage |
| CSourceInfo | Describes the statement/declaration an opcode was generated from |
| CSourceLocScope | |
| CSourceMapper | Interface for classes which map locations to sources |
| CState | Interface for the VM to interact with the AST walker's context |
| CSwitchScope | |
| CVariableScope | Scope chain managing the variable lifetimes |
| ►Noptional_detail | |
| COptionalStorage | |
| COptionalStorage< clang::DirectoryEntryRef > | Customize OptionalStorage<DirectoryEntryRef> to use DirectoryEntryRef and its optional_none_tag to keep it the size of a single pointer |
| COptionalStorage< clang::FileEntryRef > | Customize OptionalStorage<FileEntryRef> to use FileEntryRef and its optional_none_tag to keep it the size of a single pointer |
| ►Nreachable_code | |
| CCallback | |
| ►NRISCV | RISCV builtins |
| CLMULType | |
| CPolicy | |
| CPrototypeDescriptor | |
| CRVVIntrinsic | |
| CRVVIntrinsicRecord | |
| CRVVType | |
| CRVVTypeCache | |
| ►Nsema | |
| CAccessedEntity | A declaration being accessed, together with information about how it was accessed |
| ►CAnalysisBasedWarnings | |
| CInterProceduralData | InterProceduralData aims to be a storage of whatever data should be passed between analyses of different functions |
| CPolicy | |
| CBlockScopeInfo | Retains information about a block that is currently being parsed |
| CCapture | |
| CCapturedRegionScopeInfo | Retains information about a captured region |
| CCapturingScopeInfo | |
| CCompoundScopeInfo | Contains information about the compound statement currently being parsed |
| CDelayedDiagnostic | A diagnostic message which has been conditionally emitted pending the complete parsing of the current declaration |
| CDelayedDiagnosticPool | A collection of diagnostics which were delayed |
| ►CFunctionScopeInfo | Retains information about a function, method, or block that is currently being parsed |
| ►CWeakObjectProfileTy | Represents a simple identification of a weak object |
| CDenseMapInfo | |
| CWeakUseTy | Represents a single use of a weak object |
| ►CLambdaScopeInfo | |
| CShadowedOuterDecl | Contains all of the variables defined in this lambda that shadow variables that were defined in parent contexts |
| CPossiblyUnreachableDiag | |
| CRISCVIntrinsicManager | |
| CSemaPPCallbacks | |
| CTemplateDeductionInfo | Provides information about an attempted template argument deduction, whose success or failure was described by a TemplateDeductionResult value |
| ►Nserialization | |
| ►Nreader | |
| ►CASTDeclContextNameLookupTrait | Class that performs name lookup into a DeclContext stored in an AST file |
| Cdata_type_builder | |
| CASTIdentifierLookupTrait | Class that performs lookup for an identifier stored in an AST file |
| CASTIdentifierLookupTraitBase | Base class for the trait describing the on-disk hash table for the identifiers in an AST file |
| ►CASTSelectorLookupTrait | Class that performs lookup for a selector's entries in the global method pool stored in an AST file |
| Cdata_type | |
| CDeclContextLookupTable | |
| ►CHeaderFileInfoTrait | Trait class used to search the on-disk hash table containing all of the header search information |
| Cinternal_key_type | |
| CAbstractTypeReader | |
| CAbstractTypeWriter | |
| CBasicReaderBase | |
| CDataStreamBasicReader | DataStreamBasicReader provides convenience implementations for many BasicReader methods based on the assumption that the ultimate reader implementation is based on a variable-length stream of unstructured data (like Clang's module files) |
| CDataStreamBasicWriter | DataStreamBasicWriter provides convenience implementations for many BasicWriter methods based on the assumption that the ultimate writer implementation is based on a variable-length stream of unstructured data (like Clang's module files) |
| CDeclarationNameKey | A key used when looking up entities by DeclarationName |
| CDeclOffset | Source location and bit offset of a declaration |
| CInputFile | The input file that has been loaded from this AST file, along with bools indicating whether this was an overridden buffer or if it was out-of-date or not-found |
| CInputFileInfo | The input file info that has been loaded from an AST file |
| CLocalRedeclarationsInfo | Describes the redeclarations of a declaration |
| CModuleFile | Information about a module that has been loaded by the ASTReader |
| CModuleManager | Manages the set of modules loaded by an AST reader |
| CMultiOnDiskHashTable | A collection of on-disk hash tables, merged when relevant for performance |
| CMultiOnDiskHashTableGenerator | Writer for the on-disk hash table |
| CObjCCategoriesInfo | Describes the categories of an Objective-C class |
| CPPEntityOffset | Source range/offset of a preprocessed entity |
| CPPSkippedRange | Source range of a skipped preprocessor region |
| CReadMethodPoolVisitor | |
| CTypeIdx | A type index; the type ID with the qualifier bits removed |
| CUnderalignedInt64 | Offset in the AST file |
| CUnsafeQualTypeDenseMapInfo | A structure for putting "fast"-unqualified QualTypes into a DenseMap |
| ►Nserialized_diags | |
| CLocation | A location that is represented in the serialized diagnostics |
| CSerializedDiagnosticReader | A base class that handles reading serialized diagnostics from a file |
| ►NSrcMgr | Public enums and private classes that are part of the SourceManager implementation |
| CContentCache | One instance of this struct is kept for every file loaded or used |
| CExpansionInfo | Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded, and the SpellingLoc - where the actual character data for the token came from |
| CFileInfo | Information about a FileID, basically just the logical file that it represents and include stack information |
| CLineOffsetMapping | Mapping of line offsets into a source file |
| CSLocEntry | This is a discriminated union of FileInfo and ExpansionInfo |
| ►Nsyntax | |
| CArena | A memory arena for syntax trees |
| CArraySubscript | Array size specified inside a declarator |
| CBinaryOperatorExpression | <lhs> <operator> <rhs> |
| CBreakStatement | Break; |
| CCallArguments | Models arguments of a function call |
| CCaseStatement | Case : <body> |
| CCompoundStatement | { statement1; statement2; … } |
| CContinueStatement | Continue; |
| CDeclaration | A declaration that can appear at the top-level |
| CDeclarationStatement | E.g. 'int a, b = 10;' |
| CDeclarator | Covers a name, an initializer and a part of the type outside declaration specifiers |
| CDeclaratorList | |
| CDefaultStatement | Default: <body> |
| CEmptyDeclaration | A semicolon in the top-level context. Does not declare anything |
| CEmptyStatement | The no-op statement, i.e. ';' |
| CExplicitTemplateInstantiation | Template <declaration> Examples: template struct X<int> template void foo<int>() template int var<double> |
| CExpressionStatement | Expression in a statement position, e.g |
| CFactoryImpl | Exposes private syntax tree APIs required to implement node synthesis |
| CFileRange | A half-open character range inside a particular file, the start offset is included and the end offset is excluded from the range |
| CForStatement | For (<init>; <cond>; <increment>) <body> |
| CIfStatement | If (cond) <then-statement> else <else-statement> FIXME: add condition that models 'expression or variable declaration' |
| CLeaf | A leaf node points to a single token |
| CLinkageSpecificationDeclaration | Extern <string-literal> declaration extern <string-literal> { <decls> } |
| ►CList | A list of Elements separated or terminated by a fixed token |
| CElementAndDelimiter | |
| CMemberPointer | Member pointer inside a declarator E.g |
| CMutationsImpl | |
| CNamespaceAliasDefinition | Namespace <name> = <namespace-reference> |
| CNamespaceDefinition | Namespace <name> { <decls> } |
| CNestedNameSpecifier | Models a nested-name-specifier |
| CNode | A node in a syntax tree |
| CParameterDeclarationList | Models a parameter-declaration-list which appears within parameters-and-qualifiers |
| CParametersAndQualifiers | Parameter list for a function type and a trailing return type, if the function has one |
| CParenDeclarator | Declarator inside parentheses |
| CPostfixUnaryOperatorExpression | <operand> <operator> |
| CPrefixUnaryOperatorExpression | <operator> <operand> |
| CRangeBasedForStatement | For (<decl> : <init>) <body> |
| CReturnStatement | Return <expr>; return; |
| CSimpleDeclaration | Groups multiple declarators (e.g |
| CSimpleDeclarator | A top-level declarator without parentheses |
| CStatement | An abstract node for C++ statements, e.g |
| CStaticAssertDeclaration | Static_assert(<condition>, <message>) static_assert(<condition>) |
| CSwitchStatement | Switch (<cond>) <body> |
| CTemplateDeclaration | Template <template-parameters> <declaration> |
| CToken | A token coming directly from a file or from a macro invocation |
| ►CTokenBuffer | A list of tokens obtained by preprocessing a text buffer and operations to map between the expanded and spelled tokens, i.e |
| CExpansion | An expansion produced by the preprocessor, includes macro expansions and preprocessor directives |
| CTokenBufferTokenManager | A TokenBuffer-powered token manager |
| CTokenCollector | Collects tokens for the main file while running the frontend action |
| CTokenManager | Defines interfaces for operating "Token" in the clang syntax-tree |
| CTrailingReturnType | Trailing return type after the parameter list, including the arrow token |
| ►CTree | A node that has children and represents a syntactic language construct |
| CChildIterator | Child_iterator is not invalidated by mutations |
| CConstChildIterator | |
| CTreeBuilder | A helper class for constructing the syntax tree while traversing a clang AST |
| CTypeAliasDeclaration | Using <name> = <type> |
| CUnaryOperatorExpression | An abstract class for prefix and postfix unary operators |
| CUnknownDeclaration | Declaration of an unknown kind, e.g. not yet supported in syntax trees |
| CUnknownExpression | An expression of an unknown kind, i.e |
| CUnknownStatement | A statement of an unknown kind, i.e |
| CUnqualifiedId | Models an unqualified-id |
| CUsingDeclaration | Using <scope>::<name> using typename <scope>::<name> |
| CUsingNamespaceDirective | Using namespace <name> |
| CWhileStatement | While (<cond>) <body> |
| ►Ntargets | |
| CAArch64beTargetInfo | |
| CAArch64leTargetInfo | |
| CAArch64TargetInfo | |
| CAIXPPC32TargetInfo | |
| CAIXPPC64TargetInfo | |
| CAIXTargetInfo | |
| CAMDGPUTargetInfo | |
| CAndroidX86_32TargetInfo | |
| CAndroidX86_64TargetInfo | |
| CARCTargetInfo | |
| CARMbeTargetInfo | |
| CARMleTargetInfo | |
| CARMTargetInfo | |
| CAVRTargetInfo | |
| CBaseSPIRTargetInfo | |
| CBaseSPIRVTargetInfo | |
| CBPFTargetInfo | |
| CCSKYTargetInfo | |
| CCygwinARMTargetInfo | |
| CCygwinX86_32TargetInfo | |
| CCygwinX86_64TargetInfo | |
| CDarwinAArch64TargetInfo | |
| CDarwinARMTargetInfo | |
| CDarwinI386TargetInfo | |
| CDarwinTargetInfo | |
| CDarwinX86_64TargetInfo | |
| CDirectXTargetInfo | |
| CDragonFlyBSDTargetInfo | |
| CEmscriptenTargetInfo | |
| CFreeBSDTargetInfo | |
| CFuchsiaTargetInfo | |
| CHaikuTargetInfo | |
| CHaikuX86_32TargetInfo | |
| CHexagonTargetInfo | |
| CHurdTargetInfo | |
| CItaniumWindowsARMleTargetInfo | |
| CKFreeBSDTargetInfo | |
| CLanaiTargetInfo | |
| CLe64TargetInfo | |
| CLinuxTargetInfo | |
| CLoongArch32TargetInfo | |
| CLoongArch64TargetInfo | |
| CLoongArchTargetInfo | |
| CM68kTargetInfo | |
| CMCUInfo | Information about a specific microcontroller |
| CMCUX86_32TargetInfo | |
| CMicrosoftARM64TargetInfo | |
| CMicrosoftARMleTargetInfo | |
| CMicrosoftX86_32TargetInfo | |
| CMicrosoftX86_64TargetInfo | |
| CMinGWARM64TargetInfo | |
| CMinGWARMTargetInfo | |
| CMinGWX86_32TargetInfo | |
| CMinGWX86_64TargetInfo | |
| CMipsTargetInfo | |
| CMSP430TargetInfo | |
| CNaClMips32TargetInfo | |
| CNaClTargetInfo | |
| CNetBSDI386TargetInfo | |
| CNetBSDTargetInfo | |
| CNVPTXTargetInfo | |
| COHOSTargetInfo | |
| COHOSX86_32TargetInfo | |
| COHOSX86_64TargetInfo | |
| COpenBSDI386TargetInfo | |
| COpenBSDTargetInfo | |
| COpenBSDX86_64TargetInfo | |
| COSTargetInfo | |
| CPNaClTargetInfo | |
| CPPC32TargetInfo | |
| CPPC64TargetInfo | |
| CPPCTargetInfo | |
| CPS3PPUTargetInfo | |
| CPS4OSTargetInfo | |
| CPS5OSTargetInfo | |
| CPSOSTargetInfo | |
| CRenderScript32TargetInfo | |
| CRenderScript64TargetInfo | |
| CRISCV32TargetInfo | |
| CRISCV64TargetInfo | |
| CRISCVTargetInfo | |
| CRTEMSTargetInfo | |
| CRTEMSX86_32TargetInfo | |
| CSolarisTargetInfo | |
| CSparcTargetInfo | |
| CSparcV8elTargetInfo | |
| CSparcV8TargetInfo | |
| CSparcV9TargetInfo | |
| CSPIR32TargetInfo | |
| CSPIR64TargetInfo | |
| CSPIRTargetInfo | |
| CSPIRV32TargetInfo | |
| CSPIRV64TargetInfo | |
| CSPIRVTargetInfo | |
| CSystemZTargetInfo | |
| CTCELETargetInfo | |
| CTCETargetInfo | |
| CVETargetInfo | |
| CWASITargetInfo | |
| CWebAssembly32TargetInfo | |
| CWebAssembly64TargetInfo | |
| CWebAssemblyOSTargetInfo | |
| CWebAssemblyTargetInfo | |
| CWindowsARM64TargetInfo | |
| CWindowsARMTargetInfo | |
| CWindowsTargetInfo | |
| CWindowsX86_32TargetInfo | |
| CWindowsX86_64TargetInfo | |
| CX86_32TargetInfo | |
| CX86_64TargetInfo | |
| CX86TargetInfo | |
| CXCoreTargetInfo | |
| CZOSTargetInfo | |
| ►Ntemplateargumentvisitor | |
| CBase | A simple visitor class that helps create template argument visitors |
| ►NthreadSafety | |
| ►Nlexpr | |
| CAnd | |
| CBinOp | |
| CLExpr | |
| CNot | |
| COr | |
| CTerminal | |
| ►Ntil | |
| CAlloc | Allocate memory for a new value on the heap or stack |
| CApply | Apply an argument to a function |
| CArrayAdd | Pointer arithmetic, restricted to arrays only |
| CArrayIndex | If p is a reference to an array, then p[i] is a reference to the i'th element of the array |
| ►CBasicBlock | A basic block is part of an SCFG |
| CTopologyNode | |
| CBinaryOp | Simple arithmetic binary operations, e.g |
| CBranch | A conditional branch to two other blocks |
| CCall | Call a function (after all arguments have been applied) |
| CCast | Cast expressions |
| CCode | A block of code – e.g. the body of a function |
| CComparator | |
| ►CCopyReducerBase | |
| CContainer | |
| CEqualsComparator | |
| CField | A typed, writable location in memory |
| CFunction | A function – a.k.a |
| CFuture | Placeholder for an expression that has not yet been created |
| CGoto | Jump to another basic block |
| CIdentifier | An identifier, e.g |
| CIfThenElse | An if-then-else expression |
| CLet | A let-expression, e.g |
| CLiteral | |
| CLiteralPtr | A Literal pointer to an object allocated in memory |
| CLiteralT | |
| CLoad | Load a value from memory |
| CMatchComparator | |
| CMemRegionRef | |
| CPhi | Phi Node, for code in SSA form |
| CPrettyPrinter | |
| CProject | Project a named slot from a C++ struct or class |
| CReturn | Return from the enclosing function, passing the return value to the caller |
| CSApply | Apply a self-argument to a self-applicable function |
| CSCFG | An SCFG is a control-flow graph |
| CSExpr | Base class for AST nodes in the typed intermediate language |
| CSFunction | A self-applicable function |
| CSimpleArray | |
| CSimpleReducerBase | |
| CStdPrinter | |
| CStore | Store a value to memory |
| CTerminator | Base class for basic block terminators: Branch, Goto, and Return |
| CTraversal | |
| CUnaryOp | Simple arithmetic unary operations, e.g |
| CUndefined | Placeholder for expressions that cannot be represented in the TIL |
| CValueType | ValueTypes are data types that can actually be held in registers |
| CVariable | A named variable, e.g |
| CVisitReducer | |
| ►CVisitReducerBase | |
| CContainer | |
| CWildcard | Placeholder for a wildcard that matches any other expression |
| CBeforeSet | |
| CCapabilityExpr | |
| CCFGVisitor | |
| CCFGWalker | |
| CCopyOnWriteVector | |
| ►CSExprBuilder | |
| CCallingContext | Encapsulates the lexical context of a function call |
| CThreadSafetyHandler | Handler class for thread safety warnings |
| ►Ntooling | |
| ►Ndependencies | |
| CCachedFileContents | Contents and directive tokens of a cached file entry |
| CCachedFileSystemEntry | An in-memory representation of a file system entity that is of interest to the dependency scanning filesystem |
| CCallbackActionController | A simple dependency action controller that uses a callback |
| CCommand | A command-line tool invocation that is part of building a TU |
| CDependencyActionController | Dependency scanner callbacks that are used during scanning to influence the behaviour of the scan - for example, to customize the scanned invocations |
| CDependencyConsumer | |
| CDependencyScanningFilesystemLocalCache | This class is a local cache, that caches the 'stat' and 'open' calls to the underlying real file system |
| ►CDependencyScanningFilesystemSharedCache | This class is a shared cache, that caches the 'stat' and 'open' calls to the underlying real file system, and the scanned preprocessor directives of files |
| CCacheShard | |
| CDependencyScanningService | The dependency scanning service contains shared configuration and state that is used by the individual dependency scanning workers |
| CDependencyScanningTool | The high-level implementation of the dependency discovery tool that runs on an individual worker thread |
| CDependencyScanningWorker | An individual dependency scanning worker that is able to run on its own thread |
| CDependencyScanningWorkerFilesystem | A virtual file system optimized for the dependency discovery |
| CEntryRef | Reference to a CachedFileSystemEntry |
| CFullDependencyConsumer | |
| CModuleDepCollector | Collects modular and non-modular dependencies of the main file by attaching ModuleDepCollectorPP to the preprocessor |
| CModuleDepCollectorPP | Callback that records textual includes and direct modular includes/imports during preprocessing |
| CModuleDeps | |
| CModuleID | This is used to identify a specific module |
| CP1689ModuleInfo | P1689ModuleInfo - Represents the needed information of standard C++20 modules for P1689 format |
| CP1689Rule | |
| CPrebuiltModuleDep | Modular dependency that has already been built prior to the dependency scan |
| CTranslationUnitDeps | The full dependencies and module graph for a specific input |
| ►Ndetail | |
| CTransformerImpl | Implementation details of Transformer with type erasure around RewriteRule<T> as well as the corresponding consumers |
| Ctype_identity | |
| CWithMetadataImpl | Implementation when metadata is generated as a part of the rewrite |
| ►Ninternal | |
| CAreBaseOf | A type trait that returns true when the given type list contains types that derive from Base |
| CAreBaseOf< Base, T > | |
| CHasBaseOf | A type trait that returns true when the given type list has at least one type whose base is the given base type |
| CHasBaseOf< Base, T > | |
| CRangeLessThan | |
| ►Nstdlib | |
| CHeader | |
| CRecognizer | |
| CSymbol | |
| ►Ntraits | |
| ►Ninternal | |
| CHasHandle | |
| CIsValidOptionType | A type trait that returns true iff the given type is a type that can be stored in a refactoring option |
| CAllTUsToolExecutor | Executes given frontend actions on all files/TUs in the compilation database |
| CAllTUsToolExecutorPlugin | |
| CApplyChangesSpec | |
| CArgumentsAdjustingCompilations | |
| CASTMatchRefactorer | Adaptor between ast_matchers::MatchFinder and tooling::RefactoringTool |
| CASTSelectionRequirement | An AST selection requirement is satisfied when any portion of the AST overlaps with the selection range |
| CASTSrcLocProcessor | |
| CAtomicChange | An atomic change is used to create and group a set of source edits, e.g |
| CClangTool | Utility to run a FrontendAction over a set of files |
| CClassData | |
| CCodeRangeASTSelection | An AST selection value that corresponds to a selection of a set of statements that belong to one body of code (like one function) |
| CCodeRangeASTSelectionRequirement | A selection requirement that is satisfied when the selection range overlaps with a number of neighbouring statements in the AST |
| CCommonOptionsParser | A parser for options common to all command-line Clang tools |
| CCompilationDatabase | Interface for compilation databases |
| CCompilationDatabasePlugin | Interface for compilation database plugins |
| CCompileCommand | Specifies the working directory and command of a compilation |
| CDiagnostic | Represents the diagnostic with the level of severity and possible fixes to be applied |
| CDiagnosticMessage | Represents the diagnostic message with the error message associated and the information on the location of the problem |
| CExecutionContext | The context of an execution, including the information about compilation and results |
| CExtractFunction | An "Extract Function" refactoring moves code into a new function that's then called from the place where the original code was |
| CExtractionSemicolonPolicy | Determines which semicolons should be inserted during extraction |
| CFileByteRange | Represents a range within a specific source file |
| CFileMatchTrie | A trie to efficiently match against the entries of the compilation database in order of matching suffix length |
| CFileMatchTrieNode | A node of the FileMatchTrie |
| CFindSymbolOccurrencesRefactoringRule | A type of refactoring action rule that finds a set of symbol occurrences that reference a particular symbol |
| CFixedCompilationDatabase | A compilation database that returns a single compile command line |
| CFrontendActionFactory | Interface to generate clang::FrontendActions |
| CHeaderIncludes | Generates replacements for inserting or deleting #include directives in a file |
| CIncludeCategoryManager | This class manages priorities of C++ #include categories and calculates priorities for headers |
| ►CIncludeStyle | Style for sorting and grouping C++ #include directives |
| CIncludeCategory | See documentation of IncludeCategories |
| CInMemoryToolResults | Stores the key-value results in memory |
| CJSONCompilationDatabase | |
| CLocationCall | |
| CLocationCallFormatterCpp | |
| CNamedDeclFindingConsumer | |
| CNodeLocationAccessors | |
| COptionalRefactoringOption | A refactoring option that stores a value of type T |
| COptionRequirement | A requirement that evaluates to the value of the given OptionType when the OptionType is a required option |
| CPathComparator | |
| CQualifiedRenameRule | |
| CQualifiedRenamingAction | Rename all symbols identified by the given USRs |
| CRange | A source range independent of the SourceManager |
| CRecursiveSymbolVisitor | Traverses the AST and visits the occurrence of each named symbol in the given nodes |
| CRefactoringAction | A refactoring action is a class that defines a set of related refactoring action rules |
| CRefactoringActionRule | A refactoring action rule is a wrapper class around a specific refactoring action rule (SourceChangeRefactoringRule, etc) that, in addition to invoking the action, describes the requirements that determine when the action can be initiated |
| CRefactoringActionRuleBase | A common refactoring action rule interface that defines the 'invoke' function that performs the refactoring operation (either fully or partially) |
| CRefactoringActionRuleRequirement | A refactoring action rule requirement determines when a refactoring action rule can be invoked |
| CRefactoringASTConsumer | |
| CRefactoringCallback | Base class for RefactoringCallbacks |
| CRefactoringDescriptor | |
| CRefactoringOption | A refactoring option is an interface that describes a value that has an impact on the outcome of a refactoring |
| CRefactoringOptionsRequirement | A base class for any requirement that requires some refactoring options |
| CRefactoringOptionVisitor | An interface that declares functions that handle different refactoring option types |
| CRefactoringResultConsumer | An abstract interface that consumes the various refactoring results that can be produced by refactoring actions |
| CRefactoringRuleContext | The refactoring rule context stores all of the inputs that might be needed by a refactoring action rule |
| CRefactoringTool | A tool to run refactorings |
| CRenameOccurrences | |
| CRenamingAction | |
| CRenamingASTConsumer | |
| CReplaceIfStmtWithItsBody | Replace an if-statement bound to Id with the outdented text of its body, choosing the consequent or the alternative based on whether PickTrueBranch is true |
| CReplacement | A text replacement |
| CReplacementError | Carries extra error information in replacement-related llvm::Error, e.g |
| CReplacements | Maintains a set of replacements that are conflict-free |
| CReplaceNodeWithTemplate | Replace the text of an AST node bound to FromId with the result of evaluating the template in ToTemplate |
| CReplaceStmtWithStmt | Replace the text of the statement bound to FromId with the text of the statement bound to ToId |
| CReplaceStmtWithText | Replace the text of the statement bound to FromId with the text in ToText |
| CRequiredRefactoringOption | A required refactoring option that stores a value of type T |
| CSelectedASTNode | Represents a selected AST node |
| CSourceChangeRefactoringRule | A type of refactoring action rule that produces source replacements in the form of atomic changes |
| CSourceFileCallbacks | Callbacks called before and after each source file processed by a FrontendAction created by the FrontedActionFactory returned by newFrontendActionFactory |
| CSourceRangeSelectionRequirement | A selection requirement that is satisfied when any portion of the source text is selected |
| CSourceSelectionRequirement | A base class for any requirement that expects some part of the source to be selected in an editor (or the refactoring tool with the -selection option) |
| CStandaloneToolExecutor | A standalone executor that runs FrontendActions on a given set of TUs in sequence |
| CStandaloneToolExecutorPlugin | |
| CSymbolName | A name of a symbol |
| CSymbolOccurrence | An occurrence of a symbol in the source |
| CToolAction | Interface to process a clang::CompilerInvocation |
| CToolExecutor | Interface for executing clang frontend actions |
| CToolExecutorPlugin | Interface for factories that create specific executors |
| CToolInvocation | Utility to run a FrontendAction in a single clang invocation |
| CToolResults | An abstraction for the result of a tool execution |
| CTransformer | Handles the matcher and callback registration for a single RewriteRule, as defined by the arguments of the constructor |
| CTransformerResult | |
| CTransformerResult< void > | |
| CTranslationUnitDiagnostics | Collection of Diagnostics generated from a single translation unit |
| CTranslationUnitReplacements | Collection of Replacements generated from a single translation unit |
| CUSRFindingAction | |
| CUSRSymbolRenamer | |
| ►Ntransformer | |
| CASTEdit | |
| CEdit | A concrete description of a source edit, represented by a character range in the source to be replaced and a corresponding replacement string |
| CMatchComputation | A failable computation over nodes bound by AST matchers, with (limited) reflection via the toString method |
| ►CRewriteRuleBase | Description of a source-code transformation |
| CCase | |
| CRewriteRuleWith | A source-code transformation with accompanying metadata |
| CRewriteRuleWith< void > | |
| CAbstractConditionalOperator | AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOperator |
| CAccessSpecDecl | Represents an access specifier followed by colon ':' |
| CActionResult | The result of parsing/analyzing an expression, statement etc |
| CActionResult< PtrTy, true > | |
| CAddFlagValue | |
| CAddrLabelExpr | AddrLabelExpr - The GNU address of label extension, representing &&label |
| CAdjustedLocInfo | |
| CAdjustedType | Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons |
| CAdjustedTypeLoc | |
| CADLResult | A class for storing results from argument-dependent lookup |
| CAmbiguousConversionSequence | Represents an ambiguous user-defined conversion sequence |
| CAnalysisDeclContext | AnalysisDeclContext contains the context data for the function, method or block under analysis |
| CAnalysisDeclContextManager | |
| CAnalyzerOptions | Stores options for the analyzer from the command line |
| CAnyCall | An instance of this class corresponds to a call |
| CAPFloatStorage | |
| CAPINotesOptions | Tracks various options which control how API notes are found and handled |
| CAPIntStorage | |
| CAPNumericStorage | Used by IntegerLiteral/FloatingLiteral to store the numeric without leaking memory |
| ►CAPValue | APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset], [Vector: N * APValue], [Array: N * APValue] |
| CLV | |
| CLValueBase | |
| CLValuePathEntry | A non-discriminated union of a base, field, or array index |
| CLValuePathSerializationHelper | |
| CMemberPointerData | |
| CNoLValuePath | |
| CUninitArray | |
| CUninitStruct | |
| CArgumentConstructionContext | |
| CArrayInitIndexExpr | Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr |
| CArrayInitLoopExpr | Represents a loop initializing the elements of an array |
| CArrayLocInfo | |
| CArraySubscriptExpr | ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting |
| CArrayType | Represents an array type, per C99 6.7.5.2 - Array Declarators |
| CArrayTypeLoc | Wrapper for source info for arrays |
| CArrayTypeTraitExpr | An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent |
| CAsmStmt | AsmStmt is the base class for GCCAsmStmt and MSAsmStmt |
| CAssumedTemplateStorage | A structure for storing the information associated with a name that has been assumed to be a template name (despite finding no TemplateDecls) |
| CASTConstraintSatisfaction | The result of a constraint satisfaction check, containing the necessary information to diagnose an unsatisfied constraint |
| CASTConsumer | ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs |
| ►CASTContext | Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic analysis of a file |
| CBuiltinVectorTypeInfo | |
| CCUDAConstantEvalContext | |
| CCUDAConstantEvalContextRAII | |
| CSectionInfo | |
| CASTDeclListAction | |
| CASTDeclReader | |
| CASTDeclWriter | |
| CASTDeserializationListener | |
| CASTDumpAction | |
| CASTDumper | |
| CASTFileSignature | The signature of a module, which is a hash of the AST content |
| CASTFrontendAction | Abstract base class to use for AST consumer-based frontend actions |
| CASTIdentifierIterator | An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files |
| ►CASTImporter | Imports selected nodes from one AST context into another context, merging AST nodes where appropriate |
| CImportPathTy | |
| CASTImporterLookupTable | |
| CASTImportError | |
| CASTImporterSharedState | Importer specific state, which may be shared amongst several ASTImporter objects |
| CASTMergeAction | Frontend action adaptor that merges ASTs together |
| CASTMutationListener | An abstract interface that should be implemented by listeners that want to be notified when an AST entity gets modified after its initial creation |
| ►CASTNameGenerator | |
| CImplementation | |
| CASTNodeImporter | |
| ►CASTNodeKind | Kind identifier |
| CDenseMapInfo | Hooks for using ASTNodeKind as a key in a DenseMap |
| CASTNodeTraverser | ASTNodeTraverser traverses the Clang AST for dumping purposes |
| CASTPrintAction | |
| ►CASTReader | Reads an AST files chain containing the contents of a translation unit |
| CListenerScope | RAII object to temporarily add an AST callback listener |
| CModuleDeclIterator | |
| CASTReaderListener | Abstract interface for callback invocations by the ASTReader |
| ►CASTRecordLayout | ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/class |
| CVBaseInfo | |
| CASTRecordReader | An object for streaming information from a record |
| CASTRecordWriter | An object for streaming information to a record |
| CASTSourceDescriptor | Abstracts clang modules and precompiled header files and holds everything needed to generate debug info for an imported module or PCH |
| CASTStmtReader | |
| CASTStmtWriter | |
| CASTTemplateArgumentListInfo | Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>" |
| CASTTemplateKWAndArgsInfo | Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>" |
| ►CASTUnit | Utility class for loading a ASTContext from an AST file |
| CASTWriterData | |
| CCachedCodeCompletionResult | A cached code-completion result, which may be introduced in one of many different contexts |
| CConcurrencyCheck | |
| CStandaloneDiagnostic | |
| CStandaloneFixIt | |
| CASTUnresolvedSet | An UnresolvedSet-like class which uses the ASTContext's allocator |
| CASTVector | |
| CASTViewAction | |
| CASTWriter | Writes an AST file containing the contents of a translation unit |
| CAsTypeExpr | AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support for reinterpreting a type to another type of the same size |
| CAtomicConstraint | |
| CAtomicExpr | AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>, and corresponding __opencl_atomic_* for OpenCL 2.0 |
| CAtomicScopeGenericModel | Defines the generic atomic scope model |
| CAtomicScopeHIPModel | Defines the synch scope model for HIP |
| CAtomicScopeModel | Defines the interface for synch scope model |
| CAtomicScopeOpenCLModel | Defines the synch scope model for OpenCL |
| CAtomicType | |
| CAtomicTypeLoc | |
| CAtomicTypeLocInfo | |
| CAttr | Attr - This represents one attribute |
| ►CAttributeCommonInfo | |
| CForm | Combines information about the source-code form of an attribute, including its syntax and spelling |
| CAttributedLocInfo | |
| CAttributedStmt | Represents an attribute applied to a statement |
| CAttributedType | An attributed type is a type to which a type attribute has been applied |
| CAttributedTypeLoc | Type source information for an attributed type |
| CAttributeFactory | A factory, from which one makes pools, from which one creates individual attributes which are deallocated with the pool |
| CAttributePool | |
| CAttrVisitor | A simple visitor class that helps create attribute visitors |
| CAutoType | Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint |
| CAutoTypeLoc | |
| CAutoTypeLocInfo | |
| CAvailabilityChange | Represents information about a change in availability for an entity, which is part of the encoding of the 'availability' attribute |
| CAvailabilitySpec | One specifier in an @available expression |
| CBackendConsumer | |
| CBackwardDataflowWorklist | A worklist implementation for backward dataflow analysis |
| CBadConversionSequence | BadConversionSequence - Records information about an invalid conversion sequence |
| CBalancedDelimiterTracker | RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ... } or parentheses ( ... ) |
| CBaseSubobject | |
| ►CBaseUsingDecl | Represents a C++ declaration that introduces decls from somewhere else |
| Cshadow_iterator | Iterates through the using shadow declarations associated with this using declaration |
| CBeforeThanCompare | Comparison function object |
| CBeforeThanCompare< SourceLocation > | Compare two source locations |
| CBeforeThanCompare< SourceRange > | Compare two non-overlapping source ranges |
| CBinaryConditionalOperator | BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle operand to be omitted |
| CBinaryOperator | A builtin binary operation expression such as "x + y" or "x <= y" |
| CBindingDecl | A binding in a decomposition declaration |
| CBitIntType | A fixed int type of a specified bitwidth |
| CBitIntTypeLoc | |
| CBitsPacker | A simple helper class to pack several bits in order into (a) 32 bit integer(s) |
| CBitsUnpacker | A simple helper class to unpack an integer to bits and consuming the bits in order |
| ►CBlockDecl | Represents a block literal declaration, which is like an unnamed FunctionDecl |
| CCapture | A class which contains all the information about a particular captured value |
| CBlockEdge | |
| CBlockEntrance | |
| CBlockExit | |
| CBlockExpr | BlockExpr - Adaptor class for mixing a BlockDecl with expressions |
| CBlockInvocationContext | It represents a block invocation (based on BlockCall) |
| CBlockPointerType | Pointer to a block type |
| CBlockPointerTypeLoc | Wrapper for source info for block pointers |
| CBlockVarCopyInit | Copy initialization expr of a __block variable and a boolean flag that indicates whether the expression can throw |
| CBodyFarm | |
| CBreakStmt | BreakStmt - This represents a break |
| CBTFTagAttributedLocInfo | |
| CBTFTagAttributedType | |
| CBTFTagAttributedTypeLoc | Type source information for an btf_tag attributed type |
| CBuildPreambleErrorCategory | |
| CBuildResult | |
| CBuiltinBitCastExpr | Represents a C++2a __builtin_bit_cast(T, v) expression |
| CBuiltinLocInfo | |
| CBuiltinTemplateDecl | Represents the builtin template declaration which is used to implement __make_integer_seq and other builtin templates |
| CBuiltinType | This class is used for builtin types like 'int' |
| CBuiltinTypeLoc | Wrapper for source info for builtin types |
| CBumpVector | |
| CBumpVectorContext | |
| CCalledOnceCheckHandler | |
| CCallEnter | Represents a point when we begin processing an inlined call |
| CCallExitBegin | Represents a point when we start the call exit sequence (for inlined call) |
| CCallExitEnd | Represents a point when we finish the call exit sequence (for inlined call) |
| CCallExpr | CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]) |
| CCallGraph | The AST-based call graph |
| ►CCallGraphNode | |
| CCallRecord | |
| CCanonicalDeclPtr | A wrapper class around a pointer that always points to its canonical declaration |
| CCanProxy | Canonical proxy type returned when retrieving the members of a canonical type or as the result of the CanQual<T>::getAs member function |
| CCanProxyAdaptor | Replaceable canonical proxy adaptor class that provides the link between a canonical type and the accessors of the type |
| CCanProxyAdaptor< BlockPointerType > | |
| CCanProxyAdaptor< ComplexType > | |
| CCanProxyAdaptor< DecltypeType > | |
| CCanProxyAdaptor< DependentSizedExtVectorType > | |
| CCanProxyAdaptor< EnumType > | |
| CCanProxyAdaptor< ExtVectorType > | |
| CCanProxyAdaptor< FunctionNoProtoType > | |
| CCanProxyAdaptor< FunctionProtoType > | |
| CCanProxyAdaptor< FunctionType > | |
| CCanProxyAdaptor< LValueReferenceType > | |
| CCanProxyAdaptor< MemberPointerType > | |
| CCanProxyAdaptor< ObjCObjectPointerType > | |
| CCanProxyAdaptor< ObjCObjectType > | |
| CCanProxyAdaptor< PointerType > | |
| CCanProxyAdaptor< RecordType > | |
| CCanProxyAdaptor< ReferenceType > | |
| CCanProxyAdaptor< RValueReferenceType > | |
| CCanProxyAdaptor< TagType > | |
| CCanProxyAdaptor< TemplateTypeParmType > | |
| CCanProxyAdaptor< TypeOfType > | |
| CCanProxyAdaptor< UnaryTransformType > | |
| CCanProxyAdaptor< VectorType > | |
| CCanProxyBase | Base class of all canonical proxy types, which is responsible for storing the underlying canonical type and providing basic conversions |
| CCanQual | Represents a canonical, potentially-qualified type |
| CCanTypeIterator | Iterator adaptor that turns an iterator over canonical QualTypes into an iterator over CanQualTypes |
| CCapturedDecl | Represents the body of a CapturedStmt, and serves as its DeclContext |
| ►CCapturedStmt | This captures a statement into a function |
| CCapture | Describes the capture of either a variable, or 'this', or variable-length array type |
| CCaseStmt | CaseStmt - Represent a case statement |
| Ccast_convert_decl_context | |
| Ccast_convert_decl_context< ToTy, true > | |
| CCastExpr | CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit casts that have some representation in the source code (ExplicitCastExpr's derived classes) |
| ►CCFG | Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt |
| CBuildOptions | |
| CCFGAutomaticObjDtor | Represents C++ object destructor implicitly generated for automatic object or temporary bound to const reference at the point of leaving its local scope |
| CCFGBaseDtor | Represents C++ object destructor implicitly generated for base object in destructor |
| ►CCFGBlock | Represents a single basic block in a source-level CFG |
| CAdjacentBlock | This class represents a potential adjacent block in the CFG |
| CFilteredCFGBlockIterator | |
| CFilterOptions | |
| CCFGCallback | CFGCallback defines methods that should be called when a logical operator error is found when building the CFG |
| CCFGCleanupFunction | |
| CCFGConstructor | Represents C++ constructor call |
| CCFGCXXRecordTypedCall | Represents a function call that returns a C++ object by value |
| CCFGDeleteDtor | Represents C++ object destructor generated from a call to delete |
| CCFGDominatorTreeImpl | Dominator tree builder for Clang's CFG based on llvm::DominatorTreeBase |
| CCFGElement | Represents a top-level expression in a basic block |
| CCFGImplicitDtor | Represents C++ object destructor implicitly generated by compiler on various occasions |
| CCFGInitializer | Represents C++ base or member initializer from constructor's initialization list |
| CCFGLifetimeEnds | Represents the point where the lifetime of an automatic object ends |
| CCFGLoopExit | Represents the point where a loop ends |
| CCFGMemberDtor | Represents C++ object destructor implicitly generated for member object in destructor |
| CCFGNewAllocator | Represents C++ allocator call |
| CCFGReverseBlockReachabilityAnalysis | |
| CCFGScopeBegin | Represents beginning of a scope implicitly generated by the compiler on encountering a CompoundStmt |
| CCFGScopeEnd | Represents end of a scope implicitly generated by the compiler after the last Stmt in a CompoundStmt's body |
| CCFGStmt | |
| CCFGStmtMap | |
| CCFGTemporaryDtor | Represents C++ object destructor implicitly generated at the end of full expression for temporary object |
| CCFGTerminator | Represents CFGBlock terminator statement |
| CChainedASTReaderListener | Simple wrapper class for chaining listeners |
| CChainedDiagnosticConsumer | ChainedDiagnosticConsumer - Chain two diagnostic clients so that diagnostics go to the first client and then the second |
| CCharacterLiteral | |
| CCharLiteralParser | CharLiteralParser - Perform interpretation and semantic analysis of a character literal |
| CCharSourceRange | Represents a character-granular source range |
| CCharUnits | CharUnits - This is an opaque type for sizes expressed in character units |
| CChildErrorHandlingStrategy | How to handle import errors that occur when import of a child declaration of a DeclContext fails |
| CChooseExpr | ChooseExpr - GNU builtin-in function __builtin_choose_expr |
| CClangDiagnosticHandler | |
| ►CClassTemplateDecl | Declaration of a class template |
| CCommon | Data that is common to all of the declarations of a given class template |
| CClassTemplatePartialSpecializationDecl | |
| CClassTemplateSpecializationDecl | Represents a class template specialization, which refers to a class template with a given set of template arguments |
| CCleanupInfo | |
| CCloneConstraint | This class is a utility class that contains utility functions for building custom constraints |
| CCloneDetector | Searches for similar subtrees in the AST |
| CCoawaitExpr | Represents a 'co_await' expression |
| ►CCodeCompleteConsumer | Abstract interface for a consumer of code-completion information |
| COverloadCandidate | |
| CCodeCompleteOptions | Options controlling the behavior of code completion |
| CCodeCompletionAllocator | An allocator used specifically for the purpose of code completion |
| CCodeCompletionBuilder | A builder class used to construct new code-completion strings |
| CCodeCompletionContext | The context in which code completion occurred, so that the code-completion consumer can process the results accordingly |
| CCodeCompletionHandler | Callback handler that receives notifications when performing code completion within the preprocessor |
| CCodeCompletionResult | Captures a result of code completion |
| ►CCodeCompletionString | A "string" used to describe how code completion can be performed for an entity |
| CChunk | One piece of the code completion string |
| CCodeCompletionTUInfo | |
| CCodeGenAction | |
| CCodeGenerator | The primary public interface to the Clang code generator |
| ►CCodeGenOptions | CodeGenOptions - Track various options which control how the code is optimized and passed to the backend |
| CBitcodeFileToLink | |
| COptRemark | Optimization remark with an optional regular expression pattern |
| CCodeGenOptionsBase | Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure that this large collection of bitfields is a trivial class type |
| CCodeInjector | CodeInjector is an interface which is responsible for injecting AST of function definitions that may not be available in the original source |
| CColonProtectionRAIIObject | ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed |
| CColorScope | |
| CCommentHandler | Abstract base class that describes a handler that will receive source ranges for each of the comments encountered in the source file |
| CCommentOptions | Options for controlling comment parsing |
| CComparisonCategories | |
| ►CComparisonCategoryInfo | |
| CValueInfo | |
| CCompilerInstance | CompilerInstance - Helper class for managing a single instance of the Clang compiler |
| CCompilerInvocation | Helper class for holding the data necessary to invoke the compiler |
| ►CCompilerInvocationBase | The base class of CompilerInvocation |
| CEmptyConstructor | Dummy tag type whose instance can be passed into the constructor to prevent creation of the reference-counted option objects |
| CComplexType | Complex values, per C99 6.2.5p11 |
| CComplexTypeLoc | |
| CCompoundAssignOperator | CompoundAssignOperator - For compound assignments (e.g |
| CCompoundLiteralExpr | CompoundLiteralExpr - [C99 6.5.2.5] |
| CCompoundStmt | CompoundStmt - This represents a group of statements like { stmt stmt } |
| CCompressedOffloadBundle | |
| CConceptDecl | Declaration of a C++20 concept |
| CConceptReference | A reference to a concept and its template args, as it appears in the code |
| CConceptSpecializationExpr | Represents the specialization of a concept - evaluates to a prvalue of type bool |
| ►CConcreteTypeLoc | A metaprogramming base class for TypeLoc classes which correspond to a particular Type subclass |
| CHasNoInnerType | |
| CConditionalOperator | ConditionalOperator - The ?: ternary operator |
| CConstantArrayType | Represents the canonical version of C arrays with a specified constant size |
| CConstantArrayTypeLoc | |
| CConstantExpr | ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluating the expression |
| CConstantMatrixType | Represents a concrete matrix type with constant number of rows and columns |
| CConstantMatrixTypeLoc | |
| CConstAttrVisitor | A simple visitor class that helps create attribute visitors |
| CConstDeclVisitor | A simple visitor class that helps create declaration visitors |
| CConstEvaluatedExprVisitor | ConstEvaluatedExprVisitor - This class visits 'const Expr *'s |
| CConstOMPClauseVisitor | |
| CConstraintSatisfaction | The result of a constraint satisfaction check, containing the necessary information to diagnose an unsatisfied constraint |
| CConstructionContext | ConstructionContext's subclasses describe different ways of constructing an object in C++ |
| CConstructionContextItem | Represents a single point (AST node) in the program that requires attention during construction of an object |
| CConstructionContextLayer | Construction context can be seen as a linked list of multiple layers |
| CConstructorInfo | |
| CConstructorInitializerConstructionContext | |
| CConstructorUsingShadowDecl | Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that names a constructor |
| CConstStmtIterator | |
| CConstStmtVisitor | ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses |
| CConstTemplateArgumentVisitor | A simple visitor class that helps create template argument visitors |
| CContinueStmt | ContinueStmt - This represents a continue |
| ►CContinuousRangeMap | A map from continuous integer ranges to some value, with a very specialized interface |
| CBuilder | An object that helps properly build a continuous range map from a set of values |
| CControlDependencyCalculator | |
| CConversionFixItGenerator | The class facilities generation and storage of conversion FixIts |
| CConvertVectorExpr | ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for converting a vector type to another vector type of the same arity |
| CCopiedTypeVisitor | |
| CCoreturnStmt | Represents a 'co_return' statement in the C++ Coroutines TS |
| ►CCoroutineBodyStmt | Represents the body of a coroutine |
| CCtorArgs | |
| CCoroutineStmtBuilder | |
| CCoroutineSuspendExpr | Represents an expression that might suspend coroutine execution; either a co_await or co_yield expression |
| CCorrectionCandidateCallback | Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo correction |
| CCoverageSourceInfo | Stores additional source code information like skipped ranges which is required by the coverage mapping generator and is obtained from the preprocessor |
| CCowCompilerInvocation | Same as CompilerInvocation, but with copy-on-write optimization |
| CCoyieldExpr | Represents a 'co_yield' expression |
| CCreateInvocationOptions | Optional inputs to createInvocation |
| CCStyleCastExpr | CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr |
| CCUDAKernelCallExpr | Represents a call to a CUDA kernel function |
| CCudaVersionMapEntry | |
| ►CCurrentSourceLocExprScope | Represents the current source location and context used to determine the value of the source location builtins (ex |
| CSourceLocExprScopeGuard | |
| CCustomizableOptional | |
| CCXX17ElidedCopyConstructorInitializerConstructionContext | Represents construction into a field or a base class within a bigger object via a constructor initializer, with a single constructor, eg |
| CCXX17ElidedCopyReturnedValueConstructionContext | Represents a temporary object that is being immediately returned from a function by value, eg |
| CCXX17ElidedCopyVariableConstructionContext | Represents construction into a simple variable with an initializer syntax, with a single constructor, eg |
| ►CCXXABI | Implements C++ ABI-specific semantic analysis functions |
| CMemberPointerInfo | |
| CCXXAddrspaceCastExpr | A C++ addrspace_cast expression (currently only enabled for OpenCL) |
| CCXXBasePath | Represents a path from a specific derived class (which is not represented as part of the path) to a particular (direct or indirect) base class subobject |
| CCXXBasePathElement | Represents an element in a path from a derived class to a base class |
| CCXXBasePaths | BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases |
| CCXXBaseSpecifier | Represents a base class of a C++ class |
| CCXXBindTemporaryExpr | Represents binding an expression to a temporary |
| CCXXBoolLiteralExpr | A boolean literal, per ([C++ lex.bool] Boolean literals) |
| CCXXCatchStmt | CXXCatchStmt - This represents a C++ catch block |
| CCXXConstCastExpr | A C++ const_cast expression (C++ [expr.const.cast]) |
| CCXXConstructExpr | Represents a call to a C++ constructor |
| CCXXConstructorDecl | Represents a C++ constructor within a class |
| CCXXConversionDecl | Represents a C++ conversion function within a class |
| CCXXCtorInitializer | Represents a C++ base or member initializer |
| CCXXDeductionGuideDecl | Represents a C++ deduction guide declaration |
| CCXXDefaultArgExpr | A default argument (C++ [dcl.fct.default]) |
| CCXXDefaultInitExpr | A use of a default initializer in a constructor or in aggregate initialization |
| CCXXDeleteExpr | Represents a delete expression for memory deallocation and destructor calls, e.g |
| CCXXDependentScopeMemberExpr | Represents a C++ member access expression where the actual member referenced could not be resolved because the base expression or the member name was dependent |
| CCXXDestructorDecl | Represents a C++ destructor within a class |
| CCXXDynamicCastExpr | A C++ dynamic_cast expression (C++ [expr.dynamic.cast]) |
| CCXXFieldCollector | CXXFieldCollector - Used to keep track of CXXFieldDecls during parsing of C++ classes |
| CCXXFinalOverriderMap | A mapping from each virtual member function to its set of final overriders |
| CCXXFoldExpr | Represents a folding of a pack over an operator |
| CCXXForRangeStmt | CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (range-declarator : range-expression)' or 'for (init-statement range-declarator : range-expression)' |
| CCXXFunctionalCastExpr | Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]) |
| CCXXIndirectPrimaryBaseSet | A set of all the primary bases for a class |
| CCXXInheritedCtorInitExpr | Represents a call to an inherited base class constructor from an inheriting constructor |
| CCXXMemberCallExpr | Represents a call to a member function that may be written either with member call syntax (e.g., "obj.func()" or "objptr->func()") or with normal function-call syntax ("func()") within a member function that ends up calling a member function |
| CCXXMethodDecl | Represents a static or instance method of a struct/union/class |
| CCXXNamedCastExpr | Abstract class common to all of the C++ "named"/"keyword" casts |
| CCXXNewExpr | Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)" |
| CCXXNoexceptExpr | Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]) |
| CCXXNullPtrLiteralExpr | The null pointer literal (C++11 [lex.nullptr]) |
| CCXXOperatorCallExpr | A call to an overloaded operator written using operator syntax |
| CCXXParenListInitExpr | Represents a list-initialization with parenthesis |
| CCXXPseudoDestructorExpr | Represents a C++ pseudo-destructor (C++ [expr.pseudo]) |
| ►CCXXRecordDecl | Represents a C++ struct/union/class |
| Cfriend_iterator | An iterator over the friend declarations of a class |
| CLambdaNumbering | Information about how a lambda is numbered within its context |
| CCXXReinterpretCastExpr | A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]) |
| ►CCXXRewrittenBinaryOperator | A rewritten comparison expression that was originally written using operator syntax |
| CDecomposedForm | |
| CCXXScalarValueInitExpr | An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type |
| CCXXScopeSpec | Represents a C++ nested-name-specifier or a global scope specifier |
| CCXXStaticCastExpr | A C++ static_cast expression (C++ [expr.static.cast]) |
| CCXXStdInitializerListExpr | Implicit construction of a std::initializer_list<T> object from an array temporary within list-initialization (C++11 [dcl.init.list]p5) |
| CCXXTemporary | Represents a C++ temporary |
| CCXXTemporaryObjectExpr | Represents a C++ functional cast expression that builds a temporary object |
| CCXXThisExpr | Represents the this expression in C++ |
| CCXXThrowExpr | A C++ throw-expression (C++ [except.throw]) |
| CCXXTryStmt | CXXTryStmt - A C++ try block, including all handlers |
| CCXXTypeidExpr | A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplied type, or the (possibly dynamic) type of the supplied expression |
| CCXXUnresolvedConstructExpr | Describes an explicit type conversion that uses functional notion but could not be resolved because one or more arguments are type-dependent |
| CCXXUuidofExpr | A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or expression |
| ►CDarwinSDKInfo | The information about the darwin SDK that was used during this compilation |
| COSEnvPair | A value that describes two os-environment pairs that can be used as a key to the version map in the SDK |
| CRelatedTargetVersionMapping | Represents a version mapping that maps from a version of one target to a version of a related target |
| CDataflowValues | DataflowValues. Container class to store dataflow values for a CFG |
| CDataflowWorklistBase | A worklist implementation where the enqueued blocks will be dequeued based on the order defined by 'Comp' |
| CDecayedType | Represents a pointer type decayed from an array or function type |
| CDecayedTypeLoc | Wrapper for source info for pointers decayed from arrays and functions |
| ►CDecl | Decl - This represents one declaration (or definition), e.g |
| CEmptyShell | A placeholder type used to construct an empty shell of a decl-derived type that will be filled in later (e.g., by some deserialization method) |
| Credecl_iterator | Iterates through all the redeclarations of the same decl |
| CDeclAccessPair | A POD class for pairing a NamedDecl* with an access specifier |
| CDeclarationName | The name of a declaration |
| CDeclarationNameInfo | DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the corresponding source/type location info |
| CDeclarationNameLoc | DeclarationNameLoc - Additional source/type location info for a declaration name |
| CDeclarationNameTable | DeclarationNameTable is used to store and retrieve DeclarationName instances for the various kinds of declaration names, e.g., normal identifiers, C++ constructor names, etc |
| CDeclarator | Information about one declarator, including the parsed type information and the identifier |
| ►CDeclaratorChunk | One instance of this struct is used for each type in a declarator that is parsed |
| CArrayTypeInfo | |
| CBlockPointerTypeInfo | |
| CFunctionTypeInfo | |
| CMemberPointerTypeInfo | |
| CParamInfo | ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed |
| CPipeTypeInfo | |
| CPointerTypeInfo | |
| CReferenceTypeInfo | |
| CTypeAndRange | |
| CDeclaratorDecl | Represents a ValueDecl that came out of a declarator |
| ►CDeclContext | DeclContext - This is used only as base class of specific decl types that can act as declaration contexts |
| Call_lookups_iterator | All_lookups_iterator - An iterator that provides a view over the results of looking up every possible name |
| Cddiag_iterator | An iterator over the dependent diagnostics in a dependent context |
| Cdecl_iterator | Decl_iterator - Iterates through the declarations stored within this context |
| Cfiltered_decl_iterator | Iterates over a filtered subrange of declarations stored in a DeclContext |
| Cspecific_decl_iterator | Specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it) |
| Cudir_iterator | |
| CDeclContextLookupResult | The results of name lookup within a DeclContext |
| CDeclFilterCCC | Simple template class for restricting typo correction candidates to ones having a single Decl* of the given type |
| CDeclGroup | |
| CDeclGroupRef | |
| ►CDeclListNode | A list storing NamedDecls in the lookup tables |
| Citerator | |
| CDeclOrStmtAttr | |
| CDeclRefExpr | A reference to a declared variable, function, enum, etc |
| CDeclSpec | Captures information about "declaration specifiers" |
| CDeclStmt | DeclStmt - Adaptor class for mixing declarations with statements and expressions |
| CDecltypeType | Represents the type decltype(expr) (C++11) |
| CDecltypeTypeLoc | |
| CDecltypeTypeLocInfo | |
| CDeclVisitor | A simple visitor class that helps create declaration visitors |
| CDecompositionDecl | A decomposition declaration |
| ►CDecompositionDeclarator | A parsed C++17 decomposition declarator of the form '[' identifier-list ']' |
| CBinding | |
| CDeducedPack | A pack that we're currently deducing |
| CDeducedTemplateArgument | Captures a template argument whose value has been deduced via c++ template argument deduction |
| CDeducedTemplateSpecializationType | Represents a C++17 deduced template specialization type |
| CDeducedTemplateSpecializationTypeLoc | |
| CDeducedType | Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced class template types, and constrained type names |
| CDeducedTypeLoc | |
| CDeductionFailureInfo | A structure used to record information about a failed template argument deduction, for diagnosis |
| CDefaultArgStorage | Storage for a default argument |
| CDefaultFilterCCC | |
| CDefaultInitializedTypeVisitor | |
| CDefaultStmt | |
| CDefMacroDirective | A directive for a defined macro or a macro imported from a module |
| CDeltaTree | DeltaTree - a multiway search tree (BTree) structure with some fancy features |
| CDependence | |
| CDependencyCollector | An interface for collecting the dependencies of a compilation |
| CDependencyFileGenerator | Builds a dependency file when attached to a Preprocessor (for includes) and ASTReader (for module imports), and writes it out at the end of processing a source file |
| CDependencyOutputOptions | DependencyOutputOptions - Options for controlling the compiler dependency file generation |
| CDependentAddressSpaceLocInfo | |
| CDependentAddressSpaceType | Represents an extended address space qualifier where the input address space value is dependent |
| CDependentAddressSpaceTypeLoc | |
| CDependentBitIntType | |
| CDependentBitIntTypeLoc | |
| CDependentCoawaitExpr | Represents a 'co_await' expression while the type of the promise is dependent |
| CDependentDecltypeType | Internal representation of canonical, dependent decltype(expr) types |
| CDependentDiagnostic | A dependently-generated diagnostic |
| CDependentFunctionTemplateSpecializationInfo | Provides information about a dependent function-template specialization declaration |
| CDependentNameLocInfo | |
| CDependentNameType | Represents a qualified type name for which the type name is dependent |
| CDependentNameTypeLoc | |
| CDependentScopeDeclRefExpr | A qualified reference to a name whose declaration cannot yet be resolved |
| CDependentSizedArrayType | Represents an array type in C++ whose size is a value-dependent expression |
| CDependentSizedArrayTypeLoc | |
| CDependentSizedExtVectorType | Represents an extended vector type where either the type or size is dependent |
| CDependentSizedExtVectorTypeLoc | |
| CDependentSizedMatrixType | Represents a matrix type where the type and the number of rows and columns is dependent on a template |
| CDependentSizedMatrixTypeLoc | |
| CDependentStoredDeclsMap | |
| CDependentTemplateName | Represents a dependent template name that cannot be resolved prior to template instantiation |
| CDependentTemplateSpecializationLocInfo | |
| CDependentTemplateSpecializationType | Represents a template specialization type whose template cannot be resolved, e.g |
| CDependentTemplateSpecializationTypeLoc | |
| CDependentTypeOfExprType | Internal representation of canonical, dependent typeof(expr) types |
| CDependentUnaryTransformType | Internal representation of canonical, dependent __underlying_type(type) types |
| CDependentVectorType | Represents a vector type where either the type or size is dependent |
| CDependentVectorTypeLoc | |
| ►CDesignatedInitExpr | Represents a C99 designated initializer expression |
| CDesignator | Represents a single C99 designator |
| CDesignatedInitUpdateExpr | |
| CDesignation | Designation - Represent a full designation, which is a sequence of designators |
| CDesignator | Designator - A designator in a C99 designated initializer |
| CDestructedTypeVisitor | |
| CDiagnostic | A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) that allows clients to enquire about the currently in-flight diagnostic |
| CDiagnosticBuilder | A little helper class used to produce diagnostics |
| CDiagnosticConsumer | Abstract interface, implemented by clients of the front-end, which formats and prints fully processed diagnostics |
| CDiagnosticError | Carries a Clang diagnostic in an llvm::Error |
| CDiagnosticErrorTrap | RAII class that determines when any errors have occurred between the time the instance was created and the time it was queried |
| CDiagnosticIDs | Used for handling and querying diagnostic IDs |
| CDiagnosticMapping | |
| CDiagnosticNoteRenderer | Subclass of DiagnosticRender that turns all subdiagostics into explicit notes |
| CDiagnosticOptions | Options for controlling the compiler diagnostics engine |
| CDiagnosticRenderer | Class to encapsulate the logic for formatting a diagnostic message |
| CDiagnosticsEngine | Concrete class used by the front-end to report problems and issues |
| CDiagnosticStorage | |
| CDirectoryEntry | Cached information about one directory (either on disk or in the virtual file system) |
| CDirectoryEntryRef | A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the FileManager's client |
| CDirectoryLookup | DirectoryLookup - This class represents one entry in the search list that specifies the search order for directories in #include directives |
| ►CDirectoryWatcher | Provides notifications for file changes in a directory |
| CEvent | |
| CDoStmt | DoStmt - This represents a 'do/while' stmt |
| CDumpCompilerOptionsAction | |
| CDumpModuleInfoAction | Dump information about the given module file, to be used for basic debugging and discovery |
| CDumpRawTokensAction | |
| CDumpTokensAction | |
| CDynamicAllocLValue | Symbolic representation of a dynamic allocation |
| ►CDynTypedNode | A dynamically typed AST node container |
| CBaseConverter< ConceptReference, void > | |
| CBaseConverter< CXXBaseSpecifier, void > | |
| CBaseConverter< CXXCtorInitializer, void > | |
| CBaseConverter< LambdaCapture, void > | |
| CBaseConverter< NestedNameSpecifier, void > | |
| CBaseConverter< NestedNameSpecifierLoc, void > | |
| CBaseConverter< ObjCProtocolLoc, void > | |
| CBaseConverter< QualType, void > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< Attr, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< Decl, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< OMPClause, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< Stmt, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< Type, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< TypeLoc, T >::value > > | |
| CBaseConverter< TemplateArgument, void > | |
| CBaseConverter< TemplateArgumentLoc, void > | |
| CBaseConverter< TemplateName, void > | |
| CDenseMapInfo | Hooks for using DynTypedNode as a key in a DenseMap |
| CDynTypedNodeList | Container for either a single DynTypedNode or for an ArrayRef to DynTypedNode |
| CElaboratedLocInfo | |
| CElaboratedType | Represents a type that was referred to using an elaborated type keyword, e.g., struct S, or via a qualified name, e.g., N::M::type, or both |
| CElaboratedTypeLoc | |
| CElidedTemporaryObjectConstructionContext | Represents a temporary object that is constructed for the sole purpose of being immediately copied by an elidable copy/move constructor |
| CEmitAssemblyAction | |
| CEmitBCAction | |
| CEmitCodeGenOnlyAction | |
| CEmitLLVMAction | |
| CEmitLLVMOnlyAction | |
| CEmitObjAction | |
| CEmptyDecl | Represents an empty-declaration |
| CEmptylineHandler | Abstract base class that describes a handler that will receive source ranges for empty lines encountered in the source file |
| CEmptyPragmaHandler | EmptyPragmaHandler - A pragma handler which takes no action, which can be used to ignore particular pragmas |
| CEnterExpressionEvaluationContext | RAII object that enters a new expression evaluation context |
| CEnumConstantDecl | An instance of this object exists for each enum constant that is defined |
| CEnumDecl | Represents an enum |
| CEnumType | A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums |
| CEnumTypeLoc | Wrapper for source info for enum types |
| CEpsilonPoint | This is a meta program point, which should be skipped by all the diagnostic reasoning etc |
| CEvaluatedExprVisitor | EvaluatedExprVisitor - This class visits 'Expr *'s |
| CEvaluatedExprVisitorBase | Given a potentially-evaluated expression, this visitor visits all of its potentially-evaluated subexpressions, recursively |
| CEvaluatedStmt | Structure used to store a statement, the constant value to which it was evaluated (if any), and whether or not the statement is an integral constant expression (if known) |
| CExplicitCastExpr | ExplicitCastExpr - An explicit cast written in the source code |
| CExplicitSpecifier | Store information needed for an explicit specifier |
| CExportDecl | Represents a standard C++ module export declaration |
| ►CExpr | This represents one expression |
| CClassification | The return type of classify() |
| CEvalResult | EvalResult is a struct with detailed info about an evaluated expression |
| CEvalStatus | EvalStatus is a struct with detailed info about an evaluation in progress |
| CExprDependenceScope | |
| CExpressionTraitExpr | An expression trait intrinsic |
| CExprMutationAnalyzer | Analyzes whether any mutative operations are applied to an expression within a given statement |
| CExprWithCleanups | Represents an expression – generally a full-expression – that introduces cleanups to be run at the end of the sub-expression's evaluation |
| CExtensionRAIIObject | ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them |
| ►CExternalASTMerger | ExternalASTSource implementation that merges information from several ASTContexts |
| CDCOrigin | A single origin for a DeclContext |
| CImporterSource | A source for an ExternalASTMerger |
| CImporterTarget | The target for an ExternalASTMerger |
| ►CExternalASTSource | Abstract interface for external sources of AST nodes |
| CDeserializing | RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing |
| CMemoryBufferSizes | |
| CExternalHeaderFileInfoSource | An external source of header file information, which may supply information about header files already included |
| CExternalPreprocessingRecordSource | An abstract class that should be subclassed by any external source of preprocessing record entries |
| CExternalPreprocessorSource | Abstract interface for external sources of preprocessor information |
| CExternalSemaSource | An abstract interface that should be implemented by external AST sources that also provide information for semantic analysis |
| CExternalSLocEntrySource | External source of source location entries |
| CExternalSource | |
| CExternalVTableUse | A simple structure that captures a vtable use for the purposes of the ExternalSemaSource |
| CExternCContextDecl | Declaration context for names declared as extern "C" in C++ |
| CExtQuals | We can encode up to four bits in the low bits of a type pointer, but there are many more type qualifiers that we want to be able to apply to an arbitrary type |
| CExtQualsTypeCommonBase | Base class that is common to both the ExtQuals and Type classes, which allows QualType to access the common fields between the two |
| CExtractAPIAction | ExtractAPIAction sets up the output file and creates the ExtractAPIVisitor |
| CExtractAPIActionBase | Base class to be used by front end actions to generate ExtarctAPI info |
| CExtVectorElementExpr | ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the left hand side or right hand side |
| CExtVectorType | ExtVectorType - Extended vector type |
| CExtVectorTypeLoc | |
| CFieldDecl | Represents a member of a struct/union/class |
| CFieldDeclarator | This little struct is used to capture information about structure field declarators, which is basically just a bitfield size |
| CFileEntry | Cached information about one file (either on disk or in the virtual file system) |
| ►CFileEntryRef | A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's client |
| CMapValue | Type stored in the StringMap |
| CFileID | An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with its #include path and #line data |
| CFileManager | Implements support for file system lookup, file system caching, and directory search management |
| CFilenamePatternConstraint | |
| CFileNullability | Describes whether we've seen any nullability information for the given file |
| CFileNullabilityMap | A mapping from file IDs to a record of whether we've seen nullability information in that file |
| CFileScopeAsmDecl | |
| CFileSystemOptions | Keeps track of options that affect how file operations are performed |
| CFileSystemStatCache | Abstract interface for introducing a FileManager cache for 'stat' system calls, which is used by precompiled and pretokenized headers to improve performance |
| CFixedPointLiteral | |
| CFixedSizeTemplateParameterListStorage | Stores a list of template parameters and the associated requires-clause (if any) for a TemplateDecl and its derived classes |
| CFixItAction | |
| CFixItHint | Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the problem |
| CFixItOptions | |
| CFixItRecompile | Emits changes to temporary files and uses them for the original frontend action |
| CFixItRewriter | |
| CFloatingLiteral | |
| CForStmt | ForStmt - This represents a 'for (init;cond;inc)' stmt |
| CForwardDataflowWorklist | A worklist implementation for forward dataflow analysis |
| CForwardingDiagnosticConsumer | Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic consumer |
| CFPOptions | |
| CFPOptionsOverride | Represents difference between two FPOptions values |
| CFrameworkCacheEntry | This structure is used to record entries in our framework cache |
| CFriendDecl | FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type |
| CFriendTemplateDecl | Declaration of a friend template |
| CFrontendAction | Abstract base class for actions which can be performed by the frontend |
| CFrontendInputFile | An input file for the front end |
| CFrontendOptions | FrontendOptions - Options for controlling the behavior of the frontend |
| CFullExpr | FullExpr - Represents a "full-expression" node |
| ►CFullSourceLoc | A SourceLocation and its associated SourceManager |
| CBeforeThanCompare | Comparison function class, useful for sorting FullSourceLocs |
| CFunctionCallFilterCCC | |
| ►CFunctionDecl | Represents a function declaration or definition |
| CDefaultedFunctionInfo | Stashed information about a defaulted function definition whose body has not yet been lazily generated |
| CFunctionExitPoint | |
| CFunctionLocInfo | |
| CFunctionNoProtoType | Represents a K&R-style 'int foo()' function, which has no information available about its arguments |
| CFunctionNoProtoTypeLoc | |
| CFunctionParmMutationAnalyzer | |
| CFunctionParmPackExpr | Represents a reference to a function parameter pack or init-capture pack that has been substituted but not yet expanded |
| ►CFunctionProtoType | Represents a prototype with parameter type info, e.g |
| CExceptionSpecInfo | Holds information about the various types of exception specification |
| CExtProtoInfo | Extra information about a function prototype |
| CFunctionProtoTypeLoc | |
| ►CFunctionTemplateDecl | Declaration of a template function |
| CCommon | Data that is common to all of the declarations of a given function template |
| CFunctionTemplateSpecializationInfo | Provides information about a function template specialization, which is a FunctionDecl that has been explicitly specialization or instantiated from a function template |
| ►CFunctionType | FunctionType - C99 6.7.5.3 - Function Declarators |
| CExceptionType | A simple holder for a QualType representing a type in an exception specification |
| CExtInfo | A class which abstracts out some details necessary for making a call |
| CExtParameterInfo | Interesting information about a specific parameter that can't simply be reflected in parameter's type |
| CFunctionTypeExtraBitfields | A simple holder for various uncommon bits which do not fit in FunctionTypeBitfields |
| CFunctionTypeLoc | Wrapper for source info for functions |
| ►CGCCAsmStmt | This represents a GCC inline-assembly statement extension |
| CAsmStringPiece | AsmStringPiece - this is part of a decomposed asm string specification (for use with the AnalyzeAsmString function below) |
| CGenerateHeaderUnitAction | |
| CGenerateInterfaceStubsAction | |
| CGenerateModuleAction | |
| CGenerateModuleFromModuleMapAction | |
| CGenerateModuleInterfaceAction | |
| CGeneratePCHAction | |
| CGenericSelectionExpr | Represents a C11 generic selection |
| CGetDependenciesByModuleNameAction | |
| CGlobalCodeCompletionAllocator | Allocator for a cached set of global code completions |
| CGlobalDecl | GlobalDecl - represents a global declaration |
| CGlobalModuleIndex | A global index for a set of module files, providing information about the identifiers within those module files |
| CGNUNullExpr | GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that has integral type (e.g., int or long) and is the same size and alignment as a pointer |
| CGotoStmt | GotoStmt - This represents a direct goto |
| CGreaterThanIsOperatorScope | RAII object that makes '>' behave either as an operator or as the closing angle bracket for a template argument list |
| CHeaderDesc | |
| CHeaderFileInfo | The preprocessor keeps track of this information for each file that is #included |
| CHeaderMap | This class represents an Apple concept known as a 'header map' |
| CHeaderMapImpl | Implementation for HeaderMap that doesn't depend on FileManager |
| CHeaderSearch | Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc |
| ►CHeaderSearchOptions | HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSearch object |
| CEntry | |
| CSystemHeaderPrefix | |
| CHLSLAnnotationAttr | |
| CHLSLBufferDecl | HLSLBufferDecl - Represent a cbuffer or tbuffer declaration |
| CHLSLExternalSemaSource | |
| CHMapBucket | |
| CHMapHeader | |
| CHTMLPrintAction | |
| CIdentifierInfo | One of these records is kept for each identifier that is lexed |
| CIdentifierInfoLookup | Provides lookups to, and iteration over, IdentiferInfo objects |
| CIdentifierIterator | An iterator that walks over all of the known identifiers in the lookup table |
| CIdentifierLoc | Wraps an identifier and optional source location for the identifier |
| ►CIdentifierResolver | IdentifierResolver - Keeps track of shadowed decls on enclosing scopes |
| CIdDeclInfoMap | IdDeclInfoMap - Associates IdDeclInfos with declaration names |
| Citerator | Iterator - Iterate over the decls of a specified declaration name |
| CIdentifierTable | Implements an efficient mapping from strings to IdentifierInfo nodes |
| CIfStmt | IfStmt - This represents an if/then/else |
| CIgnoringDiagConsumer | A diagnostic client that ignores all diagnostics |
| CImaginaryLiteral | ImaginaryLiteral - We support imaginary integer and floating point literals, like "1.0i" |
| CImplicitCallPoint | Represents an implicit call event |
| CImplicitCastExpr | ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct representation in the original source code |
| CImplicitConceptSpecializationDecl | |
| CImplicitConversionSequence | ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conversion sequence (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2), or an ellipsis conversion sequence (C++ 13.3.3.1.3) |
| CImplicitParamDecl | |
| CImplicitValueInitExpr | Represents an implicitly-generated value initialization of an object of a given type |
| CImportDecl | Describes a module import declaration, which makes the contents of the named module visible in the current translation unit |
| CInBeforeInTUCacheEntry | Holds the cache used by isBeforeInTranslationUnit |
| CInclusionDirective | Record the location of an inclusion directive, such as an #include or #import statement |
| CIncompleteArrayType | Represents a C array with an unspecified size |
| CIncompleteArrayTypeLoc | |
| CIncrementalAction | A custom action enabling the incremental processing functionality |
| CIncrementalASTConsumer | |
| CIncrementalCompilerBuilder | Create a pre-configured CompilerInstance for incremental processing |
| CIncrementalCUDADeviceParser | |
| CIncrementalExecutor | |
| CIncrementalParser | Provides support for incremental compilation |
| CIncrementalSyntaxOnlyAction | |
| CIndirectFieldDecl | Represents a field injected from an anonymous union/struct into the parent scope |
| CIndirectGotoStmt | IndirectGotoStmt - This represents an indirect goto |
| CInheritableAttr | |
| CInheritableParamAttr | |
| CInheritedConstructor | Description of a constructor that was inherited from a base class |
| CInheritingConcreteTypeLoc | A metaprogramming class designed for concrete subtypes of abstract types where all subtypes share equivalently-structured source information |
| CInitializationKind | Describes the kind of initialization being performed, along with location information for tokens related to the initialization (equal sign, parentheses) |
| ►CInitializationSequence | Describes the sequence of initializations required to initialize a given object or reference with a set of arguments |
| ►CStep | A single step in the initialization sequence |
| CF | |
| CInitializedEntity | Describes an entity that is being initialized |
| CInitListExpr | Describes an C or C++ initializer list |
| CInitOnlyAction | |
| CInjectedClassNameType | The injected class name of a C++ class template or class template partial specialization |
| CInjectedClassNameTypeLoc | Wrapper for source info for injected class names of class templates |
| CInMemoryModuleCache | In-memory cache for modules |
| CInMessageExpressionRAIIObject | |
| CInputKind | The kind of a file that we've been handed as an input |
| CIntegerLiteral | |
| CInterpreter | Provides top-level interfaces for incremental compilation and execution |
| CInventedTemplateParameterInfo | |
| CIsResultPtrLowBitFree | |
| CIsResultPtrLowBitFree< CXXBaseSpecifier * > | |
| CIsResultPtrLowBitFree< CXXCtorInitializer * > | |
| CIsResultPtrLowBitFree< Expr * > | |
| CIsResultPtrLowBitFree< Stmt * > | |
| CItaniumMangleContext | |
| CItaniumVTableContext | |
| CJSONDumper | |
| CJSONNodeDumper | |
| CLabelDecl | Represents the declaration of a label |
| CLabelStmt | LabelStmt - Represents a label, which has a substatement |
| CLambdaCapture | Describes the capture of a variable or of this, or of a C++1y init-capture |
| CLambdaCaptureConstructionContext | |
| CLambdaExpr | A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked later |
| ►CLambdaIntroducer | Represents a complete lambda introducer |
| CLambdaCapture | An individual capture in a lambda introducer |
| CLangOptions | Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that is accepted |
| CLangOptionsBase | Bitfields of LangOptions, split out from LangOptions in order to ensure that this large collection of bitfields is a trivial class type |
| CLangStandard | LangStandard - Information about the properties of a particular language standard |
| CLateParsedTemplate | Contains a late templated function |
| CLayoutOverrideSource | An external AST source that overrides the layout of a specified set of record types |
| CLazyASTUnresolvedSet | An UnresolvedSet-like class that might not have been loaded from the external AST source yet |
| CLazyDetector | Simple wrapper for toolchain detector with costly initialization |
| ►CLazyGenerationalUpdatePtr | A lazy value (of type T) that is within an AST node of type Owner, where the value might change in later generations of the external AST source |
| CLazyData | A cache of the value of this pointer, in the most recent generation in which we queried it |
| CLazyOffsetPtr | A lazy pointer to an AST node (of base type T) that resides within an external AST source |
| ►CLazyVector | Represents a lazily-loaded vector of data |
| Citerator | Iteration over the elements in the vector |
| ►CLexer | Lexer - This provides a simple interface that turns a text buffer into a stream of tokens |
| CSizedChar | Represents a char and the number of bytes parsed to produce it |
| CLexicallyOrderedRecursiveASTVisitor | A RecursiveASTVisitor subclass that guarantees that AST traversal is performed in a lexical order (i.e |
| CLifetimeExtendedTemporaryDecl | Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-extended by a declaration |
| CLineEntry | |
| CLineTableInfo | Used to hold and unique data used to represent #line information |
| CLinkageComputer | |
| CLinkageInfo | |
| CLinkageSpecDecl | Represents a linkage specification |
| ►CLiveVariables | |
| CLivenessValues | |
| CObserver | |
| CLocalInstantiationScope | A stack-allocated class that identifies which local variable declaration instantiations are present in this scope |
| CLocationCheck | |
| CLocationContext | It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext and inside the function calls the BlockInvocationContext |
| CLocationContextManager | |
| CLocInfoType | Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing |
| CLogDiagnosticPrinter | |
| ►CLookupResult | Represents the results of name lookup |
| CFilter | A class for iterating through a result set and possibly filtering out results |
| CLoopExit | Represents a point when we exit a loop |
| CLoopHint | Loop optimization hint for loop and unroll pragmas |
| CLValueReferenceType | An lvalue reference type, per C++11 [dcl.ref] |
| CLValueReferenceTypeLoc | |
| CLVComputationKind | Kinds of LV computation |
| CMacroArgs | MacroArgs - An instance of this class captures information about the formal arguments specified to a function-like macro invocation |
| CMacroBuilder | |
| CMacroDefinition | A description of the current definition of a macro |
| CMacroDefinitionRecord | Record the location of a macro definition |
| ►CMacroDirective | Encapsulates changes to the "macros namespace" (the location where the macro name became active, the location where it was undefined, etc.) |
| CDefInfo | |
| CMacroExpansion | Records the location of a macro expansion |
| CMacroExpansionContext | MacroExpansionContext tracks the macro expansions processed by the Preprocessor |
| CMacroInfo | Encapsulates the data about a macro definition (e.g |
| CMacroPPCallbacks | |
| CMacroQualifiedLocInfo | |
| CMacroQualifiedType | Sugar type that represents a type that was qualified by a qualifier written as a macro invocation |
| CMacroQualifiedTypeLoc | |
| CManagedAnalysis | The base class of a hierarchy of objects representing analyses tied to AnalysisDeclContext |
| CMangleContext | MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangler |
| CMangleNumberingContext | Keeps track of the mangled names of lambda expressions and block literals within a particular context |
| CMatchingVariablePatternConstraint | Ensures that all clones reference variables in the same pattern |
| CMaterializeTemporaryExpr | Represents a prvalue temporary that is written into memory so that a reference can bind to it |
| CMatrixSubscriptExpr | MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension |
| CMatrixType | Represents a matrix type, as defined in the Matrix Types clang extensions |
| CMatrixTypeLoc | |
| CMatrixTypeLocInfo | |
| CMemberExpr | MemberExpr - [C99 6.5.2.3] Structure and Union Members |
| CMemberExprNameQualifier | Extra data stored in some MemberExpr objects |
| CMemberPointerLocInfo | |
| CMemberPointerType | A pointer to member type per C++ 8.3.3 - Pointers to members |
| CMemberPointerTypeLoc | Wrapper for source info for member pointers |
| CMemberSpecializationInfo | Provides information a specialization of a member of a class template, which may be a member function, static data member, member class or member enumeration |
| CMemorizeStatCalls | A stat "cache" that can be used by FileManager to keep track of the results of stat() calls that occur throughout the execution of the front end |
| CMergeable | Provides common interface for the Decls that cannot be redeclared, but can be merged if the same declaration is brought in from multiple modules |
| CMethodVFTableLocation | |
| CMicrosoftMangleContext | |
| CMicrosoftVTableContext | |
| CMigratorOptions | |
| CMinComplexityConstraint | Ensures that every clone has at least the given complexity |
| CMinGroupSizeConstraint | Ensures that all clone groups contain at least the given amount of clones |
| CMMToken | A token in a module map file |
| ►CModule | Describes a module or submodule |
| CConflict | A conflict between two modules |
| CDirectoryName | Information about a directory name as found in the module map file |
| CHeader | Information about a header directive as found in the module map file |
| CLinkLibrary | A library or framework to link against when an entity from this module is used |
| CUnresolvedConflict | An unresolved conflict with another module |
| CUnresolvedExportDecl | Describes an exported module that has not yet been resolved (perhaps because the module it refers to has not yet been loaded) |
| CUnresolvedHeaderDirective | Stored information about a header directive that was found in the module map file but has not been resolved to a file |
| CModuleDependencyCollector | Collects the dependencies for imported modules into a directory |
| CModuleFileExtension | An abstract superclass that describes a custom extension to the module/precompiled header file format |
| CModuleFileExtensionMetadata | Metadata for a module file extension |
| CModuleFileExtensionReader | Abstract base class that reads a module file extension block from a module file |
| CModuleFileExtensionWriter | Abstract base class that writes a module file extension block into a module file |
| CModuleLoader | Abstract interface for a module loader |
| CModuleLoadResult | Describes the result of attempting to load a module |
| CModuleMacro | Represents a macro directive exported by a module |
| ►CModuleMap | |
| CKnownHeader | A header that is known to reside within a given module, whether it was included or excluded |
| CModuleMapCallbacks | A mechanism to observe the actions of the module map parser as it reads module map files |
| CModuleMapParser | |
| CMSAsmStmt | This represents a Microsoft inline-assembly statement extension |
| CMSDependentExistsStmt | Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name |
| CMSGuidDecl | A global _GUID constant |
| CMSGuidDeclParts | Parts of a decomposed MSGuidDecl |
| CMSPropertyDecl | An instance of this class represents the declaration of a property member |
| CMSPropertyRefExpr | A member reference to an MSPropertyDecl |
| CMSPropertySubscriptExpr | MS property subscript expression |
| CMultiKeywordSelector | One of these variable length records is kept for each selector containing more than one keyword |
| CMultiLevelTemplateArgumentList | Data structure that captures multiple levels of template argument lists for use in template instantiation |
| CMultipleIncludeOpt | Implements the simple state machine that the Lexer class uses to detect files subject to the 'multiple-include' optimization |
| CMultiplexASTDeserializationListener | |
| CMultiplexASTMutationListener | |
| CMultiplexConsumer | |
| CMultiplexExternalSemaSource | An abstract interface that should be implemented by external AST sources that also provide information for semantic analysis |
| CNamedDecl | This represents a decl that may have a name |
| CNamespaceAliasDecl | Represents a C++ namespace alias |
| CNamespaceDecl | Represent a C++ namespace |
| CNeonTypeFlags | Flags to identify the types for overloaded Neon builtins |
| CNestedNameSpecifier | Represents a C++ nested name specifier, such as "\::std::vector<int>::" |
| CNestedNameSpecifierLoc | A C++ nested-name-specifier augmented with source location information |
| CNestedNameSpecifierLocBuilder | Class that aids in the construction of nested-name-specifiers along with source-location information for all of the components of the nested-name-specifier |
| CNewAllocatedObjectConstructionContext | Represents immediate initialization of memory allocated by operator new, eg |
| CNodeStreamer | |
| CNoInitExpr | Represents a place-holder for an object not to be initialized by anything |
| CNonTypeTemplateParmDecl | NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in |
| CNormalizedConstraint | A normalized constraint, as defined in C++ [temp.constr.normal], is either an atomic constraint, a conjunction of normalized constraints or a disjunction of normalized constraints |
| CNoSanitizeList | |
| CNoTypoCorrectionCCC | |
| CNSAPI | |
| CNullStmt | NullStmt - This is the null statement ";": C99 6.8.3p3 |
| CNumericLiteralParser | NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber, classifying it as either integer, floating, or erroneous, determines the radix of the value and can convert it to a useful value |
| CObjCArrayLiteral | ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]]; |
| CObjCAtCatchStmt | Represents Objective-C's @catch statement |
| CObjCAtDefsFieldDecl | Represents a field declaration created by an @defs(...) |
| CObjCAtFinallyStmt | Represents Objective-C's @finally statement |
| CObjCAtSynchronizedStmt | Represents Objective-C's @synchronized statement |
| CObjCAtThrowStmt | Represents Objective-C's @throw statement |
| CObjCAtTryStmt | Represents Objective-C's @try ... @catch ... @finally statement |
| CObjCAutoreleasePoolStmt | Represents Objective-C's @autoreleasepool Statement |
| CObjCAvailabilityCheckExpr | A runtime availability query |
| CObjCBoolLiteralExpr | ObjCBoolLiteralExpr - Objective-C Boolean Literal |
| CObjCBoxedExpr | ObjCBoxedExpr - used for generalized expression boxing |
| CObjCBridgedCastExpr | An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process |
| CObjCCategoryDecl | ObjCCategoryDecl - Represents a category declaration |
| CObjCCategoryImplDecl | ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration |
| CObjCCompatibleAliasDecl | ObjCCompatibleAliasDecl - Represents alias of a class |
| CObjCContainerDecl | ObjCContainerDecl - Represents a container for method declarations |
| CObjCDeclSpec | Captures information about "declaration specifiers" specific to Objective-C |
| CObjCDictionaryElement | An element in an Objective-C dictionary literal |
| CObjCDictionaryLiteral | ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserName(), @"date" : [NSDate date] }; |
| CObjCDictionaryLiteral_ExpansionData | Internal struct to describes an element that is a pack expansion, used if any of the elements in the dictionary literal are pack expansions |
| CObjCDictionaryLiteral_KeyValuePair | Internal struct for storing Key/value pair |
| CObjCEncodeExpr | ObjCEncodeExpr, used for @encode in Objective-C |
| CObjCForCollectionStmt | Represents Objective-C's collection statement |
| CObjCImplDecl | |
| CObjCImplementationDecl | ObjCImplementationDecl - Represents a class definition - this is where method definitions are specified |
| CObjCIndirectCopyRestoreExpr | ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore in ARC |
| ►CObjCInterfaceDecl | Represents an ObjC class declaration |
| Cfiltered_category_iterator | Iterator that walks over the list of categories, filtering out those that do not meet specific criteria |
| CObjCInterfaceLocInfo | |
| CObjCInterfaceType | Interfaces are the core concept in Objective-C for object oriented design |
| CObjCInterfaceTypeLoc | Wrapper for source info for ObjC interfaces |
| CObjCIsaExpr | ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type |
| CObjCIvarDecl | ObjCIvarDecl - Represents an ObjC instance variable |
| CObjCIvarRefExpr | ObjCIvarRefExpr - A reference to an ObjC instance variable |
| CObjCList | ObjCList - This is a simple template class used to hold various lists of decls etc, which is heavily used by the ObjC front-end |
| CObjCListBase | |
| CObjCMessageExpr | An expression that sends a message to the given Objective-C object or class |
| ►CObjCMethodDecl | ObjCMethodDecl - Represents an instance or class method declaration |
| CGetTypeFn | |
| CObjCMethodList | Linked list of methods with the same selector name but different signatures |
| CObjCNoReturn | |
| CObjCObjectPointerType | Represents a pointer to an Objective C object |
| CObjCObjectPointerTypeLoc | Wraps an ObjCPointerType with source location information |
| CObjCObjectType | Represents a class type in Objective C |
| CObjCObjectTypeImpl | A class providing a concrete implementation of ObjCObjectType, so as to not increase the footprint of ObjCInterfaceType |
| CObjCObjectTypeLoc | |
| CObjCObjectTypeLocInfo | |
| CObjCPropertyDecl | Represents one property declaration in an Objective-C interface |
| CObjCPropertyImplDecl | ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category implementation block |
| CObjCPropertyRefExpr | ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property |
| CObjCProtocolDecl | Represents an Objective-C protocol declaration |
| CObjCProtocolExpr | ObjCProtocolExpr used for protocol expression in Objective-C |
| CObjCProtocolList | A list of Objective-C protocols, along with the source locations at which they were referenced |
| CObjCProtocolLoc | |
| CObjCProtocolQualifiers | This class wraps the list of protocol qualifiers |
| CObjCRuntime | The basic abstraction for the target Objective-C runtime |
| CObjCSelectorExpr | ObjCSelectorExpr used for @selector in Objective-C |
| CObjCStringLiteral | ObjCStringLiteral, used for Objective-C string literals i.e |
| CObjCSubscriptRefExpr | ObjCSubscriptRefExpr - used for array and dictionary subscripting |
| CObjCTypeParamDecl | Represents the declaration of an Objective-C type parameter |
| CObjCTypeParamList | Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereof |
| CObjCTypeParamType | Represents a type parameter type in Objective C |
| CObjCTypeParamTypeLoc | ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored after Info |
| CObjCTypeParamTypeLocInfo | |
| CObjectFilePCHContainerReader | A PCHContainerReader implementation that uses LLVM to wraps Clang modules inside a COFF, ELF, or Mach-O container |
| CObjectFilePCHContainerWriter | A PCHContainerWriter implementation that uses LLVM to wraps Clang modules inside a COFF, ELF, or Mach-O container |
| CODRDiagsEmitter | |
| CODRHash | |
| COffloadBundler | |
| COffloadBundlerConfig | |
| COffloadTargetInfo | Obtain the offload kind, real machine triple, and an optional TargetID out of the target information specified by the user |
| COffsetOfExpr | OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator) |
| COffsetOfNode | Helper class for OffsetOfExpr |
| COffsetOfStateRAIIObject | |
| COMPAcqRelClause | This represents 'acq_rel' clause in the '#pragma omp atomic|flush' directives |
| COMPAcquireClause | This represents 'acquire' clause in the '#pragma omp atomic|flush' directives |
| COMPAffinityClause | This represents clause 'affinity' in the '#pragma omp task'-based directives |
| |