clang 10.0.0git

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1 2 3 4 5 6]

►N clang | Dataflow Directional Tag Classes
►N analyze_format_string | Common components of both fprintf and fscanf format strings
C ArgType |
C ConversionSpecifier |
C FormatSpecifier |
C FormatStringHandler |
C LengthModifier | Represents the length modifier in a format string in scanf/printf
C OptionalAmount |
C OptionalFlag | Class representing optional flags with location and representation information
C SpecifierResult |
►N analyze_os_log |
C OSLogBufferItem | An OSLogBufferItem represents a single item in the data written by a call to os_log() or os_trace()
C OSLogBufferLayout |
►N analyze_printf | Pieces specific to fprintf format strings
C PrintfConversionSpecifier |
C PrintfSpecifier |
►N analyze_scanf | Pieces specific to fscanf format strings
C ScanfConversionSpecifier |
C ScanfSpecifier |
►N arcmt |
►N trans |
C ASTTraverser |
C BlockObjCVariableTraverser |
C BodyContext |
C BodyTransform |
C GCAttrsTraverser |
C GCCollectableCallsTraverser |
►C MigrationContext |
C GCAttrOccurrence |
C ObjCImplementationContext |
C PropertyRewriteTraverser |
C ProtectedScopeTraverser |
C CapturedDiagList |
C CheckAction |
C FileRemapper |
C MigrateAction |
C MigrateSourceAction |
C MigrationPass |
►C MigrationProcess |
C RewriteListener |
C ModifyAction |
C ObjCMigrateAction | Migrates to modern ObjC syntax
C Transaction |
►C TransformActions |
C RewriteReceiver |
►N ast_matchers |
►N dynamic |
►N internal |
C AdaptativeOverloadCollector | Helper class used to collect all the possible overloads of an argument adaptative matcher function
C ArgTypeTraits | Helper template class to just from argument type to the right is/get functions in VariantValue
C ArgTypeTraits< ast_matchers::internal::Matcher< T > > |
C ArgTypeTraits< attr::Kind > |
C ArgTypeTraits< bool > |
C ArgTypeTraits< CastKind > |
C ArgTypeTraits< const T & > |
C ArgTypeTraits< double > |
C ArgTypeTraits< OpenMPClauseKind > |
C ArgTypeTraits< std::string > |
C ArgTypeTraits< StringRef > |
C ArgTypeTraits< unsigned > |
C BuildReturnTypeVector |
C BuildReturnTypeVector< ast_matchers::internal::BindableMatcher< T > > |
C BuildReturnTypeVector< ast_matchers::internal::Matcher< T > > |
C DynCastAllOfMatcherDescriptor | Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers
C FixedArgCountMatcherDescriptor | Simple callback implementation
C MatcherDescriptor | Matcher descriptor interface
C OverloadedMatcherDescriptor | MatcherDescriptor that wraps multiple "overloads" of the same matcher
C VariadicFuncMatcherDescriptor | Matcher descriptor for variadic functions
C VariadicOperatorMatcherDescriptor | Variadic operator marshaller function
C ArgKind | Kind identifier
►C Diagnostics | Helper class to manage error messages
C ArgStream | Helper stream class
C Context | Class defining a parser context
C ContextFrame | Information stored for one frame of the context
►C ErrorContent | Information stored for each error found
C Message |
C OverloadContext | Context for overloaded matcher construction
C MatcherCompletion |
►C Parser | Matcher expression parser
C CodeTokenizer | Simple tokenizer for the parser
C RegistrySema | Sema implementation that uses the matcher registry to process the tokens
C ScopedContextEntry |
C Sema | Interface to connect the parser with the registry and more
C TokenInfo | Simple structure to hold information for one token from the parser
C ParserValue | A VariantValue instance annotated with its parser context
C Registry |
C SourceLocation |
C SourceRange |
►C VariantMatcher | A variant matcher object
C PolymorphicPayload |
C SinglePayload |
C VariadicOpPayload |
C VariantValue | Variant value class
►N internal |
C CollectMatchesCallback |
C BoundNodes | Maps string IDs to AST nodes matched by parts of a matcher
►C MatchFinder | A class to allow finding matches over the Clang AST
C MatchCallback | Called when the Match registered for it was successfully found in the AST
C MatchersByType | For each `Matcher<>` a `MatchCallback` that will be called when it matches
►C MatchFinderOptions |
C Profiling |
C MatchResult | Contains all information for a given match
C ParsingDoneTestCallback | Called when parsing is finished. Intended for testing only
►N ast_type_traits |
►C ASTNodeKind | Kind identifier
C DenseMapInfo | Hooks for using ASTNodeKind as a key in a DenseMap
►C DynTypedNode | A dynamically typed AST node container
C BaseConverter< CXXCtorInitializer, void > |
C BaseConverter< NestedNameSpecifier, void > |
C BaseConverter< NestedNameSpecifierLoc, void > |
C BaseConverter< QualType, void > |
C BaseConverter< T, typename std::enable_if< std::is_base_of< Decl, T >::value >::type > |
C BaseConverter< T, typename std::enable_if< std::is_base_of< OMPClause, T >::value >::type > |
C BaseConverter< T, typename std::enable_if< std::is_base_of< Stmt, T >::value >::type > |
C BaseConverter< T, typename std::enable_if< std::is_base_of< Type, T >::value >::type > |
C BaseConverter< TemplateArgument, void > |
C BaseConverter< TemplateName, void > |
C BaseConverter< TypeLoc, void > |
C DenseMapInfo | Hooks for using DynTypedNode as a key in a DenseMap
►N attrvisitor |
C Base | A simple visitor class that helps create attribute visitors
►N Builtin |
C Context | Holds information about both target-independent and target-specific builtins, allowing easy queries by clients
C Info |
►N CodeGen |
►N swiftcall |
C SwiftAggLowering |
C ABIArgInfo | ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to or returned from a function
C ABIInfo | ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions
C Address | An aligned address
C AggValueSlot | An aggregate value slot
C ApplyDebugLocation | A scoped helper to set the current debug location to the specified location or preferred location of the specified Expr
C ApplyInlineDebugLocation | A scoped helper to set the current debug location to an inlined location
C BlockByrefHelpers | A pair of helper functions for a __block variable
C BlockByrefInfo | Information about the layout of a __block variable
C BlockFieldFlags |
C BlockFlags |
C BranchFixup | A branch fixup
C CallArg |
►C CallArgList | CallArgList - Type for representing both the value and type of arguments in a call
C CallArgCleanup |
C Writeback |
C CatchRetScope |
C CatchTypeInfo | 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
C CGBitFieldInfo | Structure with information about how a bitfield should be accessed
►C CGBlockInfo | CGBlockInfo - Information to generate a block literal
C Capture |
C CGBuilderInserter | This is an IRBuilder insertion helper that forwards to CodeGenFunction::InsertHelper, which adds necessary metadata to instructions
C CGBuilderTy |
C CGCallee | All available information about a concrete callee
C CGCalleeInfo | Abstract information about a function or function prototype
C CGCoroData |
C CGCUDARuntime |
►C CGCXXABI | Implements C++ ABI-specific code generation functions
C AddedStructorArgs | Notes how many arguments were added to the beginning (Prefix) and ending (Suffix) of an arg list
C CGDebugInfo | This class gathers all debug information during compilation and is responsible for emitting to llvm globals or pass directly to the backend
C CGFunctionInfo | CGFunctionInfo - Class to encapsulate the information about a function definition
C CGFunctionInfoArgInfo |
►C CGObjCRuntime | Implements runtime-specific code generation functions
C MessageSendInfo |
►C CGOpenCLRuntime |
C EnqueuedBlockInfo | Structure for enqueued block information
►C CGOpenMPRuntime |
C DisableAutoDeclareTargetRAII | Allows to disable automatic handling of functions used in target regions as those marked as `omp declare target`
C LastprivateConditionalData | 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
C LastprivateConditionalRAII | Manages list of lastprivate conditional decls for the specified directive
C NontemporalDeclsRAII | Manages list of nontemporal decls for the specified directive
C CGOpenMPRuntimeNVPTX |
C CGRecordLayout | CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM types
►C CodeGenFunction | CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code
C AbstractCallee | An abstract representation of regular/ObjC call/message targets
C ArrayInitLoopExprScope | The scope of an ArrayInitLoopExpr
C AutoVarEmission |
C CallLifetimeEnd |
C CGCapturedStmtInfo | API for captured statement code generation
C CGCapturedStmtRAII | RAII for correct setting/restoring of CapturedStmtInfo
C CGCoroInfo |
C ConditionalEvaluation | An object to manage conditionally-evaluated expressions
C ConstantEmission |
C CXXDefaultArgExprScope |
C CXXDefaultInitExprScope | The scope of a CXXDefaultInitExpr
C FieldConstructionScope | A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr
C FinallyInfo | A class controlling the emission of a finally block
C InlinedInheritingConstructorScope |
C JumpDest | A jump destination is an abstract label, branching to which may require a jump out through normal cleanups
C LexicalScope |
C LifetimeExtendedCleanupHeader | Header for data within LifetimeExtendedCleanupStack
►C MultiVersionResolverOption |
C Conds |
C OMPCancelStackRAII | Controls insertion of cancellation exit blocks in worksharing constructs
C OMPLocalDeclMapRAII | 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
C OMPMapVars | The class used to assign some variables some temporarily addresses
C OMPPrivateScope | 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
C OMPTargetDataInfo |
C OpaqueValueMapping | An RAII object to set (and then clear) a mapping for an OpaqueValueExpr
C OpaqueValueMappingData | A non-RAII class containing all the information about a bound opaque value
C ParamValue |
C PeepholeProtection | 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
C RunCleanupsScope | Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited
C SanitizerScope | RAII object to set/unset CodeGenFunction::IsSanitizerScope
C StmtExprEvaluation | An RAII object to record that we're evaluating a statement expression
C VlaSizePair |
C VPtr | Struct with all information about dynamic [sub]class needed to set vptr
►C CodeGenModule | This class organizes the cross-function state that is used while generating LLVM code
C Structor |
C CodeGenPGO | Per-function PGO state
C CodeGenTBAA | CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LLVM types
C CodeGenTypeCache | This structure provides a set of types that are commonly used during IR emission
C CodeGenTypes | This class organizes the cross-module state that is used while lowering AST types to LLVM types
C CodeGenVTables |
C ConstantAddress | A specialization of Address that requires the address to be an LLVM Constant
►C ConstantAggregateBuilderBase | A concrete base class for struct and array aggregate initializer builders
C PlaceholderPosition | An opaque class to hold the abstract position of a placeholder
C ConstantAggregateBuilderTemplateBase |
C ConstantArrayBuilder | A helper class of ConstantInitBuilder, used for building constant array initializers
C ConstantArrayBuilderTemplateBase |
C ConstantEmitter |
C ConstantInitBuilder | The standard implementation of ConstantInitBuilder used in Clang
C ConstantInitBuilderBase |
C ConstantInitBuilderTemplateBase | 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
C ConstantInitBuilderTraits |
C ConstantInitFuture | A "future" for a completed constant initializer, which can be passed around independently of any sub-builders (but not the original parent)
C ConstantStructBuilder | A helper class of ConstantInitBuilder, used for building constant struct initializers
C ConstantStructBuilderTemplateBase | 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
C CoverageMappingGen | Organizes the per-function state that is used while generating code coverage mapping data
C CoverageMappingModuleGen | Organizes the cross-function state that is used while generating code coverage mapping data
C DispatchRTInput | Struct with the values to be passed to the dispatch runtime function
C DominatingLLVMValue | Helper class with most of the code for saving a value for a conditional expression cleanup
C DominatingPointer |
C DominatingPointer< T, false > |
C DominatingPointer< T, true > | A partial specialization of DominatingValue for llvm::Values that might be llvm::Instructions
C DominatingValue | A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function
►C DominatingValue< Address > | A specialization of DominatingValue for Address
C saved_type |
►C DominatingValue< RValue > | A specialization of DominatingValue for RValue
C saved_type |
C DominatingValue< T * > |
►C EHCatchScope | A scope which attempts to handle some, possibly all, types of exceptions
C Handler |
C EHCleanupScope | A cleanup scope which generates the cleanup blocks lazily
C EHFilterScope | An exceptions scope which filters exceptions thrown through it
C EHPadEndScope |
C EHPersonality | The exceptions personality for a function
►C EHScope | A protected scope for zero-cost EH handling
C CatchBitFields |
C CleanupBitFields |
C FilterBitFields |
►C EHScopeStack | A stack of scopes which respond to exceptions, including cleanups and catch blocks
►C Cleanup | Information for lazily generating a cleanup
C Flags | Generation flags
C ConditionalCleanup | ConditionalCleanup stores the saved form of its parameters, then restores them and performs the cleanup
C iterator | A non-stable pointer into the scope stack
C stable_iterator | A saved depth on the scope stack
C EHTerminateScope | An exceptions scope which calls std::terminate if any exception reaches it
C FunctionArgList | FunctionArgList - Type for representing both the decl and type of parameters to a function
C InstrProfStats | This class records statistics on instrumentation based profiling
C InvariantValue |
C LoopAttributes | Attributes that may be specified on loops
C LoopInfo | Information used when generating a structured loop
C LoopInfoStack | A stack of loop information corresponding to loop nesting levels
C LValue | LValue - This represents an lvalue references
C LValueBaseInfo |
C ObjCEntrypoints |
►C OffloadEntriesInfoManagerTy | Entity that registers the offloading constants that were emitted so far
C OffloadEntryInfo | Base class of the entries info
C OffloadEntryInfoDeviceGlobalVar | Device global variable entries info
C OffloadEntryInfoTargetRegion | Target region entries info
C OMPTaskDataTy |
C OrderGlobalInits |
C PrePostActionTy | A basic class for pre|post-action for advanced codegen sequence for OpenMP region
C ReductionCodeGen | Class intended to support codegen of all kind of the reduction clauses
C ReductionOptionsTy |
C RegionCodeGenTy | Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possible pre|post-actions in codegen
C RequiredArgs | A class for recording the number of arguments that a function signature requires
C ReturnValueSlot | ReturnValueSlot - Contains the address where the return value of a function can be stored, and whether the address is volatile or not
C RValue | RValue - This trivial value class is used to represent the result of an expression that is evaluated
C SanitizerMetadata |
C StaticRTInput | Struct with the values to be passed to the static runtime function
C SwiftABIInfo | A refining implementation of ABIInfo for targets that support swiftcall
►C TargetCodeGenInfo | TargetCodeGenInfo - This class organizes various target-specific codegeneration issues, like target-specific attributes, builtins and so on
C TargetOpenCLBlockHelper | Interface class for filling custom fields of a block literal for OpenCL
C TargetDataInfo | Struct that keeps all the relevant information that should be kept throughout a 'target data' region
C TaskResultTy |
C TBAAAccessInfo |
C VarBypassDetector | The class detects jumps which bypass local variables declaration: goto L; int a; L:
►N comments |
►C BlockCommandComment | 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
C Argument |
C BlockContentComment | Block content (contains inline content)
C BriefParser | A very simple comment parser that extracts "a brief description"
C CommandInfo | Information about a single command
C CommandTraits | This class provides information about commands that can be used in comments
►C Comment | Any part of the comment
C BlockCommandCommentBitfields |
C CommentBitfields |
C HTMLStartTagCommentBitfields |
C HTMLTagCommentBitfields |
C InlineCommandCommentBitfields |
C InlineContentCommentBitfields |
C ParagraphCommentBitfields |
C ParamCommandCommentBitfields |
C TextCommentBitfields |
C CommentVisitor |
C CommentVisitorBase |
C ConstCommentVisitor |
C DeclInfo | Information about the declaration, useful to clients of FullComment
C FullComment | A full comment attached to a declaration, contains block content
C HTMLEndTagComment | A closing HTML tag
►C HTMLStartTagComment | An opening HTML tag with attributes
C Attribute |
C HTMLTagComment | Abstract class for opening and closing HTML tags
►C InlineCommandComment | A command with word-like arguments that is considered inline content
C Argument |
C InlineContentComment | Inline content (contained within a block)
C Lexer | Comment lexer
C ParagraphComment | A single paragraph that contains inline content
C ParamCommandComment | Doxygen \param command
C Parser | Doxygen comment parser
C Sema |
C TextComment | Plain text
C TextTokenRetokenizer | Re-lexes a sequence of tok::text tokens
C Token | Comment token
C TParamCommandComment | Doxygen \tparam command, describes a template parameter
C VerbatimBlockComment | A verbatim block command (e
C VerbatimBlockLineComment | A line of text contained in a verbatim block
C VerbatimLineComment | A verbatim line command
►N concepts |
►C ExprRequirement | A requires-expression requirement which queries the validity and properties of an expression ('simple' and 'compound' requirements)
C ReturnTypeRequirement |
C NestedRequirement | A requires-expression requirement which is satisfied when a general constraint expression is satisfied ('nested' requirements)
►C Requirement | A static requirement that can be used in a requires-expression to check properties of types and expression
C SubstitutionDiagnostic |
C TypeRequirement | A requires-expression requirement which queries the existence of a type name or type template specialization ('type' requirements)
►N consumed |
C ConsumedAnalyzer | A class that handles the analysis of uniqueness violations
C ConsumedBlockInfo |
C ConsumedStateMap |
C ConsumedStmtVisitor |
C ConsumedWarningsHandlerBase |
C PropagationInfo |
►N cross_tu |
C CrossTranslationUnitContext | This class is used for tools that requires cross translation unit capability
C IndexError |
►N dataflow |
C backward_analysis_tag |
C forward_analysis_tag |
►N declvisitor |
C Base | A simple visitor class that helps create declaration visitors
►N detail |
C AvailabilityData | Describes the trailing object for Availability attribute in ParsedAttr
C CXXDeductionGuideNameExtra | Contains extra information for the name of a C++ deduction guide
C CXXLiteralOperatorIdName | Contains the actual identifier that makes up the name of a C++ literal operator
C CXXOperatorIdName | Contains extra information for the name of an overloaded operator in C++, such as "operator+
C CXXSpecialNameExtra | CXXSpecialNameExtra records the type associated with one of the "special" kinds of declaration names in C++, e.g., constructors, destructors, and conversion functions
C DeclarationNameExtra | DeclarationNameExtra is used as a base of various uncommon special names
C PropertyData |
C TypeTagForDatatypeData |
►N diag |
C CustomDiagInfo |
►N diff |
►C ASTDiff |
C Impl |
C ComparisonOptions |
C Node | Represents a Clang AST node, alongside some additional information
C NodeId | Within a tree, this identifies a node by its preorder offset
C SNodeId | Identifies a node in a subtree by its postorder offset, starting at 1
C Subtree |
►C SyntaxTree | SyntaxTree objects represent subtrees of the AST
C Impl | Represents the AST of a TranslationUnit
C ZhangShashaMatcher | Implementation of Zhang and Shasha's Algorithm for tree edit distance
►N driver |
►N toolchains |
C AIX |
C AMDGPUToolChain |
C Ananas |
C AVRToolChain |
C BareMetal |
C CloudABI |
C Contiki |
C CrossWindowsToolChain |
C CudaToolChain |
C Darwin | Darwin - The base Darwin tool chain
C DarwinClang | DarwinClang - The Darwin toolchain used by Clang
C DragonFly |
C FreeBSD |
C Fuchsia |
C Generic_ELF |
►C Generic_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
C GCCInstallationDetector | This is a class to find a viable GCC installation for Clang to use
C GCCVersion | Struct to store and manipulate GCC versions
C Haiku |
C HexagonToolChain |
C HIPToolChain |
C Hurd |
C LanaiToolChain |
C Linux |
C MachO |
C MinGW |
C Minix |
C MipsLLVMToolChain |
C MSP430ToolChain |
C MSVCToolChain |
C MyriadToolChain | MyriadToolChain - A tool chain using either clang or the external compiler installed by the Movidius SDK to perform all subcommands
C NaClToolChain |
C NetBSD |
C OpenBSD |
C PPCLinuxToolChain |
C PS4CPU |
C RISCVToolChain |
C Solaris |
C TCELEToolChain | Toolchain for little endian TCE cores
C TCEToolChain | TCEToolChain - A tool chain using the llvm bitcode tools to perform all subcommands
C WebAssembly |
C XCoreToolChain |
►N tools |
►N aix | Aix – Directly call system default assembler and linker
C Assembler |
C Linker |
►N AMDGCN |
C Linker |
►N amdgpu |
C Linker |
►N ananas | Ananas – Directly call GNU Binutils assembler and linker
C Assembler |
C Linker |
►N AVR |
C Linker |
►N baremetal |
C Linker |
►N cloudabi | Cloudabi – Directly call GNU Binutils linker
C Linker |
►N CrossWindows |
C Assembler |
C Linker |
►N darwin |
C Assembler |
C Dsymutil |
C Linker |
C Lipo |
C MachOTool |
C VerifyDebug |
►N dragonfly | Dragonfly – Directly call GNU Binutils assembler and linker
C Assembler |
C Linker |
►N freebsd | Freebsd – Directly call GNU Binutils assembler and linker
C Assembler |
C Linker |
►N fuchsia |
C Linker |
►N gcc | Gcc - Generic GCC tool implementations
C Common |
C Compiler |
C Linker |
C Preprocessor |
►N gnutools | Directly call GNU Binutils' assembler and linker
C Assembler |
C Linker |
►N hexagon |
C Assembler |
C Linker |
►N ifstool |
C Merger |
►N MinGW | MinGW – Directly call GNU Binutils assembler and linker
C Assembler |
C Linker |
►N minix | Minix – Directly call GNU Binutils assembler and linker
C Assembler |
C Linker |
►N msp430 |
C Linker |
►N Myriad | The Myriad toolchain uses tools that are in two different namespaces
C Linker |
►N nacltools |
C AssemblerARM |
C Linker |
►N netbsd | Netbsd – Directly call GNU Binutils assembler and linker
C Assembler |
C Linker |
►N NVPTX |
C Assembler |
C Linker |
C OpenMPLinker |
►N openbsd | Openbsd – Directly call GNU Binutils assembler and linker
C Assembler |
C Linker |
►N PS4cpu |
C Assemble |
C Link |
►N RISCV |
C Linker |
►N SHAVE | SHAVE tools – Directly call moviCompile and moviAsm
C Assembler |
C Compiler |
►N solaris | Solaris – Directly call Solaris assembler and linker
C Assembler |
C Linker |
►N visualstudio | Visual studio tools
C Compiler |
C Linker |
►N wasm |
C Linker |
►N XCore |
C Assembler |
C Linker |
C Clang | Clang compiler tool
C ClangAs | Clang integrated assembler tool
C Flang | Flang compiler tool
C GnuTool | Base class for all GNU tools that provide the same behavior when it comes to response files support
C OffloadBundler | Offload bundler tool
C OffloadWrapper | Offload wrapper tool
C Action | Action - Represent an abstract compilation step to perform
C AnalyzeJobAction |
C AssembleJobAction |
C BackendJobAction |
C BindArchAction |
C CC1Command | Use the CC1 tool callback when available, to avoid creating a new process
C Command | Command - An executable path/name and argument vector to execute
C Compilation | Compilation - A set of tasks to perform for a single driver invocation
C CompileJobAction |
C CrashReportInfo |
C CudaInstallationDetector | A class to find a viable CUDA installation
C DarwinSDKInfo | The information about the darwin SDK that was used during this compilation
C DetectedMultilibs |
C Distro | Distro - Helper class for detecting and classifying Linux distributions
►C Driver | Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like command line arguments
C CompilationDiagnosticReport | Contains the files in the compilation diagnostic report generated by generateCompilationDiagnostics
C DsymutilJobAction |
C FallbackCommand | Like Command, but with a fallback which is executed in case the primary command crashes
C ForceSuccessCommand | Like Command, but always pretends that the wrapped command succeeded
C HeaderModulePrecompileJobAction |
C IfsMergeJobAction |
C InputAction |
C InputInfo | InputInfo - Wrapper for information about an input source
C JobAction |
C JobList | JobList - A sequence of jobs to perform
C LinkJobAction |
C LipoJobAction |
C MigrateJobAction |
C Multilib | This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag
C MultilibSet |
►C OffloadAction | An offload action combines host or/and device actions according to the programming model implementation needs and propagates the offloading kind to its dependences
C DeviceDependences | Type used to communicate device actions
C HostDependence | Type used to communicate host actions
C OffloadBundlingJobAction |
►C OffloadUnbundlingJobAction |
C DependentActionInfo | Type that provides information about the actions that depend on this unbundling action
C OffloadWrapperJobAction |
C ParsedClangName | Helper structure used to pass information extracted from clang executable name such as `i686-linux-android-g++`
C PrecompileJobAction |
C PreprocessJobAction |
C RegisterEffectiveTriple | Set a ToolChain's effective triple
C SanitizerArgs |
C Tool | Tool - Information on a specific compilation tool
C ToolChain | ToolChain - Access to tools for a single platform
C VerifyDebugInfoJobAction |
C VerifyJobAction |
C VerifyPCHJobAction |
C XRayArgs |
►N edit |
►C Commit |
C Edit |
C EditedSource |
C EditsReceiver |
C FileOffset |
►N ento |
►N check |
C ASTCodeBody |
C ASTDecl |
C BeginFunction |
C Bind |
C BranchCondition |
C ConstPointerEscape |
C DeadSymbols |
C EndAnalysis |
C EndFunction |
C EndOfTranslationUnit |
C Event |
C LiveSymbols |
C Location |
C NewAllocator |
C ObjCMessageNil |
C PointerEscape |
C PostCall |
C PostObjCMessage |
C PostStmt |
C PreCall |
C PreObjCMessage |
C PreStmt |
C RegionChanges |
►N eval |
C Assume |
C Call |
►N iterator |
C ContainerData |
C ContainerMap |
C IteratorPosition |
C IteratorRegionMap |
C IteratorSymbolMap |
►N loc |
C ConcreteInt |
C GotoLabel |
C MemRegionVal |
►N mpi |
C MPIBugReporter |
C MPIChecker |
C MPIFunctionClassifier |
C Request |
C RequestMap |
►N nonloc |
C CompoundVal |
C ConcreteInt | Value representing integer constant
C LazyCompoundVal |
C LocAsInteger |
C PointerToMember | Value representing pointer-to-member
C SymbolVal | Represents symbolic expression that isn't a location
►N retaincountchecker |
C RefCountBug |
C RefCountReport |
C RefLeakReport |
C RefVal | Metadata on reference
C RetainCountChecker |
►N summMgr |
C SummaryKey |
►N taint |
C TaintBugVisitor | The bug visitor prints a diagnostic message at the location where a given variable was tainted
C AllocaRegion | AllocaRegion - A region that represents an untyped blob of bytes created by a call to 'alloca'
C AnalysisAction |
C AnalysisASTConsumer |
C AnalysisManager |
C AnyFunctionCall | Represents a call to any sort of function that might have a FunctionDecl
C APSIntType | A record of the "type" of an APSInt, used for conversions
C ArgEffect | An ArgEffect summarizes the retain count behavior on an argument or receiver to a function or method
C BasicBugReport |
C BasicValueFactory |
C BinarySymExpr | Represents a symbolic expression involving a binary operator
C BlockCodeRegion | BlockCodeRegion - A region that represents code texts of blocks (closures)
►C BlockCounter | An abstract data type used to count the number of times a given block has been visited along a path analyzed by CoreEngine
C Factory |
►C BlockDataRegion | BlockDataRegion - A region that represents a block instance
C referenced_vars_iterator |
C BranchNodeBuilder | BranchNodeBuilder is responsible for constructing the nodes corresponding to the two branches of the if statement - true and false
C BugReport | This class provides an interface through which checkers can create individual bug reports
C BugReportEquivClass |
C BugReporter | BugReporter is a utility class for generating PathDiagnostics for analysis
C BugReporterContext |
C BugReporterData |
C BugType |
C BuiltinBug |
C CallEvent | Represents an abstract call to a function or method along a particular path
C CallEventRef |
C Checker |
C Checker< CHECK1 > |
C CheckerBase |
C CheckerContext |
C CheckerDocumentation | 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
C CheckerFn |
C CheckerFn< RET(Ps...)> |
C CheckerManager |
C CheckerNameRef | This wrapper is used to ensure that only StringRefs originating from the CheckerRegistry are used as check names
C CheckerProgramPointTag | Tag that can use a checker name as a message provider (see SimpleProgramPointTag)
►C CheckerRegistry | Manages a set of available checkers for running a static analysis
C CheckerInfo | Specifies a checker
C CmdLineOption | Specifies a command line option
C PackageInfo | Specifies a package
C CodeSpaceRegion | CodeSpaceRegion - The memory space that holds the executable code of functions and blocks
C CodeTextRegion |
C CompoundLiteralRegion | CompoundLiteralRegion - A memory region representing a compound literal
C CompoundValData |
C ConditionTruthVal |
C ConstraintManager |
C ConstraintRange |
C CoreEngine | CoreEngine - Implements the core logic of the graph-reachability analysis
C CXXBaseObjectRegion |
C CXXDerivedObjectRegion |
C CXXTempObjectRegion |
C CXXThisRegion | CXXThisRegion - Represents the region for the implicit 'this' parameter in a call to a C++ method
C DeclRegion |
C DefaultBool | A helper class which wraps a boolean value set to false by default
C DefinedOrUnknownSVal |
C DefinedSVal |
C DynamicCastInfo |
C DynamicTypeInfo | Stores the currently inferred strictest bound on the runtime type of a region in a given state along the analysis path
C ElementRegion | ElementRegion is used to represent both array elements and casts
C Environment | An immutable map from EnvironemntEntries to SVals
C EnvironmentEntry | An entry in the environment consists of a Stmt and an LocationContext
C EnvironmentManager |
C EventDispatcher |
C ExplodedGraph |
C ExplodedNode |
C ExplodedNodeSet |
►C ExprEngine |
C EvalCallOptions | Hints for figuring out of a call should be inlined during evalCall()
C FieldChainInfo | Represents a field chain
C FieldNode | A lightweight polymorphic wrapper around FieldRegion *
C FieldRegion |
C FindUninitializedFields | Searches for and stores uninitialized fields in a non-union object
C FullSValVisitor | FullSValVisitor - a convenient mixed visitor for all three: SVal, SymExpr and MemRegion subclasses
C FunctionCodeRegion | FunctionCodeRegion - A region that represents code texts of function
C FunctionSummariesTy |
C GlobalImmutableSpaceRegion | 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)
C GlobalInternalSpaceRegion | The region containing globals which can be modified by calls to "internally" defined functions - (for now just) functions other then system calls
C GlobalsSpaceRegion |
C GlobalSystemSpaceRegion | The region containing globals which are defined in system/external headers and are considered modifiable by system calls (ex: errno)
C HeapSpaceRegion |
C ImplicitNullDerefEvent | We dereferenced a location that may be null
►C IndirectGotoNodeBuilder |
C iterator |
C IntSymExpr | Represents a symbolic expression like 3 - 'x'
C KnownSVal | Represents an SVal that is guaranteed to not be UnknownVal
C LazyCompoundValData |
C Loc |
C MemRegion | MemRegion - The root abstract class for all memory regions
C MemRegionManager |
C MemRegionVisitor | MemRegionVisitor - this class implements a simple visitor for MemRegion subclasses
C MemSpaceRegion | MemSpaceRegion - A memory region that represents a "memory space"; for example, the set of global variables, the stack frame, etc
C ModelConsumer | ASTConsumer to consume model files' AST
C ModelInjector |
C NodeBuilder | This is the simplest builder which generates nodes in the ExplodedGraph
C NodeBuilderContext |
C NodeBuilderWithSinks | This node builder keeps track of the generated sink nodes
C NonLoc |
C NonStaticGlobalSpaceRegion | The region for all the non-static global variables
►C NoteTag | The tag upon which the TagVisitor reacts
C Factory |
C ObjCIvarRegion |
C ObjCStringRegion | The region associated with an ObjCStringLiteral
C ObjCSummaryKey | A key identifying a summary
C ParseModelFileAction | Frontend action to parse model files
C PathDiagnostic | PathDiagnostic - PathDiagnostic objects represent a single path-sensitive diagnostic
C PathDiagnosticCallPiece |
►C PathDiagnosticConsumer |
C FilesMade |
C PDFileEntry |
C PathDiagnosticControlFlowPiece |
C PathDiagnosticEventPiece |
C PathDiagnosticLocation |
C PathDiagnosticLocationPair |
C PathDiagnosticMacroPiece |
C PathDiagnosticNotePiece |
C PathDiagnosticPiece |
C PathDiagnosticPopUpPiece |
C PathDiagnosticRange |
C PathDiagnosticSpotPiece |
C PathPieces |
C PathSensitiveBugReport |
C PathSensitiveBugReporter | GRBugReporter is used for generating path-sensitive reports
C PointerToMemberData |
C PrettyStackTraceLocationContext | While alive, includes the current analysis stack in a crash trace
C ProgramState | ProgramState - This class encapsulates:
C ProgramStateManager |
C ProgramStatePartialTrait |
C ProgramStatePartialTrait< bool > |
C ProgramStatePartialTrait< const void * > |
C ProgramStatePartialTrait< llvm::ImmutableList< T > > |
C ProgramStatePartialTrait< llvm::ImmutableMap< Key, Data, Info > > |
C ProgramStatePartialTrait< llvm::ImmutableSet< Key, Info > > |
C ProgramStatePartialTrait< unsigned > |
C ProgramStatePartialTrait< void * > |
C ProgramStateTrait |
C ProgramStateTrait< ConstraintRange > |
C ProgramStateTrait< iterator::ContainerMap > |
C ProgramStateTrait< iterator::IteratorRegionMap > |
C ProgramStateTrait< iterator::IteratorSymbolMap > |
C ProgramStateTrait< mpi::RequestMap > |
C ProgramStateTrait< ReplayWithoutInlining > |
C Range | A Range represents the closed range [from, to]
C RangedConstraintManager |
C RangeSet | RangeSet contains a set of ranges
C RangeTrait |
C RegionAndSymbolInvalidationTraits | Information about invalidation for a particular region/symbol
C RegionOffset | Represent a region's offset within the top level base region
C RegionRawOffset |
C ReplayWithoutInlining | Traits for storing the call processing policy inside GDM
C RetEffect | RetEffect summarizes a call's retain/release behavior with respect to its return value
C RuntimeDefinition | Defines the runtime definition of the called function
C ScanReachableSymbols | A utility class that visits the reachable symbols using a custom SymbolVisitor
C SimpleConstraintManager |
C SimpleFunctionCall | Represents a C function or static C++ member function call
C SMTConstraintManager |
C SMTConv |
C StackArgumentsSpaceRegion |
C StackHintGenerator | Interface for classes constructing Stack hints
C StackHintGeneratorForSymbol | Constructs a Stack hint for the given symbol
C StackLocalsSpaceRegion |
C StackSpaceRegion |
C StaticGlobalSpaceRegion | The region of the static variables within the current CodeTextRegion scope
C StmtNodeBuilder | This builder class is useful for generating nodes that resulted from visiting a statement
►C StoreManager |
C BindingsHandler |
C FindUniqueBinding |
C StoreRef |
C StringRegion | StringRegion - Region associated with a StringLiteral
C SubEngine |
C SubRegion | SubRegion - A region that subsets another larger region
C SummaryManager |
C SummaryManagerImpl |
C SVal | SVal - This represents a symbolic expression, which can be either an L-value or an R-value
C SValBuilder |
C SValExplainer |
C SValVisitor | SValVisitor - this class implements a simple visitor for SVal subclasses
►C SwitchNodeBuilder |
C iterator |
C SymbolCast | Represents a cast expression
C SymbolConjured | A symbol representing the result of an expression in the case when we do not know anything about what the expression is
C SymbolData | A symbol representing data which can be stored in a memory location (region)
C SymbolDerived | A symbol representing the value of a MemRegion whose parent region has symbolic value
C SymbolExtent | SymbolExtent - Represents the extent (size in bytes) of a bounded region
C SymbolicRegion | SymbolicRegion - A special, "non-concrete" region
C SymbolManager |
C SymbolMetadata | SymbolMetadata - Represents path-dependent metadata about a specific region
C SymbolReaper | A class responsible for cleaning up unused symbols
C SymbolRegionValue | A symbol representing the value stored at a MemRegion
C SymbolVisitor |
►C SymExpr | Symbolic value
C symbol_iterator | Iterator over symbols that the current symbol depends on
C SymExprVisitor | SymExprVisitor - this class implements a simple visitor for SymExpr subclasses
C SymIntExpr | Represents a symbolic expression like 'x' + 3
C SymSymExpr | Represents a symbolic expression like 'x' + 'y'
C TypedRegion | TypedRegion - An abstract class representing regions that are typed
C TypedValueRegion | TypedValueRegion - An abstract class representing regions having a typed value
C UndefinedVal |
C UninitObjCheckerOptions |
C UnknownSpaceRegion |
C UnknownVal |
C VarRegion |
C WorkList |
C WorkListUnit |
►N format |
C AdditionalKeywords | Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's lexer
C AffectedRangeManager |
C AnnotatedLine |
C BreakableBlockComment |
C BreakableComment |
C BreakableLineCommentSection |
C BreakableStringLiteral |
C CommaSeparatedList |
C CompoundStatementIndenter |
C ContinuationIndenter |
C Environment |
C FormatStyle | The `FormatStyle` is used to configure the formatting to follow specific guidelines
C FormattingAttemptStatus | Represents the status of a formatting attempt
C FormatToken | A wrapper around a `Token` storing information about the whitespace characters preceding it
C FormatTokenLexer |
C FormatTokenSource |
C JavaScriptImportSorter |
C JsImportedSymbol |
C JsModuleReference |
C LineState | The current state when indenting a unwrapped line
C NamespaceEndCommentsFixer |
C ParenState |
C ParseErrorCategory |
C RawStringFormatStyleManager |
C ScopedLineState |
C TokenAnalyzer |
C TokenAnnotator | Determines extra information about the tokens comprising an `UnwrappedLine`
C TokenRole |
C UnwrappedLine | An unwrapped line is a sequence of `Token`, that we would like to put on a single line if there was no column limit
C UnwrappedLineConsumer |
C UnwrappedLineFormatter |
C UnwrappedLineNode |
C UnwrappedLineParser |
C UsingDeclarationsSorter |
►C WhitespaceManager | Manages the whitespaces around tokens and their replacements
►C Change | Represents a change before a token, a break inside a token, or the layout of an unchanged token (or whitespace within)
C IsBeforeInFile | Functor to sort changes in original source order
►N index |
C CommentToXMLConverter |
C DeclOccurrence |
C FileIndexRecord | Stores the declaration occurrences seen in a particular source or header file of a translation unit
►C IndexDataConsumer |
C ASTNodeInfo |
C IndexingContext |
C IndexingOptions |
C SimpleFormatContext | A small class to be used by libclang clients to format a declaration string in memory
C SymbolInfo |
C SymbolRelation | Represents a relation to another symbol for a symbol occurrence
►N interp |
C Block | A memory block, either on the stack or in the heap
C BlockScope | Scope for storage declared in a compound statement
C Boolean | Wrapper around boolean types
C ByteCodeEmitter | An emitter which links the program to bytecode for later use
C ByteCodeExprGen | Compilation context for expressions
C ByteCodeGenError | Error thrown by the compiler
C ByteCodeStmtGen | Compilation context for statements
C CodePtr | Pointer into the code segment
C Context | Holds all information required to evaluate constexpr code in a module
C DeadBlock | Descriptor for a dead block
C DeclScope | Scope used to handle temporaries in toplevel variable declarations
►C Descriptor | Describes a memory block created by an allocation site
C UnknownSize | Token to denote structures of unknown size
C EvalEmitter | An emitter which evaluates opcodes as they are emitted
C ExprScope | Expression scope which tracks potentially lifetime extended temporaries which are hoisted to the parent scope on exit
C Frame | Base class for stack frames, shared between VM and walker
C Function | Bytecode function
C InitMap | Bitfield tracking the initialisation status of elements of primitive arrays
C InlineDescriptor | Inline descriptor embedded in structures and arrays
C Integral | Wrapper around numeric types
C InterpFrame | Frame storing local variables
C InterpStack | Stack frame storing temporaries and parameters
C InterpState | Interpreter context
C LabelScope | Scope managing label targets
C LocalScope | Scope for local variables
C LoopScope | Sets the context for break/continue statements
C OptionScope | Scope used to handle initialization methods
C Pointer | A pointer to a memory block, live or dead
C PrimConv | Mapping from primitive types to their representation
C PrimConv< PT_Bool > |
C PrimConv< PT_Ptr > |
C PrimConv< PT_Sint16 > |
C PrimConv< PT_Sint32 > |
C PrimConv< PT_Sint64 > |
C PrimConv< PT_Sint8 > |
C PrimConv< PT_Uint16 > |
C PrimConv< PT_Uint32 > |
C PrimConv< PT_Uint64 > |
C PrimConv< PT_Uint8 > |
►C Program | The program contains and links the bytecode for all functions
C DeclScope | Context to manage declaration lifetimes
►C Record | Structure/Class descriptor
C Base | Describes a base class
C Field | Describes a record field
C RecordScope |
C Repr |
C Repr< 16, false > |
C Repr< 16, true > |
C Repr< 32, false > |
C Repr< 32, true > |
C Repr< 64, false > |
C Repr< 64, true > |
C Repr< 8, false > |
C Repr< 8, true > |
►C Scope | Describes a scope block
C Local | Information about a local's storage
C SourceInfo | Describes the statement/declaration an opcode was generated from
C SourceMapper | Interface for classes which map locations to sources
C State | Interface for the VM to interact with the AST walker's context
C SwitchScope |
C VariableScope | Scope chain managing the variable lifetimes
►N minimize_source_to_dependency_directives |
C SkippedRange | Simplified token range to track the range of a potentially skippable PP directive
C Token | Represents a simplified token that's lexed as part of the source minimization
►N reachable_code |
C Callback |
►N sema |
C AccessedEntity | A declaration being accessed, together with information about how it was accessed
►C AnalysisBasedWarnings |
C Policy |
C BlockScopeInfo | Retains information about a block that is currently being parsed
C Capture |
C CapturedRegionScopeInfo | Retains information about a captured region
C CapturingScopeInfo |
C CompoundScopeInfo | Contains information about the compound statement currently being parsed
C DelayedDiagnostic | A diagnostic message which has been conditionally emitted pending the complete parsing of the current declaration
C DelayedDiagnosticPool | A collection of diagnostics which were delayed
►C FunctionScopeInfo | Retains information about a function, method, or block that is currently being parsed
►C WeakObjectProfileTy | Represents a simple identification of a weak object
C DenseMapInfo |
C WeakUseTy | Represents a single use of a weak object
►C LambdaScopeInfo |
C ShadowedOuterDecl | Contains all of the variables defined in this lambda that shadow variables that were defined in parent contexts
C PossiblyUnreachableDiag |
C SemaPPCallbacks |
C TemplateDeductionInfo | Provides information about an attempted template argument deduction, whose success or failure was described by a TemplateDeductionResult value
►N serialization |
►N reader |
►C ASTDeclContextNameLookupTrait | Class that performs name lookup into a DeclContext stored in an AST file
C data_type_builder |
C ASTIdentifierLookupTrait | Class that performs lookup for an identifier stored in an AST file
C ASTIdentifierLookupTraitBase | Base class for the trait describing the on-disk hash table for the identifiers in an AST file
►C ASTSelectorLookupTrait | Class that performs lookup for a selector's entries in the global method pool stored in an AST file
C data_type |
C DeclContextLookupTable |
►C HeaderFileInfoTrait | Trait class used to search the on-disk hash table containing all of the header search information
C internal_key_type |
C AbstractTypeReader |
C AbstractTypeWriter |
C DataStreamBasicReader | 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)
C DataStreamBasicWriter | 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)
C DeclarationNameKey | A key used when looking up entities by DeclarationName
C DeclOffset | Source range/offset of a preprocessed entity
C InputFile | 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
C LocalRedeclarationsInfo | Describes the redeclarations of a declaration
C ModuleFile | Information about a module that has been loaded by the ASTReader
C ModuleManager | Manages the set of modules loaded by an AST reader
C MultiOnDiskHashTable | A collection of on-disk hash tables, merged when relevant for performance
C MultiOnDiskHashTableGenerator | Writer for the on-disk hash table
C ObjCCategoriesInfo | Describes the categories of an Objective-C class
C PPEntityOffset | Source range/offset of a preprocessed entity
C PPSkippedRange | Source range of a skipped preprocessor region
C ReadMethodPoolVisitor |
C TypeIdx | A type index; the type ID with the qualifier bits removed
C UnsafeQualTypeDenseMapInfo | A structure for putting "fast"-unqualified QualTypes into a DenseMap
►N serialized_diags |
C Location | A location that is represented in the serialized diagnostics
C SerializedDiagnosticReader | A base class that handles reading serialized diagnostics from a file
►N SrcMgr | Public enums and private classes that are part of the SourceManager implementation
C ContentCache | One instance of this struct is kept for every file loaded or used
C ExpansionInfo | 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
C FileInfo | Information about a FileID, basically just the logical file that it represents and include stack information
C SLocEntry | This is a discriminated union of FileInfo and ExpansionInfo
►N syntax |
C Arena | A memory arena for syntax trees
C BreakStatement | Break;
C CaseStatement | Case : <body>
C CompoundStatement | { statement1; statement2; … }
C ContinueStatement | Continue;
C Declaration | A declaration that can appear at the top-level
C DeclarationStatement | E.g. 'int a, b = 10;'
C DefaultStatement | Default: <body>
C EmptyDeclaration | A semicolon in the top-level context. Does not declare anything
C EmptyStatement | The no-op statement, i.e. ';'
C Expression | A base class for all expressions
C ExpressionStatement | Expression in a statement position, e.g
C FactoryImpl | Exposes private syntax tree APIs required to implement node synthesis
C FileRange | A half-open character range inside a particular file, the start offset is included and the end offset is excluded from the range
C ForStatement | For (<init>; <cond>; <increment>) <body>
C IfStatement | If (cond) <then-statement> else <else-statement> FIXME: add condition that models 'expression or variable declaration'
C Leaf | A leaf node points to a single token inside the expanded token stream
C LinkageSpecificationDeclaration | Extern <string-literal> declaration extern <string-literal> { <decls> }
C MutationsImpl |
C NamespaceAliasDefinition | Namespace <name> = <namespace-reference>
C NamespaceDefinition | Namespace <name> { <decls> }
C Node | A node in a syntax tree
C RangeBasedForStatement | For (<decl> : <init>) <body>
C ReturnStatement | Return <expr>; return;
C SimpleDeclaration | Groups multiple declarators (e.g
C Statement | An abstract node for C++ statements, e.g
C StaticAssertDeclaration | Static_assert(<condition>, <message>) static_assert(<condition>)
C SwitchStatement | Switch (<cond>) <body>
C Token | A token coming directly from a file or from a macro invocation
►C TokenBuffer | A list of tokens obtained by preprocessing a text buffer and operations to map between the expanded and spelled tokens, i.e
C Expansion | An expansion produced by the preprocessor, includes macro expansions and preprocessor directives
C TokenCollector | Collects tokens for the main file while running the frontend action
C TranslationUnit | A root node for a translation unit. Parent is always null
C Tree | A node that has children and represents a syntactic language construct
C TreeBuilder | A helper class for constructing the syntax tree while traversing a clang AST
C TypeAliasDeclaration | Using <name> = <type>
C UnknownDeclaration | Declaration of an unknown kind, e.g. not yet supported in syntax trees
C UnknownExpression | An expression of an unknown kind, i.e
C UnknownStatement | A statement of an unknown kind, i.e
C UsingDeclaration | Using <scope>::<name> using typename <scope>::<name>
C UsingNamespaceDirective | Using namespace <name>
C WhileStatement | While (<cond>) <body>
►N targets |
C AArch64beTargetInfo |
C AArch64leTargetInfo |
C AArch64TargetInfo |
C AIXPPC32TargetInfo |
C AIXPPC64TargetInfo |
C AIXTargetInfo |
C AMDGPUTargetInfo |
C AnanasTargetInfo |
C AndroidX86_32TargetInfo |
C AndroidX86_64TargetInfo |
C ARCTargetInfo |
C ARMbeTargetInfo |
C ARMleTargetInfo |
C ARMTargetInfo |
C AVRTargetInfo |
C BPFTargetInfo |
C CloudABITargetInfo |
C CygwinARMTargetInfo |
C CygwinX86_32TargetInfo |
C CygwinX86_64TargetInfo |
C DarwinAArch64TargetInfo |
C DarwinARMTargetInfo |
C DarwinI386TargetInfo |
C DarwinPPC32TargetInfo |
C DarwinPPC64TargetInfo |
C DarwinTargetInfo |
C DarwinX86_64TargetInfo |
C DragonFlyBSDTargetInfo |
C EmscriptenTargetInfo |
C FreeBSDTargetInfo |
C FuchsiaTargetInfo |
C HaikuTargetInfo |
C HaikuX86_32TargetInfo |
C HexagonTargetInfo |
C HurdTargetInfo |
C ItaniumWindowsARMleTargetInfo |
C KFreeBSDTargetInfo |
C LanaiTargetInfo |
C Le64TargetInfo |
C LinuxTargetInfo |
C MCUInfo | Information about a specific microcontroller
C MCUX86_32TargetInfo |
C MicrosoftARM64TargetInfo |
C MicrosoftARMleTargetInfo |
C MicrosoftX86_32TargetInfo |
C MicrosoftX86_64TargetInfo |
C MinGWARM64TargetInfo |
C MinGWARMTargetInfo |
C MinGWX86_32TargetInfo |
C MinGWX86_64TargetInfo |
C MinixTargetInfo |
C MipsTargetInfo |
C MSP430TargetInfo |
C NaClMips32TargetInfo |
C NaClTargetInfo |
C NetBSDI386TargetInfo |
C NetBSDTargetInfo |
C NVPTXTargetInfo |
C OpenBSDI386TargetInfo |
C OpenBSDTargetInfo |
C OpenBSDX86_64TargetInfo |
C OSTargetInfo |
C PNaClTargetInfo |
C PPC32TargetInfo |
C PPC64TargetInfo |
C PPCTargetInfo |
C PS3PPUTargetInfo |
C PS4OSTargetInfo |
C PSPTargetInfo |
C RenderScript32TargetInfo |
C RenderScript64TargetInfo |
C RISCV32TargetInfo |
C RISCV64TargetInfo |
C RISCVTargetInfo |
C RTEMSTargetInfo |
C RTEMSX86_32TargetInfo |
C SolarisTargetInfo |
C SparcTargetInfo |
C SparcV8elTargetInfo |
C SparcV8TargetInfo |
C SparcV9TargetInfo |
C SPIR32TargetInfo |
C SPIR64TargetInfo |
C SPIRTargetInfo |
C SystemZTargetInfo |
C TCELETargetInfo |
C TCETargetInfo |
C WASITargetInfo |
C WebAssembly32TargetInfo |
C WebAssembly64TargetInfo |
C WebAssemblyOSTargetInfo |
C WebAssemblyTargetInfo |
C WindowsARM64TargetInfo |
C WindowsARMTargetInfo |
C WindowsTargetInfo |
C WindowsX86_32TargetInfo |
C WindowsX86_64TargetInfo |
C X86_32TargetInfo |
C X86_64TargetInfo |
C X86TargetInfo |
C XCoreTargetInfo |
►N templateargumentvisitor |
C Base | A simple visitor class that helps create template argument visitors
►N threadSafety |
►N lexpr |
C And |
C BinOp |
C LExpr |
C Not |
C Or |
C Terminal |
►N til |
C Alloc | Allocate memory for a new value on the heap or stack
C Apply | Apply an argument to a function
C ArrayAdd | Pointer arithmetic, restricted to arrays only
C ArrayIndex | If p is a reference to an array, then p[i] is a reference to the i'th element of the array
►C BasicBlock | A basic block is part of an SCFG
C TopologyNode |
C BinaryOp | Simple arithmetic binary operations, e.g
C Branch | A conditional branch to two other blocks
C Call | Call a function (after all arguments have been applied)
C Cast | Cast expressions
C Code | A block of code – e.g. the body of a function
C Comparator |
►C CopyReducerBase |
C Container |
C EqualsComparator |
C Field | A typed, writable location in memory
C Function | A function – a.k.a
C Future | Placeholder for an expression that has not yet been created
C Goto | Jump to another basic block
C Identifier | An identifier, e.g
C IfThenElse | An if-then-else expression
C Let | A let-expression, e.g
C Literal |
C LiteralPtr | A Literal pointer to an object allocated in memory
C LiteralT |
C Load | Load a value from memory
C MatchComparator |
C MemRegionRef |
C Phi | Phi Node, for code in SSA form
C PrettyPrinter |
C Project | Project a named slot from a C++ struct or class
C Return | Return from the enclosing function, passing the return value to the caller
C SApply | Apply a self-argument to a self-applicable function
C SCFG | An SCFG is a control-flow graph
C SExpr | Base class for AST nodes in the typed intermediate language
C SFunction | A self-applicable function
C SimpleArray |
C SimpleReducerBase |
C StdPrinter |
C Store | Store a value to memory
C Terminator | Base class for basic block terminators: Branch, Goto, and Return
C Traversal |
C UnaryOp | Simple arithmetic unary operations, e.g
C Undefined | Placeholder for expressions that cannot be represented in the TIL
C ValueType | ValueTypes are data types that can actually be held in registers
C Variable | A named variable, e.g
C VisitReducer |
►C VisitReducerBase |
C Container |
C Wildcard | Placeholder for a wildcard that matches any other expression
C BeforeSet |
C CapabilityExpr |
C CFGVisitor |
C CFGWalker |
C CopyOnWriteVector |
►C SExprBuilder |
C CallingContext | Encapsulates the lexical context of a function call
C ThreadSafetyHandler | Handler class for thread safety warnings
►N tooling |
►N dependencies |
C CachedFileSystemEntry | An in-memory representation of a file system entity that is of interest to the dependency scanning filesystem
C DependencyConsumer |
►C DependencyScanningFilesystemSharedCache | This class is a shared cache, that caches the 'stat' and 'open' calls to the underlying real file system
C SharedFileSystemEntry |
C DependencyScanningService | The dependency scanning service contains the shared state that is used by the invidual dependency scanning workers
C DependencyScanningTool | The high-level implementation of the dependency discovery tool that runs on an individual worker thread
C DependencyScanningWorker | An individual dependency scanning worker that is able to run on its own thread
C DependencyScanningWorkerFilesystem | A virtual file system optimized for the dependency discovery
C ModuleDepCollector |
C ModuleDepCollectorPP |
C ModuleDeps |
►N fixit |
►N internal |
C AreBaseOf | A type trait that returns true when the given type list contains types that derive from Base
C AreBaseOf< Base, T > |
C HasBaseOf | A type trait that returns true when the given type list has at least one type whose base is the given base type
C HasBaseOf< Base, T > |
►N traits |
►N internal |
C HasHandle |
C IsValidOptionType | A type trait that returns true iff the given type is a type that can be stored in a refactoring option
C AllTUsToolExecutor | Executes given frontend actions on all files/TUs in the compilation database
C AllTUsToolExecutorPlugin |
C ApplyChangesSpec |
C ArgumentsAdjustingCompilations |
C ASTMatchRefactorer | Adaptor between `ast_matchers::MatchFinder` and `tooling::RefactoringTool`
C ASTSelectionRequirement | An AST selection requirement is satisfied when any portion of the AST overlaps with the selection range
C AtomicChange | An atomic change is used to create and group a set of source edits, e.g
C ClangTool | Utility to run a FrontendAction over a set of files
C CodeRangeASTSelection | An AST selection value that corresponds to a selection of a set of statements that belong to one body of code (like one function)
C CodeRangeASTSelectionRequirement | A selection requirement that is satisfied when the selection range overlaps with a number of neighbouring statements in the AST
C CommonOptionsParser | A parser for options common to all command-line Clang tools
C CompilationDatabase | Interface for compilation databases
C CompilationDatabasePlugin | Interface for compilation database plugins
C CompileCommand | Specifies the working directory and command of a compilation
C Diagnostic | Represents the diagnostic with the level of severity and possible fixes to be applied
C DiagnosticMessage | Represents the diagnostic message with the error message associated and the information on the location of the problem
C ExecutionContext | The context of an execution, including the information about compilation and results
C ExtractFunction | An "Extract Function" refactoring moves code into a new function that's then called from the place where the original code was
C ExtractionSemicolonPolicy | Determines which semicolons should be inserted during extraction
C FileMatchTrie | A trie to efficiently match against the entries of the compilation database in order of matching suffix length
C FileMatchTrieNode | A node of the `FileMatchTrie`
C FindSymbolOccurrencesRefactoringRule | A type of refactoring action rule that finds a set of symbol occurrences that reference a particular symbol
C FixedCompilationDatabase | A compilation database that returns a single compile command line
C FrontendActionFactory | Interface to generate clang::FrontendActions
C HeaderIncludes | Generates replacements for inserting or deleting #include directives in a file
C IncludeCategoryManager | This class manages priorities of C++ #include categories and calculates priorities for headers
►C IncludeStyle | Style for sorting and grouping C++ #include directives
C IncludeCategory | See documentation of `IncludeCategories`
C InMemoryToolResults | Stores the key-value results in memory
C JSONCompilationDatabase |
C NamedDeclFindingConsumer |
C OptionalRefactoringOption | A refactoring option that stores a value of type `T`
C OptionRequirement | A requirement that evaluates to the value of the given `OptionType` when the `OptionType` is a required option
C PathComparator |
C QualifiedRenameRule |
C QualifiedRenamingAction | Rename all symbols identified by the given USRs
C Range | A source range independent of the `SourceManager`
C RecursiveSymbolVisitor | Traverses the AST and visits the occurrence of each named symbol in the given nodes
C RefactoringAction | A refactoring action is a class that defines a set of related refactoring action rules
C RefactoringActionRule | 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
C RefactoringActionRuleBase | A common refactoring action rule interface that defines the 'invoke' function that performs the refactoring operation (either fully or partially)
C RefactoringActionRuleRequirement | A refactoring action rule requirement determines when a refactoring action rule can be invoked
C RefactoringASTConsumer |
C RefactoringCallback | Base class for RefactoringCallbacks
C RefactoringDescriptor |
C RefactoringOption | A refactoring option is an interface that describes a value that has an impact on the outcome of a refactoring
C RefactoringOptionsRequirement | A base class for any requirement that requires some refactoring options
C RefactoringOptionVisitor | An interface that declares functions that handle different refactoring option types
C RefactoringResultConsumer | An abstract interface that consumes the various refactoring results that can be produced by refactoring actions
C RefactoringRuleContext | The refactoring rule context stores all of the inputs that might be needed by a refactoring action rule
C RefactoringTool | A tool to run refactorings
C RenameOccurrences |
C RenamingAction |
C RenamingASTConsumer |
C ReplaceIfStmtWithItsBody | 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
C Replacement | A text replacement
C ReplacementError | Carries extra error information in replacement-related llvm::Error, e.g
C Replacements | Maintains a set of replacements that are conflict-free
C ReplaceNodeWithTemplate | Replace the text of an AST node bound to `FromId` with the result of evaluating the template in `ToTemplate`
C ReplaceStmtWithStmt | Replace the text of the statement bound to `FromId` with the text of the statement bound to `ToId`
C ReplaceStmtWithText | Replace the text of the statement bound to `FromId` with the text in `ToText`
C RequiredRefactoringOption | A required refactoring option that stores a value of type `T`
C SelectedASTNode | Represents a selected AST node
C SourceChangeRefactoringRule | A type of refactoring action rule that produces source replacements in the form of atomic changes
C SourceFileCallbacks | Callbacks called before and after each source file processed by a FrontendAction created by the FrontedActionFactory returned by `newFrontendActionFactory`
C SourceRangeSelectionRequirement | A selection requirement that is satisfied when any portion of the source text is selected
C SourceSelectionRequirement | 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)
C StandaloneToolExecutor | A standalone executor that runs FrontendActions on a given set of TUs in sequence
C StandaloneToolExecutorPlugin |
C SymbolName | A name of a symbol
C SymbolOccurrence | An occurrence of a symbol in the source
C ToolAction | Interface to process a clang::CompilerInvocation
C ToolExecutor | Interface for executing clang frontend actions
C ToolExecutorPlugin | Interface for factories that create specific executors
C ToolInvocation | Utility to run a FrontendAction in a single clang invocation
C ToolResults | An abstraction for the result of a tool execution
C Transformer | Handles the matcher and callback registration for a single `RewriteRule`, as defined by the arguments of the constructor
C TranslationUnitDiagnostics | Collection of Diagnostics generated from a single translation unit
C TranslationUnitReplacements | Collection of Replacements generated from a single translation unit
C USRFindingAction |
C USRSymbolRenamer |
►N transformer |
►N detail | The following three functions are a low-level part of the RewriteRule API
C Transformation | A source "transformation," represented by a character range in the source to be replaced and a corresponding replacement string
C ASTEdit |
C MatchComputation | A failable computation over nodes bound by AST matchers, with (limited) reflection via the `toString` method
►C RewriteRule | Description of a source-code transformation
C Case |
C AbstractConditionalOperator | AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOperator
C AccessSpecDecl | Represents an access specifier followed by colon ':'
C ActionResult | ActionResult - This structure is used while parsing/acting on expressions, stmts, etc
C ActionResult< PtrTy, true > |
C AddFlagValue |
C AddrLabelExpr | AddrLabelExpr - The GNU address of label extension, representing &&label
C AdjustedLocInfo |
C AdjustedType | Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons
C AdjustedTypeLoc |
C ADLResult | A class for storing results from argument-dependent lookup
C AmbiguousConversionSequence | Represents an ambiguous user-defined conversion sequence
C AnalysisDeclContext | AnalysisDeclContext contains the context data for the function or method under analysis
C AnalysisDeclContextManager |
C AnalyzerOptions | Stores options for the analyzer from the command line
C APFixedPoint | Works similarly to APInt/APSInt in that it is a functional replacement for a scaled integer
C APFloatStorage |
C APIntStorage |
C APNumericStorage | Used by IntegerLiteral/FloatingLiteral to store the numeric without leaking memory
►C APValue | APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset], [Vector: N * APValue], [Array: N * APValue]
C LV |
C LValueBase |
C LValuePathEntry | A non-discriminated union of a base, field, or array index
C MemberPointerData |
C NoLValuePath |
C UninitArray |
C UninitStruct |
C ArgumentConstructionContext |
C ArrayInitIndexExpr | Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr
C ArrayInitLoopExpr | Represents a loop initializing the elements of an array
C ArrayLocInfo |
C ArraySubscriptExpr | ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting
C ArrayType | Represents an array type, per C99 6.7.5.2 - Array Declarators
C ArrayTypeLoc | Wrapper for source info for arrays
C ArrayTypeTraitExpr | An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent
C AsmStmt | AsmStmt is the base class for GCCAsmStmt and MSAsmStmt
C AssumedTemplateStorage | A structure for storing the information associated with a name that has been assumed to be a template name (despite finding no TemplateDecls)
C ASTConstraintSatisfaction | The result of a constraint satisfaction check, containing the necessary information to diagnose an unsatisfied constraint
C ASTConsumer | ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs
►C ASTContext | Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic analysis of a file
C DynTypedNodeList | Container for either a single DynTypedNode or for an ArrayRef to DynTypedNode
►C ParentMap |
C ASTVisitor | A `RecursiveASTVisitor` that builds a map from nodes to their parents as defined by the `RecursiveASTVisitor`
C SectionInfo |
C ASTDeclListAction |
C ASTDeclReader |
C ASTDeclWriter |
C ASTDeserializationListener |
C ASTDumpAction |
C ASTDumper |
C ASTFileSignature | The signature of a module, which is a hash of the AST content
C ASTFrontendAction | Abstract base class to use for AST consumer-based frontend actions
C ASTIdentifierIterator | An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files
►C ASTImporter | Imports selected nodes from one AST context into another context, merging AST nodes where appropriate
C ImportPathTy |
C ASTImporterLookupTable |
C ASTImporterSharedState | Importer specific state, which may be shared amongst several ASTImporter objects
C ASTMergeAction | Frontend action adaptor that merges ASTs together
C ASTMutationListener | An abstract interface that should be implemented by listeners that want to be notified when an AST entity gets modified after its initial creation
►C ASTNameGenerator |
C Implementation |
C ASTNodeImporter |
C ASTNodeTraverser | ASTNodeTraverser traverses the Clang AST for dumping purposes
C ASTPrintAction |
►C ASTReader | Reads an AST files chain containing the contents of a translation unit
C ImportedSubmodule |
C ListenerScope | RAII object to temporarily add an AST callback listener
C ModuleDeclIterator |
C ASTReaderListener | Abstract interface for callback invocations by the ASTReader
►C ASTRecordLayout | ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/class
C VBaseInfo |
C ASTRecordReader | An object for streaming information from a record
C ASTRecordWriter | An object for streaming information to a record
C ASTStmtReader |
C ASTStmtWriter |
C ASTTemplateArgumentListInfo | Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>"
C ASTTemplateKWAndArgsInfo | Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>"
►C ASTUnit | Utility class for loading a ASTContext from an AST file
C ASTWriterData |
C CachedCodeCompletionResult | A cached code-completion result, which may be introduced in one of many different contexts
C ConcurrencyCheck |
C StandaloneDiagnostic |
C StandaloneFixIt |
C ASTUnresolvedSet | An UnresolvedSet-like class which uses the ASTContext's allocator
C ASTVector |
C ASTViewAction |
C ASTWriter | Writes an AST file containing the contents of a translation unit
C AsTypeExpr | 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
C AtomicConstraint |
C AtomicExpr | 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
C AtomicScopeModel | Defines the interface for synch scope model
C AtomicScopeOpenCLModel | Defines the synch scope model for OpenCL
C AtomicType |
C AtomicTypeLoc |
C AtomicTypeLocInfo |
C Attr | Attr - This represents one attribute
C AttributeCommonInfo |
C AttributedLocInfo |
C AttributedStmt | Represents an attribute applied to a statement
C AttributedType | An attributed type is a type to which a type attribute has been applied
C AttributedTypeLoc | Type source information for an attributed type
C AttributeFactory | A factory, from which one makes pools, from which one creates individual attributes which are deallocated with the pool
C AttributePool |
C AttrVisitor | A simple visitor class that helps create attribute visitors
C AutoType | Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint
C AutoTypeLoc |
C AutoTypeLocInfo |
C AvailabilityChange | Represents information about a change in availability for an entity, which is part of the encoding of the 'availability' attribute
C AvailabilitySpec | One specifier in an expression
C BackendConsumer |
C BadConversionSequence | BadConversionSequence - Records information about an invalid conversion sequence
C BalancedDelimiterTracker | RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ..
C BaseSubobject |
C BeforeThanCompare | Comparison function object
C BeforeThanCompare< RawComment > | Compare comments' source locations
C BeforeThanCompare< SourceLocation > | Compare two source locations
C BeforeThanCompare< SourceRange > | Compare two non-overlapping source ranges
C BinaryConditionalOperator | BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle operand to be omitted
C BinaryOperator | A builtin binary operation expression such as "x + y" or "x <= y"
C BindingDecl | A binding in a decomposition declaration
C BlockCall |
►C BlockDecl | Represents a block literal declaration, which is like an unnamed FunctionDecl
C Capture | A class which contains all the information about a particular captured value
C BlockEdge |
C BlockEntrance |
C BlockExit |
C BlockExpr | BlockExpr - Adaptor class for mixing a BlockDecl with expressions
C BlockInvocationContext |
C BlockPointerType | Pointer to a block type
C BlockPointerTypeLoc | Wrapper for source info for block pointers
C BlockVarCopyInit | Copy initialization expr of a __block variable and a boolean flag that indicates whether the expression can throw
C BodyFarm |
C BreakStmt | BreakStmt - This represents a break
C BuildPreambleErrorCategory |
C BuiltinBitCastExpr | Represents a C++2a __builtin_bit_cast(T, v) expression
C BuiltinLocInfo |
C BuiltinTemplateDecl | Represents the builtin template declaration which is used to implement __make_integer_seq and other builtin templates
C BuiltinType | This class is used for builtin types like 'int'
C BuiltinTypeLoc | Wrapper for source info for builtin types
C BumpVector |
C BumpVectorContext |
C CallDescription | This class represents a description of a function call using the number of arguments and the name of the function
C CallDescriptionMap | An immutable map from CallDescriptions to arbitrary data
C CallEnter | Represents a point when we begin processing an inlined call
C CallEventManager | Manages the lifetime of CallEvent objects
C CallExitBegin | Represents a point when we start the call exit sequence (for inlined call)
C CallExitEnd | Represents a point when we finish the call exit sequence (for inlined call)
C CallExpr | CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call])
C CallGraph | The AST-based call graph
C CallGraphNode |
C CanonicalDeclPtr | A wrapper class around a pointer that always points to its canonical declaration
C CanProxy | Canonical proxy type returned when retrieving the members of a canonical type or as the result of the `CanQual<T>::getAs` member function
C CanProxyAdaptor | Replaceable canonical proxy adaptor class that provides the link between a canonical type and the accessors of the type
C CanProxyAdaptor< BlockPointerType > |
C CanProxyAdaptor< ComplexType > |
C CanProxyAdaptor< DecltypeType > |
C CanProxyAdaptor< DependentSizedExtVectorType > |
C CanProxyAdaptor< EnumType > |
C CanProxyAdaptor< ExtVectorType > |
C CanProxyAdaptor< FunctionNoProtoType > |
C CanProxyAdaptor< FunctionProtoType > |
C CanProxyAdaptor< FunctionType > |
C CanProxyAdaptor< LValueReferenceType > |
C CanProxyAdaptor< MemberPointerType > |
C CanProxyAdaptor< ObjCObjectPointerType > |
C CanProxyAdaptor< ObjCObjectType > |
C CanProxyAdaptor< PointerType > |
C CanProxyAdaptor< RecordType > |
C CanProxyAdaptor< ReferenceType > |
C CanProxyAdaptor< RValueReferenceType > |
C CanProxyAdaptor< TagType > |
C CanProxyAdaptor< TemplateTypeParmType > |
C CanProxyAdaptor< TypeOfType > |
C CanProxyAdaptor< UnaryTransformType > |
C CanProxyAdaptor< VectorType > |
C CanProxyBase | Base class of all canonical proxy types, which is responsible for storing the underlying canonical type and providing basic conversions
C CanQual | Represents a canonical, potentially-qualified type
C CanTypeIterator | Iterator adaptor that turns an iterator over canonical QualTypes into an iterator over CanQualTypes
C CapturedDecl | Represents the body of a CapturedStmt, and serves as its DeclContext
►C CapturedStmt | This captures a statement into a function
C Capture | Describes the capture of either a variable, or 'this', or variable-length array type
C CaseStmt | CaseStmt - Represent a case statement
C cast_convert_decl_context |
C cast_convert_decl_context< ToTy, true > |
C CastExpr | 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)
►C CFG | Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt
C BuildOptions |
C CFGAutomaticObjDtor | Represents C++ object destructor implicitly generated for automatic object or temporary bound to const reference at the point of leaving its local scope
C CFGBaseDtor | Represents C++ object destructor implicitly generated for base object in destructor
►C CFGBlock | Represents a single basic block in a source-level CFG
C AdjacentBlock | This class represents a potential adjacent block in the CFG
C FilteredCFGBlockIterator |
C FilterOptions |
C CFGCallback | CFGCallback defines methods that should be called when a logical operator error is found when building the CFG
C CFGConstructor | Represents C++ constructor call
C CFGCXXRecordTypedCall | Represents a function call that returns a C++ object by value
C CFGDeleteDtor | Represents C++ object destructor generated from a call to delete
C CFGDominatorTreeImpl | Dominator tree builder for Clang's CFG based on llvm::DominatorTreeBase
C CFGElement | Represents a top-level expression in a basic block
C CFGImplicitDtor | Represents C++ object destructor implicitly generated by compiler on various occasions
C CFGInitializer | Represents C++ base or member initializer from constructor's initialization list
C CFGLifetimeEnds | Represents the point where the lifetime of an automatic object ends
C CFGLoopExit | Represents the point where a loop ends
C CFGMemberDtor | Represents C++ object destructor implicitly generated for member object in destructor
C CFGNewAllocator | Represents C++ allocator call
C CFGReverseBlockReachabilityAnalysis |
C CFGScopeBegin | Represents beginning of a scope implicitly generated by the compiler on encountering a CompoundStmt
C CFGScopeEnd | Represents end of a scope implicitly generated by the compiler after the last Stmt in a CompoundStmt's body
C CFGStmt |
C CFGStmtMap |
C CFGTemporaryDtor | Represents C++ object destructor implicitly generated at the end of full expression for temporary object
C CFGTerminator | Represents CFGBlock terminator statement
C CGOpenMPSIMDRuntime | Class supports emissionof SIMD-only code
C ChainedASTReaderListener | Simple wrapper class for chaining listeners
C ChainedDiagnosticConsumer | ChainedDiagnosticConsumer - Chain two diagnostic clients so that diagnostics go to the first client and then the second
C CharacterLiteral |
C CharLiteralParser | CharLiteralParser - Perform interpretation and semantic analysis of a character literal
C CharSourceRange | Represents a character-granular source range
C CharUnits | CharUnits - This is an opaque type for sizes expressed in character units
C ChooseExpr | ChooseExpr - GNU builtin-in function __builtin_choose_expr
C ClangDiagnosticHandler |
C ClassScopeFunctionSpecializationDecl | Declaration of a function specialization at template class scope
►C ClassTemplateDecl | Declaration of a class template
C Common | Data that is common to all of the declarations of a given class template
C ClassTemplatePartialSpecializationDecl |
C ClassTemplateSpecializationDecl | Represents a class template specialization, which refers to a class template with a given set of template arguments
C CleanupInfo |
C CloneConstraint | This class is a utility class that contains utility functions for building custom constraints
C CloneDetector | Searches for similar subtrees in the AST
C CoawaitExpr | Represents a 'co_await' expression
►C CodeCompleteConsumer | Abstract interface for a consumer of code-completion information
C OverloadCandidate |
C CodeCompleteOptions | Options controlling the behavior of code completion
C CodeCompletionAllocator | An allocator used specifically for the purpose of code completion
C CodeCompletionBuilder | A builder class used to construct new code-completion strings
C CodeCompletionContext | The context in which code completion occurred, so that the code-completion consumer can process the results accordingly
C CodeCompletionHandler | Callback handler that receives notifications when performing code completion within the preprocessor
C CodeCompletionResult | Captures a result of code completion
►C CodeCompletionString | A "string" used to describe how code completion can be performed for an entity
C Chunk | One piece of the code completion string
C CodeCompletionTUInfo |
C CodeGenAction |
C CodeGenerator | The primary public interface to the Clang code generator
►C CodeGenOptions | CodeGenOptions - Track various options which control how the code is optimized and passed to the backend
C BitcodeFileToLink |
C CodeGenOptionsBase | Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure that this large collection of bitfields is a trivial class type
C CodeInjector | CodeInjector is an interface which is responsible for injecting AST of function definitions that may not be available in the original source
C ColonProtectionRAIIObject | ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed
C ColorScope |
C CommentHandler | Abstract base class that describes a handler that will receive source ranges for each of the comments encountered in the source file
C CommentOptions | Options for controlling comment parsing
C ComparisonCategories |
►C ComparisonCategoryInfo |
C ValueInfo |
C CompilerInstance | CompilerInstance - Helper class for managing a single instance of the Clang compiler
C CompilerInvocation | Helper class for holding the data necessary to invoke the compiler
C CompilerInvocationBase |
C ComplexType | Complex values, per C99 6.2.5p11
C ComplexTypeLoc |
C CompoundAssignOperator | CompoundAssignOperator - For compound assignments (e.g
C CompoundLiteralExpr | CompoundLiteralExpr - [C99 6.5.2.5]
C CompoundStmt | CompoundStmt - This represents a group of statements like { stmt stmt }
C ConceptDecl |
C ConceptReference | Common data class for constructs that reference concepts with template arguments
C ConceptSpecializationExpr | Represents the specialization of a concept - evaluates to a prvalue of type bool
►C ConcreteTypeLoc | A metaprogramming base class for TypeLoc classes which correspond to a particular Type subclass
C HasNoInnerType |
C ConditionalOperator | ConditionalOperator - The ?: ternary operator
C ConstantArrayType | Represents the canonical version of C arrays with a specified constant size
C ConstantArrayTypeLoc |
C ConstantExpr | ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluating the expression
C ConstAttrVisitor | A simple visitor class that helps create attribute visitors
C ConstDeclVisitor | A simple visitor class that helps create declaration visitors
C ConstEvaluatedExprVisitor | ConstEvaluatedExprVisitor - This class visits 'const Expr *'s
C ConstraintSatisfaction | The result of a constraint satisfaction check, containing the necessary information to diagnose an unsatisfied constraint
C ConstructionContext | ConstructionContext's subclasses describe different ways of constructing an object in C++
C ConstructionContextItem | Represents a single point (AST node) in the program that requires attention during construction of an object
C ConstructionContextLayer | Construction context can be seen as a linked list of multiple layers
C ConstructorInfo |
C ConstructorInitializerConstructionContext |
C ConstructorUsingShadowDecl | Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that names a constructor
C ConstStmtIterator |
C ConstStmtVisitor | ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses
C ConstTemplateArgumentVisitor | A simple visitor class that helps create template argument visitors
C ContinueStmt | ContinueStmt - This represents a continue
►C ContinuousRangeMap | A map from continuous integer ranges to some value, with a very specialized interface
C Builder | An object that helps properly build a continuous range map from a set of values
C ControlDependencyCalculator |
C ConversionFixItGenerator | The class facilities generation and storage of conversion FixIts
C ConvertVectorExpr | ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for converting a vector type to another vector type of the same arity
C CopiedTypeVisitor |
C CoreturnStmt | Represents a 'co_return' statement in the C++ Coroutines TS
►C CoroutineBodyStmt | Represents the body of a coroutine
C CtorArgs |
C CoroutineStmtBuilder |
C CoroutineSuspendExpr | Represents an expression that might suspend coroutine execution; either a co_await or co_yield expression
C CorrectionCandidateCallback | Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo correction
C CoverageSourceInfo | Stores additional source code information like skipped ranges which is required by the coverage mapping generator and is obtained from the preprocessor
C CoyieldExpr | Represents a 'co_yield' expression
C CStyleCastExpr | 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
C CUDAKernelCallExpr | Represents a call to a CUDA kernel function
►C CurrentSourceLocExprScope | Represents the current source location and context used to determine the value of the source location builtins (ex
C SourceLocExprScopeGuard |
C CXX17ElidedCopyConstructorInitializerConstructionContext | Represents construction into a field or a base class within a bigger object via a constructor initializer, with a single constructor, eg
C CXX17ElidedCopyReturnedValueConstructionContext | Represents a temporary object that is being immediately returned from a function by value, eg
C CXX17ElidedCopyVariableConstructionContext | Represents construction into a simple variable with an initializer syntax, with a single constructor, eg
►C CXXABI | Implements C++ ABI-specific semantic analysis functions
C MemberPointerInfo |
C CXXAllocatorCall | Represents the memory allocation call in a C++ new-expression
C CXXBasePath | 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
C CXXBasePathElement | Represents an element in a path from a derived class to a base class
C CXXBasePaths | BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases
C CXXBaseSpecifier | Represents a base class of a C++ class
C CXXBindTemporaryExpr | Represents binding an expression to a temporary
C CXXBoolLiteralExpr | A boolean literal, per ([C++ lex.bool] Boolean literals)
C CXXCatchStmt | CXXCatchStmt - This represents a C++ catch block
C CXXConstCastExpr | A C++ `const_cast` expression (C++ [expr.const.cast])
C CXXConstructExpr | Represents a call to a C++ constructor
C CXXConstructorCall | Represents a call to a C++ constructor
C CXXConstructorDecl | Represents a C++ constructor within a class
C CXXConversionDecl | Represents a C++ conversion function within a class
C CXXCtorInitializer | Represents a C++ base or member initializer
C CXXDeductionGuideDecl | Represents a C++ deduction guide declaration
C CXXDefaultArgExpr | A default argument (C++ [dcl.fct.default])
C CXXDefaultInitExpr | A use of a default initializer in a constructor or in aggregate initialization
C CXXDeleteExpr | Represents a `delete` expression for memory deallocation and destructor calls, e.g
C CXXDependentScopeMemberExpr | 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
C CXXDestructorCall | Represents an implicit call to a C++ destructor
C CXXDestructorDecl | Represents a C++ destructor within a class
C CXXDynamicCastExpr | A C++ `dynamic_cast` expression (C++ [expr.dynamic.cast])
C CXXFieldCollector | CXXFieldCollector - Used to keep track of CXXFieldDecls during parsing of C++ classes
C CXXFinalOverriderMap | A mapping from each virtual member function to its set of final overriders
C CXXFoldExpr | Represents a folding of a pack over an operator
C CXXForRangeStmt | 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)'
C CXXFunctionalCastExpr | Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv])
C CXXIndirectPrimaryBaseSet | A set of all the primary bases for a class
C CXXInheritedCtorInitExpr | Represents a call to an inherited base class constructor from an inheriting constructor
C CXXInstanceCall | Represents a non-static C++ member function call, no matter how it is written
C CXXMemberCall | Represents a non-static C++ member function call
C CXXMemberCallExpr | 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
C CXXMemberOperatorCall | Represents a C++ overloaded operator call where the operator is implemented as a non-static member function
C CXXMethodDecl | Represents a static or instance method of a struct/union/class
C CXXNamedCastExpr | Abstract class common to all of the C++ "named"/"keyword" casts
C CXXNewExpr | Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"
C CXXNoexceptExpr | Represents a C++11 noexcept expression (C++ [expr.unary.noexcept])
C CXXNullPtrLiteralExpr | The null pointer literal (C++11 [lex.nullptr])
C CXXOperatorCallExpr | A call to an overloaded operator written using operator syntax
C CXXPseudoDestructorExpr | Represents a C++ pseudo-destructor (C++ [expr.pseudo])
►C CXXRecordDecl | Represents a C++ struct/union/class
C friend_iterator | An iterator over the friend declarations of a class
C CXXReinterpretCastExpr | A C++ `reinterpret_cast` expression (C++ [expr.reinterpret.cast])
►C CXXRewrittenBinaryOperator | A rewritten comparison expression that was originally written using operator syntax
C DecomposedForm |
C CXXScalarValueInitExpr | An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type
C CXXScopeSpec | Represents a C++ nested-name-specifier or a global scope specifier
C CXXStaticCastExpr | A C++ `static_cast` expression (C++ [expr.static.cast])
C CXXStdInitializerListExpr | Implicit construction of a std::initializer_list<T> object from an array temporary within list-initialization (C++11 [dcl.init.list]p5)
C CXXTemporary | Represents a C++ temporary
C CXXTemporaryObjectExpr | Represents a C++ functional cast expression that builds a temporary object
C CXXThisExpr | Represents the `this` expression in C++
C CXXThrowExpr | A C++ throw-expression (C++ [except.throw])
C CXXTryStmt | CXXTryStmt - A C++ try block, including all handlers
C CXXTypeidExpr | 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
C CXXUnresolvedConstructExpr | Describes an explicit type conversion that uses functional notion but could not be resolved because one or more arguments are type-dependent
C CXXUuidofExpr | A Microsoft C++ `__uuidof` expression, which gets the _GUID that corresponds to the supplied type or expression
C DataflowValues | DataflowValues. Container class to store dataflow values for a CFG
C DecayedType | Represents a pointer type decayed from an array or function type
C DecayedTypeLoc | Wrapper for source info for pointers decayed from arrays and functions
►C Decl | Decl - This represents one declaration (or definition), e.g
C EmptyShell | 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)
C redecl_iterator | Iterates through all the redeclarations of the same decl
C DeclAccessPair | A POD class for pairing a NamedDecl* with an access specifier
C DeclarationName | The name of a declaration
C DeclarationNameInfo | DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnding source/type location info
►C DeclarationNameLoc | DeclarationNameLoc - Additional source/type location info for a declaration name
C CXXLitOpName |
C CXXOpName |
C NT |
C DeclarationNameTable | DeclarationNameTable is used to store and retrieve DeclarationName instances for the various kinds of declaration names, e.g., normal identifiers, C++ constructor names, etc
C Declarator | Information about one declarator, including the parsed type information and the identifier
►C DeclaratorChunk | One instance of this struct is used for each type in a declarator that is parsed
C ArrayTypeInfo |
C BlockPointerTypeInfo |
C FunctionTypeInfo |
C MemberPointerTypeInfo |
C ParamInfo | ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed
C PipeTypeInfo |
C PointerTypeInfo |
C ReferenceTypeInfo |
C TypeAndRange |
C DeclaratorDecl | Represents a ValueDecl that came out of a declarator
►C DeclContext | DeclContext - This is used only as base class of specific decl types that can act as declaration contexts
C all_lookups_iterator | All_lookups_iterator - An iterator that provides a view over the results of looking up every possible name
C ddiag_iterator | An iterator over the dependent diagnostics in a dependent context
C decl_iterator | Decl_iterator - Iterates through the declarations stored within this context
C filtered_decl_iterator | Iterates over a filtered subrange of declarations stored in a DeclContext
C specific_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)
C udir_iterator |
►C DeclContextLookupResult | The results of name lookup within a DeclContext
C iterator |
C DeclFilterCCC | Simple template class for restricting typo correction candidates to ones having a single Decl* of the given type
C DeclGroup |
C DeclGroupRef |
C DeclRefExpr | A reference to a declared variable, function, enum, etc
C DeclSpec | Captures information about "declaration specifiers"
C DeclStmt | DeclStmt - Adaptor class for mixing declarations with statements and expressions
C DecltypeType | Represents the type `decltype(expr)` (C++11)
C DecltypeTypeLoc |
C DeclVisitor | A simple visitor class that helps create declaration visitors
C DecompositionDecl | A decomposition declaration
►C DecompositionDeclarator | A parsed C++17 decomposition declarator of the form '[' identifier-list ']'
C Binding |
C DeducedPack | A pack that we're currently deducing
C DeducedTemplateArgument | Captures a template argument whose value has been deduced via c++ template argument deduction
C DeducedTemplateSpecializationType | Represents a C++17 deduced template specialization type
C DeducedTemplateSpecializationTypeLoc |
C DeducedType | 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
C DeducedTypeLoc |
C DeductionFailureInfo | A structure used to record information about a failed template argument deduction, for diagnosis
C DefaultArgStorage | Storage for a default argument
C DefaultFilterCCC |
C DefaultInitializedTypeVisitor |
C DefaultStmt |
C DefMacroDirective | A directive for a defined macro or a macro imported from a module
C DeltaTree | DeltaTree - a multiway search tree (BTree) structure with some fancy features
C DependencyCollector | An interface for collecting the dependencies of a compilation
C DependencyFileGenerator | 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
C DependencyOutputOptions | DependencyOutputOptions - Options for controlling the compiler dependency file generation
C DependentAddressSpaceLocInfo |
C DependentAddressSpaceType | Represents an extended address space qualifier where the input address space value is dependent
C DependentAddressSpaceTypeLoc |
C DependentCoawaitExpr | Represents a 'co_await' expression while the type of the promise is dependent
C DependentDecltypeType | Internal representation of canonical, dependent decltype(expr) types
C DependentDiagnostic | A dependently-generated diagnostic
C DependentFunctionTemplateSpecializationInfo | Provides information about a dependent function-template specialization declaration
C DependentNameLocInfo |
C DependentNameType | Represents a qualified type name for which the type name is dependent
C DependentNameTypeLoc |
C DependentScopeDeclRefExpr | A qualified reference to a name whose declaration cannot yet be resolved
C DependentSizedArrayType | Represents an array type in C++ whose size is a value-dependent expression
C DependentSizedArrayTypeLoc |
C DependentSizedExtVectorType | Represents an extended vector type where either the type or size is dependent
C DependentSizedExtVectorTypeLoc |
C DependentStoredDeclsMap |
C DependentTemplateName | Represents a dependent template name that cannot be resolved prior to template instantiation
C DependentTemplateSpecializationLocInfo |
C DependentTemplateSpecializationType | Represents a template specialization type whose template cannot be resolved, e.g
C DependentTemplateSpecializationTypeLoc |
C DependentTypeOfExprType | Internal representation of canonical, dependent `typeof(expr)` types
C DependentUnaryTransformType | Internal representation of canonical, dependent __underlying_type(type) types
C DependentVectorType | Represents a vector type where either the type or size is dependent
C DependentVectorTypeLoc |
►C DesignatedInitExpr | Represents a C99 designated initializer expression
C ArrayOrRangeDesignator | An array or GNU array-range designator, e.g., "[9]" or "[10..15]"
C Designator | Represents a single C99 designator
C FieldDesignator | A field designator, e.g., ".x"
C DesignatedInitUpdateExpr |
C Designation | Designation - Represent a full designation, which is a sequence of designators
C Designator | Designator - A designator in a C99 designated initializer
C DestroyTemplateIdAnnotationsRAIIObj | RAIIObject to destroy the contents of a SmallVector of TemplateIdAnnotation pointers and clear the vector
C DestructedTypeVisitor |
C Diagnostic | 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
C DiagnosticBuilder | A little helper class used to produce diagnostics
C DiagnosticConsumer | Abstract interface, implemented by clients of the front-end, which formats and prints fully processed diagnostics
C DiagnosticError | Carries a Clang diagnostic in an llvm::Error
C DiagnosticErrorTrap | RAII class that determines when any errors have occurred between the time the instance was created and the time it was queried
C DiagnosticIDs | Used for handling and querying diagnostic IDs
C DiagnosticMapping |
C DiagnosticNoteRenderer | Subclass of DiagnosticRender that turns all subdiagostics into explicit notes
C DiagnosticOptions | Options for controlling the compiler diagnostics engine
C DiagnosticRenderer | Class to encapsulate the logic for formatting a diagnostic message
C DiagnosticsEngine | Concrete class used by the front-end to report problems and issues
C DirectoryEntry | Cached information about one directory (either on disk or in the virtual file system)
C DirectoryEntryRef | A reference to a `DirectoryEntry` that includes the name of the directory as it was accessed by the FileManager's client
C DirectoryLookup | DirectoryLookup - This class represents one entry in the search list that specifies the search order for directories in #include directives
►C DirectoryWatcher | Provides notifications for file changes in a directory
C Event |
C DoStmt | DoStmt - This represents a 'do/while' stmt
C DumpCompilerOptionsAction |
C DumpModuleInfoAction | Dump information about the given module file, to be used for basic debugging and discovery
C DumpRawTokensAction |
C DumpTokensAction |
C DynamicAllocLValue | Symbolic representation of a dynamic allocation
C ElaboratedLocInfo |
C ElaboratedType | 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
C ElaboratedTypeLoc |
C ElidedTemporaryObjectConstructionContext | Represents a temporary object that is constructed for the sole purpose of being immediately copied by an elidable copy/move constructor
C EmitAssemblyAction |
C EmitBCAction |
C EmitCodeGenOnlyAction |
C EmitLLVMAction |
C EmitLLVMOnlyAction |
C EmitObjAction |
C EmptyDecl | Represents an empty-declaration
C EmptyPragmaHandler | EmptyPragmaHandler - A pragma handler which takes no action, which can be used to ignore particular pragmas
C EnterExpressionEvaluationContext | RAII object that enters a new expression evaluation context
C EnumConstantDecl | An instance of this object exists for each enum constant that is defined
C EnumDecl | Represents an enum
C EnumType | A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums
C EnumTypeLoc | Wrapper for source info for enum types
C EpsilonPoint | This is a meta program point, which should be skipped by all the diagnostic reasoning etc
C EvaluatedExprVisitor | EvaluatedExprVisitor - This class visits 'Expr *'s
C EvaluatedExprVisitorBase | Given a potentially-evaluated expression, this visitor visits all of its potentially-evaluated subexpressions, recursively
C EvaluatedStmt | 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)
C ExplicitCastExpr | ExplicitCastExpr - An explicit cast written in the source code
C ExplicitSpecifier | Store information needed for an explicit specifier
C ExportDecl | Represents a C++ Modules TS module export declaration
►C Expr | This represents one expression
C Classification | The return type of classify()
C EvalResult | EvalResult is a struct with detailed info about an evaluated expression
C EvalStatus | EvalStatus is a struct with detailed info about an evaluation in progress
C ExpressionTraitExpr | An expression trait intrinsic
C ExprMutationAnalyzer | Analyzes whether any mutative operations are applied to an expression within a given statement
C ExprWithCleanups | Represents an expression – generally a full-expression – that introduces cleanups to be run at the end of the sub-expression's evaluation
C ExtensionRAIIObject | ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them
►C ExternalASTMerger | ExternalASTSource implementation that merges information from several ASTContexts
C DCOrigin | A single origin for a DeclContext
C ImporterSource | A source for an ExternalASTMerger
C ImporterTarget | The target for an ExternalASTMerger
►C ExternalASTSource | Abstract interface for external sources of AST nodes
C ASTSourceDescriptor | Abstracts clang modules and precompiled header files and holds everything needed to generate debug info for an imported module or PCH
C Deserializing | RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing
C MemoryBufferSizes |
C ExternalHeaderFileInfoSource | An external source of header file information, which may supply information about header files already included
C ExternalPreprocessingRecordSource | An abstract class that should be subclassed by any external source of preprocessing record entries
C ExternalPreprocessorSource | Abstract interface for external sources of preprocessor information
C ExternalSemaSource | An abstract interface that should be implemented by external AST sources that also provide information for semantic analysis
C ExternalSLocEntrySource | External source of source location entries
C ExternalVTableUse | A simple structure that captures a vtable use for the purposes of the `ExternalSemaSource`
C ExternCContextDecl | Declaration context for names declared as extern "C" in C++
C ExtQuals | 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
C ExtQualsTypeCommonBase | Base class that is common to both the `ExtQuals` and `Type` classes, which allows `QualType` to access the common fields between the two
C ExtVectorElementExpr | ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the left hand side or right hand side
C ExtVectorType | ExtVectorType - Extended vector type
C ExtVectorTypeLoc |
C FieldDecl | Represents a member of a struct/union/class
C FieldDeclarator | This little struct is used to capture information about structure field declarators, which is basically just a bitfield size
C FileEntry | Cached information about one file (either on disk or in the virtual file system)
C FileEntryRef | A reference to a `FileEntry` that includes the name of the file as it was accessed by the FileManager's client
C FileID | An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with its #include path and #line data
C FileManager | Implements support for file system lookup, file system caching, and directory search management
C FilenamePatternConstraint |
C FileNullability | Describes whether we've seen any nullability information for the given file
C FileNullabilityMap | A mapping from file IDs to a record of whether we've seen nullability information in that file
C FileScopeAsmDecl |
C FileSystemOptions | Keeps track of options that affect how file operations are performed
C FileSystemStatCache | Abstract interface for introducing a FileManager cache for 'stat' system calls, which is used by precompiled and pretokenized headers to improve performance
C FixedPointLiteral |
C FixedPointSemantics | The fixed point semantics work similarly to llvm::fltSemantics
C FixedSizeTemplateParameterListStorage | Stores a list of template parameters and the associated requires-clause (if any) for a TemplateDecl and its derived classes
C FixItAction |
C FixItHint | Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the problem
C FixItOptions |
C FixItRecompile | Emits changes to temporary files and uses them for the original frontend action
C FixItRewriter |
C FloatingLiteral |
C ForStmt | ForStmt - This represents a 'for (init;cond;inc)' stmt
C ForwardingDiagnosticConsumer | Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic consumer
C FPOptions | Floating point control options
C FrameworkCacheEntry | This structure is used to record entries in our framework cache
C FriendDecl | FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type
C FriendTemplateDecl | Declaration of a friend template
C FrontendAction | Abstract base class for actions which can be performed by the frontend
C FrontendInputFile | An input file for the front end
C FrontendOptions | FrontendOptions - Options for controlling the behavior of the frontend
C FullExpr | FullExpr - Represents a "full-expression" node
►C FullSourceLoc | A SourceLocation and its associated SourceManager
C BeforeThanCompare | Comparison function class, useful for sorting FullSourceLocs
C FunctionCallFilterCCC |
►C FunctionDecl | Represents a function declaration or definition
C DefaultedFunctionInfo | Stashed information about a defaulted function definition whose body has not yet been lazily generated
C FunctionExitPoint |
C FunctionLocInfo |
C FunctionNoProtoType | Represents a K&R-style 'int foo()' function, which has no information available about its arguments
C FunctionNoProtoTypeLoc |
C FunctionParmMutationAnalyzer |
C FunctionParmPackExpr | Represents a reference to a function parameter pack or init-capture pack that has been substituted but not yet expanded
►C FunctionProtoType | Represents a prototype with parameter type info, e.g
C ExceptionSpecInfo | Holds information about the various types of exception specification
C ExtProtoInfo | Extra information about a function prototype
C FunctionProtoTypeLoc |
►C FunctionTemplateDecl | Declaration of a template function
C Common | Data that is common to all of the declarations of a given function template
C FunctionTemplateSpecializationInfo | Provides information about a function template specialization, which is a FunctionDecl that has been explicitly specialization or instantiated from a function template
►C FunctionType | FunctionType - C99 6.7.5.3 - Function Declarators
C ExceptionType | A simple holder for a QualType representing a type in an exception specification
C ExtInfo | A class which abstracts out some details necessary for making a call
C ExtParameterInfo | Interesting information about a specific parameter that can't simply be reflected in parameter's type
C FunctionTypeExtraBitfields | A simple holder for various uncommon bits which do not fit in FunctionTypeBitfields
C FunctionTypeLoc | Wrapper for source info for functions
►C GCCAsmStmt | This represents a GCC inline-assembly statement extension
C AsmStringPiece | AsmStringPiece - this is part of a decomposed asm string specification (for use with the AnalyzeAsmString function below)
C GenerateHeaderModuleAction |
C GenerateInterfaceIfsExpV1Action |
C GenerateInterfaceStubAction |
C GenerateModuleAction |
C GenerateModuleFromModuleMapAction |
C GenerateModuleInterfaceAction |
C GeneratePCHAction |
C GenericSelectionExpr | Represents a C11 generic selection
C GlobalCodeCompletionAllocator | Allocator for a cached set of global code completions
C GlobalDecl | GlobalDecl - represents a global declaration
C GlobalModuleIndex | A global index for a set of module files, providing information about the identifiers within those module files
C GNUNullExpr | 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
C GotoStmt | GotoStmt - This represents a direct goto
C GreaterThanIsOperatorScope | RAII object that makes '>' behave either as an operator or as the closing angle bracket for a template argument list
C HeaderFileInfo | The preprocessor keeps track of this information for each file that is #included
C HeaderMap | This class represents an Apple concept known as a 'header map'
C HeaderMapImpl | Implementation for HeaderMap that doesn't depend on FileManager
C HeaderSearch | Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc
►C HeaderSearchOptions | HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSearch object
C Entry |
C SystemHeaderPrefix |
C HMapBucket |
C HMapHeader |
C HTMLPrintAction |
C IdentifierInfo | One of these records is kept for each identifier that is lexed
C IdentifierInfoLookup | Provides lookups to, and iteration over, IdentiferInfo objects
C IdentifierIterator | An iterator that walks over all of the known identifiers in the lookup table
C IdentifierLoc | Wraps an identifier and optional source location for the identifier
►C IdentifierResolver | IdentifierResolver - Keeps track of shadowed decls on enclosing scopes
C IdDeclInfoMap | IdDeclInfoMap - Associates IdDeclInfos with declaration names
C iterator | Iterator - Iterate over the decls of a specified declaration name
C IdentifierTable | Implements an efficient mapping from strings to IdentifierInfo nodes
C IfStmt | IfStmt - This represents an if/then/else
C IgnoringDiagConsumer | A diagnostic client that ignores all diagnostics
C ImaginaryLiteral | ImaginaryLiteral - We support imaginary integer and floating point literals, like "1.0i"
C ImplicitCallPoint | Represents an implicit call event
C ImplicitCastExpr | ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct representation in the original source code
C ImplicitConversionSequence | 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)
C ImplicitParamDecl |
C ImplicitValueInitExpr | Represents an implicitly-generated value initialization of an object of a given type
C ImportDecl | Describes a module import declaration, which makes the contents of the named module visible in the current translation unit
C ImportError |
C InBeforeInTUCacheEntry | Holds the cache used by isBeforeInTranslationUnit
C InclusionDirective | Record the location of an inclusion directive, such as an `#include` or `#import` statement
C IncompleteArrayType | Represents a C array with an unspecified size
C IncompleteArrayTypeLoc |
C IndirectFieldDecl | Represents a field injected from an anonymous union/struct into the parent scope
C IndirectGotoStmt | IndirectGotoStmt - This represents an indirect goto
C InheritableAttr |
C InheritableParamAttr |
C InheritedConstructor | Description of a constructor that was inherited from a base class
C InheritingConcreteTypeLoc | A metaprogramming class designed for concrete subtypes of abstract types where all subtypes share equivalently-structured source information
C InitializationKind | Describes the kind of initialization being performed, along with location information for tokens related to the initialization (equal sign, parentheses)
►C InitializationSequence | Describes the sequence of initializations required to initialize a given object or reference with a set of arguments
►C Step | A single step in the initialization sequence
C F |
C InitializedEntity | Describes an entity that is being initialized
C InitListExpr | Describes an C or C++ initializer list
C InitOnlyAction |
C InjectedClassNameType | The injected class name of a C++ class template or class template partial specialization
C InjectedClassNameTypeLoc | Wrapper for source info for injected class names of class templates
C InMemoryModuleCache | In-memory cache for modules
C InMessageExpressionRAIIObject |
C InputKind | The kind of a file that we've been handed as an input
C IntegerLiteral |
C InventedTemplateParameterInfo |
C IsResultPtrLowBitFree |
C IsResultPtrLowBitFree< CXXBaseSpecifier * > |
C IsResultPtrLowBitFree< CXXCtorInitializer * > |
C IsResultPtrLowBitFree< Expr * > |
C IsResultPtrLowBitFree< Stmt * > |
C ItaniumMangleContext |
C ItaniumVTableContext |
C JSONDumper |
C JSONNodeDumper |
C LabelDecl | Represents the declaration of a label
C LabelStmt | LabelStmt - Represents a label, which has a substatement
C LambdaCapture | Describes the capture of a variable or of `this`, or of a C++1y init-capture
C LambdaExpr | A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked later
►C LambdaIntroducer | Represents a complete lambda introducer
C LambdaCapture | An individual capture in a lambda introducer
C LangOptions | Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that is accepted
C LangOptionsBase | Bitfields of LangOptions, split out from LangOptions in order to ensure that this large collection of bitfields is a trivial class type
C LangStandard | LangStandard - Information about the properties of a particular language standard
C LateParsedTemplate | Contains a late templated function
C LayoutOverrideSource | An external AST source that overrides the layout of a specified set of record types
C LazyASTUnresolvedSet | An UnresolvedSet-like class that might not have been loaded from the external AST source yet
►C LazyGenerationalUpdatePtr | 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
C LazyData | A cache of the value of this pointer, in the most recent generation in which we queried it
C LazyOffsetPtr | A lazy pointer to an AST node (of base type T) that resides within an external AST source
►C LazyVector | Represents a lazily-loaded vector of data
C iterator | Iteration over the elements in the vector
C Lexer | Lexer - This provides a simple interface that turns a text buffer into a stream of tokens
C LexicallyOrderedRecursiveASTVisitor | A RecursiveASTVisitor subclass that guarantees that AST traversal is performed in a lexical order (i.e
C LifetimeExtendedTemporaryDecl | Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-extended by a declaration
C LineEntry |
C LineTableInfo | Used to hold and unique data used to represent #line information
C LinkageComputer |
C LinkageInfo |
C LinkageSpecDecl | Represents a linkage specification
►C LiveVariables |
C LivenessValues |
C Observer |
C LocalInstantiationScope | A stack-allocated class that identifies which local variable declaration instantiations are present in this scope
C LocationCheck |
C LocationContext |
C LocationContextManager |
C LocInfoType | Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing
C LogDiagnosticPrinter |
►C LookupResult | Represents the results of name lookup
C Filter | A class for iterating through a result set and possibly filtering out results
C LoopExit | Represents a point when we exit a loop
C LoopHint | Loop optimization hint for loop and unroll pragmas
C LValueReferenceType | An lvalue reference type, per C++11 [dcl.ref]
C LValueReferenceTypeLoc |
C LVComputationKind | Kinds of LV computation
C MacroArgs | MacroArgs - An instance of this class captures information about the formal arguments specified to a function-like macro invocation
C MacroBuilder |
C MacroDefinition | A description of the current definition of a macro
C MacroDefinitionRecord | Record the location of a macro definition
►C MacroDirective | Encapsulates changes to the "macros namespace" (the location where the macro name became active, the location where it was undefined, etc.)
C DefInfo |
C MacroExpansion | Records the location of a macro expansion
C MacroInfo | Encapsulates the data about a macro definition (e.g
C MacroPPCallbacks |
C MacroQualifiedLocInfo |
C MacroQualifiedType | Sugar type that represents a type that was qualified by a qualifier written as a macro invocation
C MacroQualifiedTypeLoc |
C ManagedAnalysis | The base class of a hierarchy of objects representing analyses tied to AnalysisDeclContext
C MangleContext | MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangler
C MangleNumberingContext | Keeps track of the mangled names of lambda expressions and block literals within a particular context
C MatchingVariablePatternConstraint | Ensures that all clones reference variables in the same pattern
C MaterializeTemporaryExpr | Represents a prvalue temporary that is written into memory so that a reference can bind to it
C MemberExpr | MemberExpr - [C99 6.5.2.3] Structure and Union Members
C MemberExprNameQualifier | Extra data stored in some MemberExpr objects
C MemberPointerLocInfo |
C MemberPointerType | A pointer to member type per C++ 8.3.3 - Pointers to members
C MemberPointerTypeLoc | Wrapper for source info for member pointers
C MemberSpecializationInfo | 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
C MemorizeStatCalls | 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
C Mergeable | Provides common interface for the Decls that cannot be redeclared, but can be merged if the same declaration is brought in from multiple modules
C MethodVFTableLocation |
C MicrosoftMangleContext |
C MicrosoftVTableContext |
C MigratorOptions |
C MinComplexityConstraint | Ensures that every clone has at least the given complexity
C MinGroupSizeConstraint | Ensures that all clone groups contain at least the given amount of clones
C MMToken | A token in a module map file
►C Module | Describes a module or submodule
C Conflict | A conflict between two modules
C DirectoryName | Information about a directory name as found in the module map file
C Header | Information about a header directive as found in the module map file
C LinkLibrary | A library or framework to link against when an entity from this module is used
C UnresolvedConflict | An unresolved conflict with another module
C UnresolvedExportDecl | Describes an exported module that has not yet been resolved (perhaps because the module it refers to has not yet been loaded)
C UnresolvedHeaderDirective | Stored information about a header directive that was found in the module map file but has not been resolved to a file
C ModuleDependencyCollector | Collects the dependencies for imported modules into a directory
C ModuleFileExtension | An abstract superclass that describes a custom extension to the module/precompiled header file format
C ModuleFileExtensionMetadata | Metadata for a module file extension
C ModuleFileExtensionReader | Abstract base class that reads a module file extension block from a module file
C ModuleFileExtensionWriter | Abstract base class that writes a module file extension block into a module file
C ModuleLoader | Abstract interface for a module loader
C ModuleLoadResult | Describes the result of attempting to load a module
C ModuleMacro | Represents a macro directive exported by a module
►C ModuleMap |
C KnownHeader | A header that is known to reside within a given module, whether it was included or excluded
C ModuleMapCallbacks | A mechanism to observe the actions of the module map parser as it reads module map files
C ModuleMapParser |
C MSAsmStmt | This represents a Microsoft inline-assembly statement extension
C MSDependentExistsStmt | Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name
C MSPropertyDecl | An instance of this class represents the declaration of a property member
C MSPropertyRefExpr | A member reference to an MSPropertyDecl
C MSPropertySubscriptExpr | MS property subscript expression
C MultiKeywordSelector | One of these variable length records is kept for each selector containing more than one keyword
C MultiLevelTemplateArgumentList | Data structure that captures multiple levels of template argument lists for use in template instantiation
C MultipleIncludeOpt | Implements the simple state machine that the Lexer class uses to detect files subject to the 'multiple-include' optimization
C MultiplexASTDeserializationListener |
C MultiplexASTMutationListener |
C MultiplexConsumer |
C MultiplexExternalSemaSource | An abstract interface that should be implemented by external AST sources that also provide information for semantic analysis
C NamedDecl | This represents a decl that may have a name
C NamespaceAliasDecl | Represents a C++ namespace alias
C NamespaceDecl | Represent a C++ namespace
C NeonTypeFlags | Flags to identify the types for overloaded Neon builtins
C NestedNameSpecifier | Represents a C++ nested name specifier, such as "\::std::vector<int>::"
C NestedNameSpecifierLoc | A C++ nested-name-specifier augmented with source location information
C NestedNameSpecifierLocBuilder | 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
C NewAllocatedObjectConstructionContext | Represents immediate initialization of memory allocated by operator new, eg
C NodeStreamer |
C NoInitExpr | Represents a place-holder for an object not to be initialized by anything
C NonTypeTemplateParmDecl | NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in
C NormalizedConstraint | 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
C NoTypoCorrectionCCC |
C NSAPI |
C NullStmt | NullStmt - This is the null statement ";": C99 6.8.3p3
C NumericLiteralParser | 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
C ObjCArrayLiteral | ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];
C ObjCAtCatchStmt | Represents Objective-C's @catch statement
C ObjCAtDefsFieldDecl | Represents a field declaration created by an @defs(...)
C ObjCAtFinallyStmt | Represents Objective-C's @finally statement
C ObjCAtSynchronizedStmt | Represents Objective-C's @synchronized statement
C ObjCAtThrowStmt | Represents Objective-C's @throw statement
C ObjCAtTryStmt | Represents Objective-C's @try ... @catch ... @finally statement
C ObjCAutoreleasePoolStmt | Represents Objective-C's @autoreleasepool Statement
C ObjCAvailabilityCheckExpr | A runtime availability query
C ObjCBoolLiteralExpr | ObjCBoolLiteralExpr - Objective-C Boolean Literal
C ObjCBoxedExpr | ObjCBoxedExpr - used for generalized expression boxing
C ObjCBridgedCastExpr | An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process
C ObjCCategoryDecl | ObjCCategoryDecl - Represents a category declaration
C ObjCCategoryImplDecl | ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration
C ObjCCompatibleAliasDecl | ObjCCompatibleAliasDecl - Represents alias of a class
C ObjCContainerDecl | ObjCContainerDecl - Represents a container for method declarations
C ObjCDeclSpec | Captures information about "declaration specifiers" specific to Objective-C
C ObjCDictionaryElement | An element in an Objective-C dictionary literal
C ObjCDictionaryLiteral | ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserName(), @"date" : [NSDate date] };
C ObjCDictionaryLiteral_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
C ObjCDictionaryLiteral_KeyValuePair | Internal struct for storing Key/value pair
C ObjCEncodeExpr | ObjCEncodeExpr, used for @encode in Objective-C
C ObjCForCollectionStmt | Represents Objective-C's collection statement
C ObjCImplDecl |
C ObjCImplementationDecl | ObjCImplementationDecl - Represents a class definition - this is where method definitions are specified
C ObjCIndirectCopyRestoreExpr | ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore in ARC
►C ObjCInterfaceDecl | Represents an ObjC class declaration
C filtered_category_iterator | Iterator that walks over the list of categories, filtering out those that do not meet specific criteria
C ObjCInterfaceLocInfo |
C ObjCInterfaceType | Interfaces are the core concept in Objective-C for object oriented design
C ObjCInterfaceTypeLoc | Wrapper for source info for ObjC interfaces
C ObjCIsaExpr | ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type
C ObjCIvarDecl | ObjCIvarDecl - Represents an ObjC instance variable
C ObjCIvarRefExpr | ObjCIvarRefExpr - A reference to an ObjC instance variable
C ObjCList | ObjCList - This is a simple template class used to hold various lists of decls etc, which is heavily used by the ObjC front-end
C ObjCListBase |
C ObjCMessageExpr | An expression that sends a message to the given Objective-C object or class
C ObjCMethodCall | Represents any expression that calls an Objective-C method
►C ObjCMethodDecl | ObjCMethodDecl - Represents an instance or class method declaration
C GetTypeFn |
C ObjCMethodList | Linked list of methods with the same selector name but different signatures
C ObjCNoReturn |
C ObjCObjectPointerType | Represents a pointer to an Objective C object
C ObjCObjectPointerTypeLoc | Wraps an ObjCPointerType with source location information
C ObjCObjectType | Represents a class type in Objective C
C ObjCObjectTypeImpl | A class providing a concrete implementation of ObjCObjectType, so as to not increase the footprint of ObjCInterfaceType
C ObjCObjectTypeLoc |
C ObjCObjectTypeLocInfo |
C ObjCPropertyDecl | Represents one property declaration in an Objective-C interface
C ObjCPropertyImplDecl | ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category implementation block
C ObjCPropertyRefExpr | ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property
C ObjCProtocolDecl | Represents an Objective-C protocol declaration
C ObjCProtocolExpr | ObjCProtocolExpr used for protocol expression in Objective-C
C ObjCProtocolList | A list of Objective-C protocols, along with the source locations at which they were referenced
C ObjCProtocolQualifiers | This class wraps the list of protocol qualifiers
C ObjCRuntime | The basic abstraction for the target Objective-C runtime
C ObjCSelectorExpr | ObjCSelectorExpr used for @selector in Objective-C
C ObjCStringLiteral | ObjCStringLiteral, used for Objective-C string literals i.e
C ObjCSubscriptRefExpr | ObjCSubscriptRefExpr - used for array and dictionary subscripting
C ObjCTypeParamDecl | Represents the declaration of an Objective-C type parameter
C ObjCTypeParamList | Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereof
C ObjCTypeParamType | Represents a type parameter type in Objective C
C ObjCTypeParamTypeLoc | ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored after Info
C ObjCTypeParamTypeLocInfo |
C ObjectFilePCHContainerReader | A PCHContainerReader implementation that uses LLVM to wraps Clang modules inside a COFF, ELF, or Mach-O container
C ObjectFilePCHContainerWriter | A PCHContainerWriter implementation that uses LLVM to wraps Clang modules inside a COFF, ELF, or Mach-O container
C ODRHash |
C OffsetOfExpr | OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator)
C OffsetOfNode | Helper class for OffsetOfExpr
C OMPAllocateClause | This represents clause 'allocate' in the '#pragma omp ...' directives
C OMPAllocateDecl | This represents '#pragma omp allocate ...' directive
C OMPAllocatorClause | This represents 'allocator' clause in the '#pragma omp ...' directive
C OMPArraySectionExpr | OpenMP 4.0 [2.4, Array Sections]
C OMPAtomicDefaultMemOrderClause | This represents 'atomic_default_mem_order' clause in the '#pragma omp requires' directive
C OMPAtomicDirective | This represents '#pragma omp atomic' directive
C OMPBarrierDirective | This represents '#pragma omp barrier' directive
C OMPCancelDirective | This represents '#pragma omp cancel' directive
C OMPCancellationPointDirective | This represents '#pragma omp cancellation point' directive
C OMPCaptureClause | This represents 'capture' clause in the '#pragma omp atomic' directive
C OMPCapturedExprDecl | Pseudo declaration for capturing expressions
C OMPClause | This is a basic class for representing single OpenMP clause
C OMPClauseReader |
C OMPClauseWithPostUpdate | Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc
C OMPClauseWithPreInit | Class that handles pre-initialization statement for some clauses, like 'shedule', 'firstprivate' etc
C OMPCollapseClause | This represents 'collapse' clause in the '#pragma omp ...' directive
C OMPCriticalDirective | This represents '#pragma omp critical' directive
C OMPDeclareMapperDecl | This represents '#pragma omp declare mapper ...' directive
C OMPDeclareReductionDecl | This represents '#pragma omp declare reduction ...' directive
C OMPDefaultClause | This represents 'default' clause in the '#pragma omp ...' directive
C OMPDistributeDirective | This represents '#pragma omp distribute' directive
C OMPDistributeParallelForDirective | This represents '#pragma omp distribute parallel for' composite directive
C OMPDistributeParallelForSimdDirective | This represents '#pragma omp distribute parallel for simd' composite directive
C OMPDistributeSimdDirective | This represents '#pragma omp distribute simd' composite directive
C OMPDynamicAllocatorsClause | This represents 'dynamic_allocators' clause in the '#pragma omp requires' directive
►C OMPExecutableDirective | This is a basic class for representing single OpenMP executable directive
C specific_clause_iterator | Iterates over a filtered subrange of clauses applied to a directive
C used_clauses_child_iterator | Iterates over expressions/statements used in the construct
C OMPFinalClause | This represents 'final' clause in the '#pragma omp ...' directive
C OMPFirstprivateClause | This represents clause 'firstprivate' in the '#pragma omp ...' directives
C OMPFlushDirective | This represents '#pragma omp flush' directive
C OMPForDirective | This represents '#pragma omp for' directive
C OMPForSimdDirective | This represents '#pragma omp for simd' directive
C OMPIfClause | This represents 'if' clause in the '#pragma omp ...' directive
C OMPInReductionClause | This represents clause 'in_reduction' in the '#pragma omp task' directives
C OMPLastprivateClause | This represents clause 'lastprivate' in the '#pragma omp ...' directives
C OMPLinearClause | This represents clause 'linear' in the '#pragma omp ...' directives
►C OMPLoopDirective | This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc.)
C DistCombinedHelperExprs | The expressions built to support OpenMP loops in combined/composite pragmas (e.g
C HelperExprs | The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest
C OMPMasterDirective | This represents '#pragma omp master' directive
C OMPMasterTaskLoopDirective | This represents '#pragma omp master taskloop' directive
C OMPMasterTaskLoopSimdDirective | This represents '#pragma omp master taskloop simd' directive
C OMPMergeableClause | This represents 'mergeable' clause in the '#pragma omp ...' directive
C OMPNowaitClause | This represents 'nowait' clause in the '#pragma omp ...' directive
C OMPNumThreadsClause | This represents 'num_threads' clause in the '#pragma omp ...' directive
C OMPOrderedClause | This represents 'ordered' clause in the '#pragma omp ...' directive
C OMPOrderedDirective | This represents '#pragma omp ordered' directive
C OMPParallelDirective | This represents '#pragma omp parallel' directive
C OMPParallelForDirective | This represents '#pragma omp parallel for' directive
C OMPParallelForSimdDirective | This represents '#pragma omp parallel for simd' directive
C OMPParallelMasterDirective | This represents '#pragma omp parallel master' directive
C OMPParallelMasterTaskLoopDirective | This represents '#pragma omp parallel master taskloop' directive
C OMPParallelMasterTaskLoopSimdDirective | This represents '#pragma omp parallel master taskloop simd' directive
C OMPParallelSectionsDirective | This represents '#pragma omp parallel sections' directive
C OMPPrivateClause | This represents clause 'private' in the '#pragma omp ...' directives
C OMPProcBindClause | This represents 'proc_bind' clause in the '#pragma omp ...' directive
C OMPReadClause | This represents 'read' clause in the '#pragma omp atomic' directive
C OMPReductionClause | This represents clause 'reduction' in the '#pragma omp ...' directives
C OMPRequiresDecl | This represents '#pragma omp requires...' directive
C OMPReverseOffloadClause | This represents 'reverse_offload' clause in the '#pragma omp requires' directive
C OMPSafelenClause | This represents 'safelen' clause in the '#pragma omp ...' directive
C OMPScheduleClause | This represents 'schedule' clause in the '#pragma omp ...' directive
C OMPSectionDirective | This represents '#pragma omp section' directive
C OMPSectionsDirective | This represents '#pragma omp sections' directive
C OMPSeqCstClause | This represents 'seq_cst' clause in the '#pragma omp atomic' directive
C OMPSharedClause | This represents clause 'shared' in the '#pragma omp ...' directives
C OMPSimdDirective | This represents '#pragma omp simd' directive
C OMPSimdlenClause | This represents 'simdlen' clause in the '#pragma omp ...' directive
C OMPSingleDirective | This represents '#pragma omp single' directive
C OMPTargetDataDirective | This represents '#pragma omp target data' directive
C OMPTargetDirective | This represents '#pragma omp target' directive
C OMPTargetEnterDataDirective | This represents '#pragma omp target enter data' directive
C OMPTargetExitDataDirective | This represents '#pragma omp target exit data' directive
C OMPTargetParallelDirective | This represents '#pragma omp target parallel' directive
C OMPTargetParallelForDirective | This represents '#pragma omp target parallel for' directive
C OMPTargetParallelForSimdDirective | This represents '#pragma omp target parallel for simd' directive
C OMPTargetSimdDirective | This represents '#pragma omp target simd' directive
C OMPTargetTeamsDirective | This represents '#pragma omp target teams' directive
C OMPTargetTeamsDistributeDirective | This represents '#pragma omp target teams distribute' combined directive
C OMPTargetTeamsDistributeParallelForDirective | This represents '#pragma omp target teams distribute parallel for' combined directive
C OMPTargetTeamsDistributeParallelForSimdDirective | This represents '#pragma omp target teams distribute parallel for simd' combined directive
C OMPTargetTeamsDistributeSimdDirective | This represents '#pragma omp target teams distribute simd' combined directive
C OMPTargetUpdateDirective | This represents '#pragma omp target update' directive
C OMPTaskDirective | This represents '#pragma omp task' directive
C OMPTaskgroupDirective | This represents '#pragma omp taskgroup' directive
C OMPTaskLoopDirective | This represents '#pragma omp taskloop' directive
C OMPTaskLoopSimdDirective | This represents '#pragma omp taskloop simd' directive
C OMPTaskReductionClause | This represents clause 'task_reduction' in the '#pragma omp taskgroup' directives
C OMPTaskwaitDirective | This represents '#pragma omp taskwait' directive
C OMPTaskyieldDirective | This represents '#pragma omp taskyield' directive
C OMPTeamsDirective | This represents '#pragma omp teams' directive
C OMPTeamsDistributeDirective | This represents '#pragma omp teams distribute' directive
C OMPTeamsDistributeParallelForDirective | This represents '#pragma omp teams distribute parallel for' composite directive
C OMPTeamsDistributeParallelForSimdDirective | This represents '#pragma omp teams distribute parallel for simd' composite directive
C OMPTeamsDistributeSimdDirective | This represents '#pragma omp teams distribute simd' combined directive
C OMPThreadPrivateDecl | This represents '#pragma omp threadprivate ...' directive
C OMPUnifiedAddressClause | This represents 'unified_address' clause in the '#pragma omp requires' directive
C OMPUnifiedSharedMemoryClause | This represents 'unified_shared_memory' clause in the '#pragma omp requires' directive
C OMPUntiedClause | This represents 'untied' clause in the '#pragma omp ...' directive
C OMPUpdateClause | This represents 'update' clause in the '#pragma omp atomic' directive
C OMPVarListClause | This represents clauses with the list of variables like 'private', 'firstprivate', 'copyin', 'shared', or 'reduction' clauses in the '#pragma omp ...' directives
C OMPVarListLocTy | This structure contains most locations needed for by an OMPVarListClause
C OMPWriteClause | This represents 'write' clause in the '#pragma omp atomic' directive
C OnlyLargestCloneConstraint | Ensures that no clone group fully contains another clone group
C OpaquePtr | Wrapper for void* pointer
C OpaqueValueExpr | OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class
C OpenCLOptions | OpenCL supported extensions and optional core features
C OpenMPCtxSelectorData | Struct to store the context selectors info
C OpenMPScheduleTy | Scheduling data for loop-based OpenMP directives
C OptionalDiagnostic | A partial diagnostic which we might know in advance that we are not going to emit
C OverloadCandidate | OverloadCandidate - A single candidate in an overload set (C++ 13.3)
►C OverloadCandidateSet | OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13.3)
C OperatorRewriteInfo | Information about operator rewrites to consider when adding operator functions to a candidate set
C OverloadedTemplateStorage | A structure for storing the information associated with an overloaded template name
►C OverloadExpr | A reference to an overloaded function set, either an `UnresolvedLookupExpr` or an `UnresolvedMemberExpr`
C FindResult |
C OverridingMethods | The set of methods that override a given virtual method in each subobject where it occurs
C PackExpansionExpr | Represents a C++11 pack expansion that produces a sequence of expressions
C PackExpansionType | Represents a pack expansion of types
C PackExpansionTypeLoc |
C PackExpansionTypeLocInfo |
C ParameterABIAttr | A parameter attribute which changes the argument-passing ABI rule for the parameter
C ParamIdx | A single parameter index whose accessors require each use to make explicit the parameter index encoding needed
C ParenBraceBracketBalancer | RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing, even when there's a parsing error
C ParenExpr | ParenExpr - This represents a parethesized expression, e.g
C ParenListExpr |
C ParenLocInfo |
C ParentMap |
C ParenType | Sugar for parentheses used when specifying types
C ParenTypeLoc |
C ParmVarDecl | Represents a parameter to a function
C ParsedAttr | ParsedAttr - Represents a syntactic attribute
C ParsedAttributes | ParsedAttributes - A collection of parsed attributes
►C ParsedAttributesView |
C const_iterator |
C iterator |
C ParsedSourceLocation | A source location that has been parsed on the command line
C ParsedSourceRange | A source range that has been parsed on the command line
C ParsedTargetAttr | Contains information gathered from parsing the contents of TargetAttr
C ParsedTemplateArgument | Represents the parsed form of a C++ template argument
►C Parser | Parser - This implements a parser for the C family of languages
C ConditionDeclarationOrInitStatementState |
C ObjCTypeParamListScope | Class to handle popping type parameters when leaving the scope
C OpenMPVarListDataTy | Data used for parsing list of variables in OpenMP clauses
C ParseScope | ParseScope - Introduces a new scope for parsing
C UnannotatedTentativeParsingAction | A tentative parsing action that can also revert token annotations
C ParsingDeclarator | A class for parsing a declarator
C ParsingDeclRAIIObject | RAII object used to inform the actions that we're currently parsing a declaration
C ParsingDeclSpec | A class for parsing a DeclSpec
C ParsingFieldDeclarator | A class for parsing a field declarator
C ParsingOpenMPDirectiveRAII | Activates OpenMP parsing mode to preseve OpenMP specific annotation tokens
►C PartialDiagnostic |
C NullDiagnostic |
C Storage |
C StorageAllocator | An allocator for Storage objects, which uses a small cache to objects, used to reduce malloc()/free() traffic for partial diagnostics
C PCHBuffer |
C PCHContainerOperations | A registry of PCHContainerWriter and -Reader objects for different formats
C PCHContainerReader | This abstract interface provides operations for unwrapping containers for serialized ASTs (precompiled headers and clang modules)
C PCHContainerWriter | This abstract interface provides operations for creating containers for serialized ASTs (precompiled headers and clang modules)
C PCHGenerator | AST and semantic-analysis consumer that generates a precompiled header from the parsed source code
C PCHValidator | ASTReaderListener implementation to validate the information of the PCH file against an initialized Preprocessor
C PipeType | PipeType - OpenCL20
C PipeTypeLoc |
C PipeTypeLocInfo |
C PluginASTAction |
C PointerLikeLocInfo |
C PointerLikeTypeLoc | A base class for
C PointerType | PointerType - C99 6.7.5.1 - Pointer Declarators
C PointerTypeLoc | Wrapper for source info for pointers
C PoisonIdentifierRAIIObject | An RAII object for [un]poisoning an identifier within a scope
C PoisonSEHIdentifiersRAIIObject |
C PostAllocatorCall |
C PostCondition |
C PostImplicitCall | Represents a program point just after an implicit call event
C PostInitializer |
C PostLoad |
C PostLValue |
►C PostOrderCFGView |
C BlockOrderCompare |
►C CFGBlockSet | Implements a set of CFGBlocks using a BitVector
C iterator |
C PostStmt |
C PostStmtPurgeDeadSymbols | Represents a point after we ran remove dead bindings AFTER processing the given statement
C PostStore | Represents a program point after a store evaluation
C PPCallbacks | This interface provides a way to observe the actions of the preprocessor as it does its thing
C PPChainedCallbacks | Simple wrapper class for chaining callbacks
C PPConditionalDirectiveRecord | Records preprocessor conditional directive regions and allows querying in which region source locations belong to
C PPConditionalInfo | Information about the conditional stack (#if directives) currently active
C PragmaCommentDecl | Represents a `#pragma comment` line
C PragmaDetectMismatchDecl | Represents a `#pragma detect_mismatch` line
C PragmaHandler | PragmaHandler - Instances of this interface defined to handle the various pragmas that the language front-end uses
C PragmaIntroducer | Describes how and where the pragma was introduced
C PragmaNamespace | PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas, allowing hierarchical pragmas to be defined
C PreambleBounds | Describes the bounds (start, size) of the preamble and a flag required by PreprocessorOptions::PrecompiledPreambleBytes
C PreambleCallbacks | A set of callbacks to gather useful information while building a preamble
C PrecompiledPreamble | A class holding a PCH and all information to check whether it is valid to reuse the PCH for the subsequent runs
C PredefinedExpr | [C99 6.4.2.2] - A predefined identifier such as func
C PreferredTypeBuilder | Keeps track of expected type during expression parsing
C PreImplicitCall | Represents a program point just before an implicit call event
C PreLoad |
C PreprocessedEntity | Base class that describes a preprocessed entity, which may be a preprocessor directive or macro expansion
C PreprocessingDirective | Records the presence of a preprocessor directive
►C PreprocessingRecord | A record of the steps taken while preprocessing a source file, including the various preprocessing directives processed, macros expanded, etc
C iterator | Iteration over the preprocessed entities
C PreprocessOnlyAction |
►C Preprocessor | Engages in a tight little dance with the lexer to efficiently preprocess tokens
C PreambleSkipInfo |
C ResetMacroExpansionHelper |
C PreprocessorFrontendAction | Abstract base class to use for preprocessor-based frontend actions
C PreprocessorLexer |
►C PreprocessorOptions | PreprocessorOptions - This class is used for passing the various options used in preprocessor initialization to InitializePreprocessor()
C FailedModulesSet | Records the set of modules
C PreprocessorOutputOptions | PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g., -E)
C PreStmt |
C PreStmtPurgeDeadSymbols | Represents a point after we ran remove dead bindings BEFORE processing the given statement
C PreStore |
C PresumedLoc | Represents an unpacked "presumed" location which can be presented to the user
C PrettyDeclStackTraceEntry | PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a declaration, include that declaration in the stack trace
C PrettyStackTraceDecl | PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specific decl
C PrettyStackTraceLoc | If a crash happens while one of these objects are live, the message is printed out along with the specified source location
C PrintDependencyDirectivesSourceMinimizerAction |
C PrinterHelper |
C PrintingCallbacks | Callbacks to use to customize the behavior of the pretty-printer
C PrintingCodeCompleteConsumer | A simple code-completion consumer that prints the results it receives in a simple format
C PrintingPolicy | Describes how types, statements, expressions, and declarations should be printed
C PrintPreambleAction |
C PrintPreprocessedAction |
C ProgramPoint |
C ProgramPointTag | ProgramPoints can be "tagged" as representing points specific to a given analysis entity
C PseudoDestructorTypeStorage | Stores the type being destroyed by a pseudo-destructor expression
C PseudoObjectExpr | PseudoObjectExpr - An expression which accesses a pseudo-object l-value
C QualifiedTemplateName | Represents a template name that was expressed as a qualified name
C QualifiedTypeLoc | Wrapper of type source information for a type with non-trivial direct qualifiers
C QualifierCollector | A qualifier set is used to build a set of qualifiers
C QualifierInfo | A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line declarations
C Qualifiers | The collection of all-type qualifiers we support
►C QualType | A (possibly-)qualified type
C StreamedQualTypeHelper |
C QualTypeOrdering | Function object that provides a total ordering on QualType values
C RawComment |
C RawCommentList | This class represents all comments included in the translation unit, sorted in order of appearance in the translation unit
C RawPCHContainerReader | Implements read operations for a raw pass-through PCH container
C RawPCHContainerWriter | Implements write operations for a raw pass-through PCH container
C RecordDecl | Represents a struct/union/class
C RecordType | A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/classes
C RecordTypeLoc | Wrapper for source info for record types
C RecursiveASTVisitor | A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each node
C RecursiveCloneTypeIIHashConstraint | This constraint moves clones into clone groups of type II via hashing
C RecursiveCloneTypeIIVerifyConstraint | This constraint moves clones into clone groups of type II by comparing them
►C Redeclarable | Provides common interface for the Decls that can be redeclared
C DeclLink |
C redecl_iterator | Iterates through all the redeclarations of the same decl
►C RedeclarableTemplateDecl | Declaration of a redeclarable template
C CommonBase |
C SpecEntryTraits |
C SpecEntryTraits< FunctionTemplateSpecializationInfo > |
C SpecIterator |
C ReferenceType | Base for LValueReferenceType and RValueReferenceType
C ReferenceTypeLoc |
C RelaxedLiveVariables |
C RequiresExpr | C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on template arguments
C RequiresExprBodyDecl | Represents the body of a requires-expression
►C ReturnAdjustment | A return adjustment
C VirtualAdjustment | Holds the ABI-specific information about the virtual return adjustment, if needed
C ReturnedValueConstructionContext |
C ReturnStmt | ReturnStmt - This represents a return, optionally of an expression: return; return 4;
C RewriteBuffer | RewriteBuffer - As code is rewritten, SourceBuffer's from the original input with modifications get a new RewriteBuffer associated with them
►C RewriteIncludesAction |
C RewriteImportsListener |
C RewriteMacrosAction |
C RewriteObjCAction |
►C Rewriter | Rewriter - This is the main interface to the rewrite buffers
C RewriteOptions |
C RewriteRope | RewriteRope - A powerful string class
C RewriteTestAction |
C RopePiece | RopePiece - This class represents a view into a RopeRefCountString object
C RopePieceBTree |
C RopePieceBTreeIterator | RopePieceBTreeIterator - This class provides read-only forward iteration over bytes that are in a RopePieceBTree
C RopeRefCountString | RopeRefCountString - This struct is allocated with 'new char[]' from the heap, and represents a reference counted chunk of string data
C RValueReferenceType | An rvalue reference type, per C++11 [dcl.ref]
C RValueReferenceTypeLoc |
C SanitizerBlacklist |
C SanitizerKind |
C SanitizerMask |
C SanitizerSet |
►C SanitizerSpecialCaseList |
C SanitizerSection |
C SavedStreamPosition | Helper class that saves the current stream position and then restores it when destroyed
C Scope | Scope - A scope is a transient data structure that is used while parsing the program
C ScopeContext |
C ScratchBuffer | ScratchBuffer - This class exposes a simple interface for the dynamic construction of tokens
C SEHExceptStmt |
C SEHFinallyStmt |
C SEHLeaveStmt | Represents a __leave statement
C SEHTryStmt |
C Selector | Smart pointer class that efficiently represents Objective-C method names
C SelectorTable | This table allows us to fully hide how we implement multi-keyword caching
►C Sema | Sema - This implements semantic analysis and AST building for C
C ActOnMemberAccessExtraArgs |
C ArgumentPackSubstitutionIndexRAII | RAII object used to change the argument pack substitution index within a `Sema` object
C BoundTypeDiagnoser |
C CodeCompleteExpressionData |
C CodeSynthesisContext | A context in which code is being synthesized (where a source location alone is not sufficient to identify the context)
C CompoundScopeRAII | A RAII object to enter scope of a compound statement
C ConditionResult |
C ContextRAII | A RAII object to temporarily push a declaration context
C ContextualImplicitConverter | Abstract base class used to perform a contextual implicit conversion from an expression to any type passing a filter
C CXXThisScopeRAII | RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers on the current class type
C DefaultedFunctionKind | For a defaulted function, the kind of defaulted function that it is
C DelayedDiagnostics | A class which encapsulates the logic for delaying diagnostics during parsing and other processing
C DelayedDiagnosticsState |
C DeviceDiagBuilder | Diagnostic builder for CUDA/OpenMP devices errors which may or may not be deferred
C ExpressionEvaluationContextRecord | Data structure used to record current or nested expression evaluation contexts
C ExtParameterInfoBuilder | A helper class for building up ExtParameterInfos
C FPContractStateRAII | Records and restores the FP_CONTRACT state on entry/exit of compound statements
C FullExprArg |
C FunctionDeclAndLoc | A pair of a canonical FunctionDecl and a SourceLocation
C FunctionScopeRAII | An RAII helper that pops function a function scope on exit
C GlobalEagerInstantiationScope |
C ICEConvertDiagnoser |
C ImplicitExceptionSpecification | Helper class that collects exception specifications for implicitly-declared special member functions
C InheritedConstructorInfo |
►C InstantiatingTemplate | A stack object to be created when performing template instantiation
C ConstraintNormalization |
C ConstraintsCheck |
C ConstraintSubstitution |
C ExceptionSpecification |
C ParameterMappingSubstitution |
C LateInstantiatedAttribute |
C LocalEagerInstantiationScope |
C NameClassification |
C NestedNameSpecInfo | Keeps information about an identifier in a nested-name-spec
C ObjCArgInfo |
C OffsetOfComponent |
C OriginalCallArg | Brief A function argument from which we performed template argument
C PackIncludeState |
C PoppedFunctionScopeDeleter | Custom deleter to allow FunctionScopeInfos to be kept alive for a short time after they've been popped
C PragmaAttributeEntry | This an attribute introduced by #pragma clang attribute
C PragmaAttributeGroup | A push'd group of PragmaAttributeEntries
C PragmaClangSection |
►C PragmaStack |
C Slot |
C PragmaStackSentinelRAII |
C ReferenceConversionsScope |
C SemaDiagnosticBuilder | Helper class that creates diagnostics with optional template instantiation stacks
C SFINAETrap | RAII class used to determine whether SFINAE has trapped any errors that occur during template argument deduction
C SkipBodyInfo |
C SpecialMemberOverloadResult | SpecialMemberOverloadResult - The overloading result for a special member function
C SpecialMemberOverloadResultEntry |
C SynthesizedFunctionScope | RAII object to handle the state changes required to synthesize a function body
C TentativeAnalysisScope | RAII class used to indicate that we are performing provisional semantic analysis to determine the validity of a construct, so typo-correction and diagnostics in the immediate context (not within implicitly-instantiated templates) should be suppressed
C TypeDiagnoser | Abstract class used to diagnose incomplete types
C TypeTagData |
C VerifyICEDiagnoser | Abstract base class used for diagnosing integer constant expression violations
C SemaConsumer | An abstract interface that should be implemented by clients that read ASTs and then require further semantic analysis of the entities in those ASTs
C ShuffleVectorExpr | ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector
C SimpleASTReaderListener | ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a pch file
C SimpleConstructorInitializerConstructionContext | Represents construction into a field or a base class within a bigger object via a constructor initializer, eg
C SimpleProgramPointTag |
C SimpleReturnedValueConstructionContext | Represents a temporary object that is being immediately returned from a function by value, eg
C SimpleTemporaryObjectConstructionContext | Represents a temporary object that is not constructed for the purpose of being immediately copied/moved by an elidable copy/move-constructor
C SimpleVariableConstructionContext | Represents construction into a simple local variable, eg
C SizeOfPackExpr | Represents an expression that computes the length of a parameter pack
C SourceLocation | Encodes a location in the source
C SourceLocExpr | Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(), or __builtin_FILE()
►C SourceManager | This class handles loading and caching of source files into memory
C MemoryBufferSizes |
C SourceManagerForFile | SourceManager and necessary depdencies (e.g
C SourceRange | A trivial tuple used to represent a source range
C specific_attr_iterator | Specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are of a specific type
C SplitQualType | A std::pair-like structure for storing a qualified type split into its local qualifiers and its locally-unqualified type
C StackFrameContext |
C StandardConversionSequence | StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1)
C StaticAssertDecl | Represents a C++11 static_assert declaration
►C Stmt | Stmt - This represents one statement
C ArraySubscriptExprBitfields |
C AttributedStmtBitfields |
C BinaryOperatorBitfields |
C BreakStmtBitfields |
C CallExprBitfields |
C CastExprBitfields |
C CastIterator | Iterator for iterating over Stmt * arrays that contain only T *
C CharacterLiteralBitfields |
C CoawaitExprBitfields |
C CompoundStmtBitfields |
C ConstantExprBitfields |
C ContinueStmtBitfields |
C CXXBoolLiteralExprBitfields |
C CXXConstructExprBitfields |
C CXXDefaultArgExprBitfields |
C CXXDefaultInitExprBitfields |
C CXXDeleteExprBitfields |
C CXXDependentScopeMemberExprBitfields |
C CXXNewExprBitfields |
C CXXNoexceptExprBitfields |
C CXXNullPtrLiteralExprBitfields |
C CXXOperatorCallExprBitfields |
C CXXRewrittenBinaryOperatorBitfields |
C CXXScalarValueInitExprBitfields |
C CXXThisExprBitfields |
C CXXThrowExprBitfields |
C CXXUnresolvedConstructExprBitfields |
C DeclRefExprBitfields |
C DependentScopeDeclRefExprBitfields |
C DoStmtBitfields |
C EmptyShell | A placeholder type used to construct an empty shell of a type, that will be filled in later (e.g., by some de-serialization)
C ExprBitfields |
C ExprWithCleanupsBitfields |
C FloatingLiteralBitfields |
C ForStmtBitfields |
C GenericSelectionExprBitfields |
C GotoStmtBitfields |
C IfStmtBitfields |
C InitListExprBitfields |
C LabelStmtBitfields |
C MemberExprBitfields |
C NullStmtBitfields |
C ObjCIndirectCopyRestoreExprBitfields |
C OpaqueValueExprBitfields |
C OverloadExprBitfields |
C ParenListExprBitfields |
C PredefinedExprBitfields |
C PseudoObjectExprBitfields |
C RequiresExprBitfields |
C ReturnStmtBitfields |
C SourceLocExprBitfields |
C StmtBitfields |
C StringLiteralBitfields |
C SubstNonTypeTemplateParmExprBitfields |
C SwitchCaseBitfields |
C SwitchStmtBitfields |
C TypeTraitExprBitfields |
C UnaryExprOrTypeTraitExprBitfields |
C UnaryOperatorBitfields |
C UnresolvedLookupExprBitfields |
C UnresolvedMemberExprBitfields |
C WhileStmtBitfields |
C StmtAttr |
C StmtExpr | StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;})
C StmtIterator |
C StmtIteratorBase |
C StmtIteratorImpl |
C StmtPoint |
C StmtSequence | Identifies a list of statements
C StmtVisitor | StmtVisitor - This class implements a simple visitor for Stmt subclasses
C StmtVisitorBase | StmtVisitorBase - This class implements a simple visitor for Stmt subclasses
C StoredDeclsList | An array of decls optimized for the common case of only containing one entry
C StoredDeclsMap |
C StoredDiagnostic | Represents a diagnostic in a form that can be retained until its corresponding source manager is destroyed
C StringLiteral | StringLiteral - This represents a string literal expression, e.g
C StringLiteralParser | StringLiteralParser - This decodes string escape characters and performs wide string analysis and Translation Phase #6 (concatenation of string literals) (C99 5.1.1.2p1)
C StringSizerHelper |
C StructuralEquivalenceContext |
►C SubobjectAdjustment | An adjustment to be made to the temporary created when emitting a reference binding, which accesses a particular subobject of that temporary
C DTB |
C P |
C SubstNonTypeTemplateParmExpr | Represents a reference to a non-type template parameter that has been substituted with a template argument
C SubstNonTypeTemplateParmPackExpr | Represents a reference to a non-type template parameter pack that has been substituted with a non-template argument pack
C SubstTemplateTemplateParmPackStorage | A structure for storing an already-substituted template template parameter pack
C SubstTemplateTemplateParmStorage | A structure for storing the information associated with a substituted template template parameter
C SubstTemplateTypeParmPackType | Represents the result of substituting a set of types for a template type parameter pack
C SubstTemplateTypeParmPackTypeLoc | Wrapper for substituted template type parameters
C SubstTemplateTypeParmType | Represents the result of substituting a type for a template type parameter
C SubstTemplateTypeParmTypeLoc | Wrapper for substituted template type parameters
C SuppressAccessChecks | A RAII object used to temporarily suppress access-like checking
C SwitchCase |
C SwitchStmt | SwitchStmt - This represents a 'switch' stmt
C SyntaxOnlyAction |
C TagDecl | Represents the declaration of a struct/union/class/enum
C TagType |
C TagTypeLoc | Wrapper for source info for tag types
C TargetCXXABI | The basic abstraction for the target C++ ABI
►C TargetInfo | Exposes information about the current target
C AddlRegName |
C BranchProtectionInfo |
C ConstraintInfo |
C GCCRegAlias |
C TargetOptions | Options for controlling the target
C TemplateArgument | Represents a template argument
C TemplateArgumentList | A template argument list
C TemplateArgumentListInfo | A convenient class for passing around template argument information
C TemplateArgumentLoc | Location wrapper for a TemplateArgument
►C TemplateArgumentLocContainerIterator | Simple iterator that traverses the template arguments in a container that provides a `getArgLoc()` member function
C pointer |
C TemplateArgumentLocInfo | Location information for a TemplateArgument
►C TemplateArgumentLocInventIterator | Iterator adaptor that invents template argument location information for each of the template arguments in its underlying iterator
C pointer |
C TemplateArgumentVisitor | A simple visitor class that helps create template argument visitors
C TemplateDecl | The base class of all kinds of template declarations (e.g., class, function, etc.)
C TemplateDeclInstantiator |
C TemplateDiffTypes |
C TemplateIdAnnotation | Information about a template-id annotation token
C TemplateInstantiationCallback | This is a base class for callbacks that will be notified at every template instantiation
C TemplateName | Represents a C++ template name within the type system
C TemplateNameLocInfo |
C TemplateParameterList | Stores a list of template parameters for a TemplateDecl and its derived classes
C TemplateParmPosition | Defines the position of a template parameter within a template parameter list
C TemplatePartialOrderingContext |
C TemplateSpecCandidate | TemplateSpecCandidate - This is a generalization of OverloadCandidate which keeps track of template argument deduction failure info, when handling explicit specializations (and instantiations) of templates beyond function overloading
C TemplateSpecCandidateSet | TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations
C TemplateSpecializationLocInfo |
C TemplateSpecializationType | Represents a type template specialization; the template must be a class template, a type alias template, or a template template parameter
C TemplateSpecializationTypeLoc |
C TemplateTemplateParmDecl | TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in
C TemplateTypeParmDecl | Declaration of a template type parameter
C TemplateTypeParmType |
C TemplateTypeParmTypeLoc | Wrapper for template type parameters
C TemplightDumpAction |
C TemporaryObjectConstructionContext | Represents a temporary object, eg
C TerminalColor |
C TestModuleFileExtension | A module file extension used for testing purposes
C TextDiagnostic | Class to encapsulate the logic for formatting and printing a textual diagnostic message
C TextDiagnosticBuffer |
C TextDiagnosticPrinter |
C TextNodeDumper |
C TextTreeStructure |
►C ThisAdjustment | A `this` pointer adjustment
C VirtualAdjustment | Holds the ABI-specific information about the virtual this adjustment, if needed
C ThunkInfo | The `this` pointer adjustment as well as an optional return adjustment for a thunk
C Token | Token - This structure provides full information about a lexed token
C TokenConcatenation | TokenConcatenation class, which answers the question of "Is it safe to emit two tokens without a whitespace between them, or would that cause implicit concatenation of the tokens?"
C TokenLexer | TokenLexer - This implements a lexer that returns tokens from a macro body or token stream instead of lexing from a character buffer
C TokenRewriter |
C TokenValue | Stores token information for comparing actual tokens with predefined values
C TransferrableTargetInfo | Fields controlling how types are laid out in memory; these may need to be copied for targets like AMDGPU that base their ABIs on an auxiliary CPU target
C TranslationUnitDecl | The top declaration context
C TraversalKindScope |
►C TreeTransform | A semantic tree transformation that allows one to transform one abstract syntax tree into another
C TemporaryBase | RAII object that temporarily sets the base location and entity used for reporting diagnostics in types
C TrivialModuleLoader | A module loader that doesn't know how to create or load modules
►C Type | The base class of the type hierarchy
C ArrayTypeBitfields |
C AttributedTypeBitfields |
C AutoTypeBitfields |
C BuiltinTypeBitfields |
C ConstantArrayTypeBitfields |
C DependentTemplateSpecializationTypeBitfields |
C ElaboratedTypeBitfields |
C FunctionTypeBitfields | FunctionTypeBitfields store various bits belonging to FunctionProtoType
C ObjCObjectTypeBitfields |
C PackExpansionTypeBitfields |
C ReferenceTypeBitfields |
C SubstTemplateTypeParmPackTypeBitfields |
C TemplateSpecializationTypeBitfields |
C TypeWithKeywordBitfields |
C VectorTypeBitfields |
C TypeAliasDecl | Represents the declaration of a typedef-name via a C++11 alias-declaration
C TypeAliasTemplateDecl | Declaration of an alias template
C TypeAttr |
C TypeConstraint |
C TypeDecl | Represents a declaration of a type
C TypedefDecl | Represents the declaration of a typedef-name via the 'typedef' type specifier
C TypedefNameDecl | Base class for declarations which introduce a typedef-name
C TypedefType |
C TypedefTypeLoc | Wrapper for source info for typedefs
C TypeInfo |
C TypeInfoLValue | Symbolic representation of typeid(T) for some type T
C TypeLoc | Base wrapper for a particular "section" of type source info
C TypeLocBuilder |
C TypeLocReader |
C TypeLocVisitor |
C TypeOfExprType | Represents a `typeof` (or typeof) expression (a GCC extension)
C TypeOfExprTypeLoc |
C TypeOfExprTypeLocInfo |
C TypeofLikeTypeLoc |
C TypeofLocInfo |
C TypeOfType | Represents `typeof(type)`, a GCC extension
C TypeOfTypeLoc |
C TypeOfTypeLocInfo |
C TypePropertyCache | The type-property cache
C TypeSourceInfo | A container of type source information
C TypeSpecLocInfo |
C TypeSpecTypeLoc | A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier
C TypeTraitExpr | A type trait used in the implementation of various C++11 and Library TR1 trait templates
C TypeVisitor | An operation on a type
►C TypeWithKeyword | A helper class for Type nodes having an ElaboratedTypeKeyword
C CannotCastToThisType |
C TypoCorrection | Simple class containing the result of Sema::CorrectTypo
C TypoCorrectionConsumer |
C TypoExpr | TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and/or an error diagnostic emitted
C UnaryExprOrTypeTraitExpr | UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand
C UnaryOperator | UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions
C UnaryTransformType | A unary type transform, which is a type constructed from another
C UnaryTransformTypeLoc |
C UnaryTransformTypeLocInfo |
►C UncommonTemplateNameStorage | Implementation class used to describe either a set of overloaded template names or an already-substituted template template parameter pack
C BitsTag |
C UndefMacroDirective | A directive for an undefined macro
►C UninitUse | A use of a variable, which might be uninitialized
C Branch |
C UninitVariablesAnalysisStats |
C UninitVariablesHandler |
C UnionOpaquePtr | UnionOpaquePtr - A version of OpaquePtr suitable for membership in a union
C UniqueVirtualMethod | Uniquely identifies a virtual method within a class hierarchy by the method itself and a class subobject number
►C UnqualifiedId | Represents a C++ unqualified-id that has been parsed
C OFI |
C UnqualTypeLoc | Wrapper of type source information for a type with no direct qualifiers
C UnresolvedLookupExpr | A reference to a name which we were able to look up during parsing but could not resolve to a specific declaration
C UnresolvedMemberExpr | Represents a C++ member access expression for which lookup produced a set of overloaded functions
C UnresolvedSet | A set of unresolved declarations
C UnresolvedSetImpl | A set of unresolved declarations
C UnresolvedSetIterator | The iterator over UnresolvedSets
C UnresolvedUsingType | Represents the dependent type named by a dependently-scoped typename using declaration, e.g
C UnresolvedUsingTypeLoc | Wrapper for source info for unresolved typename using decls
C UnresolvedUsingTypenameDecl | Represents a dependent using declaration which was marked with `typename`
C UnresolvedUsingValueDecl | Represents a dependent using declaration which was not marked with `typename`
C UpdateOnReturn |
C UserDefinedConversionSequence | UserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13.3.3.1.2)
C UserDefinedLiteral | A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit.ext])
►C UsingDecl | Represents a C++ using-declaration
C shadow_iterator | Iterates through the using shadow declarations associated with this using declaration
C UsingDirectiveDecl | Represents C++ using-directive
C UsingPackDecl | Represents a pack of using declarations that a single using-declarator pack-expanded into
C UsingShadowDecl | Represents a shadow declaration introduced into a scope by a (resolved) using declaration
C VAArgExpr | Represents a call to the builtin function `__builtin_va_arg`
C ValueDecl | Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it is a function designator) or an enum constant
C ValueStmt | Represents a statement that could possibly have a value and type
C VAOptDefinitionContext | A class for tracking whether we're inside a VA_OPT during a traversal of the tokens of a variadic macro definition
C VAOptExpansionContext | A class for tracking whether we're inside a VA_OPT during a traversal of the tokens of a macro during macro expansion
►C VarDecl | Represents a variable declaration or definition
C NonParmVarDeclBitfields |
C ParmVarDeclBitfields |
C VariableArrayType | Represents a C array with a specified size that is not an integer-constant-expression
C VariableArrayTypeLoc |
C VariableConstructionContext | An abstract base class for local variable constructors
►C VariablePattern | Analyzes the pattern of the referenced variables in a statement
►C SuspiciousClonePair | Describes two clones that reference their variables in a different pattern which could indicate a programming error
C SuspiciousCloneInfo | Utility class holding the relevant information about a single clone in this pair
C VariadicMacroScopeGuard | An RAII class that tracks when the Preprocessor starts and stops lexing the definition of a (ISO C/C++) variadic macro
►C VarTemplateDecl | Declaration of a variable template
C Common | Data that is common to all of the declarations of a given variable template
C VarTemplatePartialSpecializationDecl |
C VarTemplateSpecializationDecl | Represents a variable template specialization, which refers to a variable template with a given set of template arguments
C VectorType | Represents a GCC generic vector type
C VectorTypeLoc |
►C VerifyDiagnosticConsumer | VerifyDiagnosticConsumer - Create a diagnostic client which will use markers in the input source to check that all the emitted diagnostics match those expected
C Directive | Directive - Abstract class representing a parsed verify directive
C ExpectedData | ExpectedData - owns directive objects and deletes on destructor
C MarkerTracker |
C VerifyPCHAction |
C VirtSpecifiers | Represents a C++11 virt-specifier-seq
C VirtualBaseInfo | All virtual base related information about a given record decl
C VisibilityMacroDirective | A directive for setting the module visibility of a macro
C VisibleDeclConsumer | Consumes visible declarations found when searching for all visible names within a given scope or context
C VisibleModuleSet | A set of visible modules
C VPtrInfo | Holds information about the inheritance path to a virtual base or function table pointer
C VTableComponent | Represents a single component in a vtable
C VTableContextBase |
►C VTableLayout |
C AddressPointLocation |
C VTTBuilder | Class for building VTT layout information
C VTTComponent |
C VTTVTable |
C WeakInfo | Captures information about a #pragma weak directive
C WhileStmt | WhileStmt - This represents a 'while' stmt
C WrapperFrontendAction | A frontend action which simply wraps some other runtime-specified frontend action
C WrittenBuiltinSpecs | Structure that packs information about the type specifiers that were written in a particular type specifier sequence
C XRayFunctionFilter |
C XRayInstrSet |
►N llvm | Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be placed into a PointerUnion
►N cl |
C parser< clang::ParsedSourceLocation > | Command-line option parser that parses source locations
►N IDFCalculatorDetail |
C ChildrenGetterTy< clang::CFGBlock, IsPostDom > | Specialize ChildrenGetterTy to skip nullpointer successors
►N yaml |
C DocumentListTraits< std::vector< FormatStyle > > |
C MappingTraits< clang::tooling::AtomicChange > | Specialized MappingTraits to describe how an AtomicChange is (de)serialized
►C MappingTraits< clang::tooling::Diagnostic > |
C NormalizedDiagnostic | Helper to (de)serialize a Diagnostic since we don't have direct access to its data members
C MappingTraits< clang::tooling::DiagnosticMessage > |
C MappingTraits< clang::tooling::IncludeStyle::IncludeCategory > |
►C MappingTraits< clang::tooling::Replacement > | Specialized MappingTraits to describe how a Replacement is (de)serialized
C NormalizedReplacement | Helper to (de)serialize a Replacement since we don't have direct access to its data members
C MappingTraits< clang::tooling::TranslationUnitDiagnostics > | Specialized MappingTraits to describe how a TranslationUnitDiagnostics is (de)serialized
C MappingTraits< clang::tooling::TranslationUnitReplacements > | Specialized MappingTraits to describe how a TranslationUnitReplacements is (de)serialized
C MappingTraits< FormatStyle > |
C MappingTraits< FormatStyle::BraceWrappingFlags > |
C MappingTraits< FormatStyle::RawStringFormat > |
C MappingTraits< NormalizedAtomicChange > | Specialized MappingTraits to describe how an AtomicChange is (de)serialized
C MappingTraits< TaintConfig > |
C MappingTraits< TaintConfig::NameScopeArgs > |
C MappingTraits< TaintConfig::Propagation > |
C MappingTraits< TemplightEntry > |
C ScalarEnumerationTraits< clang::tooling::IncludeStyle::IncludeBlocksStyle > |
C ScalarEnumerationTraits< FormatStyle::BinaryOperatorStyle > |
C ScalarEnumerationTraits< FormatStyle::BinPackStyle > |
C ScalarEnumerationTraits< FormatStyle::BraceBreakingStyle > |
C ScalarEnumerationTraits< FormatStyle::BraceWrappingAfterControlStatementStyle > |
C ScalarEnumerationTraits< FormatStyle::BracketAlignmentStyle > |
C ScalarEnumerationTraits< FormatStyle::BreakConstructorInitializersStyle > |
C ScalarEnumerationTraits< FormatStyle::BreakInheritanceListStyle > |
C ScalarEnumerationTraits< FormatStyle::BreakTemplateDeclarationsStyle > |
C ScalarEnumerationTraits< FormatStyle::DefinitionReturnTypeBreakingStyle > |
C ScalarEnumerationTraits< FormatStyle::EscapedNewlineAlignmentStyle > |
C ScalarEnumerationTraits< FormatStyle::JavaScriptQuoteStyle > |
C ScalarEnumerationTraits< FormatStyle::LanguageKind > |
C ScalarEnumerationTraits< FormatStyle::LanguageStandard > |
C ScalarEnumerationTraits< FormatStyle::NamespaceIndentationKind > |
C ScalarEnumerationTraits< FormatStyle::PointerAlignmentStyle > |
C ScalarEnumerationTraits< FormatStyle::PPDirectiveIndentStyle > |
C ScalarEnumerationTraits< FormatStyle::ReturnTypeBreakingStyle > |
C ScalarEnumerationTraits< FormatStyle::ShortBlockStyle > |
C ScalarEnumerationTraits< FormatStyle::ShortFunctionStyle > |
C ScalarEnumerationTraits< FormatStyle::ShortIfStyle > |
C ScalarEnumerationTraits< FormatStyle::ShortLambdaStyle > |
C ScalarEnumerationTraits< FormatStyle::SpaceBeforeParensOptions > |
C ScalarEnumerationTraits< FormatStyle::UseTabStyle > |
C ScalarEnumerationTraits< GenericTaintChecker::VariadicType > |
C ArrayRef |
C cast_convert_val< ::clang::DeclContext, FromTy *, FromTy * > |
C cast_convert_val< ::clang::DeclContext, FromTy, FromTy > | Implement cast_convert_val for Decl -> DeclContext conversions
C cast_convert_val< const ::clang::DeclContext, FromTy *, FromTy * > |
C cast_convert_val< const ::clang::DeclContext, FromTy, FromTy > |
C cast_convert_val< ToTy, ::clang::DeclContext *, ::clang::DeclContext * > |
C cast_convert_val< ToTy, ::clang::DeclContext, ::clang::DeclContext > |
C cast_convert_val< ToTy, const ::clang::DeclContext *, const ::clang::DeclContext * > |
C cast_convert_val< ToTy, const ::clang::DeclContext, const ::clang::DeclContext > | Cast<T>(DeclContext*)
C DenseMapInfo |
C DenseMapInfo< CatchHandlerType > |
C DenseMapInfo< clang::APValue::LValueBase > |
C DenseMapInfo< clang::ast_type_traits::ASTNodeKind > |
C DenseMapInfo< clang::ast_type_traits::DynTypedNode > |
C DenseMapInfo< clang::BaseSubobject > |
C DenseMapInfo< clang::CanonicalDeclPtr< decl_type > > |
C DenseMapInfo< clang::CanQualType > |
C DenseMapInfo< clang::CharUnits > |
C DenseMapInfo< clang::CodeGen::TBAAAccessInfo > |
C DenseMapInfo< clang::DeclarationName > | Define DenseMapInfo so that DeclarationNames can be used as keys in DenseMap and DenseSets
C DenseMapInfo< clang::FileID > | Define DenseMapInfo so that FileID's can be used as keys in DenseMap and DenseSets
C DenseMapInfo< clang::GlobalDecl > |
C DenseMapInfo< clang::ProgramPoint > |
C DenseMapInfo< clang::QualType > |
C DenseMapInfo< clang::Selector > | Define DenseMapInfo so that Selectors can be used as keys in DenseMap and DenseSets
C DenseMapInfo< clang::Sema::FunctionDeclAndLoc > |
C DenseMapInfo< clang::serialization::DeclarationNameKey > |
C DenseMapInfo< DecompositionDeclName > |
C DenseMapInfo< EditEntry > |
C DenseMapInfo< ObjCSummaryKey > |
C DenseMapInfo< ObjectUnderConstruction > |
C DenseSet |
C DOTGraphTraits< const CallGraph * > |
C DOTGraphTraits< const CFG * > |
C DOTGraphTraits< const Stmt * > |
C DOTGraphTraits< ExplodedGraph * > |
C DOTGraphTraits< ModuleManager > |
C Expected |
C FoldingSetTrait< AllocKind > |
C FoldingSetTrait< ArgEffect > |
C FoldingSetTrait< ObjectState > |
C FoldingSetTrait< RetEffect > |
C FoldingSetTrait< SValData > |
C FoldingSetTrait< SValPair > |
C GraphTraits< ::clang::CFG *> |
C GraphTraits< ::clang::CFGBlock * > |
C GraphTraits< clang::CallGraph * > |
C GraphTraits< clang::CallGraphNode * > |
C GraphTraits< clang::CFGBlock > |
C GraphTraits< clang::CFGDomTree * > |
C GraphTraits< clang::DomTreeNode * > | DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterators
C GraphTraits< clang::ento::ExplodedGraph * > |
C GraphTraits< clang::Stmt * > |
C GraphTraits< const ::clang::CFG *> |
C GraphTraits< const ::clang::CFGBlock * > |
C GraphTraits< const clang::CallGraph * > |
C GraphTraits< const clang::CallGraphNode * > |
C GraphTraits< const clang::CFGBlock > |
C GraphTraits< const clang::Stmt * > |
C GraphTraits< const Inverse< clang::CFGBlock > > |
C GraphTraits< Inverse< ::clang::CFG * > > |
C GraphTraits< Inverse< ::clang::CFGBlock * > > |
C GraphTraits< Inverse< clang::CFGBlock > > |
C GraphTraits< Inverse< const ::clang::CFG * > > |
C GraphTraits< Inverse< const ::clang::CFGBlock * > > |
C GraphTraits< ModuleManager > |
C IntrusiveRefCntPtr |
C IntrusiveRefCntPtrInfo |
C IntrusiveRefCntPtrInfo< const clang::ento::ProgramState > |
C isa_impl< To, ::clang::DeclContext > | Isa<T>(DeclContext*)
C MutableArrayRef |
C Optional |
C OwningArrayRef |
C PointerLikeTypeTraits |
C PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitBuilderBase * > |
C PointerLikeTypeTraits< ::clang::CodeGen::ConstantInitFuture > |
C PointerLikeTypeTraits< ::clang::ExtQuals * > |
C PointerLikeTypeTraits< ::clang::Type * > |
C PointerLikeTypeTraits< clang::CanQual< T > > |
C PointerLikeTypeTraits< clang::DeclGroupRef > |
C PointerLikeTypeTraits< clang::DynamicAllocLValue > |
C PointerLikeTypeTraits< clang::IdentifierInfo * > |
C PointerLikeTypeTraits< clang::LazyGenerationalUpdatePtr< Owner, T, Update > > |
C PointerLikeTypeTraits< clang::OpaquePtr< T > > |
C PointerLikeTypeTraits< clang::QualType > |
C PointerLikeTypeTraits< clang::Selector > |
C PointerLikeTypeTraits< clang::SourceLocation > |
C PointerLikeTypeTraits< clang::TemplateName > | The clang::TemplateName class is effectively a pointer
C PointerLikeTypeTraits< clang::TypeInfoLValue > |
C PointerLikeTypeTraits< const clang::IdentifierInfo * > |
C RefCountedBase |
C SaveAndRestore |
C simplify_type< ::clang::CanQual< T > > | Implement simplify_type for CanQual<T>, so that we can dyn_cast from CanQual<T> to a specific Type class
C simplify_type< ::clang::CFGTerminator > | Implement simplify_type for CFGTerminator, so that we can dyn_cast from CFGTerminator to a specific Stmt class
C simplify_type< ::clang::QualType > | Implement simplify_type for QualType, so that we can dyn_cast from QualType to a specific Type class
C simplify_type< clang::ento::CallEventRef< T > > |
C SmallSetVector |
C SmallString |
C SmallVector |
C SmallVectorImpl |
►N std |
C is_error_code_enum< clang::BuildPreambleError > |
C is_error_code_enum< clang::format::ParseError > |
C is_error_code_enum< clang::serialized_diags::SDError > |
►N syntax |
C TreeBuilder | A helper class for constructing the syntax tree while traversing a clang AST
C__clang_cuda_enable_if |
C__clang_cuda_enable_if< true, __T > |
C__cuda_builtin_blockDim_t |
C__cuda_builtin_blockIdx_t |
C__cuda_builtin_gridDim_t |
C__cuda_builtin_threadIdx_t |
C_Unwind_Exception |
C AnyFunctionCall |
C atomic_flag |
C basic_parser |
C BugReporterVisitor |
C CallEvent |
C CGBuilderBaseTy |
C CGOpenMPRuntime |
C CHECK1 |
C CleanupTy | A basic class for pre|post-action for advanced codegen sequence for OpenMP region
C CommonBase |
C ConstOMPClauseVisitor |
C CopyOptionsTy |
C CPUSuffix |
C CXCodeCompleteResults | Contains the results of code-completion
C CXComment | A parsed comment
C CXCompletionResult | A single result of code completion
C CXCursor | A cursor representing some element in the abstract syntax tree for a translation unit
C CXCursorAndRangeVisitor |
C CXFileUniqueID | Uniquely identifies a CXFile, that refers to the same underlying file, across an indexing session
C CXIdxAttrInfo |
C CXIdxBaseClassInfo |
C CXIdxContainerInfo |
C CXIdxCXXClassDeclInfo |
C CXIdxDeclInfo |
C CXIdxEntityInfo |
C CXIdxEntityRefInfo | Data for IndexerCallbacks::indexEntityReference
C CXIdxIBOutletCollectionAttrInfo |
C CXIdxImportedASTFileInfo | Data for IndexerCallbacks::importedASTFile
C CXIdxIncludedFileInfo | Data for ppIncludedFile callback
C CXIdxLoc | Source location passed to index callbacks
C CXIdxObjCCategoryDeclInfo |
C CXIdxObjCContainerDeclInfo |
C CXIdxObjCInterfaceDeclInfo |
C CXIdxObjCPropertyDeclInfo |
C CXIdxObjCProtocolRefInfo |
C CXIdxObjCProtocolRefListInfo |
C CXPlatformAvailability | Describes the availability of a given entity on a particular platform, e.g., a particular class might only be available on Mac OS 10.7 or newer
C CXSourceLocation | Identifies a specific source location within a translation unit
C CXSourceRange | Identifies a half-open character range in the source code
C CXSourceRangeList | Identifies an array of ranges
C CXString | A character string
C CXStringSet |
C CXToken | Describes a single preprocessing token
C CXTUResourceUsage | The memory usage of a CXTranslationUnit, broken into categories
C CXTUResourceUsageEntry |
C CXType | The type of an element in the abstract syntax tree
C CXUnsavedFile | Provides the contents of a file that has not yet been saved to disk
C CXVersion | Describes a version number of the form major.minor.subminor
C DefaultDOTGraphTraits |
C DefinedTracker | DefinedTracker - This struct is used while parsing expressions to keep track of whether !defined(X) has been seen
C DereferenceInfo |
C DiagnosticHandler |
C DynamicType |
C Emitter |
C ExitFunctionBodyRAII | RAII object that pops an ExpressionEvaluationContext when exiting a function body
C GEPOffsetAndOverflow |
C GraphTraits |
C IndexerCallbacks | A group of callbacks used by clang_indexSourceFile and clang_indexTranslationUnit
C ISANameRevision |
C IsPartialSpecialization |
C IsPartialSpecialization< ClassTemplatePartialSpecializationDecl > |
C IsPartialSpecialization< VarTemplatePartialSpecializationDecl > |
C IteratorBase |
C Kind2Unsigned |
C LoopState |
C max_align_t |
C ndrange_t |
C OMPAlignedClause | This represents clause 'aligned' in the '#pragma omp ...' directives
C OMPClause |
►C OMPClauseMappableExprCommon | Struct that defines common infrastructure to handle mappable expressions used in OpenMP clauses
C MappableComponent | Class that represents a component of a mappable expression
C OMPClausePrinter |
C OMPClauseVisitor |
C OMPClauseVisitorBase | This class implements a simple visitor for OMPClause subclasses
C OMPClauseWithPreInit |
C OMPCopyinClause | This represents clause 'copyin' in the '#pragma omp ...' directives
C OMPCopyprivateClause | This represents clause 'copyprivate' in the '#pragma omp ...' directives
C OMPDefaultmapClause | This represents 'defaultmap' clause in the '#pragma omp ...' directive
C OMPDependClause | This represents implicit clause 'depend' for the '#pragma omp task' directive
C OMPDeviceClause | This represents 'device' clause in the '#pragma omp ...' directive
C OMPDistScheduleClause | This represents 'dist_schedule' clause in the '#pragma omp ...' directive
C OMPFlushClause | This represents implicit clause 'flush' for the '#pragma omp flush' directive
C OMPFromClause | This represents clause 'from' in the '#pragma omp ...' directives
C OMPGrainsizeClause | This represents 'grainsize' clause in the '#pragma omp ...' directive
C OMPHintClause | This represents 'hint' clause in the '#pragma omp ...' directive
C OMPIsDevicePtrClause | This represents clause 'is_device_ptr' in the '#pragma omp ...' directives
C OMPMapClause | This represents clause 'map' in the '#pragma omp ...' directives
►C OMPMappableExprListClause | This represents clauses with a list of expressions that are mappable
C const_component_lists_iterator | Iterator that browse the components by lists
C OMPMappableExprListSizeTy | This structure contains all sizes needed for by an OMPMappableExprListClause
C OMPNogroupClause | This represents 'nogroup' clause in the '#pragma omp ...' directive
C OMPNontemporalClause | This represents clause 'nontemporal' in the '#pragma omp ...' directives
C OMPNumTasksClause | This represents 'num_tasks' clause in the '#pragma omp ...' directive
C OMPNumTeamsClause | This represents 'num_teams' clause in the '#pragma omp ...' directive
C OMPPriorityClause | This represents 'priority' clause in the '#pragma omp ...' directive
C OMPSIMDClause | This represents 'simd' clause in the '#pragma omp ...' directive
C OMPThreadLimitClause | This represents 'thread_limit' clause in the '#pragma omp ...' directive
C OMPThreadsClause | This represents 'threads' clause in the '#pragma omp ...' directive
C OMPToClause | This represents clause 'to' in the '#pragma omp ...' directives
C OMPUseDevicePtrClause | This represents clause 'use_device_ptr' in the '#pragma omp ...' directives
C ParsedAttrInfo |
C ProxyFileSystem |
C ReadySuspendResumeResult |
C SparcCPUInfo |
C StmtClassNameTable |
C type |
C TypeInfo |
C udir_iterator_base |