 AttributeLangSupport | |
 clang | Dataflow Directional Tag Classes |
  AArch64 | AArch64 builtins |
  AMDGPU | AMDGPU builtins |
  analyze_format_string | Common components of both fprintf and fscanf format strings |
   OptionalFlag | Class representing optional flags with location and representation information |
   LengthModifier | Represents the length modifier in a format string in scanf/printf |
   ConversionSpecifier | |
   ArgType | |
   OptionalAmount | |
   FormatSpecifier | |
   FormatStringHandler | |
   SpecifierResult | |
  analyze_printf | Pieces specific to fprintf format strings |
   PrintfConversionSpecifier | |
   PrintfSpecifier | |
  analyze_scanf | Pieces specific to fscanf format strings |
   ScanfConversionSpecifier | |
   ScanfSpecifier | |
  arcmt | |
   trans | |
    BodyContext | |
    ObjCImplementationContext | |
    ASTTraverser | |
    MigrationContext | |
     GCAttrOccurrence | |
    PropertyRewriteTraverser | |
    BlockObjCVariableTraverser | |
    ProtectedScopeTraverser | |
    GCAttrsTraverser | |
    GCCollectableCallsTraverser | |
    BodyTransform | |
   MigrationProcess | |
    RewriteListener | |
   CheckAction | |
   ModifyAction | |
   MigrateSourceAction | |
   MigrateAction | |
   ObjCMigrateAction | Migrates to modern ObjC syntax |
   FileRemapper | |
   CapturedDiagList | |
   TransformActions | |
    RewriteReceiver | |
   Transaction | |
   MigrationPass | |
  ARM | ARM builtins |
  ast_matchers | |
   dynamic | |
    internal | |
     ArgTypeTraits | Helper template class to just from argument type to the right is/get functions in VariantValue |
     ArgTypeTraits< const T & > | |
     ArgTypeTraits< std::string > | |
     ArgTypeTraits< StringRef > | |
     ArgTypeTraits< ast_matchers::internal::Matcher< T > > | |
     ArgTypeTraits< unsigned > | |
     ArgTypeTraits< attr::Kind > | |
     ArgTypeTraits< clang::CastKind > | |
     MatcherDescriptor | Matcher descriptor interface |
     FixedArgCountMatcherDescriptor | Simple callback implementation |
     BuildReturnTypeVector | |
     BuildReturnTypeVector< ast_matchers::internal::Matcher< T > > | |
     BuildReturnTypeVector< ast_matchers::internal::BindableMatcher< T > > | |
     VariadicFuncMatcherDescriptor | Matcher descriptor for variadic functions |
     DynCastAllOfMatcherDescriptor | Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers |
     AdaptativeOverloadCollector | Helper class used to collect all the possible overloads of an argument adaptative matcher function |
     OverloadedMatcherDescriptor | MatcherDescriptor that wraps multiple "overloads" of the same matcher |
     VariadicOperatorMatcherDescriptor | Variadic operator marshaller function |
    SourceLocation | |
    SourceRange | |
    ParserValue | A VariantValue instance annotated with its parser context |
    Diagnostics | Helper class to manage error messages |
     ArgStream | Helper stream class |
     Context | Class defining a parser context |
     ContextFrame | Information stored for one frame of the context |
     ErrorContent | Information stored for each error found |
      Message | |
     OverloadContext | Context for overloaded matcher construction |
    Parser | Matcher expression parser |
     CodeTokenizer | Simple tokenizer for the parser |
     RegistrySema | Sema implementation that uses the matcher registry to process the tokens |
     ScopedContextEntry | |
     Sema | Interface to connect the parser with the registry and more |
     TokenInfo | Simple structure to hold information for one token from the parser |
    MatcherCompletion | |
    Registry | |
    ArgKind | Kind identifier |
    VariantMatcher | A variant matcher object |
     PolymorphicPayload | |
     SinglePayload | |
     VariadicOpPayload | |
    VariantValue | Variant value class |
   internal | |
    CollectMatchesCallback | |
   BoundNodes | Maps string IDs to AST nodes matched by parts of a matcher |
   MatchFinder | A class to allow finding matches over the Clang AST |
    MatchCallback | Called when the Match registered for it was successfully found in the AST |
    MatchersByType | For each Matcher<> a MatchCallback that will be called when it matches |
    MatchFinderOptions | |
     Profiling | |
    MatchResult | Contains all information for a given match |
    ParsingDoneTestCallback | Called when parsing is finished. Intended for testing only |
  ast_type_traits | |
   ASTNodeKind | Kind identifier |
    DenseMapInfo | Hooks for using ASTNodeKind as a key in a DenseMap |
   DynTypedNode | A dynamically typed AST node container |
    BaseConverter< CXXCtorInitializer, void > | |
    BaseConverter< NestedNameSpecifier, void > | |
    BaseConverter< NestedNameSpecifierLoc, void > | |
    BaseConverter< QualType, void > | |
    BaseConverter< T, typename std::enable_if< std::is_base_of< Decl, T >::value >::type > | |
    BaseConverter< T, typename std::enable_if< std::is_base_of< Stmt, T >::value >::type > | |
    BaseConverter< T, typename std::enable_if< std::is_base_of< Type, T >::value >::type > | |
    BaseConverter< TemplateArgument, void > | |
    BaseConverter< TypeLoc, void > | |
    DenseMapInfo | Hooks for using DynTypedNode as a key in a DenseMap |
  attr | |
  Builtin | |
   Info | |
   Context | Holds information about both target-independent and target-specific builtins, allowing easy queries by clients |
  charinfo | |
  CodeGen | |
   swiftcall | |
    SwiftAggLowering | |
   ABIArgInfo | ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to or returned from a function |
   RequiredArgs | A class for recording the number of arguments that a function signature requires |
   CGFunctionInfoArgInfo | |
   CGFunctionInfo | CGFunctionInfo - Class to encapsulate the information about a function definition |
   CGCalleeInfo | CGCalleeInfo - Class to encapsulate the information about a callee to be used during the generation of call/invoke instructions |
   ABIInfo | ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions |
   SwiftABIInfo | A refining implementation of ABIInfo for targets that support swiftcall |
   Address | An aligned address |
   ConstantAddress | A specialization of Address that requires the address to be an LLVM Constant |
   BlockFlags | |
   BlockFieldFlags | |
   BlockByrefInfo | Information about the layout of a __block variable |
   CGBlockInfo | CGBlockInfo - Information to generate a block literal |
    Capture | |
   CGBuilderInserter | This is an IRBuilder insertion helper that forwards to CodeGenFunction::InsertHelper, which adds necessary metadata to instructions |
   CGBuilderTy | |
   CallArg | |
   CallArgList | CallArgList - Type for representing both the value and type of arguments in a call |
    CallArgCleanup | |
    Writeback | |
   FunctionArgList | FunctionArgList - Type for representing both the decl and type of parameters to a function |
   ReturnValueSlot | ReturnValueSlot - Contains the address where the return value of a function can be stored, and whether the address is volatile or not |
   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 |
   EHScope | A protected scope for zero-cost EH handling |
    CatchBitFields | |
    CleanupBitFields | |
    FilterBitFields | |
   EHCatchScope | A scope which attempts to handle some, possibly all, types of exceptions |
    Handler | |
   ExtInfo | Extra information required for cleanups that have resolved branches through them |
   EHFilterScope | An exceptions scope which filters exceptions thrown through it |
   EHTerminateScope | An exceptions scope which calls std::terminate if any exception reaches it |
   EHPadEndScope | |
   EHPersonality | The exceptions personality for a function |
   CGCUDARuntime | |
   CGCXXABI | Implements C++ ABI-specific code generation functions |
   CGDebugInfo | This class gathers all debug information during compilation and is responsible for emitting to llvm globals or pass directly to the backend |
   ApplyDebugLocation | A scoped helper to set the current debug location to the specified location or preferred location of the specified Expr |
   LoopAttributes | Attributes that may be specified on loops |
   LoopInfo | Information used when generating a structured loop |
   LoopInfoStack | A stack of loop information corresponding to loop nesting levels |
   CGObjCRuntime | Implements runtime-specific code generation functions |
    MessageSendInfo | |
   CGOpenCLRuntime | |
   PrePostActionTy | A basic class for pre|post-action for advanced codegen sequence for OpenMP region |
   RegionCodeGenTy | Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possible pre|post-actions in codegen |
   OMPTaskDataTy | |
   CGOpenMPRuntime | |
   OffloadEntriesInfoManagerTy | Entity that registers the offloading constants that were emitted so far |
    OffloadEntryInfo | Base class of the entries info |
    OffloadEntryInfoTargetRegion | Target region entries related |
   TaskResultTy | |
   CGOpenMPRuntimeNVPTX | |
    EntryFunctionState | |
    WorkerFunctionState | |
   CGBitFieldInfo | Structure with information about how a bitfield should be accessed |
   CGRecordLayout | CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM types |
   RValue | RValue - This trivial value class is used to represent the result of an expression that is evaluated |
   LValue | LValue - This represents an lvalue references |
   AggValueSlot | An aggregate value slot |
   CodeGenVTables | |
   CodeGenFunction | CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code |
    AutoVarEmission | |
    CallLifetimeEnd | |
    CGCapturedStmtInfo | API for captured statement code generation |
    CGCapturedStmtRAII | RAII for correct setting/restoring of CapturedStmtInfo |
    ConditionalEvaluation | An object to manage conditionally-evaluated expressions |
    ConstantEmission | |
    CXXDefaultInitExprScope | The scope of a CXXDefaultInitExpr |
    FieldConstructionScope | A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr |
    FinallyInfo | A class controlling the emission of a finally block |
    InlinedInheritingConstructorScope | |
    JumpDest | A jump destination is an abstract label, branching to which may require a jump out through normal cleanups |
    LexicalScope | |
    LifetimeExtendedCleanupHeader | Header for data within LifetimeExtendedCleanupStack |
    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 |
    OpaqueValueMapping | An RAII object to set (and then clear) a mapping for an OpaqueValueExpr |
    OpaqueValueMappingData | A non-RAII class containing all the information about a bound opaque value |
    ParamValue | |
    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 |
    RunCleanupsScope | Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited |
    SanitizerScope | RAII object to set/unset CodeGenFunction::IsSanitizerScope |
    StmtExprEvaluation | An RAII object to record that we're evaluating a statement expression |
    VPtr | Struct with all informations about dynamic [sub]class needed to set vptr |
   DominatingLLVMValue | Helper class with most of the code for saving a value for a conditional expression cleanup |
   DominatingPointer< T, true > | A partial specialization of DominatingValue for llvm::Values that might be llvm::Instructions |
   DominatingValue< Address > | A specialization of DominatingValue for Address |
    saved_type | |
   DominatingValue< RValue > | A specialization of DominatingValue for RValue |
    saved_type | |
   OrderGlobalInits | |
   ObjCEntrypoints | |
   InstrProfStats | This class records statistics on instrumentation based profiling |
   BlockByrefHelpers | A pair of helper functions for a __block variable |
   CodeGenModule | This class organizes the cross-function state that is used while generating LLVM code |
    Structor | |
   CodeGenPGO | Per-function PGO state |
   TBAAPathTag | |
   CodeGenTBAA | CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LLVM types |
   CodeGenTypeCache | This structure provides a set of types that are commonly used during IR emission |
   CodeGenTypes | This class organizes the cross-module state that is used while lowering AST types to LLVM types |
   CoverageMappingModuleGen | Organizes the cross-function state that is used while generating code coverage mapping data |
   CoverageMappingGen | Organizes the per-function state that is used while generating code coverage mapping data |
   BranchFixup | A branch fixup |
   InvariantValue | |
   DominatingValue | A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function |
   DominatingPointer | |
   DominatingPointer< T, false > | |
   DominatingValue< T * > | |
   EHScopeStack | A stack of scopes which respond to exceptions, including cleanups and catch blocks |
    Cleanup | Information for lazily generating a cleanup |
     Flags | Generation flags |
    ConditionalCleanup | ConditionalCleanup stores the saved form of its parameters, then restores them and performs the cleanup |
    iterator | A non-stable pointer into the scope stack |
    stable_iterator | A saved depth on the scope stack |
   SanitizerMetadata | |
   TargetCodeGenInfo | TargetCodeGenInfo - This class organizes various target-specific codegeneration issues, like target-specific attributes, builtins and so on |
  codegenoptions | |
  comments | |
   tok | |
   Comment | Any part of the comment |
    BlockCommandCommentBitfields | |
    CommentBitfields | |
    HTMLStartTagCommentBitfields | |
    HTMLTagCommentBitfields | |
    InlineCommandCommentBitfields | |
    InlineContentCommentBitfields | |
    ParagraphCommentBitfields | |
    ParamCommandCommentBitfields | |
    TextCommentBitfields | |
   InlineContentComment | Inline content (contained within a block) |
   TextComment | Plain text |
   InlineCommandComment | A command with word-like arguments that is considered inline content |
    Argument | |
   HTMLTagComment | Abstract class for opening and closing HTML tags |
   HTMLStartTagComment | An opening HTML tag with attributes |
    Attribute | |
   HTMLEndTagComment | A closing HTML tag |
   BlockContentComment | Block content (contains inline content) |
   ParagraphComment | A single paragraph that contains inline content |
   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 |
    Argument | |
   ParamCommandComment | Doxygen \param command |
   TParamCommandComment | Doxygen \tparam command, describes a template parameter |
   VerbatimBlockLineComment | A line of text contained in a verbatim block |
   VerbatimBlockComment | A verbatim block command (e |
   VerbatimLineComment | A verbatim line command |
   DeclInfo | Information about the declaration, useful to clients of FullComment |
   FullComment | A full comment attached to a declaration, contains block content |
   BriefParser | A very simple comment parser that extracts "a brief description" |
   CommandInfo | Information about a single command |
   CommandTraits | This class provides information about commands that can be used in comments |
   Token | Comment token |
   Lexer | Comment lexer |
   Parser | Doxygen comment parser |
   Sema | |
   make_ptr | |
   make_const_ptr | |
   CommentVisitorBase | |
   CommentVisitor | |
   ConstCommentVisitor | |
   TextTokenRetokenizer | Re-lexes a sequence of tok::text tokens |
  consumed | |
   ConsumedWarningsHandlerBase | |
   ConsumedStateMap | |
   ConsumedBlockInfo | |
   ConsumedAnalyzer | A class that handles the analysis of uniqueness violations |
   PropagationInfo | |
   ConsumedStmtVisitor | |
  dataflow | |
   forward_analysis_tag | |
   backward_analysis_tag | |
  declvisitor | |
   make_ptr | |
   make_const_ptr | |
   Base | A simple visitor class that helps create declaration visitors |
  diag | |
   CustomDiagInfo | |
  driver | |
   options | |
   phases | |
   toolchains | |
    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 |
     CudaInstallationDetector | |
     GCCInstallationDetector | This is a class to find a viable GCC installation for Clang to use |
     GCCVersion | Struct to store and manipulate GCC versions |
    MachO | |
    Darwin | Darwin - The base Darwin tool chain |
    DarwinClang | DarwinClang - The Darwin toolchain used by Clang |
    Generic_ELF | |
    CloudABI | |
    Solaris | |
    MinGW | |
    Haiku | |
    OpenBSD | |
    Bitrig | |
    FreeBSD | |
    NetBSD | |
    Minix | |
    DragonFly | |
    Linux | |
    CudaToolChain | |
    MipsLLVMToolChain | |
    LanaiToolChain | |
    HexagonToolChain | |
    AMDGPUToolChain | |
    NaClToolChain | |
    TCEToolChain | TCEToolChain - A tool chain using the llvm bitcode tools to perform all subcommands |
    MSVCToolChain | |
    CrossWindowsToolChain | |
    XCoreToolChain | |
    MyriadToolChain | MyriadToolChain - A tool chain using either clang or the external compiler installed by the Movidius SDK to perform all subcommands |
    WebAssembly | |
    PS4CPU | |
   tools | |
    amdgpu | |
     Linker | |
    arm | |
    bitrig | Bitrig – Directly call GNU Binutils assembler and linker |
     Assembler | |
     Linker | |
    cloudabi | Cloudabi – Directly call GNU Binutils linker |
     Linker | |
    CrossWindows | |
     Assembler | |
     Linker | |
    darwin | |
     MachOTool | |
     Assembler | |
     Linker | |
     Lipo | |
     Dsymutil | |
     VerifyDebug | |
    dragonfly | Dragonfly – Directly call GNU Binutils assembler and linker |
     Assembler | |
     Linker | |
    freebsd | Freebsd – Directly call GNU Binutils assembler and linker |
     Assembler | |
     Linker | |
    gcc | Gcc - Generic GCC tool implementations |
     Common | |
     Preprocessor | |
     Compiler | |
     Linker | |
    gnutools | Directly call GNU Binutils' assembler and linker |
     Assembler | |
     Linker | |
    hexagon | |
     Assembler | |
     Linker | |
    MinGW | MinGW – Directly call GNU Binutils assembler and linker |
     Assembler | |
     Linker | |
    minix | Minix – Directly call GNU Binutils assembler and linker |
     Assembler | |
     Linker | |
    mips | |
    Myriad | The Myriad toolchain uses tools that are in two different namespaces |
     Linker | |
    nacltools | |
     AssemblerARM | |
     Linker | |
    netbsd | Netbsd – Directly call GNU Binutils assembler and linker |
     Assembler | |
     Linker | |
    NVPTX | |
     Assembler | |
     Linker | |
    openbsd | Openbsd – Directly call GNU Binutils assembler and linker |
     Assembler | |
     Linker | |
    ppc | |
    PS4cpu | |
     Assemble | |
     Link | |
    SHAVE | SHAVE tools – Directly call moviCompile and moviAsm |
     Compiler | |
     Assembler | |
    solaris | Solaris – Directly call Solaris assembler and linker |
     Assembler | |
     Linker | |
    sparc | |
    visualstudio | Visual studio tools |
     Linker | |
     Compiler | |
    wasm | |
     Linker | |
    XCore | |
     Assembler | |
     Linker | |
    Clang | Clang compiler tool |
    ClangAs | Clang integrated assembler tool |
    GnuTool | Base class for all GNU tools that provide the same behavior when it comes to response files support |
   types | |
   Action | Action - Represent an abstract compilation step to perform |
   InputAction | |
   BindArchAction | |
   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 |
    DeviceDependences | Type used to communicate device actions |
    HostDependence | Type used to communicate host actions |
   JobAction | |
   PreprocessJobAction | |
   PrecompileJobAction | |
   AnalyzeJobAction | |
   MigrateJobAction | |
   CompileJobAction | |
   BackendJobAction | |
   AssembleJobAction | |
   LinkJobAction | |
   LipoJobAction | |
   DsymutilJobAction | |
   VerifyJobAction | |
   VerifyDebugInfoJobAction | |
   VerifyPCHJobAction | |
   Compilation | Compilation - A set of tasks to perform for a single driver invocation |
   Driver | Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like command line arguments |
   CrashReportInfo | |
   Command | Command - An executable path/name and argument vector to execute |
   FallbackCommand | Like Command, but with a fallback which is executed in case the primary command crashes |
   ForceSuccessCommand | Like Command, but always pretends that the wrapped command succeeded |
   JobList | JobList - A sequence of jobs to perform |
   Multilib | This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag |
   MultilibSet | |
   SanitizerArgs | |
   Tool | Tool - Information on a specific compilation tool |
   ToolChain | ToolChain - Access to tools for a single platform |
   InputInfo | InputInfo - Wrapper for information about an input source |
  edit | |
   Commit | |
    Edit | |
   EditedSource | |
   EditsReceiver | |
   FileOffset | |
  ento | |
   bugreporter | |
   categories | |
   check | |
    ASTDecl | |
    ASTCodeBody | |
    EndOfTranslationUnit | |
    PreStmt | |
    PostStmt | |
    PreObjCMessage | |
    ObjCMessageNil | |
    PostObjCMessage | |
    PreCall | |
    PostCall | |
    Location | |
    Bind | |
    EndAnalysis | |
    BeginFunction | |
    EndFunction | |
    BranchCondition | |
    LiveSymbols | |
    DeadSymbols | |
    RegionChanges | |
    PointerEscape | |
    ConstPointerEscape | |
    Event | |
   cocoa | |
   coreFoundation | |
   eval | |
    Assume | |
    Call | |
   loc | |
    GotoLabel | |
    MemRegionVal | |
    ConcreteInt | |
   mpi | |
    MPIBugReporter | |
    MPIChecker | |
    MPIFunctionClassifier | |
    Request | |
    RequestMap | |
   nonloc | |
    SymbolVal | Represents symbolic expression |
    ConcreteInt | Value representing integer constant |
    LocAsInteger | |
    CompoundVal | |
    LazyCompoundVal | |
   objc_retain | |
    RetEffect | RetEffect summarizes a call's retain/release behavior with respect to its return value |
    CallEffects | Encapsulates the retain count semantics on the arguments, return value, and receiver (if any) of a function/method call |
   summMgr | |
    SummaryKey | |
   SValExplainer | |
   BugReport | This class provides an interface through which checkers can create individual bug reports |
    NodeResolver | |
   BugReportEquivClass | |
   BugReporterData | |
   BugReporter | BugReporter is a utility class for generating PathDiagnostics for analysis |
   GRBugReporter | |
   BugReporterContext | |
   BugReporterVisitor | BugReporterVisitors are used to add custom diagnostics along a path |
   BugReporterVisitorImpl | This class provides a convenience implementation for clone() using the Curiously-Recurring Template Pattern |
   FindLastStoreBRVisitor | |
   TrackConstraintBRVisitor | |
   NilReceiverBRVisitor | Prints path notes when a message is sent to a nil receiver |
   ConditionBRVisitor | Visitor that tries to report interesting diagnostics from conditions |
   LikelyFalsePositiveSuppressionBRVisitor | Suppress reports that might lead to known false positives |
   UndefOrNullArgVisitor | When a region containing undefined value or '0' value is passed as an argument in a call, marks the call as interesting |
   SuppressInlineDefensiveChecksVisitor | |
   BugType | |
   BuiltinBug | |
   PathDiagnosticConsumer | |
    FilesMade | |
    PDFileEntry | |
   PathDiagnosticRange | |
   PathDiagnosticLocation | |
   PathDiagnosticLocationPair | |
   PathDiagnosticPiece | |
   PathPieces | |
   PathDiagnosticSpotPiece | |
   StackHintGenerator | Interface for classes constructing Stack hints |
   StackHintGeneratorForSymbol | Constructs a Stack hint for the given symbol |
   PathDiagnosticEventPiece | |
   PathDiagnosticCallPiece | |
   PathDiagnosticControlFlowPiece | |
   PathDiagnosticMacroPiece | |
   PathDiagnostic | PathDiagnostic - PathDiagnostic objects represent a single path-sensitive diagnostic |
   CheckerBase | |
   CheckerProgramPointTag | Tag that can use a checker name as a message provider (see SimpleProgramPointTag) |
   Checker | |
   Checker< CHECK1 > | |
   EventDispatcher | |
   ImplicitNullDerefEvent | We dereferenced a location that may be null |
   DefaultBool | A helper class which wraps a boolean value set to false by default |
   CheckerFn | |
   CheckerFn< RET(Ps...)> | |
   CheckName | |
   CheckerManager | |
   CheckerOptInfo | Represents a request to include or exclude a checker or package from a specific analysis run |
   CheckerRegistry | Manages a set of available checkers for running a static analysis |
    CheckerInfo | |
   AnalysisManager | |
   APSIntType | A record of the "type" of an APSInt, used for conversions |
   CompoundValData | |
   LazyCompoundValData | |
   BasicValueFactory | |
   BlockCounter | An abstract data type used to count the number of times a given block has been visited along a path analyzed by CoreEngine |
    Factory | |
   CallDescription | This class represents a description of a function call using the number of arguments and the name of the function |
   CallEventRef | |
   RuntimeDefinition | Defines the runtime definition of the called function |
   CallEvent | Represents an abstract call to a function or method along a particular path |
   AnyFunctionCall | Represents a call to any sort of function that might have a FunctionDecl |
   SimpleFunctionCall | Represents a C function or static C++ member function call |
   CheckerContext | |
   ConditionTruthVal | |
   ConstraintManager | |
   CoreEngine | CoreEngine - Implements the core logic of the graph-reachability analysis |
   NodeBuilderContext | |
   NodeBuilder | This is the simplest builder which generates nodes in the ExplodedGraph |
   NodeBuilderWithSinks | This node builder keeps track of the generated sink nodes |
   StmtNodeBuilder | This builder class is useful for generating nodes that resulted from visiting a statement |
   BranchNodeBuilder | BranchNodeBuilder is responsible for constructing the nodes corresponding to the two branches of the if statement - true and false |
   IndirectGotoNodeBuilder | |
    iterator | |
   SwitchNodeBuilder | |
    iterator | |
   DynamicTypeInfo | Stores the currently inferred strictest bound on the runtime type of a region in a given state along the analysis path |
   DynamicTypeMap | The GDM component containing the dynamic type info |
   ProgramStateTrait< DynamicTypeMap > | |
   EnvironmentEntry | An entry in the environment consists of a Stmt and an LocationContext |
   Environment | An immutable map from EnvironemntEntries to SVals |
   EnvironmentManager | |
   ExplodedNode | |
    Auditor | |
   ExplodedGraph | |
   ExplodedNodeSet | |
   ExprEngine | |
   ReplayWithoutInlining | Traits for storing the call processing policy inside GDM |
   ProgramStateTrait< ReplayWithoutInlining > | |
   FunctionSummariesTy | |
   RegionOffset | Represent a region's offset within the top level base region |
   MemRegion | MemRegion - The root abstract class for all memory regions |
   MemSpaceRegion | MemSpaceRegion - A memory region that represents a "memory space"; for example, the set of global variables, the stack frame, etc |
   CodeSpaceRegion | CodeSpaceRegion - The memory space that holds the executable code of functions and blocks |
   GlobalsSpaceRegion | |
   StaticGlobalSpaceRegion | The region of the static variables within the current CodeTextRegion scope |
   NonStaticGlobalSpaceRegion | The region for all the non-static global variables |
   GlobalSystemSpaceRegion | The region containing globals which are defined in system/external headers and are considered modifiable by system calls (ex: errno) |
   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) |
   GlobalInternalSpaceRegion | The region containing globals which can be modified by calls to "internally" defined functions - (for now just) functions other then system calls |
   HeapSpaceRegion | |
   UnknownSpaceRegion | |
   StackSpaceRegion | |
   StackLocalsSpaceRegion | |
   StackArgumentsSpaceRegion | |
   SubRegion | SubRegion - A region that subsets another larger region |
   AllocaRegion | AllocaRegion - A region that represents an untyped blob of bytes created by a call to 'alloca' |
   TypedRegion | TypedRegion - An abstract class representing regions that are typed |
   TypedValueRegion | TypedValueRegion - An abstract class representing regions having a typed value |
   CodeTextRegion | |
   FunctionCodeRegion | FunctionCodeRegion - A region that represents code texts of function |
   BlockCodeRegion | BlockCodeRegion - A region that represents code texts of blocks (closures) |
   BlockDataRegion | BlockDataRegion - A region that represents a block instance |
    referenced_vars_iterator | |
   SymbolicRegion | SymbolicRegion - A special, "non-concrete" region |
   StringRegion | StringRegion - Region associated with a StringLiteral |
   ObjCStringRegion | The region associated with an ObjCStringLiteral |
   CompoundLiteralRegion | CompoundLiteralRegion - A memory region representing a compound literal |
   DeclRegion | |
   VarRegion | |
   CXXThisRegion | CXXThisRegion - Represents the region for the implicit 'this' parameter in a call to a C++ method |
   FieldRegion | |
   ObjCIvarRegion | |
   RegionRawOffset | |
   ElementRegion | ElementRegin is used to represent both array elements and casts |
   CXXTempObjectRegion | |
   CXXBaseObjectRegion | |
   MemRegionManager | |
   RegionAndSymbolInvalidationTraits | Information about invalidation for a particular region/symbol |
   ProgramStatePartialTrait | |
   ProgramStateTrait | |
   ProgramState | ProgramState - This class encapsulates: |
   ProgramStateManager | |
   ScanReachableSymbols | A Utility class that allows to visit the reachable symbols using a custom SymbolVisitor |
   ProgramStatePartialTrait< llvm::ImmutableMap< Key, Data, Info > > | |
   ProgramStatePartialTrait< llvm::ImmutableSet< Key, Info > > | |
   ProgramStatePartialTrait< llvm::ImmutableList< T > > | |
   ProgramStatePartialTrait< bool > | |
   ProgramStatePartialTrait< unsigned > | |
   ProgramStatePartialTrait< void * > | |
   ProgramStatePartialTrait< const void * > | |
   StoreManager | |
    BindingsHandler | |
    FindUniqueBinding | |
   StoreRef | |
   SubEngine | |
   SummaryManagerImpl | |
   SummaryManager | |
   SValBuilder | |
   SVal | SVal - This represents a symbolic expression, which can be either an L-value or an R-value |
   UndefinedVal | |
   DefinedOrUnknownSVal | |
   UnknownVal | |
   DefinedSVal | |
   KnownSVal | Represents an SVal that is guaranteed to not be UnknownVal |
   NonLoc | |
   Loc | |
   SValVisitor | SValVisitor - this class implements a simple visitor for SVal subclasses |
   SymExprVisitor | SymExprVisitor - this class implements a simple visitor for SymExpr subclasses |
   MemRegionVisitor | MemRegionVisitor - this class implements a simple visitor for MemRegion subclasses |
   FullSValVisitor | FullSValVisitor - a convenient mixed visitor for all three: SVal, SymExpr and MemRegion subclasses |
   SymbolRegionValue | A symbol representing the value stored at a MemRegion |
   SymbolConjured | A symbol representing the result of an expression in the case when we do not know anything about what the expression is |
   SymbolDerived | A symbol representing the value of a MemRegion whose parent region has symbolic value |
   SymbolExtent | SymbolExtent - Represents the extent (size in bytes) of a bounded region |
   SymbolMetadata | SymbolMetadata - Represents path-dependent metadata about a specific region |
   SymbolCast | Represents a cast expression |
   BinarySymExpr | Represents a symbolic expression involving a binary operator |
   SymIntExpr | Represents a symbolic expression like 'x' + 3 |
   IntSymExpr | Represents a symbolic expression like 3 - 'x' |
   SymSymExpr | Represents a symbolic expression like 'x' + 'y' |
   SymbolManager | |
   SymbolReaper | A class responsible for cleaning up unused symbols |
   SymbolVisitor | |
   SymExpr | Symbolic value |
    symbol_iterator | Iterator over symbols that the current symbol depends on |
   SymbolData | A symbol representing data which can be stored in a memory location (region) |
   TaintMap | The GDM component containing the tainted root symbols |
   ProgramStateTrait< TaintMap > | |
   TaintManager | |
   WorkListUnit | |
   WorkList | |
    Visitor | |
   AnalysisASTConsumer | |
   AnalysisAction | |
   ParseModelFileAction | Frontend action to parse model files |
   ModelConsumer | ASTConsumer to consume model files' AST |
   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 |
   ProgramStateTrait< SymbolSet > | |
   ProgramStateTrait< mpi::RequestMap > | |
   PrettyStackTraceLocationContext | While alive, includes the current analysis stack in a crash trace |
   SimpleConstraintManager | |
   ModelInjector | |
  format | |
   encoding | |
   ParseErrorCategory | |
   FormatStyle | The FormatStyle is used to configure the formatting to follow specific guidelines |
    BraceWrappingFlags | Precise control over the wrapping of braces |
    IncludeCategory | See documentation of IncludeCategories |
   AffectedRangeManager | |
   BreakableToken | Base class for strategies on how to break tokens |
   BreakableSingleLineToken | Base class for single line tokens that can be broken |
   BreakableStringLiteral | |
   BreakableLineComment | |
   BreakableBlockComment | |
   ContinuationIndenter | |
   ParenState | |
   LineState | The current state when indenting a unwrapped line |
   FormatToken | A wrapper around a Token storing information about the whitespace characters preceding it |
   TokenRole | |
   CommaSeparatedList | |
   AdditionalKeywords | Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's lexer |
   FormatTokenLexer | |
   JsImportedSymbol | |
   JsModuleReference | |
   JavaScriptImportSorter | |
   Environment | |
   TokenAnalyzer | |
   AnnotatedLine | |
   TokenAnnotator | Determines extra information about the tokens comprising an UnwrappedLine |
   UnwrappedLineFormatter | |
   FormatTokenSource | |
   ScopedLineState | |
   CompoundStatementIndenter | |
   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 |
   UnwrappedLineConsumer | |
   UnwrappedLineParser | |
   UnwrappedLineNode | |
   WhitespaceManager | Manages the whitespaces around tokens and their replacements |
    Change | Represents a change before a token, a break inside a token, or the layout of an unchanged token (or whitespace within) |
     IsBeforeInFile | Functor to sort changes in original source order |
  frontend | |
  Hexagon | Hexagon builtins |
  html | |
  idx | |
  index | |
   CodegenNameGenerator | |
    Implementation | |
   CommentToXMLConverter | |
   IndexDataConsumer | |
    ASTNodeInfo | |
   IndexingOptions | |
   SymbolRelation | Represents a relation to another symbol for a symbol occurrence |
   SymbolInfo | |
   IndexingContext | |
   SimpleFormatContext | A small class to be used by libclang clients to format a declaration string in memory |
  LangAS | |
  Le64 | Le64 builtins |
  markup | |
  Mips | MIPS builtins |
  NEON | |
  NVPTX | NVPTX builtins |
  PPC | PPC builtins |
  prec | PrecedenceLevels - These are precedences for the binary/ternary operators in the C99 grammar |
  reachable_code | |
   Callback | |
  SanitizerKind | |
  sema | |
   AnalysisBasedWarnings | |
    Policy | |
   AccessedEntity | A declaration being accessed, together with information about how it was accessed |
   DelayedDiagnostic | A diagnostic message which has been conditionally emitted pending the complete parsing of the current declaration |
   DelayedDiagnosticPool | A collection of diagnostics which were delayed |
   CompoundScopeInfo | Contains information about the compound statement currently being parsed |
   PossiblyUnreachableDiag | |
   FunctionScopeInfo | Retains information about a function, method, or block that is currently being parsed |
    WeakObjectProfileTy | Represents a simple identification of a weak object |
     DenseMapInfo | |
    WeakUseTy | Represents a single use of a weak object |
   CapturingScopeInfo | |
    Capture | |
   BlockScopeInfo | Retains information about a block that is currently being parsed |
   CapturedRegionScopeInfo | Retains information about a captured region |
   LambdaScopeInfo | |
   TemplateDeductionInfo | Provides information about an attempted template argument deduction, whose success or failure was described by a TemplateDeductionResult value |
  serialization | |
   reader | |
    ASTDeclContextNameLookupTrait | Class that performs name lookup into a DeclContext stored in an AST file |
     data_type_builder | |
    DeclContextLookupTable | |
    ASTIdentifierLookupTraitBase | Base class for the trait describing the on-disk hash table for the identifiers in an AST file |
    ASTIdentifierLookupTrait | Class that performs lookup for an identifier stored in an AST file |
    ASTSelectorLookupTrait | Class that performs lookup for a selector's entries in the global method pool stored in an AST file |
     data_type | |
    HeaderFileInfoTrait | Trait class used to search the on-disk hash table containing all of the header search information |
     internal_key_type | |
   TypeIdx | A type index; the type ID with the qualifier bits removed |
   UnsafeQualTypeDenseMapInfo | A structure for putting "fast"-unqualified QualTypes into a DenseMap |
   PPEntityOffset | Source range/offset of a preprocessed entity |
   DeclOffset | Source range/offset of a preprocessed entity |
   LocalRedeclarationsInfo | Describes the redeclarations of a declaration |
   ObjCCategoriesInfo | Describes the categories of an Objective-C class |
   DeclarationNameKey | A key used when looking up entities by DeclarationName |
   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 |
   ModuleFile | Information about a module that has been loaded by the ASTReader |
   ModuleManager | Manages the set of modules loaded by an AST reader |
   ReadMethodPoolVisitor | |
   MultiOnDiskHashTable | A collection of on-disk hash tables, merged when relevant for performance |
   MultiOnDiskHashTableGenerator | Writer for the on-disk hash table |
  serialized_diags | |
   Location | A location that is represented in the serialized diagnostics |
   SerializedDiagnosticReader | A base class that handles reading serialized diagnostics from a file |
  SrcMgr | Public enums and private classes that are part of the SourceManager implementation |
   FileInfo | Information about a FileID, basically just the logical file that it represents and include stack information |
   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 |
   SLocEntry | This is a discriminated union of FileInfo and ExpansionInfo |
  SystemZ | SystemZ builtins |
  threadSafety | |
   lexpr | |
    LExpr | |
    Terminal | |
    BinOp | |
    And | |
    Or | |
    Not | |
   sx | |
   til | |
    ThreadSafetyTIL | |
    ValueType | ValueTypes are data types that can actually be held in registers |
    SExpr | Base class for AST nodes in the typed intermediate language |
    Variable | A named variable, e.g |
    Future | Placeholder for an expression that has not yet been created |
    Undefined | Placeholder for expressions that cannot be represented in the TIL |
    Wildcard | Placeholder for a wildcard that matches any other expression |
    LiteralT | |
    Literal | |
    LiteralPtr | A Literal pointer to an object allocated in memory |
    Function | A function – a.k.a |
    SFunction | A self-applicable function |
    Code | A block of code – e.g. the body of a function |
    Field | A typed, writable location in memory |
    Apply | Apply an argument to a function |
    SApply | Apply a self-argument to a self-applicable function |
    Project | Project a named slot from a C++ struct or class |
    Call | Call a function (after all arguments have been applied) |
    Alloc | Allocate memory for a new value on the heap or stack |
    Load | Load a value from memory |
    Store | Store a value to memory |
    ArrayIndex | If p is a reference to an array, then p[i] is a reference to the i'th element of the array |
    ArrayAdd | Pointer arithmetic, restricted to arrays only |
    UnaryOp | Simple arithmetic unary operations, e.g |
    BinaryOp | Simple arithmetic binary operations, e.g |
    Cast | Cast expressions |
    Phi | Phi Node, for code in SSA form |
    Terminator | Base class for basic block terminators: Branch, Goto, and Return |
    Goto | Jump to another basic block |
    Branch | A conditional branch to two other blocks |
    Return | Return from the enclosing function, passing the return value to the caller |
    BasicBlock | A basic block is part of an SCFG |
     TopologyNode | |
    SCFG | An SCFG is a control-flow graph |
    Identifier | An identifier, e.g |
    IfThenElse | An if-then-else expression |
    Let | A let-expression, e.g |
    Traversal | |
    SimpleReducerBase | |
    CopyReducerBase | |
     Container | |
    VisitReducerBase | |
     Container | |
    VisitReducer | |
    Comparator | |
    EqualsComparator | |
    MatchComparator | |
    PrettyPrinter | |
    StdPrinter | |
    MemRegionRef | |
    SimpleArray | |
   ThreadSafetyHandler | Handler class for thread safety warnings |
   CFGVisitor | |
   CFGWalker | |
   CapabilityExpr | |
   SExprBuilder | |
    CallingContext | Encapsulates the lexical context of a function call |
   CopyOnWriteVector | |
   BeforeSet | |
  tok | |
  tooling | |
   fixit | |
    internal | |
   CommonOptionsParser | A parser for options common to all command-line Clang tools |
   CompileCommand | Specifies the working directory and command of a compilation |
   CompilationDatabase | Interface for compilation databases |
   CompilationDatabasePlugin | Interface for compilation database plugins |
   FixedCompilationDatabase | A compilation database that returns a single compile command line |
   Range | A source range independent of the SourceManager |
   Replacement | A text replacement |
   TranslationUnitReplacements | Collection of Replacements generated from a single translation unit |
   PathComparator | |
   FileMatchTrie | A trie to efficiently match against the entries of the compilation database in order of matching suffix length |
   JSONCompilationDatabase | A JSON based compilation database |
   RefactoringTool | A tool to run refactorings |
   RefactoringCallback | Base class for RefactoringCallbacks |
   ReplaceStmtWithText | Replace the text of the statement bound to FromId with the text in ToText |
   ReplaceStmtWithStmt | Replace the text of the statement bound to FromId with the text of the statement bound to ToId |
   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 |
   ToolAction | Interface to process a clang::CompilerInvocation |
   FrontendActionFactory | Interface to generate clang::FrontendActions |
   SourceFileCallbacks | Callbacks called before and after each source file processed by a FrontendAction created by the FrontedActionFactory returned by newFrontendActionFactory |
   ToolInvocation | Utility to run a FrontendAction in a single clang invocation |
   ClangTool | Utility to run a FrontendAction over a set of files |
   FileMatchTrieNode | A node of the FileMatchTrie |
  TypeName | |
  vfs | |
   detail | |
    DirIterImpl | An interface for virtual file systems to provide an iterator over the (non-recursive) contents of a directory |
    InMemoryNode | The in memory file system is a tree of Nodes |
    InMemoryDirectory | |
   Status | The result of a status operation |
   File | Represents an open file |
   directory_iterator | An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator |
   recursive_directory_iterator | An input iterator over the recursive contents of a virtual path, similar to llvm::sys::fs::recursive_directory_iterator |
   FileSystem | The virtual file system interface |
   OverlayFileSystem | A file system that allows overlaying one AbstractFileSystem on top of another |
   InMemoryFileSystem | An in-memory file system |
   YAMLVFSEntry | |
   YAMLVFSWriter | |
  WebAssembly | WebAssembly builtins |
  X86 | X86 builtins |
  XCore | XCore builtins |
  CFGReverseBlockReachabilityAnalysis | |
  DominatorTree | Concrete subclass of DominatorTreeBase for Clang This class implements the dominators tree functionality given a Clang CFG |
  LiveVariables | |
   LivenessValues | |
   Observer | |
  RelaxedLiveVariables | |
  PostOrderCFGView | |
   BlockOrderCompare | |
   CFGBlockSet | Implements a set of CFGBlocks using a BitVector |
    iterator | |
  PseudoConstantAnalysis | |
  UninitUse | A use of a variable, which might be uninitialized |
   Branch | |
  UninitVariablesHandler | |
  UninitVariablesAnalysisStats | |
  ManagedAnalysis | The base class of a hierarchy of objects representing analyses tied to AnalysisDeclContext |
  AnalysisDeclContext | AnalysisDeclContext contains the context data for the function or method under analysis |
  LocationContext | |
  StackFrameContext | |
  ScopeContext | |
  BlockInvocationContext | |
  LocationContextManager | |
  AnalysisDeclContextManager | |
  CallGraph | The AST-based call graph |
  CallGraphNode | |
  CFGElement | CFGElement - Represents a top-level expression in a basic block |
  CFGStmt | |
  CFGInitializer | CFGInitializer - Represents C++ base or member initializer from constructor's initialization list |
  CFGNewAllocator | CFGNewAllocator - Represents C++ allocator call |
  CFGImplicitDtor | CFGImplicitDtor - Represents C++ object destructor implicitly generated by compiler on various occasions |
  CFGAutomaticObjDtor | CFGAutomaticObjDtor - Represents C++ object destructor implicitly generated for automatic object or temporary bound to const reference at the point of leaving its local scope |
  CFGDeleteDtor | CFGDeleteDtor - Represents C++ object destructor generated from a call to delete |
  CFGBaseDtor | CFGBaseDtor - Represents C++ object destructor implicitly generated for base object in destructor |
  CFGMemberDtor | CFGMemberDtor - Represents C++ object destructor implicitly generated for member object in destructor |
  CFGTemporaryDtor | CFGTemporaryDtor - Represents C++ object destructor implicitly generated at the end of full expression for temporary object |
  CFGTerminator | CFGTerminator - Represents CFGBlock terminator statement |
  CFGBlock | CFGBlock - Represents a single basic block in a source-level CFG |
   AdjacentBlock | This class represents a potential adjacent block in the CFG |
   FilteredCFGBlockIterator | |
   FilterOptions | |
  CFGCallback | CFGCallback defines methods that should be called when a logical operator error is found when building the CFG |
  CFG | CFG - Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt |
   BuildOptions | |
   const_graph_iterator | |
   graph_iterator | Provides a custom implementation of the iterator class to have the same interface as Function::iterator - iterator returns CFGBlock (not a pointer to CFGBlock) |
  CFGStmtMap | |
  CodeInjector | CodeInjector is an interface which is responsible for injecting AST of function definitions that may not be available in the original source |
  ObjCNoReturn | |
  DataflowValues | DataflowValues. Container class to store dataflow values for a CFG |
  ProgramPointTag | ProgramPoints can be "tagged" as representing points specific to a given analysis entity |
  SimpleProgramPointTag | |
  ProgramPoint | |
  BlockEntrance | |
  BlockExit | |
  StmtPoint | |
  PreStmt | |
  PostStmt | |
  PostCondition | |
  LocationCheck | |
  PreLoad | |
  PreStore | |
  PostLoad | |
  PostStore | Represents a program point after a store evaluation |
  PostLValue | |
  PreStmtPurgeDeadSymbols | Represents a point after we ran remove dead bindings BEFORE processing the given statement |
  PostStmtPurgeDeadSymbols | Represents a point after we ran remove dead bindings AFTER processing the given statement |
  BlockEdge | |
  PostInitializer | |
  ImplicitCallPoint | Represents an implicit call event |
  PreImplicitCall | Represents a program point just before an implicit call event |
  PostImplicitCall | Represents a program point just after an implicit call event |
  CallEnter | Represents a point when we begin processing an inlined call |
  CallExitBegin | Represents a point when we start the call exit sequence (for inlined call) |
  CallExitEnd | Represents a point when we finish the call exit sequence (for inlined call) |
  EpsilonPoint | This is a meta program point, which should be skipped by all the diagnostic reasoning etc |
  BumpVectorContext | |
  BumpVector | |
  APValue | APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset], [Vector: N * APValue], [Array: N * APValue] |
   LV | |
   LValuePathEntry | |
   MemberPointerData | |
   NoLValuePath | |
   UninitArray | |
   UninitStruct | |
  ASTConsumer | ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs |
  TypeInfo | |
  ASTContext | Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic analysis of a file |
   DynTypedNodeList | Container for either a single DynTypedNode or for an ArrayRef to DynTypedNode |
   RawCommentAndCacheFlags | |
   SectionInfo | |
  ASTImporter | Imports selected nodes from one AST context into another context, merging AST nodes where appropriate |
  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 |
  ASTUnresolvedSet | An UnresolvedSet-like class which uses the ASTContext's allocator |
  LazyASTUnresolvedSet | An UnresolvedSet-like class that might not have been loaded from the external AST source yet |
  ASTVector | |
  Attr | Attr - This represents one attribute |
  StmtAttr | |
  InheritableAttr | |
  InheritableParamAttr | |
  ParameterABIAttr | A parameter attribute which changes the argument-passing ABI rule for the parameter |
  specific_attr_iterator | Specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are of a specific type |
  AvailabilitySpec | One specifier in an expression |
  BaseSubobject | |
  CanProxy | Canonical proxy type returned when retrieving the members of a canonical type or as the result of the CanQual<T>::getAs member function |
  CanProxyAdaptor | Replacable canonical proxy adaptor class that provides the link between a canonical type and the accessors of the type |
  CanQual | Represents a canonical, potentially-qualified type |
  CanProxyBase | Base class of all canonical proxy types, which is responsible for storing the underlying canonical type and providing basic conversions |
  CanTypeIterator | Iterator adaptor that turns an iterator over canonical QualTypes into an iterator over CanQualTypes |
  CanProxyAdaptor< ComplexType > | |
  CanProxyAdaptor< PointerType > | |
  CanProxyAdaptor< BlockPointerType > | |
  CanProxyAdaptor< ReferenceType > | |
  CanProxyAdaptor< LValueReferenceType > | |
  CanProxyAdaptor< RValueReferenceType > | |
  CanProxyAdaptor< MemberPointerType > | |
  CanProxyAdaptor< DependentSizedExtVectorType > | |
  CanProxyAdaptor< VectorType > | |
  CanProxyAdaptor< ExtVectorType > | |
  CanProxyAdaptor< FunctionType > | |
  CanProxyAdaptor< FunctionNoProtoType > | |
  CanProxyAdaptor< FunctionProtoType > | |
  CanProxyAdaptor< TypeOfType > | |
  CanProxyAdaptor< DecltypeType > | |
  CanProxyAdaptor< UnaryTransformType > | |
  CanProxyAdaptor< TagType > | |
  CanProxyAdaptor< RecordType > | |
  CanProxyAdaptor< EnumType > | |
  CanProxyAdaptor< TemplateTypeParmType > | |
  CanProxyAdaptor< ObjCObjectType > | |
  CanProxyAdaptor< ObjCObjectPointerType > | |
  CharUnits | CharUnits - This is an opaque type for sizes expressed in character units |
  CXXBasePathElement | Represents an element in a path from a derived class to a base class |
  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 |
  CXXBasePaths | BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases |
  UniqueVirtualMethod | Uniquely identifies a virtual method within a class hierarchy by the method itself and a class subobject number |
  OverridingMethods | The set of methods that override a given virtual method in each subobject where it occurs |
  CXXFinalOverriderMap | A mapping from each virtual member function to its set of final overriders |
  CXXIndirectPrimaryBaseSet | A set of all the primary bases for a class |
  TypeSourceInfo | A container of type source information |
  TranslationUnitDecl | TranslationUnitDecl - The top declaration context |
  PragmaCommentDecl | Represents a #pragma comment line |
  PragmaDetectMismatchDecl | Represents a #pragma detect_mismatch line |
  ExternCContextDecl | Declaration context for names declared as extern "C" in C++ |
  NamedDecl | NamedDecl - This represents a decl with a name |
  LabelDecl | LabelDecl - Represents the declaration of a label |
  NamespaceDecl | NamespaceDecl - Represent a C++ namespace |
  ValueDecl | 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 |
  QualifierInfo | QualifierInfo - A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line declarations |
  DeclaratorDecl | Represents a ValueDecl that came out of a declarator |
  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) |
  VarDecl | VarDecl - An instance of this class is created to represent a variable declaration or definition |
   NonParmVarDeclBitfields | |
   ParmVarDeclBitfields | |
  ImplicitParamDecl | |
  ParmVarDecl | ParmVarDecl - Represents a parameter to a function |
  FunctionDecl | FunctionDecl - An instance of this class is created to represent a function declaration or definition |
  FieldDecl | FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struct/union/class |
  EnumConstantDecl | EnumConstantDecl - An instance of this object exists for each enum constant that is defined |
  IndirectFieldDecl | IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonymous union/struct into the parent scope |
  TypeDecl | TypeDecl - Represents a declaration of a type |
  TypedefNameDecl | Base class for declarations which introduce a typedef-name |
  TypedefDecl | TypedefDecl - Represents the declaration of a typedef-name via the 'typedef' type specifier |
  TypeAliasDecl | TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x alias-declaration |
  TagDecl | TagDecl - Represents the declaration of a struct/union/class/enum |
  EnumDecl | EnumDecl - Represents an enum |
  RecordDecl | RecordDecl - Represents a struct/union/class |
  FileScopeAsmDecl | |
  BlockDecl | BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl |
   Capture | A class which contains all the information about a particular captured value |
  CapturedDecl | This represents the body of a CapturedStmt, and serves as its DeclContext |
  ImportDecl | Describes a module import declaration, which makes the contents of the named module visible in the current translation unit |
  EmptyDecl | Represents an empty-declaration |
  DeclAccessPair | A POD class for pairing a NamedDecl* with an access specifier |
  DeclarationName | DeclarationName - The name of a declaration |
  DeclarationNameTable | DeclarationNameTable - Used to store and retrieve DeclarationName instances for the various kinds of declaration names, e.g., normal identifiers, C++ constructor names, etc |
  DeclarationNameLoc | DeclarationNameLoc - Additional source/type location info for a declaration name |
   CXXLitOpName | |
   CXXOpName | |
   NT | |
  DeclarationNameInfo | DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnding source/type location info |
  PrettyStackTraceDecl | PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specific decl |
  DeclContextLookupResult | The results of name lookup within a DeclContext |
   iterator | |
  DeclContext | DeclContext - This is used only as base class of specific decl types that can act as declaration contexts |
   all_lookups_iterator | All_lookups_iterator - An iterator that provides a view over the results of looking up every possible name |
   ddiag_iterator | An iterator over the dependent diagnostics in a dependent context |
   decl_iterator | Decl_iterator - Iterates through the declarations stored within this context |
   filtered_decl_iterator | Iterates over a filtered subrange of declarations stored in a DeclContext |
   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) |
   udir_iterator | |
  cast_convert_decl_context | |
  cast_convert_decl_context< ToTy, true > | |
  StoredDeclsList | An array of decls optimized for the common case of only containing one entry |
  StoredDeclsMap | |
  DependentStoredDeclsMap | |
  AnyFunctionDecl | Represents any kind of function declaration, whether it is a concrete function or a function template |
  AccessSpecDecl | Represents an access specifier followed by colon ':' |
  CXXBaseSpecifier | Represents a base class of a C++ class |
  CXXRecordDecl | Represents a C++ struct/union/class |
   friend_iterator | An iterator over the friend declarations of a class |
  CXXMethodDecl | Represents a static or instance method of a struct/union/class |
  CXXCtorInitializer | Represents a C++ base or member initializer |
  InheritedConstructor | Description of a constructor that was inherited from a base class |
  CXXConstructorDecl | Represents a C++ constructor within a class |
  CXXDestructorDecl | Represents a C++ destructor within a class |
  CXXConversionDecl | Represents a C++ conversion function within a class |
  LinkageSpecDecl | Represents a linkage specification |
  UsingDirectiveDecl | Represents C++ using-directive |
  NamespaceAliasDecl | Represents a C++ namespace alias |
  UsingShadowDecl | Represents a shadow declaration introduced into a scope by a (resolved) using declaration |
  ConstructorUsingShadowDecl | Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that names a constructor |
  UsingDecl | Represents a C++ using-declaration |
   shadow_iterator | Iterates through the using shadow declarations associated with this using declaration |
  UnresolvedUsingValueDecl | Represents a dependent using declaration which was not marked with typename |
  UnresolvedUsingTypenameDecl | Represents a dependent using declaration which was marked with typename |
  StaticAssertDecl | Represents a C++11 static_assert declaration |
  MSPropertyDecl | An instance of this class represents the declaration of a property member |
  FriendDecl | FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type |
  DeclGroup | |
  DeclGroupRef | |
  ObjCListBase | |
  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 |
  ObjCProtocolList | A list of Objective-C protocols, along with the source locations at which they were referenced |
  ObjCMethodDecl | ObjCMethodDecl - Represents an instance or class method declaration |
  ObjCTypeParamDecl | Represents the declaration of an Objective-C type parameter |
  ObjCTypeParamList | Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereof |
  ObjCPropertyDecl | Represents one property declaration in an Objective-C interface |
  ObjCContainerDecl | ObjCContainerDecl - Represents a container for method declarations |
  ObjCInterfaceDecl | Represents an ObjC class declaration |
   filtered_category_iterator | Iterator that walks over the list of categories, filtering out those that do not meet specific criteria |
  ObjCIvarDecl | ObjCIvarDecl - Represents an ObjC instance variable |
  ObjCAtDefsFieldDecl | Represents a field declaration created by an @defs(...) |
  ObjCProtocolDecl | Represents an Objective-C protocol declaration |
  ObjCCategoryDecl | ObjCCategoryDecl - Represents a category declaration |
  ObjCImplDecl | |
  ObjCCategoryImplDecl | ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration |
  ObjCImplementationDecl | ObjCImplementationDecl - Represents a class definition - this is where method definitions are specified |
  ObjCCompatibleAliasDecl | ObjCCompatibleAliasDecl - Represents alias of a class |
  ObjCPropertyImplDecl | ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category implementation block |
  OMPThreadPrivateDecl | This represents '#pragma omp threadprivate ...' directive |
  OMPDeclareReductionDecl | This represents '#pragma omp declare reduction ...' directive |
  OMPCapturedExprDecl | Pseudo declaration for capturing expressions |
  TemplateParameterList | Stores a list of template parameters for a TemplateDecl and its derived classes |
  FixedSizeTemplateParameterListStorage | Stores a list of template parameters for a TemplateDecl and its derived classes |
  TemplateArgumentList | A template argument list |
  DefaultArgStorage | Storage for a default argument |
  TemplateDecl | The base class of all kinds of template declarations (e.g., class, function, etc.) |
  FunctionTemplateSpecializationInfo | Provides information about a function template specialization, which is a FunctionDecl that has been explicitly specialization or instantiated from a function template |
  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 |
  DependentFunctionTemplateSpecializationInfo | Provides information about a dependent function-template specialization declaration |
  RedeclarableTemplateDecl | Declaration of a redeclarable template |
   CommonBase | |
   SpecEntryTraits | |
   SpecEntryTraits< FunctionTemplateSpecializationInfo > | |
   SpecIterator | |
  FunctionTemplateDecl | Declaration of a template function |
   Common | Data that is common to all of the declarations of a given function template |
  TemplateParmPosition | Defines the position of a template parameter within a template parameter list |
  TemplateTypeParmDecl | Declaration of a template type parameter |
  NonTypeTemplateParmDecl | NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in |
  TemplateTemplateParmDecl | TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in |
  BuiltinTemplateDecl | Represents the builtin template declaration which is used to implement __make_integer_seq and other builtin templates |
  ClassTemplateSpecializationDecl | Represents a class template specialization, which refers to a class template with a given set of template arguments |
  ClassTemplatePartialSpecializationDecl | |
  ClassTemplateDecl | Declaration of a class template |
   Common | Data that is common to all of the declarations of a given class template |
  FriendTemplateDecl | Declaration of a friend template |
  TypeAliasTemplateDecl | Declaration of an alias template |
  ClassScopeFunctionSpecializationDecl | Declaration of a function specialization at template class scope |
  VarTemplateSpecializationDecl | Represents a variable template specialization, which refers to a variable template with a given set of template arguments |
  VarTemplatePartialSpecializationDecl | |
  VarTemplateDecl | Declaration of a variable template |
   Common | Data that is common to all of the declarations of a given variable template |
  DeclVisitor | A simple visitor class that helps create declaration visitors |
  ConstDeclVisitor | A simple visitor class that helps create declaration visitors |
  DependentDiagnostic | A dependently-generated diagnostic |
  EvaluatedExprVisitorBase | Given a potentially-evaluated expression, this visitor visits all of its potentially-evaluated subexpressions, recursively |
  EvaluatedExprVisitor | EvaluatedExprVisitor - This class visits 'Expr *'s |
  ConstEvaluatedExprVisitor | ConstEvaluatedExprVisitor - This class visits 'const Expr *'s |
  SubobjectAdjustment | An adjustment to be made to the temporary created when emitting a reference binding, which accesses a particular subobject of that temporary |
   DTB | |
   P | |
  Expr | Expr - This represents one expression |
   Classification | The return type of classify() |
   EvalResult | EvalResult is a struct with detailed info about an evaluated expression |
   EvalStatus | EvalStatus is a struct with detailed info about an evaluation in progress |
  OpaqueValueExpr | OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class |
  DeclRefExpr | A reference to a declared variable, function, enum, etc |
  PredefinedExpr | [C99 6.4.2.2] - A predefined identifier such as func |
  APNumericStorage | Used by IntegerLiteral/FloatingLiteral to store the numeric without leaking memory |
  APIntStorage | |
  APFloatStorage | |
  IntegerLiteral | |
  CharacterLiteral | |
  FloatingLiteral | |
  ImaginaryLiteral | ImaginaryLiteral - We support imaginary integer and floating point literals, like "1.0i" |
  StringLiteral | StringLiteral - This represents a string literal expression, e.g |
  ParenExpr | ParenExpr - This represents a parethesized expression, e.g |
  UnaryOperator | UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions |
  OffsetOfNode | Helper class for OffsetOfExpr |
  OffsetOfExpr | OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator) |
  UnaryExprOrTypeTraitExpr | UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand |
  ArraySubscriptExpr | ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting |
  CallExpr | CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]) |
  MemberExprNameQualifier | Extra data stored in some MemberExpr objects |
  MemberExpr | MemberExpr - [C99 6.5.2.3] Structure and Union Members |
  CompoundLiteralExpr | CompoundLiteralExpr - [C99 6.5.2.5] |
  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) |
  ImplicitCastExpr | ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct representation in the original source code |
  ExplicitCastExpr | ExplicitCastExpr - An explicit cast written in the source code |
  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 |
  BinaryOperator | A builtin binary operation expression such as "x + y" or "x <= y" |
  CompoundAssignOperator | CompoundAssignOperator - For compound assignments (e.g |
  AbstractConditionalOperator | AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOperator |
  ConditionalOperator | ConditionalOperator - The ?: ternary operator |
  BinaryConditionalOperator | BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle operand to be omitted |
  AddrLabelExpr | AddrLabelExpr - The GNU address of label extension, representing &&label |
  StmtExpr | StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}) |
  ShuffleVectorExpr | ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector |
  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 |
  ChooseExpr | ChooseExpr - GNU builtin-in function __builtin_choose_expr |
  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 |
  VAArgExpr | Represents a call to the builtin function __builtin_va_arg |
  InitListExpr | Describes an C or C++ initializer list |
  DesignatedInitExpr | Represents a C99 designated initializer expression |
   ArrayOrRangeDesignator | An array or GNU array-range designator, e.g., "[9]" or "[10..15]" |
   Designator | Represents a single C99 designator |
   FieldDesignator | A field designator, e.g., ".x" |
  NoInitExpr | Represents a place-holder for an object not to be initialized by anything |
  DesignatedInitUpdateExpr | |
  ImplicitValueInitExpr | Represents an implicitly-generated value initialization of an object of a given type |
  ParenListExpr | |
  GenericSelectionExpr | Represents a C11 generic selection |
  ExtVectorElementExpr | ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the left hand side or right hand side |
  BlockExpr | BlockExpr - Adaptor class for mixing a BlockDecl with expressions |
  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 |
  PseudoObjectExpr | PseudoObjectExpr - An expression which accesses a pseudo-object l-value |
  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> |
  TypoExpr | TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and/or an error diagnostic emitted |
  CXXOperatorCallExpr | A call to an overloaded operator written using operator syntax |
  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 |
  CUDAKernelCallExpr | Represents a call to a CUDA kernel function |
  CXXNamedCastExpr | Abstract class common to all of the C++ "named"/"keyword" casts |
  CXXStaticCastExpr | A C++ static_cast expression (C++ [expr.static.cast]) |
  CXXDynamicCastExpr | A C++ dynamic_cast expression (C++ [expr.dynamic.cast]) |
  CXXReinterpretCastExpr | A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]) |
  CXXConstCastExpr | A C++ const_cast expression (C++ [expr.const.cast]) |
  UserDefinedLiteral | A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit.ext]) |
  CXXBoolLiteralExpr | A boolean literal, per ([C++ lex.bool] Boolean literals) |
  CXXNullPtrLiteralExpr | The null pointer literal (C++11 [lex.nullptr]) |
  CXXStdInitializerListExpr | Implicit construction of a std::initializer_list<T> object from an array temporary within list-initialization (C++11 [dcl.init.list]p5) |
  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 |
  MSPropertyRefExpr | A member reference to an MSPropertyDecl |
  MSPropertySubscriptExpr | MS property subscript expression |
  CXXUuidofExpr | A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or expression |
  CXXThisExpr | Represents the this expression in C++ |
  CXXThrowExpr | A C++ throw-expression (C++ [except.throw]) |
  CXXDefaultArgExpr | A default argument (C++ [dcl.fct.default]) |
  CXXDefaultInitExpr | A use of a default initializer in a constructor or in aggregate initialization |
  CXXTemporary | Represents a C++ temporary |
  CXXBindTemporaryExpr | Represents binding an expression to a temporary |
  CXXConstructExpr | Represents a call to a C++ constructor |
  CXXInheritedCtorInitExpr | Represents a call to an inherited base class constructor from an inheriting constructor |
  CXXFunctionalCastExpr | Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]) |
  CXXTemporaryObjectExpr | Represents a C++ functional cast expression that builds a temporary object |
  LambdaExpr | A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked later |
  CXXScalarValueInitExpr | An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type |
  CXXNewExpr | Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)" |
  CXXDeleteExpr | Represents a delete expression for memory deallocation and destructor calls, e.g |
  PseudoDestructorTypeStorage | Stores the type being destroyed by a pseudo-destructor expression |
  CXXPseudoDestructorExpr | Represents a C++ pseudo-destructor (C++ [expr.pseudo]) |
  TypeTraitExpr | A type trait used in the implementation of various C++11 and Library TR1 trait templates |
  ArrayTypeTraitExpr | An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent |
  ExpressionTraitExpr | An expression trait intrinsic |
  OverloadExpr | A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr |
   FindResult | |
  UnresolvedLookupExpr | A reference to a name which we were able to look up during parsing but could not resolve to a specific declaration |
  DependentScopeDeclRefExpr | A qualified reference to a name whose declaration cannot yet be resolved |
  ExprWithCleanups | Represents an expression – generally a full-expression – that introduces cleanups to be run at the end of the sub-expression's evaluation |
  CXXUnresolvedConstructExpr | Describes an explicit type conversion that uses functional notion but could not be resolved because one or more arguments are type-dependent |
  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 |
  UnresolvedMemberExpr | Represents a C++ member access expression for which lookup produced a set of overloaded functions |
  CXXNoexceptExpr | Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]) |
  PackExpansionExpr | Represents a C++11 pack expansion that produces a sequence of expressions |
  SizeOfPackExpr | Represents an expression that computes the length of a parameter pack |
  SubstNonTypeTemplateParmExpr | Represents a reference to a non-type template parameter that has been substituted with a template argument |
  SubstNonTypeTemplateParmPackExpr | Represents a reference to a non-type template parameter pack that has been substituted with a non-template argument pack |
  FunctionParmPackExpr | Represents a reference to a function parameter pack that has been substituted but not yet expanded |
  MaterializeTemporaryExpr | Represents a prvalue temporary that is written into memory so that a reference can bind to it |
  CXXFoldExpr | Represents a folding of a pack over an operator |
  CoroutineSuspendExpr | Represents an expression that might suspend coroutine execution; either a co_await or co_yield expression |
  CoawaitExpr | Represents a 'co_await' expression |
  CoyieldExpr | Represents a 'co_yield' expression |
  ObjCStringLiteral | ObjCStringLiteral, used for Objective-C string literals i.e |
  ObjCBoolLiteralExpr | ObjCBoolLiteralExpr - Objective-C Boolean Literal |
  ObjCBoxedExpr | ObjCBoxedExpr - used for generalized expression boxing |
  ObjCArrayLiteral | ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]]; |
  ObjCDictionaryElement | An element in an Objective-C dictionary literal |
  ObjCDictionaryLiteral_KeyValuePair | Internal struct for storing Key/value pair |
  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 |
  ObjCDictionaryLiteral | ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserName(), @"date" : [NSDate date] }; |
  ObjCEncodeExpr | ObjCEncodeExpr, used for @encode in Objective-C |
  ObjCSelectorExpr | ObjCSelectorExpr used for @selector in Objective-C |
  ObjCProtocolExpr | ObjCProtocolExpr used for protocol expression in Objective-C |
  ObjCIvarRefExpr | ObjCIvarRefExpr - A reference to an ObjC instance variable |
  ObjCPropertyRefExpr | ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property |
  ObjCSubscriptRefExpr | ObjCSubscriptRefExpr - used for array and dictionary subscripting |
  ObjCMessageExpr | An expression that sends a message to the given Objective-C object or class |
  ObjCIsaExpr | ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type |
  ObjCIndirectCopyRestoreExpr | ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore in ARC |
  ObjCBridgedCastExpr | An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process |
  ObjCAvailabilityCheckExpr | A runtime availability query |
  OMPArraySectionExpr | OpenMP 4.0 [2.4, Array Sections] |
  ExternalASTSource | Abstract interface for external sources of AST nodes |
   ASTSourceDescriptor | Abstracts clang modules and precompiled header files and holds everything needed to generate debug info for an imported module or PCH |
   Deserializing | RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing |
   MemoryBufferSizes | |
  LazyOffsetPtr | A lazy pointer to an AST node (of base type T) that resides within an external AST source |
  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 |
   LazyData | A cache of the value of this pointer, in the most recent generation in which we queried it |
  LazyVector | Represents a lazily-loaded vector of data |
   iterator | Iteration over the elements in the vector |
  GlobalDecl | GlobalDecl - represents a global declaration |
  LambdaCapture | Describes the capture of a variable or of this , or of a C++1y init-capture |
  LocInfoType | Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing |
  MangleContext | MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangler |
  ItaniumMangleContext | |
  MicrosoftMangleContext | |
  MangleNumberingContext | Keeps track of the mangled names of lambda expressions and block literals within a particular context |
  NestedNameSpecifier | Represents a C++ nested name specifier, such as "\::std::vector<int>::" |
  NestedNameSpecifierLoc | A C++ nested-name-specifier augmented with source location information |
  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 |
  NSAPI | |
  OMPClause | This is a basic class for representing single OpenMP clause |
  OMPClauseWithPreInit | Class that handles pre-initialization statement for some clauses, like 'shedule', 'firstprivate' etc |
  OMPClauseWithPostUpdate | Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc |
  OMPVarListClause | This represents clauses with the list of variables like 'private', 'firstprivate', 'copyin', 'shared', or 'reduction' clauses in the '#pragma omp ...' directives |
  OMPIfClause | This represents 'if' clause in the '#pragma omp ...' directive |
  OMPFinalClause | This represents 'final' clause in the '#pragma omp ...' directive |
  OMPNumThreadsClause | This represents 'num_threads' clause in the '#pragma omp ...' directive |
  OMPSafelenClause | This represents 'safelen' clause in the '#pragma omp ...' directive |
  OMPSimdlenClause | This represents 'simdlen' clause in the '#pragma omp ...' directive |
  OMPCollapseClause | This represents 'collapse' clause in the '#pragma omp ...' directive |
  OMPDefaultClause | This represents 'default' clause in the '#pragma omp ...' directive |
  OMPProcBindClause | This represents 'proc_bind' clause in the '#pragma omp ...' directive |
  OMPScheduleClause | This represents 'schedule' clause in the '#pragma omp ...' directive |
  OMPOrderedClause | This represents 'ordered' clause in the '#pragma omp ...' directive |
  OMPNowaitClause | This represents 'nowait' clause in the '#pragma omp ...' directive |
  OMPUntiedClause | This represents 'untied' clause in the '#pragma omp ...' directive |
  OMPMergeableClause | This represents 'mergeable' clause in the '#pragma omp ...' directive |
  OMPReadClause | This represents 'read' clause in the '#pragma omp atomic' directive |
  OMPWriteClause | This represents 'write' clause in the '#pragma omp atomic' directive |
  OMPUpdateClause | This represents 'update' clause in the '#pragma omp atomic' directive |
  OMPCaptureClause | This represents 'capture' clause in the '#pragma omp atomic' directive |
  OMPSeqCstClause | This represents 'seq_cst' clause in the '#pragma omp atomic' directive |
  OMPPrivateClause | This represents clause 'private' in the '#pragma omp ...' directives |
  OMPFirstprivateClause | This represents clause 'firstprivate' in the '#pragma omp ...' directives |
  OMPLastprivateClause | This represents clause 'lastprivate' in the '#pragma omp ...' directives |
  OMPSharedClause | This represents clause 'shared' in the '#pragma omp ...' directives |
  OMPReductionClause | This represents clause 'reduction' in the '#pragma omp ...' directives |
  OMPLinearClause | This represents clause 'linear' in the '#pragma omp ...' directives |
  ParentMap | |
  PrinterHelper | |
  PrintingPolicy | Describes how types, statements, expressions, and declarations should be printed |
  RawComment | |
  BeforeThanCompare< RawComment > | Compare comments' source locations |
  RawCommentList | This class represents all comments included in the translation unit, sorted in order of appearance in the translation unit |
  ASTRecordLayout | ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/class |
   VBaseInfo | |
  RecursiveASTVisitor | A class that does preordor or postorder depth-first traversal on the entire Clang AST and visits each node |
  Redeclarable | Provides common interface for the Decls that can be redeclared |
   DeclLink | |
   redecl_iterator | Iterates through all the redeclarations of the same decl |
  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 |
  DeclStmt | DeclStmt - Adaptor class for mixing declarations with statements and expressions |
  NullStmt | NullStmt - This is the null statement ";": C99 6.8.3p3 |
  CompoundStmt | CompoundStmt - This represents a group of statements like { stmt stmt } |
  SwitchCase | |
  CaseStmt | |
  DefaultStmt | |
  LabelStmt | LabelStmt - Represents a label, which has a substatement |
  AttributedStmt | Represents an attribute applied to a statement |
  IfStmt | IfStmt - This represents an if/then/else |
  SwitchStmt | SwitchStmt - This represents a 'switch' stmt |
  WhileStmt | WhileStmt - This represents a 'while' stmt |
  DoStmt | DoStmt - This represents a 'do/while' stmt |
  ForStmt | ForStmt - This represents a 'for (init;cond;inc)' stmt |
  GotoStmt | GotoStmt - This represents a direct goto |
  IndirectGotoStmt | IndirectGotoStmt - This represents an indirect goto |
  ContinueStmt | ContinueStmt - This represents a continue |
  BreakStmt | BreakStmt - This represents a break |
  ReturnStmt | ReturnStmt - This represents a return, optionally of an expression: return; return 4; |
  AsmStmt | AsmStmt is the base class for GCCAsmStmt and MSAsmStmt |
  GCCAsmStmt | This represents a GCC inline-assembly statement extension |
   AsmStringPiece | AsmStringPiece - this is part of a decomposed asm string specification (for use with the AnalyzeAsmString function below) |
  MSAsmStmt | This represents a Microsoft inline-assembly statement extension |
  SEHExceptStmt | |
  SEHFinallyStmt | |
  SEHTryStmt | |
  SEHLeaveStmt | Represents a __leave statement |
  CapturedStmt | This captures a statement into a function |
   Capture | Describes the capture of either a variable, or 'this', or variable-length array type |
  CXXCatchStmt | CXXCatchStmt - This represents a C++ catch block |
  CXXTryStmt | CXXTryStmt - A C++ try block, including all handlers |
  CXXForRangeStmt | CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (range-declarator : range-expression)' |
  MSDependentExistsStmt | Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name |
  CoroutineBodyStmt | Represents the body of a coroutine |
  CoreturnStmt | Represents a 'co_return' statement in the C++ Coroutines TS |
  StmtIteratorBase | |
  StmtIteratorImpl | |
  StmtIterator | |
  ConstStmtIterator | |
  ObjCForCollectionStmt | Represents Objective-C's collection statement |
  ObjCAtCatchStmt | Represents Objective-C's @catch statement |
  ObjCAtFinallyStmt | Represents Objective-C's @finally statement |
  ObjCAtTryStmt | Represents Objective-C's @try ... @catch ... @finally statement |
  ObjCAtSynchronizedStmt | Represents Objective-C's @synchronized statement |
  ObjCAtThrowStmt | Represents Objective-C's @throw statement |
  ObjCAutoreleasePoolStmt | Represents Objective-C's @autoreleasepool Statement |
  OMPExecutableDirective | This is a basic class for representing single OpenMP executable directive |
   specific_clause_iterator | Iterates over a filtered subrange of clauses applied to a directive |
  OMPParallelDirective | This represents '#pragma omp parallel' directive |
  OMPLoopDirective | This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc.) |
   HelperExprs | The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest |
  OMPSimdDirective | This represents '#pragma omp simd' directive |
  OMPForDirective | This represents '#pragma omp for' directive |
  OMPForSimdDirective | This represents '#pragma omp for simd' directive |
  OMPSectionsDirective | This represents '#pragma omp sections' directive |
  OMPSectionDirective | This represents '#pragma omp section' directive |
  OMPSingleDirective | This represents '#pragma omp single' directive |
  OMPMasterDirective | This represents '#pragma omp master' directive |
  OMPCriticalDirective | This represents '#pragma omp critical' directive |
  OMPParallelForDirective | This represents '#pragma omp parallel for' directive |
  OMPParallelForSimdDirective | This represents '#pragma omp parallel for simd' directive |
  OMPParallelSectionsDirective | This represents '#pragma omp parallel sections' directive |
  OMPTaskDirective | This represents '#pragma omp task' directive |
  OMPTaskyieldDirective | This represents '#pragma omp taskyield' directive |
  OMPBarrierDirective | This represents '#pragma omp barrier' directive |
  OMPTaskwaitDirective | This represents '#pragma omp taskwait' directive |
  OMPTaskgroupDirective | This represents '#pragma omp taskgroup' directive |
  OMPFlushDirective | This represents '#pragma omp flush' directive |
  OMPOrderedDirective | This represents '#pragma omp ordered' directive |
  OMPAtomicDirective | This represents '#pragma omp atomic' directive |
  OMPTargetDirective | This represents '#pragma omp target' directive |
  OMPTargetDataDirective | This represents '#pragma omp target data' directive |
  OMPTargetEnterDataDirective | This represents '#pragma omp target enter data' directive |
  OMPTargetExitDataDirective | This represents '#pragma omp target exit data' directive |
  OMPTargetParallelDirective | This represents '#pragma omp target parallel' directive |
  OMPTargetParallelForDirective | This represents '#pragma omp target parallel for' directive |
  OMPTeamsDirective | This represents '#pragma omp teams' directive |
  OMPCancellationPointDirective | This represents '#pragma omp cancellation point' directive |
  OMPCancelDirective | This represents '#pragma omp cancel' directive |
  OMPTaskLoopDirective | This represents '#pragma omp taskloop' directive |
  OMPTaskLoopSimdDirective | This represents '#pragma omp taskloop simd' directive |
  OMPDistributeDirective | This represents '#pragma omp distribute' directive |
  OMPTargetUpdateDirective | This represents '#pragma omp target update' directive |
  OMPDistributeParallelForDirective | This represents '#pragma omp distribute parallel for' composite directive |
  OMPDistributeParallelForSimdDirective | This represents '#pragma omp distribute parallel for simd' composite directive |
  OMPDistributeSimdDirective | This represents '#pragma omp distribute simd' composite directive |
  OMPTargetParallelForSimdDirective | This represents '#pragma omp target parallel for simd' directive |
  make_ptr | |
  make_const_ptr | |
  StmtVisitorBase | StmtVisitorBase - This class implements a simple visitor for Stmt subclasses |
  StmtVisitor | StmtVisitor - This class implements a simple visitor for Stmt subclasses |
  ConstStmtVisitor | ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses |
  OMPClauseVisitorBase | This class implements a simple visitor for OMPClause subclasses |
  OMPClauseVisitor | |
  ConstOMPClauseVisitor | |
  TemplateArgument | Represents a template argument |
  TemplateArgumentLocInfo | Location information for a TemplateArgument |
  TemplateArgumentLoc | Location wrapper for a TemplateArgument |
  TemplateArgumentListInfo | A convenient class for passing around template argument information |
  ASTTemplateArgumentListInfo | Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>" |
  UncommonTemplateNameStorage | Implementation class used to describe either a set of overloaded template names or an already-substituted template template parameter pack |
   BitsTag | |
  OverloadedTemplateStorage | A structure for storing the information associated with an overloaded template name |
  SubstTemplateTemplateParmPackStorage | A structure for storing an already-substituted template template parameter pack |
  TemplateName | Represents a C++ template name within the type system |
  SubstTemplateTemplateParmStorage | A structure for storing the information associated with a substituted template template parameter |
  QualifiedTemplateName | Represents a template name that was expressed as a qualified name |
  DependentTemplateName | Represents a dependent template name that cannot be resolved prior to template instantiation |
  Qualifiers | The collection of all-type qualifiers we support |
  SplitQualType | A std::pair-like structure for storing a qualified type split into its local qualifiers and its locally-unqualified type |
  QualType | A (possibly-)qualified type |
   StreamedQualTypeHelper | |
  ExtQualsTypeCommonBase | Base class that is common to both the ExtQuals and Type classes, which allows QualType to access the common fields between the two |
  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 |
  Type | The base class of the type hierarchy |
   ArrayTypeBitfields | |
   AttributedTypeBitfields | |
   AutoTypeBitfields | |
   BuiltinTypeBitfields | |
   FunctionTypeBitfields | |
   ObjCObjectTypeBitfields | |
   ReferenceTypeBitfields | |
   TypeWithKeywordBitfields | |
   VectorTypeBitfields | |
  BuiltinType | This class is used for builtin types like 'int' |
  ComplexType | Complex values, per C99 6.2.5p11 |
  ParenType | Sugar for parentheses used when specifying types |
  PointerType | PointerType - C99 6.7.5.1 - Pointer Declarators |
  AdjustedType | Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons |
  DecayedType | Represents a pointer type decayed from an array or function type |
  BlockPointerType | Pointer to a block type |
  ReferenceType | Base for LValueReferenceType and RValueReferenceType |
  LValueReferenceType | An lvalue reference type, per C++11 [dcl.ref] |
  RValueReferenceType | An rvalue reference type, per C++11 [dcl.ref] |
  MemberPointerType | A pointer to member type per C++ 8.3.3 - Pointers to members |
  ArrayType | Represents an array type, per C99 6.7.5.2 - Array Declarators |
  ConstantArrayType | Represents the canonical version of C arrays with a specified constant size |
  IncompleteArrayType | Represents a C array with an unspecified size |
  VariableArrayType | Represents a C array with a specified size that is not an integer-constant-expression |
  DependentSizedArrayType | Represents an array type in C++ whose size is a value-dependent expression |
  DependentSizedExtVectorType | Represents an extended vector type where either the type or size is dependent |
  VectorType | Represents a GCC generic vector type |
  ExtVectorType | ExtVectorType - Extended vector type |
  FunctionType | FunctionType - C99 6.7.5.3 - Function Declarators |
   ExtInfo | A class which abstracts out some details necessary for making a call |
  FunctionNoProtoType | Represents a K&R-style 'int foo()' function, which has no information available about its arguments |
  FunctionProtoType | Represents a prototype with parameter type info, e.g |
   ExceptionSpecInfo | |
   ExtParameterInfo | Interesting information about a specific parameter that can't simply be reflected in parameter's type |
   ExtProtoInfo | Extra information about a function prototype |
  UnresolvedUsingType | Represents the dependent type named by a dependently-scoped typename using declaration, e.g |
  TypedefType | |
  TypeOfExprType | Represents a typeof (or typeof) expression (a GCC extension) |
  DependentTypeOfExprType | Internal representation of canonical, dependent typeof(expr) types |
  TypeOfType | Represents typeof(type) , a GCC extension |
  DecltypeType | Represents the type decltype(expr) (C++11) |
  DependentDecltypeType | Internal representation of canonical, dependent decltype(expr) types |
  UnaryTransformType | A unary type transform, which is a type constructed from another |
  DependentUnaryTransformType | Internal representation of canonical, dependent __underlying_type(type) types |
  TagType | |
  RecordType | A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/classes |
  EnumType | A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums |
  AttributedType | An attributed type is a type to which a type attribute has been applied |
  TemplateTypeParmType | |
  SubstTemplateTypeParmType | Represents the result of substituting a type for a template type parameter |
  SubstTemplateTypeParmPackType | Represents the result of substituting a set of types for a template type parameter pack |
  AutoType | Represents a C++11 auto or C++14 decltype(auto) type |
  InjectedClassNameType | The injected class name of a C++ class template or class template partial specialization |
  TypeWithKeyword | A helper class for Type nodes having an ElaboratedTypeKeyword |
   CannotCastToThisType | |
  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 |
  DependentNameType | Represents a qualified type name for which the type name is dependent |
  PackExpansionType | Represents a pack expansion of types |
  ObjCObjectType | Represents a class type in Objective C |
  ObjCObjectTypeImpl | A class providing a concrete implementation of ObjCObjectType, so as to not increase the footprint of ObjCInterfaceType |
  ObjCInterfaceType | Interfaces are the core concept in Objective-C for object oriented design |
  ObjCObjectPointerType | Represents a pointer to an Objective C object |
  AtomicType | |
  PipeType | PipeType - OpenCL20 |
  QualifierCollector | A qualifier set is used to build a set of qualifiers |
  ArrayType_cannot_be_used_with_getAs | |
  TypeLoc | Base wrapper for a particular "section" of type source info |
  UnqualTypeLoc | Wrapper of type source information for a type with no direct qualifiers |
  QualifiedTypeLoc | Wrapper of type source information for a type with non-trivial direct qualifiers |
  ConcreteTypeLoc | A metaprogramming base class for TypeLoc classes which correspond to a particular Type subclass |
   HasNoInnerType | |
  InheritingConcreteTypeLoc | A metaprogramming class designed for concrete subtypes of abstract types where all subtypes share equivalently-structured source information |
  TypeSpecLocInfo | |
  TypeSpecTypeLoc | A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier |
  BuiltinLocInfo | |
  BuiltinTypeLoc | Wrapper for source info for builtin types |
  TypedefTypeLoc | Wrapper for source info for typedefs |
  InjectedClassNameTypeLoc | Wrapper for source info for injected class names of class templates |
  UnresolvedUsingTypeLoc | Wrapper for source info for unresolved typename using decls |
  TagTypeLoc | Wrapper for source info for tag types |
  RecordTypeLoc | Wrapper for source info for record types |
  EnumTypeLoc | Wrapper for source info for enum types |
  TemplateTypeParmTypeLoc | Wrapper for template type parameters |
  SubstTemplateTypeParmTypeLoc | Wrapper for substituted template type parameters |
  SubstTemplateTypeParmPackTypeLoc | Wrapper for substituted template type parameters |
  AttributedLocInfo | |
  AttributedTypeLoc | Type source information for an attributed type |
  ObjCObjectTypeLocInfo | |
  ObjCObjectTypeLoc | |
  ObjCInterfaceLocInfo | |
  ObjCInterfaceTypeLoc | Wrapper for source info for ObjC interfaces |
  ParenLocInfo | |
  ParenTypeLoc | |
  AdjustedLocInfo | |
  AdjustedTypeLoc | |
  DecayedTypeLoc | Wrapper for source info for pointers decayed from arrays and functions |
  PointerLikeLocInfo | |
  PointerLikeTypeLoc | A base class for |
  PointerTypeLoc | Wrapper for source info for pointers |
  BlockPointerTypeLoc | Wrapper for source info for block pointers |
  MemberPointerLocInfo | |
  MemberPointerTypeLoc | Wrapper for source info for member pointers |
  ObjCObjectPointerTypeLoc | Wraps an ObjCPointerType with source location information |
  ReferenceTypeLoc | |
  LValueReferenceTypeLoc | |
  RValueReferenceTypeLoc | |
  FunctionLocInfo | |
  FunctionTypeLoc | Wrapper for source info for functions |
  FunctionProtoTypeLoc | |
  FunctionNoProtoTypeLoc | |
  ArrayLocInfo | |
  ArrayTypeLoc | Wrapper for source info for arrays |
  ConstantArrayTypeLoc | |
  IncompleteArrayTypeLoc | |
  DependentSizedArrayTypeLoc | |
  VariableArrayTypeLoc | |
  TemplateNameLocInfo | |
  TemplateSpecializationLocInfo | |
  TemplateSpecializationTypeLoc | |
  VectorTypeLoc | |
  ExtVectorTypeLoc | |
  DependentSizedExtVectorTypeLoc | |
  ComplexTypeLoc | |
  TypeofLocInfo | |
  TypeOfExprTypeLocInfo | |
  TypeOfTypeLocInfo | |
  TypeofLikeTypeLoc | |
  TypeOfExprTypeLoc | |
  TypeOfTypeLoc | |
  DecltypeTypeLoc | |
  UnaryTransformTypeLocInfo | |
  UnaryTransformTypeLoc | |
  AutoTypeLoc | |
  ElaboratedLocInfo | |
  ElaboratedTypeLoc | |
  DependentNameLocInfo | |
  DependentNameTypeLoc | |
  DependentTemplateSpecializationLocInfo | |
  DependentTemplateSpecializationTypeLoc | |
  PackExpansionTypeLocInfo | |
  PackExpansionTypeLoc | |
  AtomicTypeLocInfo | |
  AtomicTypeLoc | |
  PipeTypeLocInfo | |
  PipeTypeLoc | |
  TypeLocVisitor | |
  QualTypeOrdering | Function object that provides a total ordering on QualType values |
  TypeVisitor | An operation on a type |
  UnresolvedSetIterator | The iterator over UnresolvedSets |
  UnresolvedSetImpl | A set of unresolved declarations |
  UnresolvedSet | A set of unresolved declarations |
  VTableComponent | Represents a single component in a vtable |
  VTableLayout | |
  VTableContextBase | |
  ItaniumVTableContext | |
  VPtrInfo | Holds information about the inheritance path to a virtual base or function table pointer |
  VirtualBaseInfo | All virtual base related information about a given record decl |
  MicrosoftVTableContext | |
   MethodVFTableLocation | |
  VTTVTable | |
  VTTComponent | |
  VTTBuilder | Class for building VTT layout information |
  ReturnAdjustment | A return adjustment |
   VirtualAdjustment | Holds the ABI-specific information about the virtual return adjustment, if needed |
  ThisAdjustment | A this pointer adjustment |
   VirtualAdjustment | Holds the ABI-specific information about the virtual this adjustment, if needed |
  ThunkInfo | The this pointer adjustment as well as an optional return adjustment for a thunk |
  StringSizerHelper | |
  CommentOptions | Options for controlling comment parsing |
  FixItHint | Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the problem |
  DiagnosticsEngine | Concrete class used by the front-end to report problems and issues |
  DiagnosticErrorTrap | RAII class that determines when any errors have occurred between the time the instance was created and the time it was queried |
  DiagnosticBuilder | A little helper class used to produce diagnostics |
  AddFlagValue | |
  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 |
  StoredDiagnostic | Represents a diagnostic in a form that can be retained until its corresponding source manager is destroyed |
  DiagnosticConsumer | Abstract interface, implemented by clients of the front-end, which formats and prints fully processed diagnostics |
  IgnoringDiagConsumer | A diagnostic client that ignores all diagnostics |
  ForwardingDiagnosticConsumer | Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic consumer |
  TemplateDiffTypes | |
  DiagnosticMapping | |
  DiagnosticIDs | Used for handling and querying diagnostic IDs |
  DiagnosticOptions | Options for controlling the compiler diagnostics engine |
  DirectoryEntry | Cached information about one directory (either on disk or in the virtual file system) |
  FileEntry | Cached information about one file (either on disk or in the virtual file system) |
  FileManager | Implements support for file system lookup, file system caching, and directory search management |
  FileSystemOptions | Keeps track of options that affect how file operations are performed |
  FileData | |
  FileSystemStatCache | Abstract interface for introducing a FileManager cache for 'stat' system calls, which is used by precompiled and pretokenized headers to improve performance |
  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 |
  IdentifierInfo | One of these records is kept for each identifier that is lexed |
  PoisonIdentifierRAIIObject | An RAII object for [un]poisoning an identifier within a scope |
  IdentifierIterator | An iterator that walks over all of the known identifiers in the lookup table |
  IdentifierInfoLookup | Provides lookups to, and iteration over, IdentiferInfo objects |
  IdentifierTable | Implements an efficient mapping from strings to IdentifierInfo nodes |
  Selector | Smart pointer class that efficiently represents Objective-C method names |
  SelectorTable | This table allows us to fully hide how we implement multi-keyword caching |
  DeclarationNameExtra | DeclarationNameExtra - Common base of the MultiKeywordSelector, CXXSpecialName, and CXXOperatorIdName classes, all of which are private classes that describe different kinds of names |
  LangOptionsBase | Bitfields of LangOptions, split out from LangOptions in order to ensure that this large collection of bitfields is a trivial class type |
  LangOptions | Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that is accepted |
  FPOptions | Floating point control options |
  MacroBuilder | |
  Module | Describes a module or submodule |
   Conflict | A conflict between two modules |
   DirectoryName | Information about a directory name as found in the module map file |
   Header | Information about a header directive as found in the module map file |
   LinkLibrary | A library or framework to link against when an entity from this module is used |
   UnresolvedConflict | An unresolved conflict with another module |
   UnresolvedExportDecl | Describes an exported module that has not yet been resolved (perhaps because the module it refers to has not yet been loaded) |
   UnresolvedHeaderDirective | Stored information about a header directive that was found in the module map file but has not been resolved to a file |
  VisibleModuleSet | A set of visible modules |
  ObjCRuntime | The basic abstraction for the target Objective-C runtime |
  OpenCLOptions | OpenCL supported extensions and optional core features |
  OpenMPScheduleTy | Scheduling data for loop-based OpenMP directives |
  PartialDiagnostic | |
   NullDiagnostic | |
   Storage | |
   StorageAllocator | An allocator for Storage objects, which uses a small cache to objects, used to reduce malloc()/free() traffic for partial diagnostics |
  PrettyStackTraceLoc | If a crash happens while one of these objects are live, the message is printed out along with the specified source location |
  SanitizerBlacklist | |
  SanitizerSet | |
  FileID | An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with its #include path and #line data |
  SourceLocation | Encodes a location in the source |
  SourceRange | A trivial tuple used to represent a source range |
  CharSourceRange | Represents a character-granular source range |
  FullSourceLoc | A SourceLocation and its associated SourceManager |
   BeforeThanCompare | Comparison function class, useful for sorting FullSourceLocs |
  PresumedLoc | Represents an unpacked "presumed" location which can be presented to the user |
  ExternalSLocEntrySource | External source of source location entries |
  InBeforeInTUCacheEntry | Holds the cache used by isBeforeInTranslationUnit |
  SourceManager | This class handles loading and caching of source files into memory |
   MemoryBufferSizes | |
  BeforeThanCompare | Comparison function object |
  BeforeThanCompare< SourceLocation > | Compare two source locations |
  BeforeThanCompare< SourceRange > | Compare two non-overlapping source ranges |
  LineEntry | |
  LineTableInfo | Used to hold and unique data used to represent #line information |
  WrittenBuiltinSpecs | Structure that packs information about the type specifiers that were written in a particular type specifier sequence |
  NeonTypeFlags | Flags to identify the types for overloaded Neon builtins |
  TargetCXXABI | The basic abstraction for the target C++ ABI |
  TargetInfo | Exposes information about the current target |
   AddlRegName | |
   ConstraintInfo | |
   GCCRegAlias | |
  TargetOptions | Options for controlling the target |
  VersionTuple | Represents a version number in the form major[.minor[.subminor[.build]]] |
  LinkageInfo | |
  CodeGenAction | |
  EmitAssemblyAction | |
  EmitBCAction | |
  EmitLLVMAction | |
  EmitLLVMOnlyAction | |
  EmitCodeGenOnlyAction | |
  EmitObjAction | |
  CodeGenerator | The primary public interface to the Clang code generator |
  ObjectFilePCHContainerWriter | A PCHContainerWriter implementation that uses LLVM to wraps Clang modules inside a COFF, ELF, or Mach-O container |
  ObjectFilePCHContainerReader | A PCHContainerReader implementation that uses LLVM to wraps Clang modules inside a COFF, ELF, or Mach-O container |
  ASTUnit | Utility class for loading a ASTContext from an AST file |
   ASTWriterData | |
   CachedCodeCompletionResult | A cached code-completion result, which may be introduced in one of many different contexts |
   ConcurrencyCheck | |
   PreambleData | |
   PreambleFileHash | Data used to determine if a file used in the preamble has been changed |
   StandaloneDiagnostic | |
   StandaloneFixIt | |
  ChainedDiagnosticConsumer | ChainedDiagnosticConsumer - Chain two diagnostic clients so that diagnostics go to the first client and then the second |
  CodeGenOptionsBase | Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure that this large collection of bitfields is a trivial class type |
  CodeGenOptions | CodeGenOptions - Track various options which control how the code is optimized and passed to the backend |
  ParsedSourceLocation | A source location that has been parsed on the command line |
  CompilerInstance | CompilerInstance - Helper class for managing a single instance of the Clang compiler |
  CompilerInvocationBase | |
  CompilerInvocation | Helper class for holding the data necessary to invoke the compiler |
  DependencyOutputOptions | DependencyOutputOptions - Options for controlling the compiler dependency file generation |
  DiagnosticRenderer | Class to encapsulate the logic for formatting a diagnostic message |
  DiagnosticNoteRenderer | Subclass of DiagnosticRender that turns all subdiagostics into explicit notes |
  FrontendAction | Abstract base class for actions which can be performed by the frontend |
  ASTFrontendAction | Abstract base class to use for AST consumer-based frontend actions |
  PluginASTAction | |
  PreprocessorFrontendAction | Abstract base class to use for preprocessor-based frontend actions |
  WrapperFrontendAction | A frontend action which simply wraps some other runtime-specified frontend action |
  InitOnlyAction | |
  ASTPrintAction | |
  ASTDumpAction | |
  ASTDeclListAction | |
  ASTViewAction | |
  DeclContextPrintAction | |
  GeneratePCHAction | |
  GenerateModuleAction | |
  SyntaxOnlyAction | |
  DumpModuleInfoAction | Dump information about the given module file, to be used for basic debugging and discovery |
  VerifyPCHAction | |
  ASTMergeAction | Frontend action adaptor that merges ASTs together |
  PrintPreambleAction | |
  DumpRawTokensAction | |
  DumpTokensAction | |
  GeneratePTHAction | |
  PreprocessOnlyAction | |
  PrintPreprocessedAction | |
  FrontendInputFile | An input file for the front end |
  FrontendOptions | FrontendOptions - Options for controlling the behavior of the frontend |
  LangStandard | LangStandard - Information about the properties of a particular language standard |
  LayoutOverrideSource | An external AST source that overrides the layout of a specified set of record types |
  LogDiagnosticPrinter | |
  MigratorOptions | |
  MultiplexConsumer | |
  PCHBuffer | |
  PCHContainerWriter | This abstract interface provides operations for creating containers for serialized ASTs (precompiled headers and clang modules) |
  PCHContainerReader | This abstract interface provides operations for unwrapping containers for serialized ASTs (precompiled headers and clang modules) |
  RawPCHContainerWriter | Implements write operations for a raw pass-through PCH container |
  RawPCHContainerReader | Implements read operations for a raw pass-through PCH container |
  PCHContainerOperations | A registry of PCHContainerWriter and -Reader objects for different formats |
  PreprocessorOutputOptions | PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g., -E) |
  TextDiagnostic | Class to encapsulate the logic for formatting and printing a textual diagnostic message |
  TextDiagnosticBuffer | |
  TextDiagnosticPrinter | |
  DependencyCollector | An interface for collecting the dependencies of a compilation |
  DependencyFileGenerator | Builds a depdenency 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 |
  ModuleDependencyCollector | Collects the dependencies for imported modules into a directory |
  VerifyDiagnosticConsumer | VerifyDiagnosticConsumer - Create a diagnostic client which will use markers in the input source to check that all the emitted diagnostics match those expected |
   Directive | Directive - Abstract class representing a parsed verify directive |
   ExpectedData | ExpectedData - owns directive objects and deletes on destructor |
  CodeCompletionHandler | Callback handler that receives notifications when performing code completion within the preprocessor |
  DirectoryLookup | DirectoryLookup - This class represents one entry in the search list that specifies the search order for directories in #include directives |
  ExternalPreprocessorSource | Abstract interface for external sources of preprocessor information |
  HeaderMapImpl | Implementation for HeaderMap that doesn't depend on FileManager |
  HeaderMap | This class represents an Apple concept known as a 'header map' |
  HMapBucket | |
  HMapHeader | |
  HeaderFileInfo | The preprocessor keeps track of this information for each file that is #included |
  ExternalHeaderFileInfoSource | An external source of header file information, which may supply information about header files already included |
  HeaderSearch | Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc |
  HeaderSearchOptions | HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSearch object |
   Entry | |
   SystemHeaderPrefix | |
  Lexer | Lexer - This provides a simple interface that turns a text buffer into a stream of tokens |
  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 |
  CharLiteralParser | CharLiteralParser - Perform interpretation and semantic analysis of a character literal |
  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) |
  MacroArgs | MacroArgs - An instance of this class captures information about the formal arguments specified to a function-like macro invocation |
  MacroInfo | Encapsulates the data about a macro definition (e.g |
  MacroDirective | Encapsulates changes to the "macros namespace" (the location where the macro name became active, the location where it was undefined, etc.) |
   DefInfo | |
  DefMacroDirective | A directive for a defined macro or a macro imported from a module |
  UndefMacroDirective | A directive for an undefined macro |
  VisibilityMacroDirective | A directive for setting the module visibility of a macro |
  ModuleMacro | Represents a macro directive exported by a module |
  MacroDefinition | A description of the current definition of a macro |
  ModuleLoadResult | Describes the result of attempting to load a module |
  ModuleLoader | Abstract interface for a module loader |
  ModuleMapCallbacks | A mechanism to observe the actions of the module map parser as it reads module map files |
  ModuleMap | |
   KnownHeader | A header that is known to reside within a given module, whether it was included or excluded |
  MultipleIncludeOpt | Implements the simple state machine that the Lexer class uses to detect files subject to the 'multiple-include' optimization |
  PPCallbacks | This interface provides a way to observe the actions of the preprocessor as it does its thing |
  PPChainedCallbacks | Simple wrapper class for chaining callbacks |
  PPConditionalDirectiveRecord | Records preprocessor conditional directive regions and allows querying in which region source locations belong to |
  PragmaHandler | PragmaHandler - Instances of this interface defined to handle the various pragmas that the language front-end uses |
  EmptyPragmaHandler | EmptyPragmaHandler - A pragma handler which takes no action, which can be used to ignore particular pragmas |
  PragmaNamespace | PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas, allowing hierarchical pragmas to be defined |
  PreprocessedEntity | Base class that describes a preprocessed entity, which may be a preprocessor directive or macro expansion |
  PreprocessingDirective | Records the presence of a preprocessor directive |
  MacroDefinitionRecord | Record the location of a macro definition |
  MacroExpansion | Records the location of a macro expansion |
  InclusionDirective | Record the location of an inclusion directive, such as an #include or #import statement |
  ExternalPreprocessingRecordSource | An abstract class that should be subclassed by any external source of preprocessing record entries |
  PreprocessingRecord | A record of the steps taken while preprocessing a source file, including the various preprocessing directives processed, macros expanded, etc |
   iterator | Iteration over the preprocessed entities |
  TokenValue | Stores token information for comparing actual tokens with predefined values |
  Preprocessor | Engages in a tight little dance with the lexer to efficiently preprocess tokens |
   ResetMacroExpansionHelper | |
  CommentHandler | Abstract base class that describes a handler that will receive source ranges for each of the comments encountered in the source file |
  PreprocessorLexer | |
  PreprocessorOptions | PreprocessorOptions - This class is used for passing the various options used in preprocessor initialization to InitializePreprocessor() |
   FailedModulesSet | Records the set of modules |
  PTHLexer | |
  PTHManager | |
   PTHFileLookupTrait | |
   PTHStringLookupTrait | |
  ScratchBuffer | ScratchBuffer - This class exposes a simple interface for the dynamic construction of tokens |
  Token | Token - This structure provides full information about a lexed token |
  PPConditionalInfo | Information about the conditional stack (#if directives) currently active |
  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?" |
  TokenLexer | TokenLexer - This implements a lexer that returns tokens from a macro body or token stream instead of lexing from a character buffer |
  Parser | Parser - This implements a parser for the C family of languages |
   ConditionDeclarationOrInitStatementState | |
   ObjCTypeParamListScope | Class to handle popping type parameters when leaving the scope |
   OpenMPVarListDataTy | Data used for parsing list of variables in OpenMP clauses |
   ParseScope | ParseScope - Introduces a new scope for parsing |
   UnannotatedTentativeParsingAction | A tentative parsing action that can also revert token annotations |
  DeltaTree | DeltaTree - a multiway search tree (BTree) structure with some fancy features |
  RewriteBuffer | RewriteBuffer - As code is rewritten, SourceBuffer's from the original input with modifications get a new RewriteBuffer associated with them |
  Rewriter | Rewriter - This is the main interface to the rewrite buffers |
   RewriteOptions | |
  RopeRefCountString | RopeRefCountString - This struct is allocated with 'new char[]' from the heap, and represents a reference counted chunk of string data |
  RopePiece | RopePiece - This class represents a view into a RopeRefCountString object |
  RopePieceBTreeIterator | RopePieceBTreeIterator - This class provides read-only forward iteration over bytes that are in a RopePieceBTree |
  RopePieceBTree | |
  RewriteRope | RewriteRope - A powerful string class |
  TokenRewriter | |
  FixItOptions | |
  FixItRewriter | |
  HTMLPrintAction | |
  FixItAction | |
  FixItRecompile | Emits changes to temporary files and uses them for the original frontend action |
  RewriteObjCAction | |
  RewriteMacrosAction | |
  RewriteTestAction | |
  RewriteIncludesAction | |
  AvailabilityChange | Represents information about a change in availability for an entity, which is part of the encoding of the 'availability' attribute |
  IdentifierLoc | Wraps an identifier and optional source location for the identifier |
  AttributeList | AttributeList - Represents a syntactic attribute |
   PropertyData | |
   TypeTagForDatatypeData | |
  AttributeFactory | A factory, from which one makes pools, from which one creates individual attributes which are deallocated with the pool |
  AttributePool | |
  ParsedAttributes | ParsedAttributes - A collection of parsed attributes |
  CleanupInfo | |
  CodeCompletionContext | The context in which code completion occurred, so that the code-completion consumer can process the results accordingly |
  CodeCompletionString | A "string" used to describe how code completion can be performed for an entity |
   Chunk | One piece of the code completion string |
  CodeCompletionAllocator | An allocator used specifically for the purpose of code completion |
  GlobalCodeCompletionAllocator | Allocator for a cached set of global code completions |
  CodeCompletionTUInfo | |
  CodeCompletionBuilder | A builder class used to construct new code-completion strings |
  CodeCompletionResult | Captures a result of code completion |
  CodeCompleteConsumer | Abstract interface for a consumer of code-completion information |
   OverloadCandidate | |
  PrintingCodeCompleteConsumer | A simple code-completion consumer that prints the results it receives in a simple format |
  CodeCompleteOptions | Options controlling the behavior of code completion |
  CXXFieldCollector | CXXFieldCollector - Used to keep track of CXXFieldDecls during parsing of C++ classes |
  CXXScopeSpec | Represents a C++ nested-name-specifier or a global scope specifier |
  DeclSpec | Captures information about "declaration specifiers" |
  ObjCDeclSpec | Captures information about "declaration specifiers" specific to Objective-C |
  UnqualifiedId | Represents a C++ unqualified-id that has been parsed |
   OFI | |
  DeclaratorChunk | One instance of this struct is used for each type in a declarator that is parsed |
   ArrayTypeInfo | |
   BlockPointerTypeInfo | |
   FunctionTypeInfo | |
   MemberPointerTypeInfo | |
   ParamInfo | ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed |
   PipeTypeInfo | |
   PointerTypeInfo | |
   ReferenceTypeInfo | |
   TypeAndRange | |
   TypeInfoCommon | |
  Declarator | Information about one declarator, including the parsed type information and the identifier |
  FieldDeclarator | This little struct is used to capture information about structure field declarators, which is basically just a bitfield size |
  VirtSpecifiers | Represents a C++11 virt-specifier-seq |
  LambdaIntroducer | Represents a complete lambda introducer |
   LambdaCapture | An individual capture in a lambda introducer |
  Designator | Designator - A designator in a C99 designated initializer |
  Designation | Designation - Represent a full designation, which is a sequence of designators |
  ExternalVTableUse | A simple structure that captures a vtable use for the purposes of the ExternalSemaSource |
  ExternalSemaSource | An abstract interface that should be implemented by external AST sources that also provide information for semantic analysis |
  IdentifierResolver | IdentifierResolver - Keeps track of shadowed decls on enclosing scopes |
   IdDeclInfoMap | IdDeclInfoMap - Associates IdDeclInfos with declaration names |
   iterator | Iterator - Iterate over the decls of a specified declaration name |
  InitializedEntity | Describes an entity that is being initialized |
  InitializationKind | Describes the kind of initialization being performed, along with location information for tokens related to the initialization (equal sign, parentheses) |
  InitializationSequence | Describes the sequence of initializations required to initialize a given object or reference with a set of arguments |
   Step | A single step in the initialization sequence |
    F | |
  LookupResult | Represents the results of name lookup |
   Filter | A class for iterating through a result set and possibly filtering out results |
  VisibleDeclConsumer | Consumes visible declarations found when searching for all visible names within a given scope or context |
  ADLResult | A class for storing results from argument-dependent lookup |
  LoopHint | Loop optimization hint for loop and unroll pragmas |
  MultiplexExternalSemaSource | An abstract interface that should be implemented by external AST sources that also provide information for semantic analysis |
  ObjCMethodList | Linked list of methods with the same selector name but different signatures |
  StandardConversionSequence | StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1) |
  UserDefinedConversionSequence | UserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13.3.3.1.2) |
  AmbiguousConversionSequence | Represents an ambiguous user-defined conversion sequence |
  BadConversionSequence | BadConversionSequence - Records information about an invalid conversion sequence |
  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) |
  OverloadCandidate | OverloadCandidate - A single candidate in an overload set (C++ 13.3) |
  OverloadCandidateSet | OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13.3) |
  ConstructorInfo | |
  OpaquePtr | Wrapper for void* pointer |
  UnionOpaquePtr | UnionOpaquePtr - A version of OpaquePtr suitable for membership in a union |
  IsResultPtrLowBitFree | |
  ActionResult | ActionResult - This structure is used while parsing/acting on expressions, stmts, etc |
  ActionResult< PtrTy, true > | |
  IsResultPtrLowBitFree< Expr * > | |
  IsResultPtrLowBitFree< Stmt * > | |
  IsResultPtrLowBitFree< CXXBaseSpecifier * > | |
  IsResultPtrLowBitFree< CXXCtorInitializer * > | |
  ParsedTemplateArgument | Represents the parsed form of a C++ template argument |
  TemplateIdAnnotation | Information about a template-id annotation token |
  PrettyDeclStackTraceEntry | PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a declaration, include that declaration in the stack trace |
  Scope | Scope - A scope is a transient data structure that is used while parsing the program |
  FileNullability | Describes whether we've seen any nullability information for the given file |
  FileNullabilityMap | A mapping from file IDs to a record of whether we've seen nullability information in that file |
  Sema | Sema - This implements semantic analysis and AST building for C |
   ActiveTemplateInstantiation | A template instantiation that is currently in progress |
   ActOnMemberAccessExtraArgs | |
   ArgumentPackSubstitutionIndexRAII | RAII object used to change the argument pack substitution index within a Sema object |
   BoundTypeDiagnoser | |
   CodeCompleteExpressionData | |
   CompoundScopeRAII | A RAII object to enter scope of a compound statement |
   ConditionResult | |
   ContextRAII | A RAII object to temporarily push a declaration context |
   ContextualImplicitConverter | Abstract base class used to perform a contextual implicit conversion from an expression to any type passing a filter |
   CXXThisScopeRAII | RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers on the current class type |
   DelayedDiagnostics | A class which encapsulates the logic for delaying diagnostics during parsing and other processing |
   DelayedDiagnosticsState | |
   ExpressionEvaluationContextRecord | Data structure used to record current or nested expression evaluation contexts |
   ExtParameterInfoBuilder | A helper class for building up ExtParameterInfos |
   FPContractStateRAII | Records and restores the FP_CONTRACT state on entry/exit of compound statements |
   FullExprArg | |
   FunctionScopeRAII | An RAII helper that pops function a function scope on exit |
   ICEConvertDiagnoser | |
   ImplicitExceptionSpecification | Helper class that collects exception specifications for implicitly-declared special member functions |
   InheritedConstructorInfo | |
   InstantiatingTemplate | A stack object to be created when performing template instantiation |
    ExceptionSpecification | |
   LateInstantiatedAttribute | |
   NameClassification | |
   ObjCArgInfo | |
   OffsetOfComponent | |
   OriginalCallArg | Brief A function argument from which we performed template argument |
   PragmaStack | |
    Slot | |
   PragmaStackSentinelRAII | |
   SavePendingInstantiationsAndVTableUsesRAII | |
   SavePendingLocalImplicitInstantiationsRAII | |
   SemaDiagnosticBuilder | Helper class that creates diagnostics with optional template instantiation stacks |
   SFINAETrap | RAII class used to determine whether SFINAE has trapped any errors that occur during template argument deduction |
   SkipBodyInfo | |
   SpecialMemberOverloadResult | SpecialMemberOverloadResult - The overloading result for a special member function |
   SynthesizedFunctionScope | RAII object to handle the state changes required to synthesize a function body |
   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 |
   TypeDiagnoser | Abstract class used to diagnose incomplete types |
   TypeTagData | |
   VerifyICEDiagnoser | Abstract base class used for diagnosing integer constant expression violations |
  EnterExpressionEvaluationContext | RAII object that enters a new expression evaluation context |
  LateParsedTemplate | Contains a late templated function |
  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 |
  ConversionFixItGenerator | The class facilities generation and storage of conversion FixIts |
  TypoCorrectionConsumer | |
  MultiLevelTemplateArgumentList | Data structure that captures multiple levels of template argument lists for use in template instantiation |
  TemplatePartialOrderingContext | |
  DeducedTemplateArgument | Captures a template argument whose value has been deduced via c++ template argument deduction |
  LocalInstantiationScope | A stack-allocated class that identifies which local variable declaration instantiations are present in this scope |
  TemplateDeclInstantiator | |
  DeductionFailureInfo | A structure used to record information about a failed template argument deduction, for diagnosis |
  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 |
  TemplateSpecCandidateSet | TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations |
  TypoCorrection | Simple class containing the result of Sema::CorrectTypo |
  CorrectionCandidateCallback | Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo correction |
  DeclFilterCCC | Simple template class for restricting typo correction candidates to ones having a single Decl* of the given type |
  FunctionCallFilterCCC | |
  NoTypoCorrectionCCC | |
  WeakInfo | Captures information about a #pragma weak directive |
  ASTDeserializationListener | |
  ASTReaderListener | Abstract interface for callback invocations by the ASTReader |
  ChainedASTReaderListener | Simple wrapper class for chaining listeners |
  PCHValidator | ASTReaderListener implementation to validate the information of the PCH file against an initialized Preprocessor |
  ASTReader | Reads an AST files chain containing the contents of a translation unit |
   ListenerScope | RAII object to temporarily add an AST callback listener |
  SavedStreamPosition | Helper class that saves the current stream position and then restores it when destroyed |
  ASTWriter | Writes an AST file containing the contents of a translation unit |
  ASTRecordWriter | An object for streaming information to a record |
  PCHGenerator | AST and semantic-analysis consumer that generates a precompiled header from the parsed source code |
  ContinuousRangeMap | A map from continuous integer ranges to some value, with a very specialized interface |
   Builder | An object that helps properly build a continuous range map from a set of values |
  GlobalModuleIndex | A global index for a set of module files, providing information about the identifiers within those module files |
  ModuleFileExtensionMetadata | Metadata for a module file extension |
  ModuleFileExtension | An abstract superclass that describes a custom extension to the module/precompiled header file format |
  ModuleFileExtensionWriter | Abstract base class that writes a module file extension block into a module file |
  ModuleFileExtensionReader | Abstract base class that reads a module file extension block from a module file |
  AnalyzerOptions | |
  BlockCall | |
  CXXInstanceCall | Represents a non-static C++ member function call, no matter how it is written |
  CXXMemberCall | Represents a non-static C++ member function call |
  CXXMemberOperatorCall | Represents a C++ overloaded operator call where the operator is implemented as a non-static member function |
  CXXDestructorCall | Represents an implicit call to a C++ destructor |
  CXXConstructorCall | Represents a call to a C++ constructor |
  CXXAllocatorCall | Represents the memory allocation call in a C++ new-expression |
  ObjCMethodCall | Represents any expression that calls an Objective-C method |
  CallEventManager | Manages the lifetime of CallEvent objects |
  BodyFarm | |
  UpdateOnReturn | |
  ASTNodeImporter | |
  CXXABI | Implements C++ ABI-specific semantic analysis functions |
  LinkageComputer | |
  CXXSpecialName | CXXSpecialName - Records the type associated with one of the "special" kinds of declaration names in C++, e.g., constructors, destructors, and conversion functions |
  CXXOperatorIdName | CXXOperatorIdName - Contains extra information for the name of an overloaded operator in C++, such as "operator+ |
  CXXLiteralOperatorIdName | CXXLiteralOperatorName - Contains the actual identifier that makes up the name |
  TypePropertyCache | The type-property cache |
  MultiKeywordSelector | MultiKeywordSelector - One of these variable length records is kept for each selector containing more than one keyword |
  BackendConsumer | |
  CoverageSourceInfo | Stores additional source code information like skipped ranges which is required by the coverage mapping generator and is obtained from the preprocessor |
  MultiplexASTDeserializationListener | |
  MultiplexASTMutationListener | |
  TestModuleFileExtension | A module file extension used for testing purposes |
  MMToken | A token in a module map file |
  ModuleMapParser | |
  PTHStatCache | |
  SuppressAccessChecks | A RAII object used to temporarily suppress access-like checking |
  ParsingDeclRAIIObject | RAII object used to inform the actions that we're currently parsing a declaration |
  ParsingDeclSpec | A class for parsing a DeclSpec |
  ParsingDeclarator | A class for parsing a declarator |
  ParsingFieldDeclarator | A class for parsing a field declarator |
  ExtensionRAIIObject | ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them |
  ColonProtectionRAIIObject | ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed |
  GreaterThanIsOperatorScope | RAII object that makes '>' behave either as an operator or as the closing angle bracket for a template argument list |
  InMessageExpressionRAIIObject | |
  ParenBraceBracketBalancer | RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing, even when there's a parsing error |
  PoisonSEHIdentifiersRAIIObject | |
  BalancedDelimiterTracker | RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { .. |
  DeducedPack | A pack that we're currently deducing |
  TreeTransform | A semantic tree transformation that allows one to transform one abstract syntax tree into another |
   TemporaryBase | RAII object that temporarily sets the base location and entity used for reporting diagnostics in types |
  TemplateArgumentLocInventIterator | Iterator adaptor that invents template argument location information for each of the template arguments in its underlying iterator |
   pointer | |
  TemplateArgumentLocContainerIterator | Simple iterator that traverses the template arguments in a container that provides a getArgLoc() member function |
   pointer | |
  TypeLocBuilder | |
  TypeLocReader | |
  ASTIdentifierIterator | An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files |
  ASTDeclReader | |
  ASTStmtReader | |
  OMPClauseReader | |
  ASTTypeWriter | |
  ASTDeclWriter | |
  ASTStmtWriter | |
  OMPClauseWriter | |
 llvm | DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterators |
  cl | |
   parser< clang::ParsedSourceLocation > | Command-line option parser that parses source locations |
  opt | |
  yaml | |
   MappingTraits< clang::tooling::Replacement > | Specialized MappingTraits to describe how a Replacement is (de)serialized |
    NormalizedReplacement | Helper to (de)serialize a Replacement since we don't have direct access to its data members |
   MappingTraits< clang::tooling::TranslationUnitReplacements > | Specialized MappingTraits to describe how a TranslationUnitReplacements is (de)serialized |
   ScalarEnumerationTraits< FormatStyle::LanguageKind > | |
   ScalarEnumerationTraits< FormatStyle::LanguageStandard > | |
   ScalarEnumerationTraits< FormatStyle::UseTabStyle > | |
   ScalarEnumerationTraits< FormatStyle::JavaScriptQuoteStyle > | |
   ScalarEnumerationTraits< FormatStyle::ShortFunctionStyle > | |
   ScalarEnumerationTraits< FormatStyle::BinaryOperatorStyle > | |
   ScalarEnumerationTraits< FormatStyle::BraceBreakingStyle > | |
   ScalarEnumerationTraits< FormatStyle::ReturnTypeBreakingStyle > | |
   ScalarEnumerationTraits< FormatStyle::DefinitionReturnTypeBreakingStyle > | |
   ScalarEnumerationTraits< FormatStyle::NamespaceIndentationKind > | |
   ScalarEnumerationTraits< FormatStyle::BracketAlignmentStyle > | |
   ScalarEnumerationTraits< FormatStyle::PointerAlignmentStyle > | |
   ScalarEnumerationTraits< FormatStyle::SpaceBeforeParensOptions > | |
   MappingTraits< FormatStyle > | |
   MappingTraits< FormatStyle::BraceWrappingFlags > | |
   MappingTraits< FormatStyle::IncludeCategory > | |
   DocumentListTraits< std::vector< FormatStyle > > | |
  GraphTraits< ::clang::DomTreeNode * > | |
  GraphTraits< ::clang::DominatorTree * > | |
  GraphTraits< clang::CallGraphNode * > | |
  GraphTraits< const clang::CallGraphNode * > | |
  GraphTraits< clang::CallGraph * > | |
  GraphTraits< const clang::CallGraph * > | |
  simplify_type< ::clang::CFGTerminator > | Implement simplify_type for CFGTerminator, so that we can dyn_cast from CFGTerminator to a specific Stmt class |
  GraphTraits< ::clang::CFGBlock * > | |
  GraphTraits< const ::clang::CFGBlock * > | |
  GraphTraits< Inverse< ::clang::CFGBlock * > > | |
  GraphTraits< Inverse< const ::clang::CFGBlock * > > | |
  GraphTraits< ::clang::CFG * > | |
  GraphTraits< const ::clang::CFG * > | |
  GraphTraits< Inverse< ::clang::CFG * > > | |
  GraphTraits< Inverse< const ::clang::CFG * > > | |
  DenseMapInfo< clang::ProgramPoint > | |
  isPodLike< clang::ProgramPoint > | |
  DenseMapInfo< clang::ast_type_traits::ASTNodeKind > | |
  DenseMapInfo< clang::ast_type_traits::DynTypedNode > | |
  DenseMapInfo< clang::BaseSubobject > | |
  isPodLike< clang::BaseSubobject > | |
  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 |
  PointerLikeTypeTraits< clang::CanQual< T > > | |
  DenseMapInfo< clang::CharUnits > | |
  isPodLike< clang::CharUnits > | |
  isPodLike | |
  isPodLike< clang::DeclAccessPair > | |
  DenseMapInfo | |
  DenseMapInfo< clang::DeclarationName > | Define DenseMapInfo so that DeclarationNames can be used as keys in DenseMap and DenseSets |
  isPodLike< clang::DeclarationName > | |
  isa_impl< To,::clang::DeclContext > | Isa<T>(DeclContext*) |
  cast_convert_val< ToTy, const ::clang::DeclContext, const ::clang::DeclContext > | Cast<T>(DeclContext*) |
  cast_convert_val< ToTy,::clang::DeclContext,::clang::DeclContext > | |
  cast_convert_val< ToTy, const ::clang::DeclContext *, const ::clang::DeclContext * > | |
  cast_convert_val< ToTy,::clang::DeclContext *,::clang::DeclContext * > | |
  cast_convert_val< ::clang::DeclContext, FromTy, FromTy > | Implement cast_convert_val for Decl -> DeclContext conversions |
  cast_convert_val< ::clang::DeclContext, FromTy *, FromTy * > | |
  cast_convert_val< const ::clang::DeclContext, FromTy, FromTy > | |
  cast_convert_val< const ::clang::DeclContext, FromTy *, FromTy * > | |
  PointerLikeTypeTraits< ::clang::AnyFunctionDecl > | |
  PointerLikeTypeTraits | |
  PointerLikeTypeTraits< clang::DeclGroupRef > | |
  isPodLike< clang::ObjCDictionaryElement > | |
  PointerLikeTypeTraits< clang::LazyGenerationalUpdatePtr< Owner, T, Update > > | |
  DenseMapInfo< clang::GlobalDecl > | |
  isPodLike< clang::GlobalDecl > | |
  GraphTraits< clang::Stmt * > | |
  GraphTraits< const clang::Stmt * > | |
  PointerLikeTypeTraits< clang::TemplateName > | The clang::TemplateName class is effectively a pointer |
  PointerLikeTypeTraits< ::clang::Type * > | |
  PointerLikeTypeTraits< ::clang::ExtQuals * > | |
  isPodLike< clang::QualType > | |
  simplify_type< ::clang::QualType > | Implement simplify_type for QualType, so that we can dyn_cast from QualType to a specific Type class |
  PointerLikeTypeTraits< clang::QualType > | |
  DenseMapInfo< clang::QualType > | |
  DenseMapInfo< clang::CanQualType > | |
  DenseMapInfo< clang::Selector > | Define DenseMapInfo so that Selectors can be used as keys in DenseMap and DenseSets |
  isPodLike< clang::Selector > | |
  PointerLikeTypeTraits< clang::Selector > | |
  PointerLikeTypeTraits< clang::IdentifierInfo * > | |
  PointerLikeTypeTraits< const clang::IdentifierInfo * > | |
  ArrayRef | |
  MutableArrayRef | |
  SmallString | |
  SmallVector | |
  SmallVectorImpl | |
  Optional | |
  SaveAndRestore | |
  IntrusiveRefCntPtr | |
  IntrusiveRefCntPtrInfo | |
  RefCountedBase | |
  DenseMapInfo< clang::FileID > | Define DenseMapInfo so that FileID's can be used as keys in DenseMap and DenseSets |
  isPodLike< clang::SourceLocation > | |
  isPodLike< clang::FileID > | |
  PointerLikeTypeTraits< clang::SourceLocation > | |
  isPodLike< clang::Token > | |
  isPodLike< clang::CodeCompletionString::Chunk > | |
  SmallSetVector | |
  PointerLikeTypeTraits< clang::OpaquePtr< T > > | |
  isPodLike< clang::OpaquePtr< T > > | |
  DenseSet | |
  DenseMapInfo< clang::serialization::DeclarationNameKey > | |
  OnDiskChainedHashTable | |
  OnDiskIterableChainedHashTable | |
  ilist_traits< clang::ento::BugReport > | |
  simplify_type< clang::ento::CallEventRef< T > > | |
  GraphTraits< clang::ento::ExplodedNode * > | |
  GraphTraits< const clang::ento::ExplodedNode * > | |
  IntrusiveRefCntPtrInfo< const clang::ento::ProgramState > | |
  ImmutableMap | |
  ImmutableSet | |
  ImmutableList | |
  ImmutableListImpl | |
  isPodLike< clang::ento::SVal > | |
  DOTGraphTraits< const CallGraph * > | |
  DOTGraphTraits< const CFG * > | |
  DenseMapInfo< EditEntry > | |
  DOTGraphTraits< const Stmt * > | |
  DenseMapInfo< clang::CodeGen::TBAAPathTag > | |
  DenseMapInfo< CatchHandlerType > | |
  GraphTraits< ModuleManager > | |
  DOTGraphTraits< ModuleManager > | |
  FoldingSetTrait< AllocKind > | |
  FoldingSetTrait< ArgEffect > | |
  FoldingSetTrait< RetEffect > | |
  DenseMapInfo< ObjCSummaryKey > | |
  FoldingSetTrait< SValData > | |
  FoldingSetTrait< SValPair > | |
  DOTGraphTraits< ExplodedNode * > | |
  isPodLike< BindingKey > | |
 OBJC2 | Objc-class-instance-variables: '{' objc-instance-variable-decl-list[opt] '}' |
 std | |
  is_error_code_enum< clang::format::ParseError > | |
  is_error_code_enum< clang::serialized_diags::SDError > | |
 __cuda_builtin_blockDim_t | |
 __cuda_builtin_blockIdx_t | |
 __cuda_builtin_gridDim_t | |
 __cuda_builtin_threadIdx_t | |
 _Unwind_Exception | |
 AnyFunctionCall | |
 atomic_flag | |
 basic_parser | |
 CallEvent | |
 CGBuilderBaseTy | |
 CHECK1 | |
 CleanupTy | A basic class for pre|post-action for advanced codegen sequence for OpenMP region |
 CommonBase | |
 CXCodeCompleteResults | Contains the results of code-completion |
 CXComment | A parsed comment |
 CXCompletionResult | A single result of code completion |
 CXCursor | A cursor representing some element in the abstract syntax tree for a translation unit |
 CXCursorAndRangeVisitor | |
 CXFileUniqueID | Uniquely identifies a CXFile, that refers to the same underlying file, across an indexing session |
 CXIdxAttrInfo | |
 CXIdxBaseClassInfo | |
 CXIdxContainerInfo | |
 CXIdxCXXClassDeclInfo | |
 CXIdxDeclInfo | |
 CXIdxEntityInfo | |
 CXIdxEntityRefInfo | Data for IndexerCallbacks::indexEntityReference |
 CXIdxIBOutletCollectionAttrInfo | |
 CXIdxImportedASTFileInfo | Data for IndexerCallbacks::importedASTFile |
 CXIdxIncludedFileInfo | Data for ppIncludedFile callback |
 CXIdxLoc | Source location passed to index callbacks |
 CXIdxObjCCategoryDeclInfo | |
 CXIdxObjCContainerDeclInfo | |
 CXIdxObjCInterfaceDeclInfo | |
 CXIdxObjCPropertyDeclInfo | |
 CXIdxObjCProtocolRefInfo | |
 CXIdxObjCProtocolRefListInfo | |
 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 |
 CXSourceLocation | Identifies a specific source location within a translation unit |
 CXSourceRange | Identifies a half-open character range in the source code |
 CXSourceRangeList | Identifies an array of ranges |
 CXString | A character string |
 CXStringSet | |
 CXToken | Describes a single preprocessing token |
 CXTUResourceUsage | The memory usage of a CXTranslationUnit, broken into categories |
 CXTUResourceUsageEntry | |
 CXType | The type of an element in the abstract syntax tree |
 CXUnsavedFile | Provides the contents of a file that has not yet been saved to disk |
 CXVersion | Describes a version number of the form major.minor.subminor |
 Decl | |
 DefaultDOTGraphTraits | |
 DefinedTracker | DefinedTracker - This struct is used while parsing expressions to keep track of whether !defined(X) has been seen |
 ExplicitSpecializationVisibilityChecker | Walk the path from which a declaration was instantiated, and check that every explicit specialization along that path is visible |
 ilist_default_traits | |
 IndexerCallbacks | A group of callbacks used by clang_indexSourceFile and clang_indexTranslationUnit |
 IteratorBase | |
 max_align_t | |
 MemRegionManagerTrait | |
 OMPAlignedClause | This represents clause 'aligned' in the '#pragma omp ...' directives |
 OMPClause | |
 OMPClauseMappableExprCommon | Struct that defines common infrastructure to handle mappable expressions used in OpenMP clauses |
  MappableComponent | |
 OMPClauseWithPreInit | |
 OMPCopyinClause | This represents clause 'copyin' in the '#pragma omp ...' directives |
 OMPCopyprivateClause | This represents clause 'copyprivate' in the '#pragma omp ...' directives |
 OMPDefaultmapClause | This represents 'defaultmap' clause in the '#pragma omp ...' directive |
 OMPDependClause | This represents implicit clause 'depend' for the '#pragma omp task' directive |
 OMPDeviceClause | This represents 'device' clause in the '#pragma omp ...' directive |
 OMPDistScheduleClause | This represents 'dist_schedule' clause in the '#pragma omp ...' directive |
 OMPFlushClause | This represents implicit clause 'flush' for the '#pragma omp flush' directive |
 OMPFromClause | This represents clause 'from' in the '#pragma omp ...' directives |
 OMPGrainsizeClause | This represents 'grainsize' clause in the '#pragma omp ...' directive |
 OMPHintClause | This represents 'hint' clause in the '#pragma omp ...' directive |
 OMPIsDevicePtrClause | This represents clause 'is_device_ptr' in the '#pragma omp ...' directives |
 OMPMapClause | This represents clause 'map' in the '#pragma omp ...' directives |
 OMPMappableExprListClause | This represents clauses with a list of expressions that are mappable |
  const_component_lists_iterator | Iterator that browse the components by lists |
 OMPNogroupClause | This represents 'nogroup' clause in the '#pragma omp ...' directive |
 OMPNumTasksClause | This represents 'num_tasks' clause in the '#pragma omp ...' directive |
 OMPNumTeamsClause | This represents 'num_teams' clause in the '#pragma omp ...' directive |
 OMPPriorityClause | This represents 'priority' clause in the '#pragma omp ...' directive |
 OMPSIMDClause | This represents 'simd' clause in the '#pragma omp ...' directive |
 OMPThreadLimitClause | This represents 'thread_limit' clause in the '#pragma omp ...' directive |
 OMPThreadsClause | This represents 'threads' clause in the '#pragma omp ...' directive |
 OMPToClause | This represents clause 'to' in the '#pragma omp ...' directives |
 OMPUseDevicePtrClause | This represents clause 'use_device_ptr' in the '#pragma omp ...' directives |
 ParsedAttrInfo | |
 ReadySuspendResumeResult | |
 Stmt | |
 StmtClassNameTable | |
 TypeInfo | |
 udir_iterator_base | |