clang

package module
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 13, 2026 License: MIT Imports: 8 Imported by: 0

README

clang

PkgGoDev golangci-lint

Generated Go bindings for libclang's C API.

The bindings are pure Go, using no cgo. This is achieved using goffi.

API

Most, but not all, of the C API is supported. It's enough to at least be able to parse header files, walk the AST, and extract some details. This is evidenced by this repository's use of its own bindings in its code generation code.

The documentation for the Go bindings on pkg.go.dev comes from the Doxygen comments in libclang's header files, so it reflects the C API. Refer to the C API documentation for the definitive word on the C API.

Most output parameters do not appear as function parameters in the Go API, but instead as return values.

The CX prefix is removed from C type names, and the clang_ prefix is removed from function names.

Many C functions are provided as Go methods on struct types.

Requirements

The libclang library must be available to dynamically load. The default library paths are OS-specific.

OS filename
linux libclang.so
macos libclang.dylib

The default library paths may be overridden with an argument to the Init function.

Platforms

The only architecture supported is amd64. This is because the callback parameter for Cursor.VisitChildren has struct parameters, and goffi currently only supports callback struct arguments on amd64.

The CI worklow runs tests on linux/amd64 and macos/amd64

Example

package main

import (
	"fmt"

	"github.com/pekim/clang"
)

func main() {
	// Initialise the library.
	if err := clang.Init(nil); err != nil {
		panic(err)
	}

	// Parse a header file, creating a TranslationUnit.
	index := clang.CreateIndex(0, 1)
	parseArgs := []string{"-x", "c-header"}
	tu, errorCode := index.ParseTranslationUnit2("internal/clang-c/CXString.h", parseArgs, nil,
		uint32(clang.TranslationUnit_SkipFunctionBodies|clang.TranslationUnit_DetailedPreprocessingRecord),
	)
	if errorCode != clang.Error_Success {
		panic(fmt.Sprintf("failed to create translation unit : %d", errorCode))
	}

	// Traverse the various declarations within the translation unit.
	tuCursor := tu.TranslationUnitCursor()
	tuCursor.VisitChildren(func(cursor clang.Cursor, _parent clang.Cursor) clang.ChildVisitResult {
		fmt.Println(cursor.CursorKind().CursorKindSpelling(), cursor.CursorSpelling())
		return clang.ChildVisit_Continue
	})
}

License

clang is licensed under the terms of the MIT license.

AI use

No AI was used in the creation of this library.

Development

To regenerate the bindings run go generate. This generates code and then runs tests.

pre-commit hook

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ConstructUSR_ObjCCategory 

func ConstructUSR_ObjCCategory(class_name string, category_name string) string

Construct a USR for a specified Objective-C category.

Wraps the C function clang_constructUSR_ObjCCategory.

func ConstructUSR_ObjCClass 

func ConstructUSR_ObjCClass(class_name string) string

Construct a USR for a specified Objective-C class.

Wraps the C function clang_constructUSR_ObjCClass.

func ConstructUSR_ObjCIvar 

func ConstructUSR_ObjCIvar(name string, classUSR string_) string

Construct a USR for a specified Objective-C instance variable and the USR for its containing class.

Wraps the C function clang_constructUSR_ObjCIvar.

func ConstructUSR_ObjCMethod 

func ConstructUSR_ObjCMethod(name string, isInstanceMethod uint32, classUSR string_) string

Construct a USR for a specified Objective-C method and the USR for its containing class.

Wraps the C function clang_constructUSR_ObjCMethod.

func ConstructUSR_ObjCProperty 

func ConstructUSR_ObjCProperty(property string, classUSR string_) string

Construct a USR for a specified Objective-C property and the USR for its containing class.

Wraps the C function clang_constructUSR_ObjCProperty.

func ConstructUSR_ObjCProtocol 

func ConstructUSR_ObjCProtocol(protocol_name string) string

Construct a USR for a specified Objective-C protocol.

Wraps the C function clang_constructUSR_ObjCProtocol.

func DefaultCodeCompleteOptions 

func DefaultCodeCompleteOptions() uint32

Returns a default set of code-completion options that can be passed toclang_codeCompleteAt().

Wraps the C function clang_defaultCodeCompleteOptions.

func DefaultDiagnosticDisplayOptions 

func DefaultDiagnosticDisplayOptions() uint32

Retrieve the set of display options most similar to the default behavior of the clang compiler.

Wraps the C function clang_defaultDiagnosticDisplayOptions.

func DefaultEditingTranslationUnitOptions 

func DefaultEditingTranslationUnitOptions() uint32

Returns the set of flags that is suitable for parsing a translation unit that is being edited.

The set of flags returned provide options for clang_parseTranslationUnit() to indicate that the translation unit is likely to be reparsed many times, either explicitly (via clang_reparseTranslationUnit()) or implicitly (e.g., by code completion (clang_codeCompletionAt())). The returned flag set contains an unspecified set of optimizations (e.g., the precompiled preamble) geared toward improving the performance of these routines. The set of optimizations enabled may change from one version to the next.

Wraps the C function clang_defaultEditingTranslationUnitOptions.

func EnableStackTraces 

func EnableStackTraces()

Wraps the C function clang_enableStackTraces.

func Free 

func Free(buffer unsafe.Pointer)

free memory allocated by libclang, such as the buffer returned by CXVirtualFileOverlay() or clang_ModuleMapDescriptor_writeToBuffer().

Wraps the C function clang_free.

func GetBuildSessionTimestamp 

func GetBuildSessionTimestamp() uint64

Return the timestamp for use with Clang's -fbuild-session-timestamp= option.

Wraps the C function clang_getBuildSessionTimestamp.

func GetClangVersion 

func GetClangVersion() string

Return a version string, suitable for showing to a user, but not intended to be parsed (the format is not guaranteed to be stable).

Wraps the C function clang_getClangVersion.

func GetDiagnosticCategoryName 

func GetDiagnosticCategoryName(category uint32) string

Retrieve the name of a particular diagnostic category. This is now deprecated. Use clang_getDiagnosticCategoryText() instead.

Wraps the C function clang_getDiagnosticCategoryName.

func GetSymbolGraphForUSR 

func GetSymbolGraphForUSR(usr string, api APISet) string

Generate a single symbol symbol graph for the given USR. Returns a null string if the associated symbol can not be found in the provided CXAPISet.

The output contains the symbol graph as well as some additional information about related symbols.

Wraps the C function clang_getSymbolGraphForUSR.

func Init 

func Init(userPaths *LibraryPaths) error

Init initialises the library, and must be called before any other clang function is called.

func LoadDiagnostics 

func LoadDiagnostics(file string) (LoadDiag_Error, string, DiagnosticSet)

Deserialize a set of diagnostics from a Clang diagnostics bitcode file.

Wraps the C function clang_loadDiagnostics.

func ToggleCrashRecovery 

func ToggleCrashRecovery(isEnabled uint32)

Enable/disable crash recovery.

Wraps the C function clang_toggleCrashRecovery.

Types

type APISet 

type APISet struct {
	// contains filtered or unexported fields
}

CXAPISet is an opaque type that represents a data structure containing all the API information for a given translation unit. This can be used for a single symbol symbol graph for a given symbol.

Represents the C type CXAPISet.

func (APISet) DisposeAPISet 

func (api APISet) DisposeAPISet()

Dispose of an APISet.

The provided CXAPISet can not be used after this function is called.

Wraps the C function clang_disposeAPISet.

type APISetImpl 

type APISetImpl struct {
	// contains filtered or unexported fields
}

Represents the C struct CXAPISetImpl.

type AvailabilityKind 

type AvailabilityKind uint32

Describes the availability of a particular entity, which indicates whether the use of this entity will result in a warning or error due to it being deprecated or unavailable.

Represents the C enum CXAvailabilityKind. 

const (
	// The entity is available.
	Availability_Available AvailabilityKind = 0
	// The entity is available, but has been deprecated (and its use is not recommended).
	Availability_Deprecated AvailabilityKind = 1
	// The entity is not available; any use of it will be an error.
	Availability_NotAvailable AvailabilityKind = 2
	// The entity is available, but not accessible; any use of it will be an error.
	Availability_NotAccessible AvailabilityKind = 3
)

type BinaryOperatorKind 

type BinaryOperatorKind uint32

Describes the kind of binary operators.

Represents the C enum CXBinaryOperatorKind. 

const (
	// This value describes cursors which are not binary operators.
	BinaryOperator_Invalid BinaryOperatorKind = 0
	// C++ Pointer - to - member operator.
	BinaryOperator_PtrMemD BinaryOperatorKind = 1
	// C++ Pointer - to - member operator.
	BinaryOperator_PtrMemI BinaryOperatorKind = 2
	// Multiplication operator.
	BinaryOperator_Mul BinaryOperatorKind = 3
	// Division operator.
	BinaryOperator_Div BinaryOperatorKind = 4
	// Remainder operator.
	BinaryOperator_Rem BinaryOperatorKind = 5
	// Addition operator.
	BinaryOperator_Add BinaryOperatorKind = 6
	// Subtraction operator.
	BinaryOperator_Sub BinaryOperatorKind = 7
	// Bitwise shift left operator.
	BinaryOperator_Shl BinaryOperatorKind = 8
	// Bitwise shift right operator.
	BinaryOperator_Shr BinaryOperatorKind = 9
	// C++ three-way comparison (spaceship) operator.
	BinaryOperator_Cmp BinaryOperatorKind = 10
	// Less than operator.
	BinaryOperator_LT BinaryOperatorKind = 11
	// Greater than operator.
	BinaryOperator_GT BinaryOperatorKind = 12
	// Less or equal operator.
	BinaryOperator_LE BinaryOperatorKind = 13
	// Greater or equal operator.
	BinaryOperator_GE BinaryOperatorKind = 14
	// Equal operator.
	BinaryOperator_EQ BinaryOperatorKind = 15
	// Not equal operator.
	BinaryOperator_NE BinaryOperatorKind = 16
	// Bitwise AND operator.
	BinaryOperator_And BinaryOperatorKind = 17
	// Bitwise XOR operator.
	BinaryOperator_Xor BinaryOperatorKind = 18
	// Bitwise OR operator.
	BinaryOperator_Or BinaryOperatorKind = 19
	// Logical AND operator.
	BinaryOperator_LAnd BinaryOperatorKind = 20
	// Logical OR operator.
	BinaryOperator_LOr BinaryOperatorKind = 21
	// Assignment operator.
	BinaryOperator_Assign BinaryOperatorKind = 22
	// Multiplication assignment operator.
	BinaryOperator_MulAssign BinaryOperatorKind = 23
	// Division assignment operator.
	BinaryOperator_DivAssign BinaryOperatorKind = 24
	// Remainder assignment operator.
	BinaryOperator_RemAssign BinaryOperatorKind = 25
	// Addition assignment operator.
	BinaryOperator_AddAssign BinaryOperatorKind = 26
	// Subtraction assignment operator.
	BinaryOperator_SubAssign BinaryOperatorKind = 27
	// Bitwise shift left assignment operator.
	BinaryOperator_ShlAssign BinaryOperatorKind = 28
	// Bitwise shift right assignment operator.
	BinaryOperator_ShrAssign BinaryOperatorKind = 29
	// Bitwise AND assignment operator.
	BinaryOperator_AndAssign BinaryOperatorKind = 30
	// Bitwise XOR assignment operator.
	BinaryOperator_XorAssign BinaryOperatorKind = 31
	// Bitwise OR assignment operator.
	BinaryOperator_OrAssign BinaryOperatorKind = 32
	// Comma operator.
	BinaryOperator_Comma BinaryOperatorKind = 33
	// Comma operator.
	BinaryOperator_Last BinaryOperatorKind = 33
)

func (BinaryOperatorKind) BinaryOperatorKindSpelling 

func (kind BinaryOperatorKind) BinaryOperatorKindSpelling() string

Retrieve the spelling of a given CXBinaryOperatorKind.

Wraps the C function clang_getBinaryOperatorKindSpelling.

type BinaryOperatorKind_ 

type BinaryOperatorKind_ uint32

Represents a specific kind of binary operator which can appear at a cursor.

Represents the C enum CX_BinaryOperatorKind. 

const (
	BO_Invalid   BinaryOperatorKind_ = 0
	BO_PtrMemD   BinaryOperatorKind_ = 1
	BO_PtrMemI   BinaryOperatorKind_ = 2
	BO_Mul       BinaryOperatorKind_ = 3
	BO_Div       BinaryOperatorKind_ = 4
	BO_Rem       BinaryOperatorKind_ = 5
	BO_Add       BinaryOperatorKind_ = 6
	BO_Sub       BinaryOperatorKind_ = 7
	BO_Shl       BinaryOperatorKind_ = 8
	BO_Shr       BinaryOperatorKind_ = 9
	BO_Cmp       BinaryOperatorKind_ = 10
	BO_LT        BinaryOperatorKind_ = 11
	BO_GT        BinaryOperatorKind_ = 12
	BO_LE        BinaryOperatorKind_ = 13
	BO_GE        BinaryOperatorKind_ = 14
	BO_EQ        BinaryOperatorKind_ = 15
	BO_NE        BinaryOperatorKind_ = 16
	BO_And       BinaryOperatorKind_ = 17
	BO_Xor       BinaryOperatorKind_ = 18
	BO_Or        BinaryOperatorKind_ = 19
	BO_LAnd      BinaryOperatorKind_ = 20
	BO_LOr       BinaryOperatorKind_ = 21
	BO_Assign    BinaryOperatorKind_ = 22
	BO_MulAssign BinaryOperatorKind_ = 23
	BO_DivAssign BinaryOperatorKind_ = 24
	BO_RemAssign BinaryOperatorKind_ = 25
	BO_AddAssign BinaryOperatorKind_ = 26
	BO_SubAssign BinaryOperatorKind_ = 27
	BO_ShlAssign BinaryOperatorKind_ = 28
	BO_ShrAssign BinaryOperatorKind_ = 29
	BO_AndAssign BinaryOperatorKind_ = 30
	BO_XorAssign BinaryOperatorKind_ = 31
	BO_OrAssign  BinaryOperatorKind_ = 32
	BO_Comma     BinaryOperatorKind_ = 33
	BO_LAST      BinaryOperatorKind_ = 33
)

func (BinaryOperatorKind_) CursorBinaryOpcodeStr 

func (op BinaryOperatorKind_) CursorBinaryOpcodeStr() string

Wraps the C function clang_Cursor_getBinaryOpcodeStr.

type CXXAccessSpecifier 

type CXXAccessSpecifier uint32

Represents the C++ access control level to a base class for a cursor with kind CX_CXXBaseSpecifier.

Represents the C enum CX_CXXAccessSpecifier. 

const (
	CXXInvalidAccessSpecifier CXXAccessSpecifier = 0
	CXXPublic                 CXXAccessSpecifier = 1
	CXXProtected              CXXAccessSpecifier = 2
	CXXPrivate                CXXAccessSpecifier = 3
)

type CallingConv 

type CallingConv uint32

Describes the calling convention of a function type

Represents the C enum CXCallingConv. 

const (
	CallingConv_Default            CallingConv = 0
	CallingConv_C                  CallingConv = 1
	CallingConv_X86StdCall         CallingConv = 2
	CallingConv_X86FastCall        CallingConv = 3
	CallingConv_X86ThisCall        CallingConv = 4
	CallingConv_X86Pascal          CallingConv = 5
	CallingConv_AAPCS              CallingConv = 6
	CallingConv_AAPCS_VFP          CallingConv = 7
	CallingConv_X86RegCall         CallingConv = 8
	CallingConv_IntelOclBicc       CallingConv = 9
	CallingConv_Win64              CallingConv = 10
	CallingConv_X86_64Win64        CallingConv = 10
	CallingConv_X86_64SysV         CallingConv = 11
	CallingConv_X86VectorCall      CallingConv = 12
	CallingConv_Swift              CallingConv = 13
	CallingConv_PreserveMost       CallingConv = 14
	CallingConv_PreserveAll        CallingConv = 15
	CallingConv_AArch64VectorCall  CallingConv = 16
	CallingConv_SwiftAsync         CallingConv = 17
	CallingConv_AArch64SVEPCS      CallingConv = 18
	CallingConv_M68kRTD            CallingConv = 19
	CallingConv_PreserveNone       CallingConv = 20
	CallingConv_RISCVVectorCall    CallingConv = 21
	CallingConv_RISCVVLSCall_32    CallingConv = 22
	CallingConv_RISCVVLSCall_64    CallingConv = 23
	CallingConv_RISCVVLSCall_128   CallingConv = 24
	CallingConv_RISCVVLSCall_256   CallingConv = 25
	CallingConv_RISCVVLSCall_512   CallingConv = 26
	CallingConv_RISCVVLSCall_1024  CallingConv = 27
	CallingConv_RISCVVLSCall_2048  CallingConv = 28
	CallingConv_RISCVVLSCall_4096  CallingConv = 29
	CallingConv_RISCVVLSCall_8192  CallingConv = 30
	CallingConv_RISCVVLSCall_16384 CallingConv = 31
	CallingConv_RISCVVLSCall_32768 CallingConv = 32
	CallingConv_RISCVVLSCall_65536 CallingConv = 33
	CallingConv_Invalid            CallingConv = 100
	CallingConv_Unexposed          CallingConv = 200
)

type ChildVisitResult 

type ChildVisitResult uint32

Describes how the traversal of the children of a particular cursor should proceed after visiting a particular child cursor.

A value of this enumeration type should be returned by each CXCursorVisitor to indicate how clang_visitChildren() proceed.

Represents the C enum CXChildVisitResult. 

const (
	// Terminates the cursor traversal.
	ChildVisit_Break ChildVisitResult = 0
	// Continues the cursor traversal with the next sibling of the cursor just visited, without visiting its children.
	ChildVisit_Continue ChildVisitResult = 1
	// Recursively traverse the children of this cursor, using the same visitor and client data.
	ChildVisit_Recurse ChildVisitResult = 2
)

type Choice 

type Choice uint32

Represents the C enum CXChoice. 

const (
	// Use the default value of an option that may depend on the process environment.
	Choice_Default Choice = 0
	// Enable the option.
	Choice_Enabled Choice = 1
	// Disable the option.
	Choice_Disabled Choice = 2
)

type ClientData 

type ClientData struct {
	// contains filtered or unexported fields
}

Opaque pointer representing client data that will be passed through to various callbacks and visitors.

Represents the C type CXClientData.

type CodeCompleteResults 

type CodeCompleteResults struct {

	// The code-completion results.
	Results *CompletionResult
	// The number of code-completion results stored in the Results array.
	NumResults uint32
	// contains filtered or unexported fields
}

Contains the results of code-completion.

This data structure contains the results of code completion, as produced by clang_codeCompleteAt(). Its contents must be freed by clang_disposeCodeCompleteResults.

Represents the C struct CXCodeCompleteResults.

func (*CodeCompleteResults) CodeCompleteGetContainerKind 

func (results *CodeCompleteResults) CodeCompleteGetContainerKind() (uint32, CursorKind)

Returns the cursor kind for the container for the current code completion context. The container is only guaranteed to be set for contexts where a container exists (i.e. member accesses or Objective-C message sends); if there is not a container, this function will return CXCursor_InvalidCode.

Wraps the C function clang_codeCompleteGetContainerKind.

func (*CodeCompleteResults) CodeCompleteGetContainerUSR 

func (results *CodeCompleteResults) CodeCompleteGetContainerUSR() string

Returns the USR for the container for the current code completion context. If there is not a container for the current context, this function will return the empty string.

Wraps the C function clang_codeCompleteGetContainerUSR.

func (*CodeCompleteResults) CodeCompleteGetContexts 

func (results *CodeCompleteResults) CodeCompleteGetContexts() uint64

Determines what completions are appropriate for the context the given code completion.

Wraps the C function clang_codeCompleteGetContexts.

func (*CodeCompleteResults) CodeCompleteGetDiagnostic 

func (results *CodeCompleteResults) CodeCompleteGetDiagnostic(index uint32) Diagnostic

Retrieve a diagnostic associated with the given code completion.

Wraps the C function clang_codeCompleteGetDiagnostic.

func (*CodeCompleteResults) CodeCompleteGetNumDiagnostics 

func (results *CodeCompleteResults) CodeCompleteGetNumDiagnostics() uint32

Determine the number of diagnostics produced prior to the location where code completion was performed.

Wraps the C function clang_codeCompleteGetNumDiagnostics.

func (*CodeCompleteResults) CodeCompleteGetObjCSelector 

func (results *CodeCompleteResults) CodeCompleteGetObjCSelector() string

Returns the currently-entered selector for an Objective-C message send, formatted like "initWithFoo:bar:". Only guaranteed to return a non-empty string for CXCompletionContext_ObjCInstanceMessage and CXCompletionContext_ObjCClassMessage.

Wraps the C function clang_codeCompleteGetObjCSelector.

func (*CodeCompleteResults) CompletionFixIt 

func (results *CodeCompleteResults) CompletionFixIt(completion_index uint32, fixit_index uint32) (SourceRange, string)

Fix-its that *must* be applied before inserting the text for the corresponding completion.

By default, clang_codeCompleteAt() only returns completions with empty fix-its. Extra completions with non-empty fix-its should be explicitly requested by setting CXCodeComplete_IncludeCompletionsWithFixIts.

For the clients to be able to compute position of the cursor after applying fix-its, the following conditions are guaranteed to hold for replacement_range of the stored fix-its: - Ranges in the fix-its are guaranteed to never contain the completion point (or identifier under completion point, if any) inside them, except at the start or at the end of the range. - If a fix-it range starts or ends with completion point (or starts or ends after the identifier under completion point), it will contain at least one character. It allows to unambiguously recompute completion point after applying the fix-it.

The intuition is that provided fix-its change code around the identifier we complete, but are not allowed to touch the identifier itself or the completion point. One example of completions with corrections are the ones replacing '.' with '->' and vice versa:

std::unique_ptr<std::vector<int>> vec_ptr; In 'vec_ptr.^', one of the completions is 'push_back', it requires replacing '.' with '->'. In 'vec_ptr->^', one of the completions is 'release', it requires replacing '->' with '.'.

Wraps the C function clang_getCompletionFixIt.

func (*CodeCompleteResults) CompletionNumFixIts 

func (results *CodeCompleteResults) CompletionNumFixIts(completion_index uint32) uint32

Retrieve the number of fix-its for the given completion index.

Calling this makes sense only if CXCodeComplete_IncludeCompletionsWithFixIts option was set.

Wraps the C function clang_getCompletionNumFixIts.

func (*CodeCompleteResults) DisposeCodeCompleteResults 

func (results *CodeCompleteResults) DisposeCodeCompleteResults()

Free the given set of code-completion results.

Wraps the C function clang_disposeCodeCompleteResults.

type CodeComplete_Flags 

type CodeComplete_Flags uint32

Flags that can be passed to clang_codeCompleteAt() to modify its behavior.

The enumerators in this enumeration can be bitwise-OR'd together to provide multiple options to clang_codeCompleteAt().

Represents the C enum CXCodeComplete_Flags. 

const (
	// Whether to include macros within the set of code completions returned.
	CodeComplete_IncludeMacros CodeComplete_Flags = 1
	// Whether to include code patterns for language constructs within the set of code completions, e.g., for loops.
	CodeComplete_IncludeCodePatterns CodeComplete_Flags = 2
	// Whether to include brief documentation within the set of code completions returned.
	CodeComplete_IncludeBriefComments CodeComplete_Flags = 4
	// Whether to speed up completion by omitting top- or namespace-level entities defined in the preamble. There's no guarantee any particular entity is omitted. This may be useful if the headers are indexed externally.
	CodeComplete_SkipPreamble CodeComplete_Flags = 8
	// Whether to include completions with small fix-its, e.g. change '.' to '->' on member access, etc.
	CodeComplete_IncludeCompletionsWithFixIts CodeComplete_Flags = 16
)

type Comment 

type Comment struct {
	TranslationUnit [8]byte // CXTranslationUnit
	// contains filtered or unexported fields
}

A parsed comment.

Represents the C struct CXComment.

func (Comment) BlockCommandCommentArgText 

func (comment Comment) BlockCommandCommentArgText(argIdx uint32) string

Wraps the C function clang_BlockCommandComment_getArgText.

func (Comment) BlockCommandCommentCommandName 

func (comment Comment) BlockCommandCommentCommandName() string

Wraps the C function clang_BlockCommandComment_getCommandName.

func (Comment) BlockCommandCommentNumArgs 

func (comment Comment) BlockCommandCommentNumArgs() uint32

Wraps the C function clang_BlockCommandComment_getNumArgs.

func (Comment) BlockCommandCommentParagraph 

func (comment Comment) BlockCommandCommentParagraph() Comment

Wraps the C function clang_BlockCommandComment_getParagraph.

func (Comment) Child 

func (comment Comment) Child(childIdx uint32) Comment

Wraps the C function clang_Comment_getChild.

func (Comment) FullCommentAsHTML 

func (comment Comment) FullCommentAsHTML() string

Convert a given full parsed comment to an HTML fragment.

Specific details of HTML layout are subject to change. Don't try to parse this HTML back into an AST, use other APIs instead.

Currently the following CSS classes are used:

Function argument documentation is rendered as a <dl> list with arguments sorted in function prototype order. CSS classes used:

Template parameter documentation is rendered as a <dl> list with parameters sorted in template parameter list order. CSS classes used:

Wraps the C function clang_FullComment_getAsHTML.

func (Comment) FullCommentAsXML 

func (comment Comment) FullCommentAsXML() string

Convert a given full parsed comment to an XML document.

A Relax NG schema for the XML can be found in comment-xml-schema.rng file inside clang source tree.

Wraps the C function clang_FullComment_getAsXML.

func (Comment) HTMLStartTagAttrName 

func (comment Comment) HTMLStartTagAttrName(attrIdx uint32) string

Wraps the C function clang_HTMLStartTag_getAttrName.

func (Comment) HTMLStartTagAttrValue 

func (comment Comment) HTMLStartTagAttrValue(attrIdx uint32) string

Wraps the C function clang_HTMLStartTag_getAttrValue.

func (Comment) HTMLStartTagComment_isSelfClosing 

func (comment Comment) HTMLStartTagComment_isSelfClosing() uint32

Wraps the C function clang_HTMLStartTagComment_isSelfClosing.

func (Comment) HTMLStartTagNumAttrs 

func (comment Comment) HTMLStartTagNumAttrs() uint32

Wraps the C function clang_HTMLStartTag_getNumAttrs.

func (Comment) HTMLTagCommentAsString 

func (comment Comment) HTMLTagCommentAsString() string

Convert an HTML tag AST node to string.

Wraps the C function clang_HTMLTagComment_getAsString.

func (Comment) HTMLTagCommentTagName 

func (comment Comment) HTMLTagCommentTagName() string

Wraps the C function clang_HTMLTagComment_getTagName.

func (Comment) InlineCommandCommentArgText 

func (comment Comment) InlineCommandCommentArgText(argIdx uint32) string

Wraps the C function clang_InlineCommandComment_getArgText.

func (Comment) InlineCommandCommentCommandName 

func (comment Comment) InlineCommandCommentCommandName() string

Wraps the C function clang_InlineCommandComment_getCommandName.

func (Comment) InlineCommandCommentNumArgs 

func (comment Comment) InlineCommandCommentNumArgs() uint32

Wraps the C function clang_InlineCommandComment_getNumArgs.

func (Comment) InlineCommandCommentRenderKind 

func (comment Comment) InlineCommandCommentRenderKind() CommentInlineCommandRenderKind

Wraps the C function clang_InlineCommandComment_getRenderKind.

func (Comment) InlineContentComment_hasTrailingNewline 

func (comment Comment) InlineContentComment_hasTrailingNewline() uint32

Wraps the C function clang_InlineContentComment_hasTrailingNewline.

func (Comment) IsWhitespace 

func (comment Comment) IsWhitespace() uint32

A CXComment_Paragraph node is considered whitespace if it contains only CXComment_Text nodes that are empty or whitespace.

Other AST nodes (except CXComment_Paragraph and CXComment_Text) are never considered whitespace.

Wraps the C function clang_Comment_isWhitespace.

func (Comment) Kind 

func (comment Comment) Kind() CommentKind

Wraps the C function clang_Comment_getKind.

func (Comment) NumChildren 

func (comment Comment) NumChildren() uint32

Wraps the C function clang_Comment_getNumChildren.

func (Comment) ParamCommandCommentDirection 

func (comment Comment) ParamCommandCommentDirection() CommentParamPassDirection

Wraps the C function clang_ParamCommandComment_getDirection.

func (Comment) ParamCommandCommentParamIndex 

func (comment Comment) ParamCommandCommentParamIndex() uint32

Wraps the C function clang_ParamCommandComment_getParamIndex.

func (Comment) ParamCommandCommentParamName 

func (comment Comment) ParamCommandCommentParamName() string

Wraps the C function clang_ParamCommandComment_getParamName.

func (Comment) ParamCommandComment_isDirectionExplicit 

func (comment Comment) ParamCommandComment_isDirectionExplicit() uint32

Wraps the C function clang_ParamCommandComment_isDirectionExplicit.

func (Comment) ParamCommandComment_isParamIndexValid 

func (comment Comment) ParamCommandComment_isParamIndexValid() uint32

Wraps the C function clang_ParamCommandComment_isParamIndexValid.

func (Comment) TParamCommandCommentDepth 

func (comment Comment) TParamCommandCommentDepth() uint32

For example,

for C and TT nesting depth is 0, for T nesting depth is 1.

Wraps the C function clang_TParamCommandComment_getDepth.

func (Comment) TParamCommandCommentIndex 

func (comment Comment) TParamCommandCommentIndex(depth uint32) uint32

For example,

for C and TT nesting depth is 0, so we can ask for index at depth 0: at depth 0 C's index is 0, TT's index is 1.

For T nesting depth is 1, so we can ask for index at depth 0 and 1: at depth 0 T's index is 1 (same as TT's), at depth 1 T's index is 0.

Wraps the C function clang_TParamCommandComment_getIndex.

func (Comment) TParamCommandCommentParamName 

func (comment Comment) TParamCommandCommentParamName() string

Wraps the C function clang_TParamCommandComment_getParamName.

func (Comment) TParamCommandComment_isParamPositionValid 

func (comment Comment) TParamCommandComment_isParamPositionValid() uint32

Wraps the C function clang_TParamCommandComment_isParamPositionValid.

func (Comment) TextCommentText 

func (comment Comment) TextCommentText() string

Wraps the C function clang_TextComment_getText.

func (Comment) VerbatimBlockLineCommentText 

func (comment Comment) VerbatimBlockLineCommentText() string

Wraps the C function clang_VerbatimBlockLineComment_getText.

func (Comment) VerbatimLineCommentText 

func (comment Comment) VerbatimLineCommentText() string

Wraps the C function clang_VerbatimLineComment_getText.

type CommentInlineCommandRenderKind 

type CommentInlineCommandRenderKind uint32

The most appropriate rendering mode for an inline command, chosen on command semantics in Doxygen.

Represents the C enum CXCommentInlineCommandRenderKind. 

const (
	// Command argument should be rendered in a normal font.
	CommentInlineCommandRenderKind_Normal CommentInlineCommandRenderKind = 0
	// Command argument should be rendered in a bold font.
	CommentInlineCommandRenderKind_Bold CommentInlineCommandRenderKind = 1
	// Command argument should be rendered in a monospaced font.
	CommentInlineCommandRenderKind_Monospaced CommentInlineCommandRenderKind = 2
	// Command argument should be rendered emphasized (typically italic font).
	CommentInlineCommandRenderKind_Emphasized CommentInlineCommandRenderKind = 3
	// Command argument should not be rendered (since it only defines an anchor).
	CommentInlineCommandRenderKind_Anchor CommentInlineCommandRenderKind = 4
)

type CommentKind 

type CommentKind uint32

Describes the type of the comment AST node (CXComment). A comment node can be considered block content (e. g., paragraph), inline content (plain text) or neither (the root AST node).

Represents the C enum CXCommentKind. 

const (
	// Null comment.  No AST node is constructed at the requested location because there is no text or a syntax error.
	Comment_Null CommentKind = 0
	// Plain text.  Inline content.
	Comment_Text CommentKind = 1
	/*
	   A command with word-like arguments that is considered inline content.

	   For example: \c command.
	*/
	Comment_InlineCommand CommentKind = 2
	/*
	   HTML start tag with attributes (name-value pairs).  Considered inline content.

	   For example:
	*/
	Comment_HTMLStartTag CommentKind = 3
	/*
	   HTML end tag.  Considered inline content.

	   For example:
	*/
	Comment_HTMLEndTag CommentKind = 4
	// A paragraph, contains inline comment.  The paragraph itself is block content.
	Comment_Paragraph CommentKind = 5
	/*
	   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.  Block command is block content.

	   Paragraph argument is also a child of the block command.

	   For example:  0 word-like arguments and a paragraph argument.

	   AST nodes of special kinds that parser knows about (e. g., \param command) have their own node kinds.
	*/
	Comment_BlockCommand CommentKind = 6
	/*
	   A \param or \arg command that describes the function parameter (name, passing direction, description).

	   For example: \param [in] ParamName description.
	*/
	Comment_ParamCommand CommentKind = 7
	/*
	   A \tparam command that describes a template parameter (name and description).

	   For example: \tparam T description.
	*/
	Comment_TParamCommand CommentKind = 8
	/*
	   A verbatim block command (e. g., preformatted code).  Verbatim block has an opening and a closing command and contains multiple lines of text (CXComment_VerbatimBlockLine child nodes).

	   For example: \verbatim aaa \endverbatim
	*/
	Comment_VerbatimBlockCommand CommentKind = 9
	// A line of text that is contained within a CXComment_VerbatimBlockCommand node.
	Comment_VerbatimBlockLine CommentKind = 10
	// A verbatim line command.  Verbatim line has an opening command, a single line of text (up to the newline after the opening command) and has no closing command.
	Comment_VerbatimLine CommentKind = 11
	// A full comment attached to a declaration, contains block content.
	Comment_FullComment CommentKind = 12
)

type CommentParamPassDirection 

type CommentParamPassDirection uint32

Describes parameter passing direction for \param or \arg command.

Represents the C enum CXCommentParamPassDirection. 

const (
	// The parameter is an input parameter.
	CommentParamPassDirection_In CommentParamPassDirection = 0
	// The parameter is an output parameter.
	CommentParamPassDirection_Out CommentParamPassDirection = 1
	// The parameter is an input and output parameter.
	CommentParamPassDirection_InOut CommentParamPassDirection = 2
)

type CompletionChunkKind 

type CompletionChunkKind uint32

Describes a single piece of text within a code-completion string.

Each "chunk" within a code-completion string (CXCompletionString) is either a piece of text with a specific "kind" that describes how that text should be interpreted by the client or is another completion string.

Represents the C enum CXCompletionChunkKind. 

const (
	/*
	   A code-completion string that describes "optional" text that could be a part of the template (but is not required).

	   The Optional chunk is the only kind of chunk that has a code-completion string for its representation, which is accessible via clang_getCompletionChunkCompletionString(). The code-completion string describes an additional part of the template that is completely optional. For example, optional chunks can be used to describe the placeholders for arguments that match up with defaulted function parameters, e.g. given:

	   The code-completion string for this function would contain:   - a TypedText chunk for "f".   - a LeftParen chunk for "(".   - a Placeholder chunk for "int x"   - an Optional chunk containing the remaining defaulted arguments, e.g.,       - a Comma chunk for ","       - a Placeholder chunk for "float y"       - an Optional chunk containing the last defaulted argument:           - a Comma chunk for ","           - a Placeholder chunk for "double z"   - a RightParen chunk for ")"

	   There are many ways to handle Optional chunks. Two simple approaches are:   - Completely ignore optional chunks, in which case the template for the     function "f" would only include the first parameter ("int x").   - Fully expand all optional chunks, in which case the template for the     function "f" would have all of the parameters.
	*/
	CompletionChunk_Optional CompletionChunkKind = 0
	/*
	   Text that a user would be expected to type to get this code-completion result.

	   There will be exactly one "typed text" chunk in a semantic string, which will typically provide the spelling of a keyword or the name of a declaration that could be used at the current code point. Clients are expected to filter the code-completion results based on the text in this chunk.
	*/
	CompletionChunk_TypedText CompletionChunkKind = 1
	/*
	   Text that should be inserted as part of a code-completion result.

	   A "text" chunk represents text that is part of the template to be inserted into user code should this particular code-completion result be selected.
	*/
	CompletionChunk_Text CompletionChunkKind = 2
	/*
	   Placeholder text that should be replaced by the user.

	   A "placeholder" chunk marks a place where the user should insert text into the code-completion template. For example, placeholders might mark the function parameters for a function declaration, to indicate that the user should provide arguments for each of those parameters. The actual text in a placeholder is a suggestion for the text to display before the user replaces the placeholder with real code.
	*/
	CompletionChunk_Placeholder CompletionChunkKind = 3
	/*
	   Informative text that should be displayed but never inserted as part of the template.

	   An "informative" chunk contains annotations that can be displayed to help the user decide whether a particular code-completion result is the right option, but which is not part of the actual template to be inserted by code completion.
	*/
	CompletionChunk_Informative CompletionChunkKind = 4
	/*
	   Text that describes the current parameter when code-completion is referring to function call, message send, or template specialization.

	   A "current parameter" chunk occurs when code-completion is providing information about a parameter corresponding to the argument at the code-completion point. For example, given a function

	   and the source code add(, where the code-completion point is after the "(", the code-completion string will contain a "current parameter" chunk for "int x", indicating that the current argument will initialize that parameter. After typing further, to add(17, (where the code-completion point is after the ","), the code-completion string will contain a "current parameter" chunk to "int y".
	*/
	CompletionChunk_CurrentParameter CompletionChunkKind = 5
	// A left parenthesis ('('), used to initiate a function call or signal the beginning of a function parameter list.
	CompletionChunk_LeftParen CompletionChunkKind = 6
	// A right parenthesis (')'), used to finish a function call or signal the end of a function parameter list.
	CompletionChunk_RightParen CompletionChunkKind = 7
	// A left bracket ('[').
	CompletionChunk_LeftBracket CompletionChunkKind = 8
	// A right bracket (']').
	CompletionChunk_RightBracket CompletionChunkKind = 9
	// A left brace ('{').
	CompletionChunk_LeftBrace CompletionChunkKind = 10
	// A right brace ('}').
	CompletionChunk_RightBrace CompletionChunkKind = 11
	// A left angle bracket ('<').
	CompletionChunk_LeftAngle CompletionChunkKind = 12
	// A right angle bracket ('>').
	CompletionChunk_RightAngle CompletionChunkKind = 13
	// A comma separator (',').
	CompletionChunk_Comma CompletionChunkKind = 14
	/*
	   Text that specifies the result type of a given result.

	   This special kind of informative chunk is not meant to be inserted into the text buffer. Rather, it is meant to illustrate the type that an expression using the given completion string would have.
	*/
	CompletionChunk_ResultType CompletionChunkKind = 15
	// A colon (':').
	CompletionChunk_Colon CompletionChunkKind = 16
	// A semicolon (';').
	CompletionChunk_SemiColon CompletionChunkKind = 17
	// An '=' sign.
	CompletionChunk_Equal CompletionChunkKind = 18
	// Horizontal space (' ').
	CompletionChunk_HorizontalSpace CompletionChunkKind = 19
	// Vertical space ('\n'), after which it is generally a good idea to perform indentation.
	CompletionChunk_VerticalSpace CompletionChunkKind = 20
)

type CompletionContext 

type CompletionContext uint32

Bits that represent the context under which completion is occurring.

The enumerators in this enumeration may be bitwise-OR'd together if multiple contexts are occurring simultaneously.

Represents the C enum CXCompletionContext. 

const (
	// The context for completions is unexposed, as only Clang results should be included. (This is equivalent to having no context bits set.)
	CompletionContext_Unexposed CompletionContext = 0
	// Completions for any possible type should be included in the results.
	CompletionContext_AnyType CompletionContext = 1
	// Completions for any possible value (variables, function calls, etc.) should be included in the results.
	CompletionContext_AnyValue CompletionContext = 2
	// Completions for values that resolve to an Objective-C object should be included in the results.
	CompletionContext_ObjCObjectValue CompletionContext = 4
	// Completions for values that resolve to an Objective-C selector should be included in the results.
	CompletionContext_ObjCSelectorValue CompletionContext = 8
	// Completions for values that resolve to a C++ class type should be included in the results.
	CompletionContext_CXXClassTypeValue CompletionContext = 16
	// Completions for fields of the member being accessed using the dot operator should be included in the results.
	CompletionContext_DotMemberAccess CompletionContext = 32
	// Completions for fields of the member being accessed using the arrow operator should be included in the results.
	CompletionContext_ArrowMemberAccess CompletionContext = 64
	// Completions for properties of the Objective-C object being accessed using the dot operator should be included in the results.
	CompletionContext_ObjCPropertyAccess CompletionContext = 128
	// Completions for enum tags should be included in the results.
	CompletionContext_EnumTag CompletionContext = 256
	// Completions for union tags should be included in the results.
	CompletionContext_UnionTag CompletionContext = 512
	// Completions for struct tags should be included in the results.
	CompletionContext_StructTag CompletionContext = 1024
	// Completions for C++ class names should be included in the results.
	CompletionContext_ClassTag CompletionContext = 2048
	// Completions for C++ namespaces and namespace aliases should be included in the results.
	CompletionContext_Namespace CompletionContext = 4096
	// Completions for C++ nested name specifiers should be included in the results.
	CompletionContext_NestedNameSpecifier CompletionContext = 8192
	// Completions for Objective-C interfaces (classes) should be included in the results.
	CompletionContext_ObjCInterface CompletionContext = 16384
	// Completions for Objective-C protocols should be included in the results.
	CompletionContext_ObjCProtocol CompletionContext = 32768
	// Completions for Objective-C categories should be included in the results.
	CompletionContext_ObjCCategory CompletionContext = 65536
	// Completions for Objective-C instance messages should be included in the results.
	CompletionContext_ObjCInstanceMessage CompletionContext = 131072
	// Completions for Objective-C class messages should be included in the results.
	CompletionContext_ObjCClassMessage CompletionContext = 262144
	// Completions for Objective-C selector names should be included in the results.
	CompletionContext_ObjCSelectorName CompletionContext = 524288
	// Completions for preprocessor macro names should be included in the results.
	CompletionContext_MacroName CompletionContext = 1048576
	// Natural language completions should be included in the results.
	CompletionContext_NaturalLanguage CompletionContext = 2097152
	// #include file completions should be included in the results.
	CompletionContext_IncludedFile CompletionContext = 4194304
	// The current context is unknown, so set all contexts.
	CompletionContext_Unknown CompletionContext = 8388607
)

type CompletionResult 

type CompletionResult struct {

	/*
	   The kind of entity that this completion refers to.

	   The cursor kind will be a macro, keyword, or a declaration (one of the *Decl cursor kinds), describing the entity that the completion is referring to.
	*/
	CursorKind CursorKind

	// The code-completion string that describes how to insert this code-completion result into the editing buffer.
	CompletionString [8]byte // CXCompletionString
	// contains filtered or unexported fields
}

A single result of code completion.

Represents the C struct CXCompletionResult.

func (*CompletionResult) SortCodeCompletionResults 

func (results *CompletionResult) SortCodeCompletionResults(numResults uint32)

Sort the code-completion results in case-insensitive alphabetical order.

Wraps the C function clang_sortCodeCompletionResults.

type CompletionString 

type CompletionString struct {
	// contains filtered or unexported fields
}

A semantic string that describes a code-completion result.

A semantic string that describes the formatting of a code-completion result as a single "template" of text that should be inserted into the source buffer when a particular code-completion result is selected. Each semantic string is made up of some number of "chunks", each of which contains some text along with a description of what that text means, e.g., the name of the entity being referenced, whether the text chunk is part of the template, or whether it is a "placeholder" that the user should replace with actual code,of a specific kind. See CXCompletionChunkKind for a description of the different kinds of chunks.

Represents the C type CXCompletionString.

func (CompletionString) CompletionAnnotation 

func (completion_string CompletionString) CompletionAnnotation(annotation_number uint32) string

Retrieve the annotation associated with the given completion string.

Wraps the C function clang_getCompletionAnnotation.

func (CompletionString) CompletionAvailability 

func (completion_string CompletionString) CompletionAvailability() AvailabilityKind

Determine the availability of the entity that this code-completion string refers to.

Wraps the C function clang_getCompletionAvailability.

func (CompletionString) CompletionBriefComment 

func (completion_string CompletionString) CompletionBriefComment() string

Retrieve the brief documentation comment attached to the declaration that corresponds to the given completion string.

Wraps the C function clang_getCompletionBriefComment.

func (CompletionString) CompletionChunkCompletionString 

func (completion_string CompletionString) CompletionChunkCompletionString(chunk_number uint32) CompletionString

Retrieve the completion string associated with a particular chunk within a completion string.

Wraps the C function clang_getCompletionChunkCompletionString.

func (CompletionString) CompletionChunkKind 

func (completion_string CompletionString) CompletionChunkKind(chunk_number uint32) CompletionChunkKind

Determine the kind of a particular chunk within a completion string.

Wraps the C function clang_getCompletionChunkKind.

func (CompletionString) CompletionChunkText 

func (completion_string CompletionString) CompletionChunkText(chunk_number uint32) string

Retrieve the text associated with a particular chunk within a completion string.

Wraps the C function clang_getCompletionChunkText.

func (CompletionString) CompletionNumAnnotations 

func (completion_string CompletionString) CompletionNumAnnotations() uint32

Retrieve the number of annotations associated with the given completion string.

Wraps the C function clang_getCompletionNumAnnotations.

func (CompletionString) CompletionParent 

func (completion_string CompletionString) CompletionParent() (CursorKind, string)

Retrieve the parent context of the given completion string.

The parent context of a completion string is the semantic parent of the declaration (if any) that the code completion represents. For example, a code completion for an Objective-C method would have the method's class or protocol as its context.

Wraps the C function clang_getCompletionParent.

func (CompletionString) CompletionPriority 

func (completion_string CompletionString) CompletionPriority() uint32

Determine the priority of this code completion.

The priority of a code completion indicates how likely it is that this particular completion is the completion that the user will select. The priority is selected by various internal heuristics.

Wraps the C function clang_getCompletionPriority.

func (CompletionString) NumCompletionChunks 

func (completion_string CompletionString) NumCompletionChunks() uint32

Retrieve the number of chunks in the given code-completion string.

Wraps the C function clang_getNumCompletionChunks.

type Cursor 

type Cursor struct {
	Kind  CursorKind
	Xdata int32
	Data  [24]byte // const void *[3]
	// contains filtered or unexported fields
}

A cursor representing some element in the abstract syntax tree for a translation unit.

The cursor abstraction unifies the different kinds of entities in a program--declaration, statements, expressions, references to declarations, etc.--under a single "cursor" abstraction with a common set of operations. Common operation for a cursor include: getting the physical location in a source file where the cursor points, getting the name associated with a cursor, and retrieving cursors for any child nodes of a particular cursor.

Cursors can be produced in two specific ways. clang_getTranslationUnitCursor() produces a cursor for a translation unit, from which one can use clang_visitChildren() to explore the rest of the translation unit. clang_getCursor() maps from a physical source location to the entity that resides at that location, allowing one to map from the source code into the AST.

Represents the C struct CXCursor.

func GetNullCursor 

func GetNullCursor() Cursor

Retrieve the NULL cursor, which represents no entity.

Wraps the C function clang_getNullCursor.

func (Cursor) Argument 

func (c Cursor) Argument(i uint32) Cursor

Retrieve the argument cursor of a function or method.

The argument cursor can be determined for calls as well as for declarations of functions or methods. For other cursors and for invalid indices, an invalid cursor is returned.

Wraps the C function clang_Cursor_getArgument.

func (Cursor) BinaryOpcode 

func (c Cursor) BinaryOpcode() BinaryOperatorKind_

Wraps the C function clang_Cursor_getBinaryOpcode.

func (Cursor) BriefCommentText 

func (c Cursor) BriefCommentText() string

Given a cursor that represents a documentable entity (e.g., declaration), return the associated

first paragraph.

Wraps the C function clang_Cursor_getBriefCommentText.

func (Cursor) CanonicalCursor 

func (p0 Cursor) CanonicalCursor() Cursor

Retrieve the canonical cursor corresponding to the given cursor.

In the C family of languages, many kinds of entities can be declared several times within a single translation unit. For example, a structure type can be forward-declared (possibly multiple times) and later defined:

The declarations and the definition of X are represented by three different cursors, all of which are declarations of the same underlying entity. One of these cursor is considered the "canonical" cursor, which is effectively the representative for the underlying entity. One can determine if two cursors are declarations of the same underlying entity by comparing their canonical cursors.

Wraps the C function clang_getCanonicalCursor.

func (Cursor) CommentRange 

func (c Cursor) CommentRange() SourceRange

Given a cursor that represents a declaration, return the associated comment's source range. The range may include multiple consecutive comments with whitespace in between.

Wraps the C function clang_Cursor_getCommentRange.

func (Cursor) CursorAvailability 

func (cursor Cursor) CursorAvailability() AvailabilityKind

Determine the availability of the entity that this cursor refers to, taking the current target platform into account.

Wraps the C function clang_getCursorAvailability.

func (Cursor) CursorBinaryOperatorKind 

func (cursor Cursor) CursorBinaryOperatorKind() BinaryOperatorKind

Retrieve the binary operator kind of this cursor.

If this cursor is not a binary operator then returns Invalid.

Wraps the C function clang_getCursorBinaryOperatorKind.

func (Cursor) CursorCompletionString 

func (cursor Cursor) CursorCompletionString() CompletionString

Retrieve a completion string for an arbitrary declaration or macro definition cursor.

Wraps the C function clang_getCursorCompletionString.

func (Cursor) CursorDefinition 

func (p0 Cursor) CursorDefinition() Cursor

For a cursor that is either a reference to or a declaration of some entity, retrieve a cursor that describes the definition of that entity.

Some entities can be declared multiple times within a translation unit, but only one of those declarations can also be a definition. For example, given:

there are three declarations of the function "f", but only the second one is a definition. The clang_getCursorDefinition() function will take any cursor pointing to a declaration of "f" (the first or fourth lines of the example) or a cursor referenced that uses "f" (the call to "f' inside "g") and will return a declaration cursor pointing to the definition (the second "f" declaration).

If given a cursor for which there is no corresponding definition, e.g., because there is no definition of that entity within this translation unit, returns a NULL cursor.

Wraps the C function clang_getCursorDefinition.

func (Cursor) CursorDisplayName 

func (p0 Cursor) CursorDisplayName() string

Retrieve the display name for the entity referenced by this cursor.

The display name contains extra information that helps identify the cursor, such as the parameters of a function or template or the arguments of a class template specialization.

Wraps the C function clang_getCursorDisplayName.

func (Cursor) CursorExceptionSpecificationType 

func (c Cursor) CursorExceptionSpecificationType() int32

Retrieve the exception specification type associated with a given cursor. This is a value of type CXCursor_ExceptionSpecificationKind.

This only returns a valid result if the cursor refers to a function or method.

Wraps the C function clang_getCursorExceptionSpecificationType.

func (Cursor) CursorExtent 

func (p0 Cursor) CursorExtent() SourceRange

Retrieve the physical extent of the source construct referenced by the given cursor.

The extent of a cursor starts with the file/line/column pointing at the first character within the source construct that the cursor refers to and ends with the last character within that source construct. For a declaration, the extent covers the declaration itself. For a reference, the extent covers the location of the reference (e.g., where the referenced entity was actually used).

Wraps the C function clang_getCursorExtent.

func (Cursor) CursorKind 

func (p0 Cursor) CursorKind() CursorKind

Retrieve the kind of the given cursor.

Wraps the C function clang_getCursorKind.

func (Cursor) CursorLanguage 

func (cursor Cursor) CursorLanguage() LanguageKind

Determine the "language" of the entity referred to by a given cursor.

Wraps the C function clang_getCursorLanguage.

func (Cursor) CursorLexicalParent 

func (cursor Cursor) CursorLexicalParent() Cursor

Determine the lexical parent of the given cursor.

The lexical parent of a cursor is the cursor in which the given cursor was actually written. For many declarations, the lexical and semantic parents are equivalent (the semantic parent is returned by clang_getCursorSemanticParent()). They diverge when declarations or definitions are provided out-of-line. For example:

In the out-of-line definition of C::f, the semantic parent is the class C, of which this function is a member. The lexical parent is the place where the declaration actually occurs in the source code; in this case, the definition occurs in the translation unit. In general, the lexical parent for a given entity can change without affecting the semantics of the program, and the lexical parent of different declarations of the same entity may be different. Changing the semantic parent of a declaration, on the other hand, can have a major impact on semantics, and redeclarations of a particular entity should all have the same semantic context.

In the example above, both declarations of C::f have C as their semantic context, while the lexical context of the first C::f is C and the lexical context of the second C::f is the translation unit.

For declarations written in the global scope, the lexical parent is the translation unit.

Wraps the C function clang_getCursorLexicalParent.

func (Cursor) CursorLinkage 

func (cursor Cursor) CursorLinkage() LinkageKind

Determine the linkage of the entity referred to by a given cursor.

Wraps the C function clang_getCursorLinkage.

func (Cursor) CursorLocation 

func (p0 Cursor) CursorLocation() SourceLocation

Retrieve the physical location of the source constructor referenced by the given cursor.

The location of a declaration is typically the location of the name of that declaration, where the name of that declaration would occur if it is unnamed, or some keyword that introduces that particular declaration. The location of a reference is where that reference occurs within the source code.

Wraps the C function clang_getCursorLocation.

func (Cursor) CursorPlatformAvailability 

func (cursor Cursor) CursorPlatformAvailability(availability_size int32) (int32, string, int32, string, PlatformAvailability, int32)

Determine the availability of the entity that this cursor refers to on any platforms for which availability information is known.

Note that the client is responsible for calling clang_disposeCXPlatformAvailability to free each of the platform-availability structures returned. There are min(N, availability_size) such structures.

Wraps the C function clang_getCursorPlatformAvailability.

func (Cursor) CursorPrettyPrinted 

func (cursor Cursor) CursorPrettyPrinted(policy PrintingPolicy) string

Pretty print declarations.

Wraps the C function clang_getCursorPrettyPrinted.

func (Cursor) CursorPrintingPolicy 

func (p0 Cursor) CursorPrintingPolicy() PrintingPolicy

Retrieve the default policy for the cursor.

The policy should be released after use with clang_PrintingPolicy_dispose.

Wraps the C function clang_getCursorPrintingPolicy.

func (Cursor) CursorReferenceNameRange 

func (c Cursor) CursorReferenceNameRange(nameFlags uint32, pieceIndex uint32) SourceRange

Given a cursor that references something else, return the source range covering that reference.

Wraps the C function clang_getCursorReferenceNameRange.

func (Cursor) CursorReferenced 

func (p0 Cursor) CursorReferenced() Cursor

For a cursor that is a reference, retrieve a cursor representing the entity that it references.

Reference cursors refer to other entities in the AST. For example, an Objective-C superclass reference cursor refers to an Objective-C class. This function produces the cursor for the Objective-C class from the cursor for the superclass reference. If the input cursor is a declaration or definition, it returns that declaration or definition unchanged. Otherwise, returns the NULL cursor.

Wraps the C function clang_getCursorReferenced.

func (Cursor) CursorResultType 

func (c Cursor) CursorResultType() Type

Retrieve the return type associated with a given cursor.

This only returns a valid type if the cursor refers to a function or method.

Wraps the C function clang_getCursorResultType.

func (Cursor) CursorSemanticParent 

func (cursor Cursor) CursorSemanticParent() Cursor

Determine the semantic parent of the given cursor.

The semantic parent of a cursor is the cursor that semantically contains the given cursor. For many declarations, the lexical and semantic parents are equivalent (the lexical parent is returned by clang_getCursorLexicalParent()). They diverge when declarations or definitions are provided out-of-line. For example:

In the out-of-line definition of C::f, the semantic parent is the class C, of which this function is a member. The lexical parent is the place where the declaration actually occurs in the source code; in this case, the definition occurs in the translation unit. In general, the lexical parent for a given entity can change without affecting the semantics of the program, and the lexical parent of different declarations of the same entity may be different. Changing the semantic parent of a declaration, on the other hand, can have a major impact on semantics, and redeclarations of a particular entity should all have the same semantic context.

In the example above, both declarations of C::f have C as their semantic context, while the lexical context of the first C::f is C and the lexical context of the second C::f is the translation unit.

For global declarations, the semantic parent is the translation unit.

Wraps the C function clang_getCursorSemanticParent.

func (Cursor) CursorSpelling 

func (p0 Cursor) CursorSpelling() string

Retrieve a name for the entity referenced by this cursor.

Wraps the C function clang_getCursorSpelling.

func (Cursor) CursorTLSKind 

func (cursor Cursor) CursorTLSKind() TLSKind

Determine the "thread-local storage (TLS) kind" of the declaration referred to by a cursor.

Wraps the C function clang_getCursorTLSKind.

func (Cursor) CursorType 

func (c Cursor) CursorType() Type

Retrieve the type of a CXCursor (if any).

Wraps the C function clang_getCursorType.

func (Cursor) CursorUSR 

func (p0 Cursor) CursorUSR() string

Retrieve a Unified Symbol Resolution (USR) for the entity referenced by the given cursor.

A Unified Symbol Resolution (USR) is a string that identifies a particular entity (function, class, variable, etc.) within a program. USRs can be compared across translation units to determine, e.g., when references in one translation refer to an entity defined in another translation unit.

Wraps the C function clang_getCursorUSR.

func (Cursor) CursorUnaryOperatorKind 

func (cursor Cursor) CursorUnaryOperatorKind() UnaryOperatorKind

Retrieve the unary operator kind of this cursor.

If this cursor is not a unary operator then returns Invalid.

Wraps the C function clang_getCursorUnaryOperatorKind.

func (Cursor) CursorVisibility 

func (cursor Cursor) CursorVisibility() VisibilityKind

Describe the visibility of the entity referred to by a cursor.

This returns the default visibility if not explicitly specified by a visibility attribute. The default visibility may be changed by commandline arguments.

Wraps the C function clang_getCursorVisibility.

func (Cursor) DeclObjCTypeEncoding 

func (c Cursor) DeclObjCTypeEncoding() string

Returns the Objective-C type encoding for the specified declaration.

Wraps the C function clang_getDeclObjCTypeEncoding.

func (*Cursor) DisposeOverriddenCursors 

func (overridden *Cursor) DisposeOverriddenCursors()

Free the set of overridden cursors returned by clang_getOverriddenCursors().

Wraps the C function clang_disposeOverriddenCursors.

func (Cursor) EnumConstantDeclUnsignedValue 

func (c Cursor) EnumConstantDeclUnsignedValue() uint64

Retrieve the integer value of an enum constant declaration as an unsigned long long.

If the cursor does not reference an enum constant declaration, ULLONG_MAX is returned. Since this is also potentially a valid constant value, the kind of the cursor must be verified before calling this function.

Wraps the C function clang_getEnumConstantDeclUnsignedValue.

func (Cursor) EnumConstantDeclValue 

func (c Cursor) EnumConstantDeclValue() int64

Retrieve the integer value of an enum constant declaration as a signed long long.

If the cursor does not reference an enum constant declaration, LLONG_MIN is returned. Since this is also potentially a valid constant value, the kind of the cursor must be verified before calling this function.

Wraps the C function clang_getEnumConstantDeclValue.

func (Cursor) EnumDeclIntegerType 

func (c Cursor) EnumDeclIntegerType() Type

Retrieve the integer type of an enum declaration.

If the cursor does not reference an enum declaration, an invalid type is returned.

Wraps the C function clang_getEnumDeclIntegerType.

func (Cursor) EnumDecl_isScoped 

func (c Cursor) EnumDecl_isScoped() uint32

Determine if an enum declaration refers to a scoped enum.

Wraps the C function clang_EnumDecl_isScoped.

func (Cursor) EqualCursors 

func (p0 Cursor) EqualCursors(p1 Cursor) uint32

Determine whether two cursors are equivalent.

Wraps the C function clang_equalCursors.

func (Cursor) Evaluate 

func (c Cursor) Evaluate() EvalResult

If cursor is a statement declaration tries to evaluate the statement and if its variable, tries to evaluate its initializer, into its corresponding type. If it's an expression, tries to evaluate the expression.

Wraps the C function clang_Cursor_Evaluate.

func (Cursor) FieldDeclBitWidth 

func (c Cursor) FieldDeclBitWidth() int32

Retrieve the bit width of a bit-field declaration as an integer.

If the cursor does not reference a bit-field, or if the bit-field's width expression cannot be evaluated, -1 is returned.

For example:

Wraps the C function clang_getFieldDeclBitWidth.

func (Cursor) FindReferencesInFile 

func (cursor Cursor) FindReferencesInFile(file File, visitor CursorAndRangeVisitor) Result

Find references of a declaration in a specific file.

Wraps the C function clang_findReferencesInFile.

func (Cursor) FindReferencesInFileWithBlock 

func (p0 Cursor) FindReferencesInFileWithBlock(p1 File, p2 CursorAndRangeVisitorBlock) Result

Wraps the C function clang_findReferencesInFileWithBlock.

func (Cursor) GCCAssemblyClobber 

func (cursor Cursor) GCCAssemblyClobber(index uint32) string

Given a CXCursor_GCCAsmStmt cursor, get the Index-th clobber of it. This function returns a valid empty string if the cursor does not point at a GCC inline assembly block or `Index` is out of bounds.

Users are responsible for releasing the allocation of returned string via clang_disposeString.

Wraps the C function clang_Cursor_getGCCAssemblyClobber.

func (Cursor) GCCAssemblyInput 

func (cursor Cursor) GCCAssemblyInput(index uint32) (string, Cursor, uint32)

Given a CXCursor_GCCAsmStmt cursor, get the constraint and expression cursor to the Index-th input. This function returns 1 when the cursor points at a GCC inline assembly statement, `Index` is within bounds and both the `Constraint` and `Expr` are not NULL. Otherwise, this function returns 0 but leaves `Constraint` and `Expr` intact.

Users are responsible for releasing the allocation of `Constraint` via clang_disposeString.

Wraps the C function clang_Cursor_getGCCAssemblyInput.

func (Cursor) GCCAssemblyNumClobbers 

func (cursor Cursor) GCCAssemblyNumClobbers() uint32

Given a CXCursor_GCCAsmStmt cursor, count the clobbers in it. This function also returns 0 if the cursor does not point at a GCC inline assembly block.

Wraps the C function clang_Cursor_getGCCAssemblyNumClobbers.

func (Cursor) GCCAssemblyNumInputs 

func (p0 Cursor) GCCAssemblyNumInputs() uint32

Given a CXCursor_GCCAsmStmt cursor, count the number of inputs. This function also returns 0 if the cursor does not point at a GCC inline assembly block.

Wraps the C function clang_Cursor_getGCCAssemblyNumInputs.

func (Cursor) GCCAssemblyNumOutputs 

func (p0 Cursor) GCCAssemblyNumOutputs() uint32

Given a CXCursor_GCCAsmStmt cursor, count the number of outputs. This function also returns 0 if the cursor does not point at a GCC inline assembly block.

Wraps the C function clang_Cursor_getGCCAssemblyNumOutputs.

func (Cursor) GCCAssemblyOutput 

func (cursor Cursor) GCCAssemblyOutput(index uint32) (string, Cursor, uint32)

Given a CXCursor_GCCAsmStmt cursor, get the constraint and expression cursor to the Index-th output. This function returns 1 when the cursor points at a GCC inline assembly statement, `Index` is within bounds and both the `Constraint` and `Expr` are not NULL. Otherwise, this function returns 0 but leaves `Constraint` and `Expr` intact.

Users are responsible for releasing the allocation of `Constraint` via clang_disposeString.

Wraps the C function clang_Cursor_getGCCAssemblyOutput.

func (Cursor) GCCAssemblyTemplate 

func (p0 Cursor) GCCAssemblyTemplate() string

Given a CXCursor_GCCAsmStmt cursor, return the assembly template string. As per LLVM IR Assembly Template language, template placeholders for inputs and outputs are either of the form $N where N is a decimal number as an index into the input-output specification, or ${N:M} where N is a decimal number also as an index into the input-output specification and M is the template argument modifier. The index N in both cases points into the the total inputs and outputs, or more specifically, into the list of outputs followed by the inputs, starting from index 0 as the first available template argument.

This function also returns a valid empty string if the cursor does not point at a GCC inline assembly block.

Users are responsible for releasing the allocation of returned string via clang_disposeString.

Wraps the C function clang_Cursor_getGCCAssemblyTemplate.

func (Cursor) HasAttrs 

func (c Cursor) HasAttrs() uint32

Determine whether the given cursor has any attributes.

Wraps the C function clang_Cursor_hasAttrs.

func (Cursor) HasVarDeclExternalStorage 

func (cursor Cursor) HasVarDeclExternalStorage() int32

If cursor refers to a variable declaration that has external storage returns 1. If cursor refers to a variable declaration that doesn't have external storage returns 0. Otherwise returns -1.

Wraps the C function clang_Cursor_hasVarDeclExternalStorage.

func (Cursor) HasVarDeclGlobalStorage 

func (cursor Cursor) HasVarDeclGlobalStorage() int32

If cursor refers to a variable declaration that has global storage returns 1. If cursor refers to a variable declaration that doesn't have global storage returns 0. Otherwise returns -1.

Wraps the C function clang_Cursor_hasVarDeclGlobalStorage.

func (Cursor) HashCursor 

func (p0 Cursor) HashCursor() uint32

Compute a hash value for the given cursor.

Wraps the C function clang_hashCursor.

func (Cursor) IBOutletCollectionType 

func (p0 Cursor) IBOutletCollectionType() Type

For cursors representing an iboutletcollection attribute, this function returns the collection element type.

Wraps the C function clang_getIBOutletCollectionType.

func (Cursor) IncludedFile 

func (cursor Cursor) IncludedFile() File

Retrieve the file that is included by the given inclusion directive cursor.

Wraps the C function clang_getIncludedFile.

func (Cursor) IsAnonymous 

func (c Cursor) IsAnonymous() uint32

Determine whether the given cursor represents an anonymous tag or namespace

Wraps the C function clang_Cursor_isAnonymous.

func (Cursor) IsAnonymousRecordDecl 

func (c Cursor) IsAnonymousRecordDecl() uint32

Determine whether the given cursor represents an anonymous record declaration.

Wraps the C function clang_Cursor_isAnonymousRecordDecl.

func (Cursor) IsBitField 

func (c Cursor) IsBitField() uint32

Returns non-zero if the cursor specifies a Record member that is a bit-field.

Wraps the C function clang_Cursor_isBitField.

func (Cursor) IsCursorDefinition 

func (p0 Cursor) IsCursorDefinition() uint32

Determine whether the declaration pointed to by this cursor is also a definition of that entity.

Wraps the C function clang_isCursorDefinition.

func (Cursor) IsDynamicCall 

func (c Cursor) IsDynamicCall() int32

Given a cursor pointing to a C++ method call or an Objective-C message, returns non-zero if the method/message is "dynamic", meaning:

For a C++ method: the call is virtual. For an Objective-C message: the receiver is an object instance, not 'super' or a specific class.

If the method/message is "static" or the cursor does not point to a method/message, it will return zero.

Wraps the C function clang_Cursor_isDynamicCall.

func (Cursor) IsExternalSymbol 

func (c Cursor) IsExternalSymbol() (string, string, uint32, uint32)

Returns non-zero if the given cursor points to a symbol marked with external_source_symbol attribute.

Wraps the C function clang_Cursor_isExternalSymbol.

func (Cursor) IsFunctionInlined 

func (c Cursor) IsFunctionInlined() uint32

Determine whether a CXCursor that is a function declaration, is an inline declaration.

Wraps the C function clang_Cursor_isFunctionInlined.

func (Cursor) IsGCCAssemblyHasGoto 

func (p0 Cursor) IsGCCAssemblyHasGoto() uint32

Given a CXCursor_GCCAsmStmt cursor, check if the assembly block has goto labels. This function also returns 0 if the cursor does not point at a GCC inline assembly block.

Wraps the C function clang_Cursor_isGCCAssemblyHasGoto.

func (Cursor) IsGCCAssemblyVolatile 

func (cursor Cursor) IsGCCAssemblyVolatile() uint32

Given a CXCursor_GCCAsmStmt cursor, check if the inline assembly is `volatile`. This function returns 0 if the cursor does not point at a GCC inline assembly block.

Wraps the C function clang_Cursor_isGCCAssemblyVolatile.

func (Cursor) IsInlineNamespace 

func (c Cursor) IsInlineNamespace() uint32

Determine whether the given cursor represents an inline namespace declaration.

Wraps the C function clang_Cursor_isInlineNamespace.

func (Cursor) IsInvalidDeclaration 

func (p0 Cursor) IsInvalidDeclaration() uint32

Determine whether the given declaration is invalid.

A declaration is invalid if it could not be parsed successfully.

Wraps the C function clang_isInvalidDeclaration.

func (Cursor) IsMacroBuiltin 

func (c Cursor) IsMacroBuiltin() uint32

Determine whether a CXCursor that is a macro, is a builtin one.

Wraps the C function clang_Cursor_isMacroBuiltin.

func (Cursor) IsMacroFunctionLike 

func (c Cursor) IsMacroFunctionLike() uint32

Determine whether a CXCursor that is a macro, is function like.

Wraps the C function clang_Cursor_isMacroFunctionLike.

func (Cursor) IsNull 

func (cursor Cursor) IsNull() int32

Returns non-zero if cursor is null.

Wraps the C function clang_Cursor_isNull.

func (Cursor) IsObjCOptional 

func (c Cursor) IsObjCOptional() uint32

Given a cursor that represents an Objective-C method or property declaration, return non-zero if the declaration was affected by "\@optional". Returns zero if the cursor is not such a declaration or it is "\@required".

Wraps the C function clang_Cursor_isObjCOptional.

func (Cursor) IsVariadic 

func (c Cursor) IsVariadic() uint32

Returns non-zero if the given cursor is a variadic function or method.

Wraps the C function clang_Cursor_isVariadic.

func (Cursor) IsVirtualBase 

func (p0 Cursor) IsVirtualBase() uint32

Returns 1 if the base class specified by the cursor with kind CX_CXXBaseSpecifier is virtual.

Wraps the C function clang_isVirtualBase.

func (Cursor) Mangling 

func (p0 Cursor) Mangling() string

Retrieve the CXString representing the mangled name of the cursor.

Wraps the C function clang_Cursor_getMangling.

func (Cursor) Module 

func (c Cursor) Module() Module

Given a CXCursor_ModuleImportDecl cursor, return the associated module.

Wraps the C function clang_Cursor_getModule.

func (Cursor) NumArguments 

func (c Cursor) NumArguments() int32

Retrieve the number of non-variadic arguments associated with a given cursor.

The number of arguments can be determined for calls as well as for declarations of functions or methods. For other cursors -1 is returned.

Wraps the C function clang_Cursor_getNumArguments.

func (Cursor) NumOverloadedDecls 

func (cursor Cursor) NumOverloadedDecls() uint32

Determine the number of overloaded declarations referenced by a CXCursor_OverloadedDeclRef cursor.

Wraps the C function clang_getNumOverloadedDecls.

func (Cursor) NumTemplateArguments 

func (c Cursor) NumTemplateArguments() int32

Returns the number of template args of a function, struct, or class decl representing a template specialization.

If the argument cursor cannot be converted into a template function declaration, -1 is returned.

For example, for the following declaration and specialization: template <typename T, int kInt, bool kBool> void foo() { ... }

template <> void foo<float, -7, true>();

The value 3 would be returned from this call.

Wraps the C function clang_Cursor_getNumTemplateArguments.

func (Cursor) ObjCDeclQualifiers 

func (c Cursor) ObjCDeclQualifiers() uint32

Given a cursor that represents an Objective-C method or parameter declaration, return the associated Objective-C qualifiers for the return type or the parameter respectively. The bits are formed from CXObjCDeclQualifierKind.

Wraps the C function clang_Cursor_getObjCDeclQualifiers.

func (Cursor) ObjCManglings 

func (p0 Cursor) ObjCManglings() *StringSet

Retrieve the CXStrings representing the mangled symbols of the ObjC class interface or implementation at the cursor.

Wraps the C function clang_Cursor_getObjCManglings.

func (Cursor) ObjCPropertyAttributes 

func (c Cursor) ObjCPropertyAttributes(reserved uint32) uint32

Given a cursor that represents a property declaration, return the associated property attributes. The bits are formed from CXObjCPropertyAttrKind.

Wraps the C function clang_Cursor_getObjCPropertyAttributes.

func (Cursor) ObjCPropertyGetterName 

func (c Cursor) ObjCPropertyGetterName() string

Given a cursor that represents a property declaration, return the name of the method that implements the getter.

Wraps the C function clang_Cursor_getObjCPropertyGetterName.

func (Cursor) ObjCPropertySetterName 

func (c Cursor) ObjCPropertySetterName() string

Given a cursor that represents a property declaration, return the name of the method that implements the setter, if any.

Wraps the C function clang_Cursor_getObjCPropertySetterName.

func (Cursor) ObjCSelectorIndex 

func (p0 Cursor) ObjCSelectorIndex() int32

If the cursor points to a selector identifier in an Objective-C method or message expression, this returns the selector index.

After getting a cursor with #clang_getCursor, this can be called to determine if the location points to a selector identifier.

Wraps the C function clang_Cursor_getObjCSelectorIndex.

func (Cursor) OffsetOfBase 

func (parent Cursor) OffsetOfBase(base Cursor) int64

Returns the offset in bits of a CX_CXXBaseSpecifier relative to the parent class.

Returns a small negative number if the offset cannot be computed. See CXTypeLayoutError for error codes.

Wraps the C function clang_getOffsetOfBase.

func (Cursor) OffsetOfField 

func (c Cursor) OffsetOfField() int64

Return the offset of the field represented by the Cursor.

If the cursor is not a field declaration, -1 is returned. If the cursor semantic parent is not a record field declaration, CXTypeLayoutError_Invalid is returned. If the field's type declaration is an incomplete type, CXTypeLayoutError_Incomplete is returned. If the field's type declaration is a dependent type, CXTypeLayoutError_Dependent is returned. If the field's name S is not found, CXTypeLayoutError_InvalidFieldName is returned.

Wraps the C function clang_Cursor_getOffsetOfField.

func (Cursor) OverloadedDecl 

func (cursor Cursor) OverloadedDecl(index uint32) Cursor

Retrieve a cursor for one of the overloaded declarations referenced by a CXCursor_OverloadedDeclRef cursor.

Wraps the C function clang_getOverloadedDecl.

func (Cursor) ParsedComment 

func (c Cursor) ParsedComment() Comment

Given a cursor that represents a documentable entity (e.g., declaration), return the associated parsed comment as a CXComment_FullComment AST node.

Wraps the C function clang_Cursor_getParsedComment.

func (Cursor) RawCommentText 

func (c Cursor) RawCommentText() string

Given a cursor that represents a declaration, return the associated comment text, including comment markers.

Wraps the C function clang_Cursor_getRawCommentText.

func (Cursor) ReceiverType 

func (c Cursor) ReceiverType() Type

Given a cursor pointing to an Objective-C message or property reference, or C++ method call, returns the CXType of the receiver.

Wraps the C function clang_Cursor_getReceiverType.

func (Cursor) SpecializedCursorTemplate 

func (c Cursor) SpecializedCursorTemplate() Cursor

Given a cursor that may represent a specialization or instantiation of a template, retrieve the cursor that represents the template that it specializes or from which it was instantiated.

This routine determines the template involved both for explicit specializations of templates and for implicit instantiations of the template, both of which are referred to as "specializations". For a class template specialization (e.g., std::vector<bool>), this routine will return either the primary template (std::vector) or, if the specialization was instantiated from a class template partial specialization, the class template partial specialization. For a class template partial specialization and a function template specialization (including instantiations), this this routine will return the specialized template.

For members of a class template (e.g., member functions, member classes, or static data members), returns the specialized or instantiated member. Although not strictly "templates" in the C++ language, members of class templates have the same notions of specializations and instantiations that templates do, so this routine treats them similarly.

Wraps the C function clang_getSpecializedCursorTemplate.

func (Cursor) SpellingNameRange 

func (p0 Cursor) SpellingNameRange(pieceIndex uint32, options uint32) SourceRange

Retrieve a range for a piece that forms the cursors spelling name. Most of the times there is only one range for the complete spelling but for Objective-C methods and Objective-C message expressions, there are multiple pieces for each selector identifier.

Wraps the C function clang_Cursor_getSpellingNameRange.

func (Cursor) StorageClass 

func (p0 Cursor) StorageClass() StorageClass

Returns the storage class for a function or variable declaration.

If the passed in Cursor is not a function or variable declaration, CX_SC_Invalid is returned else the storage class.

Wraps the C function clang_Cursor_getStorageClass.

func (Cursor) SymbolGraphForCursor 

func (cursor Cursor) SymbolGraphForCursor() string

Generate a single symbol symbol graph for the declaration at the given cursor. Returns a null string if the AST node for the cursor isn't a declaration.

The output contains the symbol graph as well as some additional information about related symbols.

Wraps the C function clang_getSymbolGraphForCursor.

func (Cursor) TemplateArgumentKind 

func (c Cursor) TemplateArgumentKind(i uint32) TemplateArgumentKind

Retrieve the kind of the I'th template argument of the CXCursor C.

If the argument CXCursor does not represent a FunctionDecl, StructDecl, or ClassTemplatePartialSpecialization, an invalid template argument kind is returned.

For example, for the following declaration and specialization: template <typename T, int kInt, bool kBool> void foo() { ... }

template <> void foo<float, -7, true>();

For I = 0, 1, and 2, Type, Integral, and Integral will be returned, respectively.

Wraps the C function clang_Cursor_getTemplateArgumentKind.

func (Cursor) TemplateArgumentType 

func (c Cursor) TemplateArgumentType(i uint32) Type

Retrieve a CXType representing the type of a TemplateArgument of a function decl representing a template specialization.

If the argument CXCursor does not represent a FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization whose I'th template argument has a kind of CXTemplateArgKind_Integral, an invalid type is returned.

For example, for the following declaration and specialization: template <typename T, int kInt, bool kBool> void foo() { ... }

template <> void foo<float, -7, true>();

If called with I = 0, "float", will be returned. Invalid types will be returned for I == 1 or 2.

Wraps the C function clang_Cursor_getTemplateArgumentType.

func (Cursor) TemplateArgumentUnsignedValue 

func (c Cursor) TemplateArgumentUnsignedValue(i uint32) uint64

Retrieve the value of an Integral TemplateArgument (of a function decl representing a template specialization) as an unsigned long long.

It is undefined to call this function on a CXCursor that does not represent a FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization or whose I'th template argument is not an integral value.

For example, for the following declaration and specialization: template <typename T, int kInt, bool kBool> void foo() { ... }

template <> void foo<float, 2147483649, true>();

If called with I = 1 or 2, 2147483649 or true will be returned, respectively. For I == 0, this function's behavior is undefined.

Wraps the C function clang_Cursor_getTemplateArgumentUnsignedValue.

func (Cursor) TemplateArgumentValue 

func (c Cursor) TemplateArgumentValue(i uint32) int64

Retrieve the value of an Integral TemplateArgument (of a function decl representing a template specialization) as a signed long long.

It is undefined to call this function on a CXCursor that does not represent a FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization whose I'th template argument is not an integral value.

For example, for the following declaration and specialization: template <typename T, int kInt, bool kBool> void foo() { ... }

template <> void foo<float, -7, true>();

If called with I = 1 or 2, -7 or true will be returned, respectively. For I == 0, this function's behavior is undefined.

Wraps the C function clang_Cursor_getTemplateArgumentValue.

func (Cursor) TemplateCursorKind 

func (c Cursor) TemplateCursorKind() CursorKind

Given a cursor that represents a template, determine the cursor kind of the specializations would be generated by instantiating the template.

This routine can be used to determine what flavor of function template, class template, or class template partial specialization is stored in the cursor. For example, it can describe whether a class template cursor is declared with "struct", "class" or "union".

Wraps the C function clang_getTemplateCursorKind.

func (Cursor) TranslationUnit 

func (p0 Cursor) TranslationUnit() TranslationUnit

Returns the translation unit that a cursor originated from.

Wraps the C function clang_Cursor_getTranslationUnit.

func (Cursor) TypedefDeclUnderlyingType 

func (c Cursor) TypedefDeclUnderlyingType() Type

Retrieve the underlying type of a typedef declaration.

If the cursor does not reference a typedef declaration, an invalid type is returned.

Wraps the C function clang_getTypedefDeclUnderlyingType.

func (Cursor) VarDeclInitializer 

func (cursor Cursor) VarDeclInitializer() Cursor

If cursor refers to a variable declaration and it has initializer returns cursor referring to the initializer otherwise return null cursor.

Wraps the C function clang_Cursor_getVarDeclInitializer.

func (Cursor) VisitChildren 

func (parent Cursor) VisitChildren(visitor func(
	cursor Cursor, parent Cursor,
) ChildVisitResult) uint32

Visit the children of a particular cursor.

This function visits all the direct children of the given cursor, invoking the given visitor function with the cursors of each visited child. The traversal may be recursive, if the visitor returns CXChildVisit_Recurse. The traversal may also be ended prematurely, if the visitor returns CXChildVisit_Break.

func (Cursor) VisitChildrenWithBlock 

func (parent Cursor) VisitChildrenWithBlock(block CursorVisitorBlock) uint32

Visits the children of a cursor using the specified block. Behaves identically to clang_visitChildren() in all other respects.

Wraps the C function clang_visitChildrenWithBlock.

func (Cursor) XAccessSpecifier 

func (p0 Cursor) XAccessSpecifier() CXXAccessSpecifier

Returns the access control level for the referenced object.

If the cursor refers to a C++ declaration, its access control level within its parent scope is returned. Otherwise, if the cursor refers to a base specifier or access specifier, the specifier itself is returned.

Wraps the C function clang_getCXXAccessSpecifier.

func (Cursor) XConstructor_isConvertingConstructor 

func (c Cursor) XConstructor_isConvertingConstructor() uint32

Determine if a C++ constructor is a converting constructor.

Wraps the C function clang_CXXConstructor_isConvertingConstructor.

func (Cursor) XConstructor_isCopyConstructor 

func (c Cursor) XConstructor_isCopyConstructor() uint32

Determine if a C++ constructor is a copy constructor.

Wraps the C function clang_CXXConstructor_isCopyConstructor.

func (Cursor) XConstructor_isDefaultConstructor 

func (c Cursor) XConstructor_isDefaultConstructor() uint32

Determine if a C++ constructor is the default constructor.

Wraps the C function clang_CXXConstructor_isDefaultConstructor.

func (Cursor) XConstructor_isMoveConstructor 

func (c Cursor) XConstructor_isMoveConstructor() uint32

Determine if a C++ constructor is a move constructor.

Wraps the C function clang_CXXConstructor_isMoveConstructor.

func (Cursor) XField_isMutable 

func (c Cursor) XField_isMutable() uint32

Determine if a C++ field is declared 'mutable'.

Wraps the C function clang_CXXField_isMutable.

func (Cursor) XManglings 

func (p0 Cursor) XManglings() *StringSet

Retrieve the CXStrings representing the mangled symbols of the C++ constructor or destructor at the cursor.

Wraps the C function clang_Cursor_getCXXManglings.

func (Cursor) XMethod_isConst 

func (c Cursor) XMethod_isConst() uint32

Determine if a C++ member function or member function template is declared 'const'.

Wraps the C function clang_CXXMethod_isConst.

func (Cursor) XMethod_isCopyAssignmentOperator 

func (c Cursor) XMethod_isCopyAssignmentOperator() uint32

Determine if a C++ member function is a copy-assignment operator, returning 1 if such is the case and 0 otherwise.

> A copy-assignment operator `X::operator=` is a non-static, > non-template member function of _class_ `X` with exactly one > parameter of type `X`, `X&`, `const X&`, `volatile X&` or `const > volatile X&`.

That is, for example, the `operator=` in:

class Foo { bool operator=(const volatile Foo&); };

Is a copy-assignment operator, while the `operator=` in:

class Bar { bool operator=(const int&); };

Is not.

Wraps the C function clang_CXXMethod_isCopyAssignmentOperator.

func (Cursor) XMethod_isDefaulted 

func (c Cursor) XMethod_isDefaulted() uint32

Determine if a C++ method is declared '= default'.

Wraps the C function clang_CXXMethod_isDefaulted.

func (Cursor) XMethod_isDeleted 

func (c Cursor) XMethod_isDeleted() uint32

Determine if a C++ method is declared '= delete'.

Wraps the C function clang_CXXMethod_isDeleted.

func (Cursor) XMethod_isExplicit 

func (c Cursor) XMethod_isExplicit() uint32

Determines if a C++ constructor or conversion function was declared explicit, returning 1 if such is the case and 0 otherwise.

Constructors or conversion functions are declared explicit through the use of the explicit specifier.

For example, the following constructor and conversion function are not explicit as they lack the explicit specifier:

class Foo { Foo(); operator int(); };

While the following constructor and conversion function are explicit as they are declared with the explicit specifier.

class Foo { explicit Foo(); explicit operator int(); };

This function will return 0 when given a cursor pointing to one of the former declarations and it will return 1 for a cursor pointing to the latter declarations.

The explicit specifier allows the user to specify a conditional compile-time expression whose value decides whether the marked element is explicit or not.

For example:

constexpr bool foo(int i) { return i % 2 == 0; }

class Foo { explicit(foo(1)) Foo(); explicit(foo(2)) operator int(); }

This function will return 0 for the constructor and 1 for the conversion function.

Wraps the C function clang_CXXMethod_isExplicit.

func (Cursor) XMethod_isMoveAssignmentOperator 

func (c Cursor) XMethod_isMoveAssignmentOperator() uint32

Determine if a C++ member function is a move-assignment operator, returning 1 if such is the case and 0 otherwise.

> A move-assignment operator `X::operator=` is a non-static, > non-template member function of _class_ `X` with exactly one > parameter of type `X&&`, `const X&&`, `volatile X&&` or `const > volatile X&&`.

That is, for example, the `operator=` in:

class Foo { bool operator=(const volatile Foo&&); };

Is a move-assignment operator, while the `operator=` in:

class Bar { bool operator=(const int&&); };

Is not.

Wraps the C function clang_CXXMethod_isMoveAssignmentOperator.

func (Cursor) XMethod_isPureVirtual 

func (c Cursor) XMethod_isPureVirtual() uint32

Determine if a C++ member function or member function template is pure virtual.

Wraps the C function clang_CXXMethod_isPureVirtual.

func (Cursor) XMethod_isStatic 

func (c Cursor) XMethod_isStatic() uint32

Determine if a C++ member function or member function template is declared 'static'.

Wraps the C function clang_CXXMethod_isStatic.

func (Cursor) XMethod_isVirtual 

func (c Cursor) XMethod_isVirtual() uint32

Determine if a C++ member function or member function template is explicitly declared 'virtual' or if it overrides a virtual method from one of the base classes.

Wraps the C function clang_CXXMethod_isVirtual.

func (Cursor) XRecord_isAbstract 

func (c Cursor) XRecord_isAbstract() uint32

Determine if a C++ record is abstract, i.e. whether a class or struct has a pure virtual member function.

Wraps the C function clang_CXXRecord_isAbstract.

type CursorAndRangeVisitor 

type CursorAndRangeVisitor struct {
	// contains filtered or unexported fields
}

Represents the C struct CXCursorAndRangeVisitor.

type CursorAndRangeVisitorBlock 

type CursorAndRangeVisitorBlock struct {
	// contains filtered or unexported fields
}

Represents the C type CXCursorAndRangeVisitorBlock.

type CursorKind 

type CursorKind uint32

Describes the kind of entity that a cursor refers to.

Represents the C enum CXCursorKind. 

const (
	/*
	   A declaration whose specific kind is not exposed via this interface.

	   Unexposed declarations have the same operations as any other kind of declaration; one can extract their location information, spelling, find their definitions, etc. However, the specific kind of the declaration is not reported.
	*/
	Cursor_UnexposedDecl CursorKind = 1
	// A C or C++ struct.
	Cursor_StructDecl CursorKind = 2
	// A C or C++ union.
	Cursor_UnionDecl CursorKind = 3
	// A C++ class.
	Cursor_ClassDecl CursorKind = 4
	// An enumeration.
	Cursor_EnumDecl CursorKind = 5
	// A field (in C) or non-static data member (in C++) in a struct, union, or C++ class.
	Cursor_FieldDecl CursorKind = 6
	// An enumerator constant.
	Cursor_EnumConstantDecl CursorKind = 7
	// A function.
	Cursor_FunctionDecl CursorKind = 8
	// A variable.
	Cursor_VarDecl CursorKind = 9
	// A function or method parameter.
	Cursor_ParmDecl CursorKind = 10
	// An Objective-C @interface.
	Cursor_ObjCInterfaceDecl CursorKind = 11
	// An Objective-C @interface for a category.
	Cursor_ObjCCategoryDecl CursorKind = 12
	// An Objective-C @protocol declaration.
	Cursor_ObjCProtocolDecl CursorKind = 13
	// An Objective-C @property declaration.
	Cursor_ObjCPropertyDecl CursorKind = 14
	// An Objective-C instance variable.
	Cursor_ObjCIvarDecl CursorKind = 15
	// An Objective-C instance method.
	Cursor_ObjCInstanceMethodDecl CursorKind = 16
	// An Objective-C class method.
	Cursor_ObjCClassMethodDecl CursorKind = 17
	// An Objective-C @implementation.
	Cursor_ObjCImplementationDecl CursorKind = 18
	// An Objective-C @implementation for a category.
	Cursor_ObjCCategoryImplDecl CursorKind = 19
	// A typedef.
	Cursor_TypedefDecl CursorKind = 20
	// A C++ class method.
	Cursor_CXXMethod CursorKind = 21
	// A C++ namespace.
	Cursor_Namespace CursorKind = 22
	// A linkage specification, e.g. 'extern "C"'.
	Cursor_LinkageSpec CursorKind = 23
	// A C++ constructor.
	Cursor_Constructor CursorKind = 24
	// A C++ destructor.
	Cursor_Destructor CursorKind = 25
	// A C++ conversion function.
	Cursor_ConversionFunction CursorKind = 26
	// A C++ template type parameter.
	Cursor_TemplateTypeParameter CursorKind = 27
	// A C++ non-type template parameter.
	Cursor_NonTypeTemplateParameter CursorKind = 28
	// A C++ template template parameter.
	Cursor_TemplateTemplateParameter CursorKind = 29
	// A C++ function template.
	Cursor_FunctionTemplate CursorKind = 30
	// A C++ class template.
	Cursor_ClassTemplate CursorKind = 31
	// A C++ class template partial specialization.
	Cursor_ClassTemplatePartialSpecialization CursorKind = 32
	// A C++ namespace alias declaration.
	Cursor_NamespaceAlias CursorKind = 33
	// A C++ using directive.
	Cursor_UsingDirective CursorKind = 34
	// A C++ using declaration.
	Cursor_UsingDeclaration CursorKind = 35
	// A C++ alias declaration
	Cursor_TypeAliasDecl CursorKind = 36
	// An Objective-C @synthesize definition.
	Cursor_ObjCSynthesizeDecl CursorKind = 37
	// An Objective-C @dynamic definition.
	Cursor_ObjCDynamicDecl CursorKind = 38
	// An access specifier.
	Cursor_CXXAccessSpecifier CursorKind = 39
	// An access specifier.
	Cursor_FirstDecl CursorKind = 1
	// An access specifier.
	Cursor_LastDecl CursorKind = 39
	// An access specifier.
	Cursor_FirstRef CursorKind = 40
	// An access specifier.
	Cursor_ObjCSuperClassRef CursorKind = 40
	// An access specifier.
	Cursor_ObjCProtocolRef CursorKind = 41
	// An access specifier.
	Cursor_ObjCClassRef CursorKind = 42
	/*
	   A reference to a type declaration.

	   A type reference occurs anywhere where a type is named but not declared. For example, given:

	   The typedef is a declaration of size_type (CXCursor_TypedefDecl), while the type of the variable "size" is referenced. The cursor referenced by the type of size is the typedef for size_type.
	*/
	Cursor_TypeRef CursorKind = 43
	/*
	   A reference to a type declaration.

	   A type reference occurs anywhere where a type is named but not declared. For example, given:

	   The typedef is a declaration of size_type (CXCursor_TypedefDecl), while the type of the variable "size" is referenced. The cursor referenced by the type of size is the typedef for size_type.
	*/
	Cursor_CXXBaseSpecifier CursorKind = 44
	// A reference to a class template, function template, template template parameter, or class template partial specialization.
	Cursor_TemplateRef CursorKind = 45
	// A reference to a namespace or namespace alias.
	Cursor_NamespaceRef CursorKind = 46
	// A reference to a member of a struct, union, or class that occurs in some non-expression context, e.g., a designated initializer.
	Cursor_MemberRef CursorKind = 47
	/*
	   A reference to a labeled statement.

	   This cursor kind is used to describe the jump to "start_over" in the goto statement in the following example:

	   A label reference cursor refers to a label statement.
	*/
	Cursor_LabelRef CursorKind = 48
	/*
	   A reference to a set of overloaded functions or function templates that has not yet been resolved to a specific function or function template.

	   An overloaded declaration reference cursor occurs in C++ templates where a dependent name refers to a function. For example:

	   Here, the identifier "swap" is associated with an overloaded declaration reference. In the template definition, "swap" refers to either of the two "swap" functions declared above, so both results will be available. At instantiation time, "swap" may also refer to other functions found via argument-dependent lookup (e.g., the "swap" function at the end of the example).

	   The functions clang_getNumOverloadedDecls() and clang_getOverloadedDecl() can be used to retrieve the definitions referenced by this cursor.
	*/
	Cursor_OverloadedDeclRef CursorKind = 49
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_VariableRef CursorKind = 50
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_LastRef CursorKind = 50
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_FirstInvalid CursorKind = 70
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_InvalidFile CursorKind = 70
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_NoDeclFound CursorKind = 71
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_NotImplemented CursorKind = 72
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_InvalidCode CursorKind = 73
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_LastInvalid CursorKind = 73
	// A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.
	Cursor_FirstExpr CursorKind = 100
	/*
	   An expression whose specific kind is not exposed via this interface.

	   Unexposed expressions have the same operations as any other kind of expression; one can extract their location information, spelling, children, etc. However, the specific kind of the expression is not reported.
	*/
	Cursor_UnexposedExpr CursorKind = 100
	// An expression that refers to some value declaration, such as a function, variable, or enumerator.
	Cursor_DeclRefExpr CursorKind = 101
	// An expression that refers to a member of a struct, union, class, Objective-C class, etc.
	Cursor_MemberRefExpr CursorKind = 102
	// An expression that calls a function.
	Cursor_CallExpr CursorKind = 103
	// An expression that sends a message to an Objective-C   object or class.
	Cursor_ObjCMessageExpr CursorKind = 104
	// An expression that represents a block literal.
	Cursor_BlockExpr CursorKind = 105
	// An integer literal.
	Cursor_IntegerLiteral CursorKind = 106
	// A floating point number literal.
	Cursor_FloatingLiteral CursorKind = 107
	// An imaginary number literal.
	Cursor_ImaginaryLiteral CursorKind = 108
	// A string literal.
	Cursor_StringLiteral CursorKind = 109
	// A character literal.
	Cursor_CharacterLiteral CursorKind = 110
	/*
	   A parenthesized expression, e.g. "(1)".

	   This AST node is only formed if full location information is requested.
	*/
	Cursor_ParenExpr CursorKind = 111
	// This represents the unary-expression's (except sizeof and alignof).
	Cursor_UnaryOperator CursorKind = 112
	// [C99 6.5.2.1] Array Subscripting.
	Cursor_ArraySubscriptExpr CursorKind = 113
	// A builtin binary operation expression such as "x + y" or "x <= y".
	Cursor_BinaryOperator CursorKind = 114
	// Compound assignment such as "+=".
	Cursor_CompoundAssignOperator CursorKind = 115
	// The ?: ternary operator.
	Cursor_ConditionalOperator CursorKind = 116
	/*
	   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.

	   For example: (int)f.
	*/
	Cursor_CStyleCastExpr CursorKind = 117
	// [C99 6.5.2.5]
	Cursor_CompoundLiteralExpr CursorKind = 118
	// Describes an C or C++ initializer list.
	Cursor_InitListExpr CursorKind = 119
	// The GNU address of label extension, representing &&label.
	Cursor_AddrLabelExpr CursorKind = 120
	// This is the GNU Statement Expression extension: ({int X=4; X;})
	Cursor_StmtExpr CursorKind = 121
	// Represents a C11 generic selection.
	Cursor_GenericSelectionExpr CursorKind = 122
	/*
	   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.

	   The __null extension is typically only used by system headers, which define NULL as __null in C++ rather than using 0 (which is an integer that may not match the size of a pointer).
	*/
	Cursor_GNUNullExpr CursorKind = 123
	// C++'s static_cast<> expression.
	Cursor_CXXStaticCastExpr CursorKind = 124
	// C++'s dynamic_cast<> expression.
	Cursor_CXXDynamicCastExpr CursorKind = 125
	// C++'s reinterpret_cast<> expression.
	Cursor_CXXReinterpretCastExpr CursorKind = 126
	// C++'s const_cast<> expression.
	Cursor_CXXConstCastExpr CursorKind = 127
	/*
	   Represents an explicit C++ type conversion that uses "functional" notion (C++ [expr.type.conv]).

	   Example:
	*/
	Cursor_CXXFunctionalCastExpr CursorKind = 128
	// A C++ typeid expression (C++ [expr.typeid]).
	Cursor_CXXTypeidExpr CursorKind = 129
	// [C++ 2.13.5] C++ Boolean Literal.
	Cursor_CXXBoolLiteralExpr CursorKind = 130
	// [C++0x 2.14.7] C++ Pointer Literal.
	Cursor_CXXNullPtrLiteralExpr CursorKind = 131
	// Represents the "this" expression in C++
	Cursor_CXXThisExpr CursorKind = 132
	/*
	   [C++ 15] C++ Throw Expression.

	   This handles 'throw' and 'throw' assignment-expression. When assignment-expression isn't present, Op will be null.
	*/
	Cursor_CXXThrowExpr CursorKind = 133
	// A new expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
	Cursor_CXXNewExpr CursorKind = 134
	// A delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray".
	Cursor_CXXDeleteExpr CursorKind = 135
	// A unary expression. (noexcept, sizeof, or other traits)
	Cursor_UnaryExpr CursorKind = 136
	// An Objective-C string literal i.e. "foo".
	Cursor_ObjCStringLiteral CursorKind = 137
	// An Objective-C @encode expression.
	Cursor_ObjCEncodeExpr CursorKind = 138
	// An Objective-C @selector expression.
	Cursor_ObjCSelectorExpr CursorKind = 139
	// An Objective-C @protocol expression.
	Cursor_ObjCProtocolExpr CursorKind = 140
	// An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process.
	Cursor_ObjCBridgedCastExpr CursorKind = 141
	/*
	   Represents a C++0x pack expansion that produces a sequence of expressions.

	   A pack expansion expression contains a pattern (which itself is an expression) followed by an ellipsis. For example:
	*/
	Cursor_PackExpansionExpr CursorKind = 142
	// Represents an expression that computes the length of a parameter pack.
	Cursor_SizeOfPackExpr CursorKind = 143
	Cursor_LambdaExpr     CursorKind = 144
	// Objective-c Boolean Literal.
	Cursor_ObjCBoolLiteralExpr CursorKind = 145
	// Represents the "self" expression in an Objective-C method.
	Cursor_ObjCSelfExpr CursorKind = 146
	// OpenMP 5.0 [2.1.5, Array Section]. OpenACC 3.3 [2.7.1, Data Specification for Data Clauses (Sub Arrays)]
	Cursor_ArraySectionExpr CursorKind = 147
	// Represents an (...) check.
	Cursor_ObjCAvailabilityCheckExpr CursorKind = 148
	// Fixed point literal
	Cursor_FixedPointLiteral CursorKind = 149
	// OpenMP 5.0 [2.1.4, Array Shaping].
	Cursor_OMPArrayShapingExpr CursorKind = 150
	// OpenMP 5.0 [2.1.6 Iterators]
	Cursor_OMPIteratorExpr CursorKind = 151
	// OpenCL's addrspace_cast<> expression.
	Cursor_CXXAddrspaceCastExpr CursorKind = 152
	// Expression that references a C++20 concept.
	Cursor_ConceptSpecializationExpr CursorKind = 153
	// Expression that references a C++20 requires expression.
	Cursor_RequiresExpr CursorKind = 154
	// Expression that references a C++20 parenthesized list aggregate initializer.
	Cursor_CXXParenListInitExpr CursorKind = 155
	// Represents a C++26 pack indexing expression.
	Cursor_PackIndexingExpr CursorKind = 156
	// Represents a C++26 pack indexing expression.
	Cursor_LastExpr CursorKind = 156
	// Represents a C++26 pack indexing expression.
	Cursor_FirstStmt CursorKind = 200
	/*
	   A statement whose specific kind is not exposed via this interface.

	   Unexposed statements have the same operations as any other kind of statement; one can extract their location information, spelling, children, etc. However, the specific kind of the statement is not reported.
	*/
	Cursor_UnexposedStmt CursorKind = 200
	/*
	   A labelled statement in a function.

	   This cursor kind is used to describe the "start_over:" label statement in the following example:
	*/
	Cursor_LabelStmt CursorKind = 201
	/*
	   A group of statements like { stmt stmt }.

	   This cursor kind is used to describe compound statements, e.g. function bodies.
	*/
	Cursor_CompoundStmt CursorKind = 202
	// A case statement.
	Cursor_CaseStmt CursorKind = 203
	// A default statement.
	Cursor_DefaultStmt CursorKind = 204
	// An if statement
	Cursor_IfStmt CursorKind = 205
	// A switch statement.
	Cursor_SwitchStmt CursorKind = 206
	// A while statement.
	Cursor_WhileStmt CursorKind = 207
	// A do statement.
	Cursor_DoStmt CursorKind = 208
	// A for statement.
	Cursor_ForStmt CursorKind = 209
	// A goto statement.
	Cursor_GotoStmt CursorKind = 210
	// An indirect goto statement.
	Cursor_IndirectGotoStmt CursorKind = 211
	// A continue statement.
	Cursor_ContinueStmt CursorKind = 212
	// A break statement.
	Cursor_BreakStmt CursorKind = 213
	// A return statement.
	Cursor_ReturnStmt CursorKind = 214
	// A GCC inline assembly statement extension.
	Cursor_GCCAsmStmt CursorKind = 215
	// A GCC inline assembly statement extension.
	Cursor_AsmStmt CursorKind = 215
	// Objective-C's overall @try-@catch-@finally statement.
	Cursor_ObjCAtTryStmt CursorKind = 216
	// Objective-C's @catch statement.
	Cursor_ObjCAtCatchStmt CursorKind = 217
	// Objective-C's @finally statement.
	Cursor_ObjCAtFinallyStmt CursorKind = 218
	// Objective-C's @throw statement.
	Cursor_ObjCAtThrowStmt CursorKind = 219
	// Objective-C's @synchronized statement.
	Cursor_ObjCAtSynchronizedStmt CursorKind = 220
	// Objective-C's autorelease pool statement.
	Cursor_ObjCAutoreleasePoolStmt CursorKind = 221
	// Objective-C's collection statement.
	Cursor_ObjCForCollectionStmt CursorKind = 222
	// C++'s catch statement.
	Cursor_CXXCatchStmt CursorKind = 223
	// C++'s try statement.
	Cursor_CXXTryStmt CursorKind = 224
	// C++'s for (* : *) statement.
	Cursor_CXXForRangeStmt CursorKind = 225
	// Windows Structured Exception Handling's try statement.
	Cursor_SEHTryStmt CursorKind = 226
	// Windows Structured Exception Handling's except statement.
	Cursor_SEHExceptStmt CursorKind = 227
	// Windows Structured Exception Handling's finally statement.
	Cursor_SEHFinallyStmt CursorKind = 228
	// A MS inline assembly statement extension.
	Cursor_MSAsmStmt CursorKind = 229
	/*
	   The null statement ";": C99 6.8.3p3.

	   This cursor kind is used to describe the null statement.
	*/
	Cursor_NullStmt CursorKind = 230
	// Adaptor class for mixing declarations with statements and expressions.
	Cursor_DeclStmt CursorKind = 231
	// OpenMP parallel directive.
	Cursor_OMPParallelDirective CursorKind = 232
	// OpenMP SIMD directive.
	Cursor_OMPSimdDirective CursorKind = 233
	// OpenMP for directive.
	Cursor_OMPForDirective CursorKind = 234
	// OpenMP sections directive.
	Cursor_OMPSectionsDirective CursorKind = 235
	// OpenMP section directive.
	Cursor_OMPSectionDirective CursorKind = 236
	// OpenMP single directive.
	Cursor_OMPSingleDirective CursorKind = 237
	// OpenMP parallel for directive.
	Cursor_OMPParallelForDirective CursorKind = 238
	// OpenMP parallel sections directive.
	Cursor_OMPParallelSectionsDirective CursorKind = 239
	// OpenMP task directive.
	Cursor_OMPTaskDirective CursorKind = 240
	// OpenMP master directive.
	Cursor_OMPMasterDirective CursorKind = 241
	// OpenMP critical directive.
	Cursor_OMPCriticalDirective CursorKind = 242
	// OpenMP taskyield directive.
	Cursor_OMPTaskyieldDirective CursorKind = 243
	// OpenMP barrier directive.
	Cursor_OMPBarrierDirective CursorKind = 244
	// OpenMP taskwait directive.
	Cursor_OMPTaskwaitDirective CursorKind = 245
	// OpenMP flush directive.
	Cursor_OMPFlushDirective CursorKind = 246
	// Windows Structured Exception Handling's leave statement.
	Cursor_SEHLeaveStmt CursorKind = 247
	// OpenMP ordered directive.
	Cursor_OMPOrderedDirective CursorKind = 248
	// OpenMP atomic directive.
	Cursor_OMPAtomicDirective CursorKind = 249
	// OpenMP for SIMD directive.
	Cursor_OMPForSimdDirective CursorKind = 250
	// OpenMP parallel for SIMD directive.
	Cursor_OMPParallelForSimdDirective CursorKind = 251
	// OpenMP target directive.
	Cursor_OMPTargetDirective CursorKind = 252
	// OpenMP teams directive.
	Cursor_OMPTeamsDirective CursorKind = 253
	// OpenMP taskgroup directive.
	Cursor_OMPTaskgroupDirective CursorKind = 254
	// OpenMP cancellation point directive.
	Cursor_OMPCancellationPointDirective CursorKind = 255
	// OpenMP cancel directive.
	Cursor_OMPCancelDirective CursorKind = 256
	// OpenMP target data directive.
	Cursor_OMPTargetDataDirective CursorKind = 257
	// OpenMP taskloop directive.
	Cursor_OMPTaskLoopDirective CursorKind = 258
	// OpenMP taskloop simd directive.
	Cursor_OMPTaskLoopSimdDirective CursorKind = 259
	// OpenMP distribute directive.
	Cursor_OMPDistributeDirective CursorKind = 260
	// OpenMP target enter data directive.
	Cursor_OMPTargetEnterDataDirective CursorKind = 261
	// OpenMP target exit data directive.
	Cursor_OMPTargetExitDataDirective CursorKind = 262
	// OpenMP target parallel directive.
	Cursor_OMPTargetParallelDirective CursorKind = 263
	// OpenMP target parallel for directive.
	Cursor_OMPTargetParallelForDirective CursorKind = 264
	// OpenMP target update directive.
	Cursor_OMPTargetUpdateDirective CursorKind = 265
	// OpenMP distribute parallel for directive.
	Cursor_OMPDistributeParallelForDirective CursorKind = 266
	// OpenMP distribute parallel for simd directive.
	Cursor_OMPDistributeParallelForSimdDirective CursorKind = 267
	// OpenMP distribute simd directive.
	Cursor_OMPDistributeSimdDirective CursorKind = 268
	// OpenMP target parallel for simd directive.
	Cursor_OMPTargetParallelForSimdDirective CursorKind = 269
	// OpenMP target simd directive.
	Cursor_OMPTargetSimdDirective CursorKind = 270
	// OpenMP teams distribute directive.
	Cursor_OMPTeamsDistributeDirective CursorKind = 271
	// OpenMP teams distribute simd directive.
	Cursor_OMPTeamsDistributeSimdDirective CursorKind = 272
	// OpenMP teams distribute parallel for simd directive.
	Cursor_OMPTeamsDistributeParallelForSimdDirective CursorKind = 273
	// OpenMP teams distribute parallel for directive.
	Cursor_OMPTeamsDistributeParallelForDirective CursorKind = 274
	// OpenMP target teams directive.
	Cursor_OMPTargetTeamsDirective CursorKind = 275
	// OpenMP target teams distribute directive.
	Cursor_OMPTargetTeamsDistributeDirective CursorKind = 276
	// OpenMP target teams distribute parallel for directive.
	Cursor_OMPTargetTeamsDistributeParallelForDirective CursorKind = 277
	// OpenMP target teams distribute parallel for simd directive.
	Cursor_OMPTargetTeamsDistributeParallelForSimdDirective CursorKind = 278
	// OpenMP target teams distribute simd directive.
	Cursor_OMPTargetTeamsDistributeSimdDirective CursorKind = 279
	// C++2a std::bit_cast expression.
	Cursor_BuiltinBitCastExpr CursorKind = 280
	// OpenMP master taskloop directive.
	Cursor_OMPMasterTaskLoopDirective CursorKind = 281
	// OpenMP parallel master taskloop directive.
	Cursor_OMPParallelMasterTaskLoopDirective CursorKind = 282
	// OpenMP master taskloop simd directive.
	Cursor_OMPMasterTaskLoopSimdDirective CursorKind = 283
	// OpenMP parallel master taskloop simd directive.
	Cursor_OMPParallelMasterTaskLoopSimdDirective CursorKind = 284
	// OpenMP parallel master directive.
	Cursor_OMPParallelMasterDirective CursorKind = 285
	// OpenMP depobj directive.
	Cursor_OMPDepobjDirective CursorKind = 286
	// OpenMP scan directive.
	Cursor_OMPScanDirective CursorKind = 287
	// OpenMP tile directive.
	Cursor_OMPTileDirective CursorKind = 288
	// OpenMP canonical loop.
	Cursor_OMPCanonicalLoop CursorKind = 289
	// OpenMP interop directive.
	Cursor_OMPInteropDirective CursorKind = 290
	// OpenMP dispatch directive.
	Cursor_OMPDispatchDirective CursorKind = 291
	// OpenMP masked directive.
	Cursor_OMPMaskedDirective CursorKind = 292
	// OpenMP unroll directive.
	Cursor_OMPUnrollDirective CursorKind = 293
	// OpenMP metadirective directive.
	Cursor_OMPMetaDirective CursorKind = 294
	// OpenMP loop directive.
	Cursor_OMPGenericLoopDirective CursorKind = 295
	// OpenMP teams loop directive.
	Cursor_OMPTeamsGenericLoopDirective CursorKind = 296
	// OpenMP target teams loop directive.
	Cursor_OMPTargetTeamsGenericLoopDirective CursorKind = 297
	// OpenMP parallel loop directive.
	Cursor_OMPParallelGenericLoopDirective CursorKind = 298
	// OpenMP target parallel loop directive.
	Cursor_OMPTargetParallelGenericLoopDirective CursorKind = 299
	// OpenMP parallel masked directive.
	Cursor_OMPParallelMaskedDirective CursorKind = 300
	// OpenMP masked taskloop directive.
	Cursor_OMPMaskedTaskLoopDirective CursorKind = 301
	// OpenMP masked taskloop simd directive.
	Cursor_OMPMaskedTaskLoopSimdDirective CursorKind = 302
	// OpenMP parallel masked taskloop directive.
	Cursor_OMPParallelMaskedTaskLoopDirective CursorKind = 303
	// OpenMP parallel masked taskloop simd directive.
	Cursor_OMPParallelMaskedTaskLoopSimdDirective CursorKind = 304
	// OpenMP error directive.
	Cursor_OMPErrorDirective CursorKind = 305
	// OpenMP scope directive.
	Cursor_OMPScopeDirective CursorKind = 306
	// OpenMP reverse directive.
	Cursor_OMPReverseDirective CursorKind = 307
	// OpenMP interchange directive.
	Cursor_OMPInterchangeDirective CursorKind = 308
	// OpenMP assume directive.
	Cursor_OMPAssumeDirective CursorKind = 309
	// OpenMP assume directive.
	Cursor_OMPStripeDirective CursorKind = 310
	// OpenMP fuse directive
	Cursor_OMPFuseDirective CursorKind = 311
	// OpenMP split directive.
	Cursor_OMPSplitDirective CursorKind = 312
	// OpenACC Compute Construct.
	Cursor_OpenACCComputeConstruct CursorKind = 320
	// OpenACC Loop Construct.
	Cursor_OpenACCLoopConstruct CursorKind = 321
	// OpenACC Combined Constructs.
	Cursor_OpenACCCombinedConstruct CursorKind = 322
	// OpenACC data Construct.
	Cursor_OpenACCDataConstruct CursorKind = 323
	// OpenACC enter data Construct.
	Cursor_OpenACCEnterDataConstruct CursorKind = 324
	// OpenACC exit data Construct.
	Cursor_OpenACCExitDataConstruct CursorKind = 325
	// OpenACC host_data Construct.
	Cursor_OpenACCHostDataConstruct CursorKind = 326
	// OpenACC wait Construct.
	Cursor_OpenACCWaitConstruct CursorKind = 327
	// OpenACC init Construct.
	Cursor_OpenACCInitConstruct CursorKind = 328
	// OpenACC shutdown Construct.
	Cursor_OpenACCShutdownConstruct CursorKind = 329
	// OpenACC set Construct.
	Cursor_OpenACCSetConstruct CursorKind = 330
	// OpenACC update Construct.
	Cursor_OpenACCUpdateConstruct CursorKind = 331
	// OpenACC atomic Construct.
	Cursor_OpenACCAtomicConstruct CursorKind = 332
	// OpenACC cache Construct.
	Cursor_OpenACCCacheConstruct CursorKind = 333
	// OpenACC cache Construct.
	Cursor_LastStmt CursorKind = 333
	/*
	   Cursor that represents the translation unit itself.

	   The translation unit cursor exists primarily to act as the root cursor for traversing the contents of a translation unit.
	*/
	Cursor_TranslationUnit CursorKind = 350
	/*
	   Cursor that represents the translation unit itself.

	   The translation unit cursor exists primarily to act as the root cursor for traversing the contents of a translation unit.
	*/
	Cursor_FirstAttr CursorKind = 400
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_UnexposedAttr CursorKind = 400
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_IBActionAttr CursorKind = 401
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_IBOutletAttr CursorKind = 402
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_IBOutletCollectionAttr CursorKind = 403
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_CXXFinalAttr CursorKind = 404
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_CXXOverrideAttr CursorKind = 405
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_AnnotateAttr CursorKind = 406
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_AsmLabelAttr CursorKind = 407
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_PackedAttr CursorKind = 408
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_PureAttr CursorKind = 409
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ConstAttr CursorKind = 410
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_NoDuplicateAttr CursorKind = 411
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_CUDAConstantAttr CursorKind = 412
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_CUDADeviceAttr CursorKind = 413
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_CUDAGlobalAttr CursorKind = 414
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_CUDAHostAttr CursorKind = 415
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_CUDASharedAttr CursorKind = 416
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_VisibilityAttr CursorKind = 417
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_DLLExport CursorKind = 418
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_DLLImport CursorKind = 419
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_NSReturnsRetained CursorKind = 420
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_NSReturnsNotRetained CursorKind = 421
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_NSReturnsAutoreleased CursorKind = 422
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_NSConsumesSelf CursorKind = 423
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_NSConsumed CursorKind = 424
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCException CursorKind = 425
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCNSObject CursorKind = 426
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCIndependentClass CursorKind = 427
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCPreciseLifetime CursorKind = 428
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCReturnsInnerPointer CursorKind = 429
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCRequiresSuper CursorKind = 430
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCRootClass CursorKind = 431
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCSubclassingRestricted CursorKind = 432
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCExplicitProtocolImpl CursorKind = 433
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCDesignatedInitializer CursorKind = 434
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCRuntimeVisible CursorKind = 435
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ObjCBoxable CursorKind = 436
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_FlagEnum CursorKind = 437
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_ConvergentAttr CursorKind = 438
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_WarnUnusedAttr CursorKind = 439
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_WarnUnusedResultAttr CursorKind = 440
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_AlignedAttr CursorKind = 441
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_LastAttr CursorKind = 441
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_PreprocessingDirective CursorKind = 500
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_MacroDefinition CursorKind = 501
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_MacroExpansion CursorKind = 502
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_MacroInstantiation CursorKind = 502
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_InclusionDirective CursorKind = 503
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_FirstPreprocessing CursorKind = 500
	// An attribute whose specific kind is not exposed via this interface.
	Cursor_LastPreprocessing CursorKind = 503
	// A module import declaration.
	Cursor_ModuleImportDecl CursorKind = 600
	// A module import declaration.
	Cursor_TypeAliasTemplateDecl CursorKind = 601
	// A static_assert or _Static_assert node
	Cursor_StaticAssert CursorKind = 602
	// a friend declaration.
	Cursor_FriendDecl CursorKind = 603
	// a concept declaration.
	Cursor_ConceptDecl CursorKind = 604
	// a concept declaration.
	Cursor_FirstExtraDecl CursorKind = 600
	// a concept declaration.
	Cursor_LastExtraDecl CursorKind = 604
	// A code completion overload candidate.
	Cursor_OverloadCandidate CursorKind = 700
)

func (CursorKind) CursorKindSpelling 

func (kind CursorKind) CursorKindSpelling() string

These routines are used for testing and debugging, only, and should not be relied upon.

@{

Wraps the C function clang_getCursorKindSpelling.

func (CursorKind) IsAttribute 

func (p0 CursorKind) IsAttribute() uint32

Determine whether the given cursor kind represents an attribute.

Wraps the C function clang_isAttribute.

func (CursorKind) IsDeclaration 

func (p0 CursorKind) IsDeclaration() uint32

Determine whether the given cursor kind represents a declaration.

Wraps the C function clang_isDeclaration.

func (CursorKind) IsExpression 

func (p0 CursorKind) IsExpression() uint32

Determine whether the given cursor kind represents an expression.

Wraps the C function clang_isExpression.

func (CursorKind) IsInvalid 

func (p0 CursorKind) IsInvalid() uint32

Determine whether the given cursor kind represents an invalid cursor.

Wraps the C function clang_isInvalid.

func (CursorKind) IsPreprocessing 

func (p0 CursorKind) IsPreprocessing() uint32

* Determine whether the given cursor represents a preprocessing element, such as a preprocessor directive or macro instantiation.

Wraps the C function clang_isPreprocessing.

func (CursorKind) IsReference 

func (p0 CursorKind) IsReference() uint32

Determine whether the given cursor kind represents a simple reference.

Note that other kinds of cursors (such as expressions) can also refer to other cursors. Use clang_getCursorReferenced() to determine whether a particular cursor refers to another entity.

Wraps the C function clang_isReference.

func (CursorKind) IsStatement 

func (p0 CursorKind) IsStatement() uint32

Determine whether the given cursor kind represents a statement.

Wraps the C function clang_isStatement.

func (CursorKind) IsTranslationUnit 

func (p0 CursorKind) IsTranslationUnit() uint32

Determine whether the given cursor kind represents a translation unit.

Wraps the C function clang_isTranslationUnit.

func (CursorKind) IsUnexposed 

func (p0 CursorKind) IsUnexposed() uint32

* Determine whether the given cursor represents a currently unexposed piece of the AST (e.g., CXCursor_UnexposedStmt).

Wraps the C function clang_isUnexposed.

type CursorSet 

type CursorSet struct {
	// contains filtered or unexported fields
}

A fast container representing a set of CXCursors.

Represents the C type CXCursorSet.

func CreateCXCursorSet 

func CreateCXCursorSet() CursorSet

Creates an empty CXCursorSet.

Wraps the C function clang_createCXCursorSet.

func (CursorSet) Contains 

func (cset CursorSet) Contains(cursor Cursor) uint32

Queries a CXCursorSet to see if it contains a specific CXCursor.

Wraps the C function clang_CXCursorSet_contains.

func (CursorSet) DisposeCXCursorSet 

func (cset CursorSet) DisposeCXCursorSet()

Disposes a CXCursorSet and releases its associated memory.

Wraps the C function clang_disposeCXCursorSet.

func (CursorSet) Insert 

func (cset CursorSet) Insert(cursor Cursor) uint32

Inserts a CXCursor into a CXCursorSet.

Wraps the C function clang_CXCursorSet_insert.

type CursorSetImpl 

type CursorSetImpl struct {
	// contains filtered or unexported fields
}

Represents the C struct CXCursorSetImpl.

type CursorVisitor 

type CursorVisitor struct {
	// contains filtered or unexported fields
}

Visitor invoked for each cursor found by a traversal.

This visitor function will be invoked for each cursor found by clang_visitCursorChildren(). Its first argument is the cursor being visited, its second argument is the parent visitor for that cursor, and its third argument is the client data provided to clang_visitCursorChildren().

The visitor should return one of the CXChildVisitResult values to direct clang_visitCursorChildren().

Represents the C type CXCursorVisitor.

type CursorVisitorBlock 

type CursorVisitorBlock struct {
	// contains filtered or unexported fields
}

Represents the C type CXCursorVisitorBlock.

type Cursor_ExceptionSpecificationKind 

type Cursor_ExceptionSpecificationKind uint32

Describes the exception specification of a cursor.

A negative value indicates that the cursor is not a function declaration.

Represents the C enum CXCursor_ExceptionSpecificationKind. 

const (
	// The cursor has no exception specification.
	Cursor_ExceptionSpecificationKind_None Cursor_ExceptionSpecificationKind = 0
	// The cursor has exception specification throw()
	Cursor_ExceptionSpecificationKind_DynamicNone Cursor_ExceptionSpecificationKind = 1
	// The cursor has exception specification throw(T1, T2)
	Cursor_ExceptionSpecificationKind_Dynamic Cursor_ExceptionSpecificationKind = 2
	// The cursor has exception specification throw(...).
	Cursor_ExceptionSpecificationKind_MSAny Cursor_ExceptionSpecificationKind = 3
	// The cursor has exception specification basic noexcept.
	Cursor_ExceptionSpecificationKind_BasicNoexcept Cursor_ExceptionSpecificationKind = 4
	// The cursor has exception specification computed noexcept.
	Cursor_ExceptionSpecificationKind_ComputedNoexcept Cursor_ExceptionSpecificationKind = 5
	// The exception specification has not yet been evaluated.
	Cursor_ExceptionSpecificationKind_Unevaluated Cursor_ExceptionSpecificationKind = 6
	// The exception specification has not yet been instantiated.
	Cursor_ExceptionSpecificationKind_Uninstantiated Cursor_ExceptionSpecificationKind = 7
	// The exception specification has not been parsed yet.
	Cursor_ExceptionSpecificationKind_Unparsed Cursor_ExceptionSpecificationKind = 8
	// The cursor has a __declspec(nothrow) exception specification.
	Cursor_ExceptionSpecificationKind_NoThrow Cursor_ExceptionSpecificationKind = 9
)

type Diagnostic 

type Diagnostic struct {
	// contains filtered or unexported fields
}

A single diagnostic, containing the diagnostic's severity, location, text, source ranges, and fix-it hints.

Represents the C type CXDiagnostic.

func (Diagnostic) ChildDiagnostics 

func (d Diagnostic) ChildDiagnostics() DiagnosticSet

Retrieve the child diagnostics of a CXDiagnostic.

This CXDiagnosticSet does not need to be released by clang_disposeDiagnosticSet.

Wraps the C function clang_getChildDiagnostics.

func (Diagnostic) DiagnosticCategory 

func (p0 Diagnostic) DiagnosticCategory() uint32

Retrieve the category number for this diagnostic.

Diagnostics can be categorized into groups along with other, related diagnostics (e.g., diagnostics under the same warning flag). This routine retrieves the category number for the given diagnostic.

Wraps the C function clang_getDiagnosticCategory.

func (Diagnostic) DiagnosticCategoryText 

func (p0 Diagnostic) DiagnosticCategoryText() string

Retrieve the diagnostic category text for a given diagnostic.

Wraps the C function clang_getDiagnosticCategoryText.

func (Diagnostic) DiagnosticFixIt 

func (diagnostic Diagnostic) DiagnosticFixIt(fixIt uint32) (SourceRange, string)

Retrieve the replacement information for a given fix-it.

Fix-its are described in terms of a source range whose contents should be replaced by a string. This approach generalizes over three kinds of operations: removal of source code (the range covers the code to be removed and the replacement string is empty), replacement of source code (the range covers the code to be replaced and the replacement string provides the new code), and insertion (both the start and end of the range point at the insertion location, and the replacement string provides the text to insert).

Wraps the C function clang_getDiagnosticFixIt.

func (Diagnostic) DiagnosticLocation 

func (p0 Diagnostic) DiagnosticLocation() SourceLocation

Retrieve the source location of the given diagnostic.

This location is where Clang would print the caret ('^') when displaying the diagnostic on the command line.

Wraps the C function clang_getDiagnosticLocation.

func (Diagnostic) DiagnosticNumFixIts 

func (diagnostic Diagnostic) DiagnosticNumFixIts() uint32

Determine the number of fix-it hints associated with the given diagnostic.

Wraps the C function clang_getDiagnosticNumFixIts.

func (Diagnostic) DiagnosticNumRanges 

func (p0 Diagnostic) DiagnosticNumRanges() uint32

Determine the number of source ranges associated with the given diagnostic.

Wraps the C function clang_getDiagnosticNumRanges.

func (Diagnostic) DiagnosticOption 

func (diag Diagnostic) DiagnosticOption() (string, string)

Retrieve the name of the command-line option that enabled this diagnostic.

Wraps the C function clang_getDiagnosticOption.

func (Diagnostic) DiagnosticRange 

func (diagnostic Diagnostic) DiagnosticRange(range_ uint32) SourceRange

Retrieve a source range associated with the diagnostic.

A diagnostic's source ranges highlight important elements in the source code. On the command line, Clang displays source ranges by underlining them with '~' characters.

Wraps the C function clang_getDiagnosticRange.

func (Diagnostic) DiagnosticSeverity 

func (p0 Diagnostic) DiagnosticSeverity() DiagnosticSeverity

Determine the severity of the given diagnostic.

Wraps the C function clang_getDiagnosticSeverity.

func (Diagnostic) DiagnosticSpelling 

func (p0 Diagnostic) DiagnosticSpelling() string

Retrieve the text of the given diagnostic.

Wraps the C function clang_getDiagnosticSpelling.

func (Diagnostic) DisposeDiagnostic 

func (diagnostic Diagnostic) DisposeDiagnostic()

Destroy a diagnostic.

Wraps the C function clang_disposeDiagnostic.

func (Diagnostic) FormatDiagnostic 

func (diagnostic Diagnostic) FormatDiagnostic(options uint32) string

Format the given diagnostic in a manner that is suitable for display.

This routine will format the given diagnostic to a string, rendering the diagnostic according to the various options given. The clang_defaultDiagnosticDisplayOptions() function returns the set of options that most closely mimics the behavior of the clang compiler.

Wraps the C function clang_formatDiagnostic.

type DiagnosticDisplayOptions 

type DiagnosticDisplayOptions uint32

Options to control the display of diagnostics.

The values in this enum are meant to be combined to customize the behavior of clang_formatDiagnostic().

Represents the C enum CXDiagnosticDisplayOptions. 

const (
	/*
	   Display the source-location information where the diagnostic was located.

	   When set, diagnostics will be prefixed by the file, line, and (optionally) column to which the diagnostic refers. For example,

	   This option corresponds to the clang flag -fshow-source-location.
	*/
	Diagnostic_DisplaySourceLocation DiagnosticDisplayOptions = 1
	/*
	   If displaying the source-location information of the diagnostic, also include the column number.

	   This option corresponds to the clang flag -fshow-column.
	*/
	Diagnostic_DisplayColumn DiagnosticDisplayOptions = 2
	/*
	   If displaying the source-location information of the diagnostic, also include information about source ranges in a machine-parsable format.

	   This option corresponds to the clang flag -fdiagnostics-print-source-range-info.
	*/
	Diagnostic_DisplaySourceRanges DiagnosticDisplayOptions = 4
	/*
	   Display the option name associated with this diagnostic, if any.

	   The option name displayed (e.g., -Wconversion) will be placed in brackets after the diagnostic text. This option corresponds to the clang flag -fdiagnostics-show-option.
	*/
	Diagnostic_DisplayOption DiagnosticDisplayOptions = 8
	/*
	   Display the category number associated with this diagnostic, if any.

	   The category number is displayed within brackets after the diagnostic text. This option corresponds to the clang flag -fdiagnostics-show-category=id.
	*/
	Diagnostic_DisplayCategoryId DiagnosticDisplayOptions = 16
	/*
	   Display the category name associated with this diagnostic, if any.

	   The category name is displayed within brackets after the diagnostic text. This option corresponds to the clang flag -fdiagnostics-show-category=name.
	*/
	Diagnostic_DisplayCategoryName DiagnosticDisplayOptions = 32
)

type DiagnosticSet 

type DiagnosticSet struct {
	// contains filtered or unexported fields
}

A group of CXDiagnostics.

Represents the C type CXDiagnosticSet.

func (DiagnosticSet) DiagnosticInSet 

func (diags DiagnosticSet) DiagnosticInSet(index uint32) Diagnostic

Retrieve a diagnostic associated with the given CXDiagnosticSet.

Wraps the C function clang_getDiagnosticInSet.

func (DiagnosticSet) DisposeDiagnosticSet 

func (diags DiagnosticSet) DisposeDiagnosticSet()

Release a CXDiagnosticSet and all of its contained diagnostics.

Wraps the C function clang_disposeDiagnosticSet.

func (DiagnosticSet) NumDiagnosticsInSet 

func (diags DiagnosticSet) NumDiagnosticsInSet() uint32

Determine the number of diagnostics in a CXDiagnosticSet.

Wraps the C function clang_getNumDiagnosticsInSet.

type DiagnosticSeverity 

type DiagnosticSeverity uint32

Describes the severity of a particular diagnostic.

Represents the C enum CXDiagnosticSeverity. 

const (
	// A diagnostic that has been suppressed, e.g., by a command-line option.
	Diagnostic_Ignored DiagnosticSeverity = 0
	// This diagnostic is a note that should be attached to the previous (non-note) diagnostic.
	Diagnostic_Note DiagnosticSeverity = 1
	// This diagnostic indicates suspicious code that may not be wrong.
	Diagnostic_Warning DiagnosticSeverity = 2
	// This diagnostic indicates that the code is ill-formed.
	Diagnostic_Error DiagnosticSeverity = 3
	// This diagnostic indicates that the code is ill-formed such that future parser recovery is unlikely to produce useful results.
	Diagnostic_Fatal DiagnosticSeverity = 4
)

type ErrorCode 

type ErrorCode uint32

Error codes returned by libclang routines.

Zero (CXError_Success) is the only error code indicating success. Other error codes, including not yet assigned non-zero values, indicate errors.

Represents the C enum CXErrorCode. 

const (
	// No error.
	Error_Success ErrorCode = 0
	/*
	   A generic error code, no further details are available.

	   Errors of this kind can get their own specific error codes in future libclang versions.
	*/
	Error_Failure ErrorCode = 1
	// libclang crashed while performing the requested operation.
	Error_Crashed ErrorCode = 2
	// The function detected that the arguments violate the function contract.
	Error_InvalidArguments ErrorCode = 3
	// An AST deserialization error has occurred.
	Error_ASTReadError ErrorCode = 4
)

type EvalResult 

type EvalResult struct {
	// contains filtered or unexported fields
}

Evaluation result of a cursor

Represents the C type CXEvalResult.

func (EvalResult) AsDouble 

func (e EvalResult) AsDouble() float64

Returns the evaluation result as double if the kind is double.

Wraps the C function clang_EvalResult_getAsDouble.

func (EvalResult) AsInt 

func (e EvalResult) AsInt() int32

Returns the evaluation result as integer if the kind is Int.

Wraps the C function clang_EvalResult_getAsInt.

func (EvalResult) AsLongLong 

func (e EvalResult) AsLongLong() int64

Returns the evaluation result as a long long integer if the kind is Int. This prevents overflows that may happen if the result is returned with clang_EvalResult_getAsInt.

Wraps the C function clang_EvalResult_getAsLongLong.

func (EvalResult) AsStr 

func (e EvalResult) AsStr() string

Returns the evaluation result as a constant string if the kind is other than Int or float. User must not free this pointer, instead call clang_EvalResult_dispose on the CXEvalResult returned by clang_Cursor_Evaluate.

Wraps the C function clang_EvalResult_getAsStr.

func (EvalResult) AsUnsigned 

func (e EvalResult) AsUnsigned() uint64

Returns the evaluation result as an unsigned integer if the kind is Int and clang_EvalResult_isUnsignedInt is non-zero.

Wraps the C function clang_EvalResult_getAsUnsigned.

func (EvalResult) Dispose 

func (e EvalResult) Dispose()

Disposes the created Eval memory.

Wraps the C function clang_EvalResult_dispose.

func (EvalResult) IsUnsignedInt 

func (e EvalResult) IsUnsignedInt() uint32

Returns a non-zero value if the kind is Int and the evaluation result resulted in an unsigned integer.

Wraps the C function clang_EvalResult_isUnsignedInt.

func (EvalResult) Kind 

func (e EvalResult) Kind() EvalResultKind

Returns the kind of the evaluated result.

Wraps the C function clang_EvalResult_getKind.

type EvalResultKind 

type EvalResultKind uint32

Represents the C enum CXEvalResultKind. 

const (
	Eval_Int            EvalResultKind = 1
	Eval_Float          EvalResultKind = 2
	Eval_ObjCStrLiteral EvalResultKind = 3
	Eval_StrLiteral     EvalResultKind = 4
	Eval_CFStr          EvalResultKind = 5
	Eval_Other          EvalResultKind = 6
	Eval_UnExposed      EvalResultKind = 0
)

type FieldVisitor 

type FieldVisitor struct {
	// contains filtered or unexported fields
}

Visitor invoked for each field found by a traversal.

This visitor function will be invoked for each field found by clang_Type_visitFields. Its first argument is the cursor being visited, its second argument is the client data provided to clang_Type_visitFields.

The visitor should return one of the CXVisitorResult values to direct clang_Type_visitFields.

Represents the C type CXFieldVisitor.

type File 

type File struct {
	// contains filtered or unexported fields
}

A particular source file that is part of a translation unit.

Represents the C type CXFile.

func (File) FileName 

func (sFile File) FileName() string

Retrieve the complete file and path name of the given file.

Wraps the C function clang_getFileName.

func (File) FileUniqueID 

func (file File) FileUniqueID() (FileUniqueID, int32)

Retrieve the unique ID for the given file.

Wraps the C function clang_getFileUniqueID.

func (File) IsEqual 

func (file1 File) IsEqual(file2 File) int32

Returns non-zero if the file1 and file2 point to the same file, or they are both NULL.

Wraps the C function clang_File_isEqual.

func (File) TryGetRealPathName 

func (file File) TryGetRealPathName() string

Returns the real path name of file.

An empty string may be returned. Use clang_getFileName() in that case.

Wraps the C function clang_File_tryGetRealPathName.

type FileUniqueID 

type FileUniqueID struct {
	Data [24]byte // unsigned long long[3]
	// contains filtered or unexported fields
}

Uniquely identifies a CXFile, that refers to the same underlying file, across an indexing session.

Represents the C struct CXFileUniqueID.

type GlobalOptFlags 

type GlobalOptFlags uint32

Represents the C enum CXGlobalOptFlags. 

const (
	// Used to indicate that no special CXIndex options are needed.
	GlobalOpt_None GlobalOptFlags = 0
	/*
	   Used to indicate that threads that libclang creates for indexing purposes should use background priority.

	   Affects #clang_indexSourceFile, #clang_indexTranslationUnit, #clang_parseTranslationUnit, #clang_saveTranslationUnit.
	*/
	GlobalOpt_ThreadBackgroundPriorityForIndexing GlobalOptFlags = 1
	/*
	   Used to indicate that threads that libclang creates for editing purposes should use background priority.

	   Affects #clang_reparseTranslationUnit, #clang_codeCompleteAt, #clang_annotateTokens
	*/
	GlobalOpt_ThreadBackgroundPriorityForEditing GlobalOptFlags = 2
	// Used to indicate that all threads that libclang creates should use background priority.
	GlobalOpt_ThreadBackgroundPriorityForAll GlobalOptFlags = 3
)

type IdxAttrInfo 

type IdxAttrInfo struct {
	Kind IdxAttrKind

	Cursor Cursor
	Loc    IdxLoc
	// contains filtered or unexported fields
}

Represents the C struct CXIdxAttrInfo.

func (*IdxAttrInfo) IndexIBOutletCollectionAttrInfo 

func (p0 *IdxAttrInfo) IndexIBOutletCollectionAttrInfo() *IdxIBOutletCollectionAttrInfo

Wraps the C function clang_index_getIBOutletCollectionAttrInfo.

type IdxAttrKind 

type IdxAttrKind uint32

Represents the C enum CXIdxAttrKind. 

const (
	IdxAttr_Unexposed          IdxAttrKind = 0
	IdxAttr_IBAction           IdxAttrKind = 1
	IdxAttr_IBOutlet           IdxAttrKind = 2
	IdxAttr_IBOutletCollection IdxAttrKind = 3
)

type IdxBaseClassInfo 

type IdxBaseClassInfo struct {
	Base   *IdxEntityInfo
	Cursor Cursor
	Loc    IdxLoc
	// contains filtered or unexported fields
}

Represents the C struct CXIdxBaseClassInfo.

type IdxCXXClassDeclInfo 

type IdxCXXClassDeclInfo struct {
	DeclInfo *IdxDeclInfo

	NumBases uint32
	// contains filtered or unexported fields
}

Represents the C struct CXIdxCXXClassDeclInfo.

type IdxClientASTFile 

type IdxClientASTFile struct {
	// contains filtered or unexported fields
}

The client's data object that is associated with an AST file (PCH or module).

Represents the C type CXIdxClientASTFile.

type IdxClientContainer 

type IdxClientContainer struct {
	// contains filtered or unexported fields
}

The client's data object that is associated with a semantic container of entities.

Represents the C type CXIdxClientContainer.

type IdxClientEntity 

type IdxClientEntity struct {
	// contains filtered or unexported fields
}

The client's data object that is associated with a semantic entity.

Represents the C type CXIdxClientEntity.

type IdxClientFile 

type IdxClientFile struct {
	// contains filtered or unexported fields
}

The client's data object that is associated with a CXFile.

Represents the C type CXIdxClientFile.

type IdxContainerInfo 

type IdxContainerInfo struct {
	Cursor Cursor
	// contains filtered or unexported fields
}

Represents the C struct CXIdxContainerInfo.

func (*IdxContainerInfo) IndexClientContainer 

func (p0 *IdxContainerInfo) IndexClientContainer() IdxClientContainer

For retrieving a custom CXIdxClientContainer attached to a container.

Wraps the C function clang_index_getClientContainer.

func (*IdxContainerInfo) Index_setClientContainer 

func (p0 *IdxContainerInfo) Index_setClientContainer(p1 IdxClientContainer)

For setting a custom CXIdxClientContainer attached to a container.

Wraps the C function clang_index_setClientContainer.

type IdxDeclInfo 

type IdxDeclInfo struct {
	EntityInfo        *IdxEntityInfo
	Cursor            Cursor
	Loc               IdxLoc
	SemanticContainer *IdxContainerInfo
	// Generally same as #semanticContainer but can be different in cases like out-of-line C++ member functions.
	LexicalContainer *IdxContainerInfo
	IsRedeclaration  int32
	IsDefinition     int32
	IsContainer      int32

	DeclAsContainer *IdxContainerInfo
	// Whether the declaration exists in code or was created implicitly by the compiler, e.g. implicit Objective-C methods for properties.
	IsImplicit int32

	NumAttributes uint32
	Flags         uint32
	// contains filtered or unexported fields
}

Represents the C struct CXIdxDeclInfo.

func (*IdxDeclInfo) IndexCXXClassDeclInfo 

func (p0 *IdxDeclInfo) IndexCXXClassDeclInfo() *IdxCXXClassDeclInfo

Wraps the C function clang_index_getCXXClassDeclInfo.

func (*IdxDeclInfo) IndexObjCCategoryDeclInfo 

func (p0 *IdxDeclInfo) IndexObjCCategoryDeclInfo() *IdxObjCCategoryDeclInfo

Wraps the C function clang_index_getObjCCategoryDeclInfo.

func (*IdxDeclInfo) IndexObjCContainerDeclInfo 

func (p0 *IdxDeclInfo) IndexObjCContainerDeclInfo() *IdxObjCContainerDeclInfo

Wraps the C function clang_index_getObjCContainerDeclInfo.

func (*IdxDeclInfo) IndexObjCInterfaceDeclInfo 

func (p0 *IdxDeclInfo) IndexObjCInterfaceDeclInfo() *IdxObjCInterfaceDeclInfo

Wraps the C function clang_index_getObjCInterfaceDeclInfo.

func (*IdxDeclInfo) IndexObjCPropertyDeclInfo 

func (p0 *IdxDeclInfo) IndexObjCPropertyDeclInfo() *IdxObjCPropertyDeclInfo

Wraps the C function clang_index_getObjCPropertyDeclInfo.

func (*IdxDeclInfo) IndexObjCProtocolRefListInfo 

func (p0 *IdxDeclInfo) IndexObjCProtocolRefListInfo() *IdxObjCProtocolRefListInfo

Wraps the C function clang_index_getObjCProtocolRefListInfo.

type IdxDeclInfoFlags 

type IdxDeclInfoFlags uint32

Represents the C enum CXIdxDeclInfoFlags. 

const (
	IdxDeclFlag_Skipped IdxDeclInfoFlags = 1
)

type IdxEntityCXXTemplateKind 

type IdxEntityCXXTemplateKind uint32

Extra C++ template information for an entity. This can apply to: CXIdxEntity_Function CXIdxEntity_CXXClass CXIdxEntity_CXXStaticMethod CXIdxEntity_CXXInstanceMethod CXIdxEntity_CXXConstructor CXIdxEntity_CXXConversionFunction CXIdxEntity_CXXTypeAlias

Represents the C enum CXIdxEntityCXXTemplateKind. 

const (
	IdxEntity_NonTemplate                   IdxEntityCXXTemplateKind = 0
	IdxEntity_Template                      IdxEntityCXXTemplateKind = 1
	IdxEntity_TemplatePartialSpecialization IdxEntityCXXTemplateKind = 2
	IdxEntity_TemplateSpecialization        IdxEntityCXXTemplateKind = 3
)

type IdxEntityInfo 

type IdxEntityInfo struct {
	Kind         IdxEntityKind
	TemplateKind IdxEntityCXXTemplateKind
	Lang         IdxEntityLanguage

	Cursor Cursor

	NumAttributes uint32
	// contains filtered or unexported fields
}

Represents the C struct CXIdxEntityInfo.

func (*IdxEntityInfo) IndexClientEntity 

func (p0 *IdxEntityInfo) IndexClientEntity() IdxClientEntity

For retrieving a custom CXIdxClientEntity attached to an entity.

Wraps the C function clang_index_getClientEntity.

func (*IdxEntityInfo) Index_setClientEntity 

func (p0 *IdxEntityInfo) Index_setClientEntity(p1 IdxClientEntity)

For setting a custom CXIdxClientEntity attached to an entity.

Wraps the C function clang_index_setClientEntity.

func (*IdxEntityInfo) Name 

func (s *IdxEntityInfo) Name() string

func (*IdxEntityInfo) SetName 

func (s *IdxEntityInfo) SetName(str string) (free func())

A C string will be allocated on the C heap. A function is returned that when called will free the C string's memory.

func (*IdxEntityInfo) SetUSR 

func (s *IdxEntityInfo) SetUSR(str string) (free func())

A C string will be allocated on the C heap. A function is returned that when called will free the C string's memory.

func (*IdxEntityInfo) USR 

func (s *IdxEntityInfo) USR() string

type IdxEntityKind 

type IdxEntityKind uint32

Represents the C enum CXIdxEntityKind. 

const (
	IdxEntity_Unexposed             IdxEntityKind = 0
	IdxEntity_Typedef               IdxEntityKind = 1
	IdxEntity_Function              IdxEntityKind = 2
	IdxEntity_Variable              IdxEntityKind = 3
	IdxEntity_Field                 IdxEntityKind = 4
	IdxEntity_EnumConstant          IdxEntityKind = 5
	IdxEntity_ObjCClass             IdxEntityKind = 6
	IdxEntity_ObjCProtocol          IdxEntityKind = 7
	IdxEntity_ObjCCategory          IdxEntityKind = 8
	IdxEntity_ObjCInstanceMethod    IdxEntityKind = 9
	IdxEntity_ObjCClassMethod       IdxEntityKind = 10
	IdxEntity_ObjCProperty          IdxEntityKind = 11
	IdxEntity_ObjCIvar              IdxEntityKind = 12
	IdxEntity_Enum                  IdxEntityKind = 13
	IdxEntity_Struct                IdxEntityKind = 14
	IdxEntity_Union                 IdxEntityKind = 15
	IdxEntity_CXXClass              IdxEntityKind = 16
	IdxEntity_CXXNamespace          IdxEntityKind = 17
	IdxEntity_CXXNamespaceAlias     IdxEntityKind = 18
	IdxEntity_CXXStaticVariable     IdxEntityKind = 19
	IdxEntity_CXXStaticMethod       IdxEntityKind = 20
	IdxEntity_CXXInstanceMethod     IdxEntityKind = 21
	IdxEntity_CXXConstructor        IdxEntityKind = 22
	IdxEntity_CXXDestructor         IdxEntityKind = 23
	IdxEntity_CXXConversionFunction IdxEntityKind = 24
	IdxEntity_CXXTypeAlias          IdxEntityKind = 25
	IdxEntity_CXXInterface          IdxEntityKind = 26
	IdxEntity_CXXConcept            IdxEntityKind = 27
)

func (IdxEntityKind) Index_isEntityObjCContainerKind 

func (p0 IdxEntityKind) Index_isEntityObjCContainerKind() int32

Wraps the C function clang_index_isEntityObjCContainerKind.

type IdxEntityLanguage 

type IdxEntityLanguage uint32

Represents the C enum CXIdxEntityLanguage. 

const (
	IdxEntityLang_None  IdxEntityLanguage = 0
	IdxEntityLang_C     IdxEntityLanguage = 1
	IdxEntityLang_ObjC  IdxEntityLanguage = 2
	IdxEntityLang_CXX   IdxEntityLanguage = 3
	IdxEntityLang_Swift IdxEntityLanguage = 4
)

type IdxEntityRefInfo 

type IdxEntityRefInfo struct {
	Kind IdxEntityRefKind

	// Reference cursor.
	Cursor Cursor
	Loc    IdxLoc
	// The entity that gets referenced.
	ReferencedEntity *IdxEntityInfo
	/*
	   Immediate "parent" of the reference. For example:

	   The parent of reference of type 'Foo' is the variable 'var'. For references inside statement bodies of functions/methods, the parentEntity will be the function/method.
	*/
	ParentEntity *IdxEntityInfo
	// Lexical container context of the reference.
	Container *IdxContainerInfo
	// Sets of symbol roles of the reference.
	Role SymbolRole
	// contains filtered or unexported fields
}

Data for IndexerCallbacks#indexEntityReference.

Represents the C struct CXIdxEntityRefInfo.

type IdxEntityRefKind 

type IdxEntityRefKind uint32

Data for IndexerCallbacks#indexEntityReference.

This may be deprecated in a future version as this duplicates the CXSymbolRole_Implicit bit in CXSymbolRole.

Represents the C enum CXIdxEntityRefKind. 

const (
	// The entity is referenced directly in user's code.
	IdxEntityRef_Direct IdxEntityRefKind = 1
	// An implicit reference, e.g. a reference of an Objective-C method via the dot syntax.
	IdxEntityRef_Implicit IdxEntityRefKind = 2
)

type IdxIBOutletCollectionAttrInfo 

type IdxIBOutletCollectionAttrInfo struct {
	AttrInfo    *IdxAttrInfo
	ObjcClass   *IdxEntityInfo
	ClassCursor Cursor
	ClassLoc    IdxLoc
	// contains filtered or unexported fields
}

Represents the C struct CXIdxIBOutletCollectionAttrInfo.

type IdxImportedASTFileInfo 

type IdxImportedASTFileInfo struct {

	// Top level AST file containing the imported PCH, module or submodule.
	File [8]byte // CXFile
	// The imported module or NULL if the AST file is a PCH.
	Module [8]byte // CXModule
	// Location where the file is imported. Applicable only for modules.
	Loc IdxLoc
	// Non-zero if an inclusion directive was automatically turned into a module import. Applicable only for modules.
	IsImplicit int32
	// contains filtered or unexported fields
}

Data for IndexerCallbacks#importedASTFile.

Represents the C struct CXIdxImportedASTFileInfo.

type IdxIncludedFileInfo 

type IdxIncludedFileInfo struct {

	// Location of '#' in the #include/#import directive.
	HashLoc IdxLoc

	// The actual file that the #include/#import directive resolved to.
	File     [8]byte // CXFile
	IsImport int32
	IsAngled int32
	// Non-zero if the directive was automatically turned into a module import.
	IsModuleImport int32
	// contains filtered or unexported fields
}

Data for ppIncludedFile callback.

Represents the C struct CXIdxIncludedFileInfo.

func (*IdxIncludedFileInfo) Filename 

func (s *IdxIncludedFileInfo) Filename() string

Filename as written in the #include/#import directive.

func (*IdxIncludedFileInfo) SetFilename 

func (s *IdxIncludedFileInfo) SetFilename(str string) (free func())

Filename as written in the #include/#import directive.

A C string will be allocated on the C heap. A function is returned that when called will free the C string's memory.

type IdxLoc 

type IdxLoc struct {
	Ptr_data [16]byte // void *[2]
	Int_data uint32
	// contains filtered or unexported fields
}

Source location passed to index callbacks.

Represents the C struct CXIdxLoc.

func (IdxLoc) IndexLocCXSourceLocation 

func (loc IdxLoc) IndexLocCXSourceLocation() SourceLocation

Retrieve the CXSourceLocation represented by the given CXIdxLoc.

Wraps the C function clang_indexLoc_getCXSourceLocation.

func (IdxLoc) IndexLocFileLocation 

func (loc IdxLoc) IndexLocFileLocation() (IdxClientFile, File, uint32, uint32, uint32)

Retrieve the CXIdxFile, file, line, column, and offset represented by the given CXIdxLoc.

If the location refers into a macro expansion, retrieves the location of the macro expansion and if it refers into a macro argument retrieves the location of the argument.

Wraps the C function clang_indexLoc_getFileLocation.

type IdxObjCCategoryDeclInfo 

type IdxObjCCategoryDeclInfo struct {
	ContainerInfo *IdxObjCContainerDeclInfo
	ObjcClass     *IdxEntityInfo
	ClassCursor   Cursor
	ClassLoc      IdxLoc
	Protocols     *IdxObjCProtocolRefListInfo
	// contains filtered or unexported fields
}

Represents the C struct CXIdxObjCCategoryDeclInfo.

type IdxObjCContainerDeclInfo 

type IdxObjCContainerDeclInfo struct {
	DeclInfo *IdxDeclInfo
	Kind     IdxObjCContainerKind
	// contains filtered or unexported fields
}

Represents the C struct CXIdxObjCContainerDeclInfo.

type IdxObjCContainerKind 

type IdxObjCContainerKind uint32

Represents the C enum CXIdxObjCContainerKind. 

const (
	IdxObjCContainer_ForwardRef     IdxObjCContainerKind = 0
	IdxObjCContainer_Interface      IdxObjCContainerKind = 1
	IdxObjCContainer_Implementation IdxObjCContainerKind = 2
)

type IdxObjCInterfaceDeclInfo 

type IdxObjCInterfaceDeclInfo struct {
	ContainerInfo *IdxObjCContainerDeclInfo
	SuperInfo     *IdxBaseClassInfo
	Protocols     *IdxObjCProtocolRefListInfo
	// contains filtered or unexported fields
}

Represents the C struct CXIdxObjCInterfaceDeclInfo.

type IdxObjCPropertyDeclInfo 

type IdxObjCPropertyDeclInfo struct {
	DeclInfo *IdxDeclInfo
	Getter   *IdxEntityInfo
	Setter   *IdxEntityInfo
	// contains filtered or unexported fields
}

Represents the C struct CXIdxObjCPropertyDeclInfo.

type IdxObjCProtocolRefInfo 

type IdxObjCProtocolRefInfo struct {
	Protocol *IdxEntityInfo
	Cursor   Cursor
	Loc      IdxLoc
	// contains filtered or unexported fields
}

Represents the C struct CXIdxObjCProtocolRefInfo.

type IdxObjCProtocolRefListInfo 

type IdxObjCProtocolRefListInfo struct {
	NumProtocols uint32
	// contains filtered or unexported fields
}

Represents the C struct CXIdxObjCProtocolRefListInfo.

type InclusionVisitor 

type InclusionVisitor struct {
	// contains filtered or unexported fields
}

Visitor invoked for each file in a translation unit (used with clang_getInclusions()).

This visitor function will be invoked by clang_getInclusions() for each file included (either at the top-level or by #include directives) within a translation unit. The first argument is the file being included, and the second and third arguments provide the inclusion stack. The array is sorted in order of immediate inclusion. For example, the first element refers to the location that included 'included_file'.

Represents the C type CXInclusionVisitor.

type Index 

type Index struct {
	// contains filtered or unexported fields
}

An "index" that consists of a set of translation units that would typically be linked together into an executable or library.

Represents the C type CXIndex.

func CreateIndex 

func CreateIndex(excludeDeclarationsFromPCH int32, displayDiagnostics int32) Index

Provides a shared context for creating translation units.

It provides two options:

- excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local" declarations (when loading any new translation units). A "local" declaration is one that belongs in the translation unit itself and not in a precompiled header that was used by the translation unit. If zero, all declarations will be enumerated.

Here is an example:

This process of creating the 'pch', loading it separately, and using it (via -include-pch) allows 'excludeDeclsFromPCH' to remove redundant callbacks (which gives the indexer the same performance benefit as the compiler).

Wraps the C function clang_createIndex.

func (Index) Action_create 

func (cIdx Index) Action_create() IndexAction

An indexing action/session, to be applied to one or multiple translation units.

Wraps the C function clang_IndexAction_create.

func (Index) CreateTranslationUnit 

func (cIdx Index) CreateTranslationUnit(ast_filename string) TranslationUnit

Same as clang_createTranslationUnit2, but returns the CXTranslationUnit instead of an error code. In case of an error this routine returns a NULL CXTranslationUnit, without further detailed error codes.

Wraps the C function clang_createTranslationUnit.

func (Index) CreateTranslationUnit2 

func (cIdx Index) CreateTranslationUnit2(ast_filename string) (TranslationUnit, ErrorCode)

Create a translation unit from an AST file (-emit-ast).

Wraps the C function clang_createTranslationUnit2.

func (Index) CreateTranslationUnitFromSourceFile 

func (cIdx Index) CreateTranslationUnitFromSourceFile(source_filename string, clang_command_line_args []string, unsaved_files []UnsavedFile) TranslationUnit

Return the CXTranslationUnit for a given source file and the provided command line arguments one would pass to the compiler.

Note: The 'source_filename' argument is optional. If the caller provides a NULL pointer, the name of the source file is expected to reside in the specified command line arguments.

Note: When encountered in 'clang_command_line_args', the following options are ignored:

'-c' '-emit-ast' '-fsyntax-only' '-o <output file>' (both '-o' and '<output file>' are ignored)

Wraps the C function clang_createTranslationUnitFromSourceFile.

func (Index) DisposeIndex 

func (index Index) DisposeIndex()

Destroy the given index.

The index must not be destroyed until all of the translation units created within that index have been destroyed.

Wraps the C function clang_disposeIndex.

func (Index) GlobalOptions 

func (p0 Index) GlobalOptions() uint32

Gets the general options associated with a CXIndex.

This function allows to obtain the final option values used by libclang after specifying the option policies via CXChoice enumerators.

Wraps the C function clang_CXIndex_getGlobalOptions.

func (Index) ParseTranslationUnit 

func (cIdx Index) ParseTranslationUnit(source_filename string, command_line_args []string, unsaved_files []UnsavedFile, options uint32) TranslationUnit

Same as clang_parseTranslationUnit2, but returns the CXTranslationUnit instead of an error code. In case of an error this routine returns a NULL CXTranslationUnit, without further detailed error codes.

Wraps the C function clang_parseTranslationUnit.

func (Index) ParseTranslationUnit2 

func (cIdx Index) ParseTranslationUnit2(source_filename string, command_line_args []string, unsaved_files []UnsavedFile, options uint32) (TranslationUnit, ErrorCode)

Parse the given source file and the translation unit corresponding to that file.

This routine is the main entry point for the Clang C API, providing the ability to parse a source file into a translation unit that can then be queried by other functions in the API. This routine accepts a set of command-line arguments so that the compilation can be configured in the same way that the compiler is configured on the command line.

Wraps the C function clang_parseTranslationUnit2.

func (Index) ParseTranslationUnit2FullArgv 

func (cIdx Index) ParseTranslationUnit2FullArgv(source_filename string, command_line_args []string, unsaved_files []UnsavedFile, options uint32) (TranslationUnit, ErrorCode)

Same as clang_parseTranslationUnit2 but requires a full command line for command_line_args including argv[0]. This is useful if the standard library paths are relative to the binary.

Wraps the C function clang_parseTranslationUnit2FullArgv.

func (Index) SetGlobalOptions 

func (p0 Index) SetGlobalOptions(options uint32)

Sets general options associated with a CXIndex.

This function is DEPRECATED. Set CXIndexOptions::ThreadBackgroundPriorityForIndexing and/or CXIndexOptions::ThreadBackgroundPriorityForEditing and call clang_createIndexWithOptions() instead.

For example:

Wraps the C function clang_CXIndex_setGlobalOptions.

func (Index) SetInvocationEmissionPathOption 

func (p0 Index) SetInvocationEmissionPathOption(path string)

Sets the invocation emission path option in a CXIndex.

This function is DEPRECATED. Set CXIndexOptions::InvocationEmissionPath and call clang_createIndexWithOptions() instead.

The invocation emission path specifies a path which will contain log files for certain libclang invocations. A null value (default) implies that libclang invocations are not logged..

Wraps the C function clang_CXIndex_setInvocationEmissionPathOption.

type IndexAction 

type IndexAction struct {
	// contains filtered or unexported fields
}

An indexing action/session, to be applied to one or multiple translation units.

Represents the C type CXIndexAction.

func (IndexAction) Dispose 

func (p0 IndexAction) Dispose()

Destroy the given index action.

The index action must not be destroyed until all of the translation units created within that index action have been destroyed.

Wraps the C function clang_IndexAction_dispose.

func (IndexAction) IndexSourceFile 

func (p0 IndexAction) IndexSourceFile(client_data ClientData, index_callbacks_size uint32, index_options uint32, source_filename string, command_line_args []string, unsaved_files []UnsavedFile, tU_options uint32) (IndexerCallbacks, TranslationUnit, int32)

Index the given source file and the translation unit corresponding to that file via callbacks implemented through #IndexerCallbacks.

The rest of the parameters are the same as #clang_parseTranslationUnit.

Wraps the C function clang_indexSourceFile.

func (IndexAction) IndexSourceFileFullArgv 

func (p0 IndexAction) IndexSourceFileFullArgv(client_data ClientData, index_callbacks_size uint32, index_options uint32, source_filename string, command_line_args []string, unsaved_files []UnsavedFile, tU_options uint32) (IndexerCallbacks, TranslationUnit, int32)

Same as clang_indexSourceFile but requires a full command line for command_line_args including argv[0]. This is useful if the standard library paths are relative to the binary.

Wraps the C function clang_indexSourceFileFullArgv.

func (IndexAction) IndexTranslationUnit 

func (p0 IndexAction) IndexTranslationUnit(client_data ClientData, index_callbacks_size uint32, index_options uint32, p5 TranslationUnit) (IndexerCallbacks, int32)

Index the given translation unit via callbacks implemented through #IndexerCallbacks.

The order of callback invocations is not guaranteed to be the same as when indexing a source file. The high level order will be:

-Preprocessor callbacks invocations -Declaration/reference callbacks invocations -Diagnostic callback invocations

The parameters are the same as #clang_indexSourceFile.

Wraps the C function clang_indexTranslationUnit.

type IndexOptFlags 

type IndexOptFlags uint32

Represents the C enum CXIndexOptFlags. 

const (
	// Used to indicate that no special indexing options are needed.
	IndexOpt_None IndexOptFlags = 0
	// Used to indicate that IndexerCallbacks#indexEntityReference should be invoked for only one reference of an entity per source file that does not also include a declaration/definition of the entity.
	IndexOpt_SuppressRedundantRefs IndexOptFlags = 1
	// Function-local symbols should be indexed. If this is not set function-local symbols will be ignored.
	IndexOpt_IndexFunctionLocalSymbols IndexOptFlags = 2
	// Implicit function/class template instantiations should be indexed. If this is not set, implicit instantiations will be ignored.
	IndexOpt_IndexImplicitTemplateInstantiations IndexOptFlags = 4
	// Suppress all compiler warnings when parsing for indexing.
	IndexOpt_SuppressWarnings IndexOptFlags = 8
	// Skip a function/method body that was already parsed during an indexing session associated with a CXIndexAction object. Bodies in system headers are always skipped.
	IndexOpt_SkipParsedBodiesInSession IndexOptFlags = 16
)

type IndexOptions 

type IndexOptions struct {

	/*
	   The size of struct CXIndexOptions used for option versioning.

	   Always initialize this member to sizeof(CXIndexOptions), or assign sizeof(CXIndexOptions) to it right after creating a CXIndexOptions object.
	*/
	Size uint32
	// A CXChoice enumerator that specifies the indexing priority policy.
	ThreadBackgroundPriorityForIndexing byte
	// A CXChoice enumerator that specifies the editing priority policy.
	ThreadBackgroundPriorityForEditing byte
	// contains filtered or unexported fields
}

Index initialization options.

0 is the default value of each member of this struct except for Size. Initialize the struct in one of the following three ways to avoid adapting code each time a new member is added to it:

or explicitly initialize the first data member and zero-initialize the rest:

or to prevent the -Wmissing-field-initializers warning for the above version:

Represents the C struct CXIndexOptions.

func (*IndexOptions) CreateIndexWithOptions 

func (options *IndexOptions) CreateIndexWithOptions() Index

Provides a shared context for creating translation units.

Call this function instead of clang_createIndex() if you need to configure the additional options in CXIndexOptions.

For example:

Wraps the C function clang_createIndexWithOptions.

func (*IndexOptions) DisplayDiagnostics 

func (s *IndexOptions) DisplayDiagnostics() uint

func (*IndexOptions) ExcludeDeclarationsFromPCH 

func (s *IndexOptions) ExcludeDeclarationsFromPCH() uint

func (*IndexOptions) InvocationEmissionPath 

func (s *IndexOptions) InvocationEmissionPath() string

Specifies a path which will contain log files for certain libclang invocations. A null value implies that libclang invocations are not logged.

func (*IndexOptions) PreambleStoragePath 

func (s *IndexOptions) PreambleStoragePath() string

The path to a directory, in which to store temporary PCH files. If null or empty, the default system temporary directory is used. These PCH files are deleted on clean exit but stay on disk if the program crashes or is killed.

This option is ignored if StorePreamblesInMemory is non-zero.

Libclang does not create the directory at the specified path in the file system. Therefore it must exist, or storing PCH files will fail.

func (*IndexOptions) SetDisplayDiagnostics 

func (s *IndexOptions) SetDisplayDiagnostics(value uint)

func (*IndexOptions) SetExcludeDeclarationsFromPCH 

func (s *IndexOptions) SetExcludeDeclarationsFromPCH(value uint)

func (*IndexOptions) SetInvocationEmissionPath 

func (s *IndexOptions) SetInvocationEmissionPath(str string) (free func())

Specifies a path which will contain log files for certain libclang invocations. A null value implies that libclang invocations are not logged.

A C string will be allocated on the C heap. A function is returned that when called will free the C string's memory.

func (*IndexOptions) SetPreambleStoragePath 

func (s *IndexOptions) SetPreambleStoragePath(str string) (free func())

The path to a directory, in which to store temporary PCH files. If null or empty, the default system temporary directory is used. These PCH files are deleted on clean exit but stay on disk if the program crashes or is killed.

This option is ignored if StorePreamblesInMemory is non-zero.

Libclang does not create the directory at the specified path in the file system. Therefore it must exist, or storing PCH files will fail.

A C string will be allocated on the C heap. A function is returned that when called will free the C string's memory.

func (*IndexOptions) SetStorePreamblesInMemory 

func (s *IndexOptions) SetStorePreamblesInMemory(value uint)

Store PCH in memory. If zero, PCH are stored in temporary files.

func (*IndexOptions) StorePreamblesInMemory 

func (s *IndexOptions) StorePreamblesInMemory() uint

Store PCH in memory. If zero, PCH are stored in temporary files.

type IndexerCallbacks 

type IndexerCallbacks struct {
	// contains filtered or unexported fields
}

A group of callbacks used by #clang_indexSourceFile and #clang_indexTranslationUnit.

Represents the C struct IndexerCallbacks.

type LanguageKind 

type LanguageKind uint32

Describe the "language" of the entity referred to by a cursor.

Represents the C enum CXLanguageKind. 

const (
	Language_Invalid   LanguageKind = 0
	Language_C         LanguageKind = 1
	Language_ObjC      LanguageKind = 2
	Language_CPlusPlus LanguageKind = 3
)

type LibraryPaths 

type LibraryPaths struct {
	Darwin string
	Linux  string
}

type LinkageKind 

type LinkageKind uint32

Describe the linkage of the entity referred to by a cursor.

Represents the C enum CXLinkageKind. 

const (
	// This value indicates that no linkage information is available for a provided CXCursor.
	Linkage_Invalid LinkageKind = 0
	// This is the linkage for variables, parameters, and so on that  have automatic storage.  This covers normal (non-extern) local variables.
	Linkage_NoLinkage LinkageKind = 1
	// This is the linkage for static variables and static functions.
	Linkage_Internal LinkageKind = 2
	// This is the linkage for entities with external linkage that live in C++ anonymous namespaces.
	Linkage_UniqueExternal LinkageKind = 3
	// This is the linkage for entities with true, external linkage.
	Linkage_External LinkageKind = 4
)

type LoadDiag_Error 

type LoadDiag_Error uint32

Describes the kind of error that occurred (if any) in a call to clang_loadDiagnostics.

Represents the C enum CXLoadDiag_Error. 

const (
	// Indicates that no error occurred.
	LoadDiag_None LoadDiag_Error = 0
	// Indicates that an unknown error occurred while attempting to deserialize diagnostics.
	LoadDiag_Unknown LoadDiag_Error = 1
	// Indicates that the file containing the serialized diagnostics could not be opened.
	LoadDiag_CannotLoad LoadDiag_Error = 2
	// Indicates that the serialized diagnostics file is invalid or corrupt.
	LoadDiag_InvalidFile LoadDiag_Error = 3
)

type Module 

type Module struct {
	// contains filtered or unexported fields
}

The functions in this group provide access to information about modules.

@{

Represents the C type CXModule.

func (Module) ASTFile 

func (module Module) ASTFile() File

Wraps the C function clang_Module_getASTFile.

func (Module) FullName 

func (module Module) FullName() string

Wraps the C function clang_Module_getFullName.

func (Module) IsSystem 

func (module Module) IsSystem() int32

Wraps the C function clang_Module_isSystem.

func (Module) Name 

func (module Module) Name() string

Wraps the C function clang_Module_getName.

func (Module) Parent 

func (module Module) Parent() Module

Wraps the C function clang_Module_getParent.

type ModuleMapDescriptor 

type ModuleMapDescriptor struct {
	// contains filtered or unexported fields
}

Object encapsulating information about a module.modulemap file.

Represents the C type CXModuleMapDescriptor.

func ModuleMapDescriptor_create 

func ModuleMapDescriptor_create(options uint32) ModuleMapDescriptor

Create a CXModuleMapDescriptor object. Must be disposed with clang_ModuleMapDescriptor_dispose().

Wraps the C function clang_ModuleMapDescriptor_create.

func (ModuleMapDescriptor) Dispose 

func (p0 ModuleMapDescriptor) Dispose()

Dispose a CXModuleMapDescriptor object.

Wraps the C function clang_ModuleMapDescriptor_dispose.

func (ModuleMapDescriptor) SetFrameworkModuleName 

func (p0 ModuleMapDescriptor) SetFrameworkModuleName(name string) ErrorCode

Sets the framework module name that the module.modulemap describes.

Wraps the C function clang_ModuleMapDescriptor_setFrameworkModuleName.

func (ModuleMapDescriptor) SetUmbrellaHeader 

func (p0 ModuleMapDescriptor) SetUmbrellaHeader(name string) ErrorCode

Sets the umbrella header name that the module.modulemap describes.

Wraps the C function clang_ModuleMapDescriptor_setUmbrellaHeader.

type ModuleMapDescriptorImpl 

type ModuleMapDescriptorImpl struct {
	// contains filtered or unexported fields
}

Represents the C struct CXModuleMapDescriptorImpl.

type NameRefFlags 

type NameRefFlags uint32

Represents the C enum CXNameRefFlags. 

const (
	// Include the nested-name-specifier, e.g. Foo:: in x.Foo::y, in the range.
	NameRange_WantQualifier NameRefFlags = 1
	// Include the explicit template arguments, e.g. <int> in x.f<int>, in the range.
	NameRange_WantTemplateArgs NameRefFlags = 2
	/*
	   If the name is non-contiguous, return the full spanning range.

	   Non-contiguous names occur in Objective-C when a selector with two or more parameters is used, or in C++ when using an operator:
	*/
	NameRange_WantSinglePiece NameRefFlags = 4
)

type ObjCDeclQualifierKind 

type ObjCDeclQualifierKind uint32

'Qualifiers' written next to the return and parameter types in Objective-C method declarations.

Represents the C enum CXObjCDeclQualifierKind. 

const (
	ObjCDeclQualifier_None   ObjCDeclQualifierKind = 0
	ObjCDeclQualifier_In     ObjCDeclQualifierKind = 1
	ObjCDeclQualifier_Inout  ObjCDeclQualifierKind = 2
	ObjCDeclQualifier_Out    ObjCDeclQualifierKind = 4
	ObjCDeclQualifier_Bycopy ObjCDeclQualifierKind = 8
	ObjCDeclQualifier_Byref  ObjCDeclQualifierKind = 16
	ObjCDeclQualifier_Oneway ObjCDeclQualifierKind = 32
)

type ObjCPropertyAttrKind 

type ObjCPropertyAttrKind uint32

Property attributes for a CXCursor_ObjCPropertyDecl.

Represents the C enum CXObjCPropertyAttrKind. 

const (
	ObjCPropertyAttr_noattr            ObjCPropertyAttrKind = 0
	ObjCPropertyAttr_readonly          ObjCPropertyAttrKind = 1
	ObjCPropertyAttr_getter            ObjCPropertyAttrKind = 2
	ObjCPropertyAttr_assign            ObjCPropertyAttrKind = 4
	ObjCPropertyAttr_readwrite         ObjCPropertyAttrKind = 8
	ObjCPropertyAttr_retain            ObjCPropertyAttrKind = 16
	ObjCPropertyAttr_copy              ObjCPropertyAttrKind = 32
	ObjCPropertyAttr_nonatomic         ObjCPropertyAttrKind = 64
	ObjCPropertyAttr_setter            ObjCPropertyAttrKind = 128
	ObjCPropertyAttr_atomic            ObjCPropertyAttrKind = 256
	ObjCPropertyAttr_weak              ObjCPropertyAttrKind = 512
	ObjCPropertyAttr_strong            ObjCPropertyAttrKind = 1024
	ObjCPropertyAttr_unsafe_unretained ObjCPropertyAttrKind = 2048
	ObjCPropertyAttr_class             ObjCPropertyAttrKind = 4096
)

type PlatformAvailability 

type PlatformAvailability struct {

	// The version number in which this entity was introduced.
	Introduced Version
	// The version number in which this entity was deprecated (but is still available).
	Deprecated Version
	// The version number in which this entity was obsoleted, and therefore is no longer available.
	Obsoleted Version
	// Whether the entity is unconditionally unavailable on this platform.
	Unavailable int32
	// contains filtered or unexported fields
}

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.

Represents the C struct CXPlatformAvailability.

func (*PlatformAvailability) DisposeCXPlatformAvailability 

func (availability *PlatformAvailability) DisposeCXPlatformAvailability()

Free the memory associated with a CXPlatformAvailability structure.

Wraps the C function clang_disposeCXPlatformAvailability.

func (*PlatformAvailability) Message 

func (s *PlatformAvailability) Message() string

An optional message to provide to a user of this API, e.g., to suggest replacement APIs.

func (*PlatformAvailability) Platform 

func (s *PlatformAvailability) Platform() string

A string that describes the platform for which this structure provides availability information.

Possible values are "ios" or "macos".

type PrintingPolicy 

type PrintingPolicy struct {
	// contains filtered or unexported fields
}

Opaque pointer representing a policy that controls pretty printing for clang_getCursorPrettyPrinted.

Represents the C type CXPrintingPolicy.

func (PrintingPolicy) Dispose 

func (policy PrintingPolicy) Dispose()

Release a printing policy.

Wraps the C function clang_PrintingPolicy_dispose.

func (PrintingPolicy) Property 

func (policy PrintingPolicy) Property(property PrintingPolicyProperty) uint32

Get a property value for the given printing policy.

Wraps the C function clang_PrintingPolicy_getProperty.

func (PrintingPolicy) SetProperty 

func (policy PrintingPolicy) SetProperty(property PrintingPolicyProperty, value uint32)

Set a property value for the given printing policy.

Wraps the C function clang_PrintingPolicy_setProperty.

type PrintingPolicyProperty 

type PrintingPolicyProperty uint32

Properties for the printing policy.

See clang::PrintingPolicy for more information.

Represents the C enum CXPrintingPolicyProperty. 

const (
	PrintingPolicy_Indentation                           PrintingPolicyProperty = 0
	PrintingPolicy_SuppressSpecifiers                    PrintingPolicyProperty = 1
	PrintingPolicy_SuppressTagKeyword                    PrintingPolicyProperty = 2
	PrintingPolicy_IncludeTagDefinition                  PrintingPolicyProperty = 3
	PrintingPolicy_SuppressScope                         PrintingPolicyProperty = 4
	PrintingPolicy_SuppressUnwrittenScope                PrintingPolicyProperty = 5
	PrintingPolicy_SuppressInitializers                  PrintingPolicyProperty = 6
	PrintingPolicy_ConstantArraySizeAsWritten            PrintingPolicyProperty = 7
	PrintingPolicy_AnonymousTagLocations                 PrintingPolicyProperty = 8
	PrintingPolicy_SuppressStrongLifetime                PrintingPolicyProperty = 9
	PrintingPolicy_SuppressLifetimeQualifiers            PrintingPolicyProperty = 10
	PrintingPolicy_SuppressTemplateArgsInCXXConstructors PrintingPolicyProperty = 11
	PrintingPolicy_Bool                                  PrintingPolicyProperty = 12
	PrintingPolicy_Restrict                              PrintingPolicyProperty = 13
	PrintingPolicy_Alignof                               PrintingPolicyProperty = 14
	PrintingPolicy_UnderscoreAlignof                     PrintingPolicyProperty = 15
	PrintingPolicy_UseVoidForZeroParams                  PrintingPolicyProperty = 16
	PrintingPolicy_TerseOutput                           PrintingPolicyProperty = 17
	PrintingPolicy_PolishForDeclaration                  PrintingPolicyProperty = 18
	PrintingPolicy_Half                                  PrintingPolicyProperty = 19
	PrintingPolicy_MSWChar                               PrintingPolicyProperty = 20
	PrintingPolicy_IncludeNewlines                       PrintingPolicyProperty = 21
	PrintingPolicy_MSVCFormatting                        PrintingPolicyProperty = 22
	PrintingPolicy_ConstantsAsWritten                    PrintingPolicyProperty = 23
	PrintingPolicy_SuppressImplicitBase                  PrintingPolicyProperty = 24
	PrintingPolicy_FullyQualifiedName                    PrintingPolicyProperty = 25
	PrintingPolicy_LastProperty                          PrintingPolicyProperty = 25
)

type RefQualifierKind 

type RefQualifierKind uint32

Represents the C enum CXRefQualifierKind. 

const (
	// No ref-qualifier was provided.
	RefQualifier_None RefQualifierKind = 0
	// An lvalue ref-qualifier was provided (&).
	RefQualifier_LValue RefQualifierKind = 1
	// An rvalue ref-qualifier was provided (&&).
	RefQualifier_RValue RefQualifierKind = 2
)

type Remapping 

type Remapping struct {
	// contains filtered or unexported fields
}

@}

Represents the C type CXRemapping.

func GetRemappings 

func GetRemappings(p0 string) Remapping

Wraps the C function clang_getRemappings.

func (Remapping) RemapFilenames 

func (p0 Remapping) RemapFilenames(p1 uint32) (string, string)

Wraps the C function clang_remap_getFilenames.

func (Remapping) RemapNumFiles 

func (p0 Remapping) RemapNumFiles() uint32

Wraps the C function clang_remap_getNumFiles.

func (Remapping) Remap_dispose 

func (p0 Remapping) Remap_dispose()

Wraps the C function clang_remap_dispose.

type Reparse_Flags 

type Reparse_Flags uint32

Flags that control the reparsing of translation units.

The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when reparsing the translation unit.

Represents the C enum CXReparse_Flags. 

const (
	// Used to indicate that no special reparsing options are needed.
	Reparse_None Reparse_Flags = 0
)

type Result 

type Result uint32

Represents the C enum CXResult. 

const (
	// Function returned successfully.
	Result_Success Result = 0
	// One of the parameters was invalid for the function.
	Result_Invalid Result = 1
	// The function was terminated by a callback (e.g. it returned CXVisit_Break)
	Result_VisitBreak Result = 2
)

type SaveError 

type SaveError uint32

Describes the kind of error that occurred (if any) in a call to clang_saveTranslationUnit().

Represents the C enum CXSaveError. 

const (
	// Indicates that no error occurred while saving a translation unit.
	SaveError_None SaveError = 0
	/*
	   Indicates that an unknown error occurred while attempting to save the file.

	   This error typically indicates that file I/O failed when attempting to write the file.
	*/
	SaveError_Unknown SaveError = 1
	/*
	   Indicates that errors during translation prevented this attempt to save the translation unit.

	   Errors that prevent the translation unit from being saved can be extracted using clang_getNumDiagnostics() and clang_getDiagnostic().
	*/
	SaveError_TranslationErrors SaveError = 2
	// Indicates that the translation unit to be saved was somehow invalid (e.g., NULL).
	SaveError_InvalidTU SaveError = 3
)

type SaveTranslationUnit_Flags 

type SaveTranslationUnit_Flags uint32

Flags that control how translation units are saved.

The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when saving the translation unit.

Represents the C enum CXSaveTranslationUnit_Flags. 

const (
	// Used to indicate that no special saving options are needed.
	SaveTranslationUnit_None SaveTranslationUnit_Flags = 0
)

type SourceLocation 

type SourceLocation struct {
	Ptr_data [16]byte // const void *[2]
	Int_data uint32
	// contains filtered or unexported fields
}

Identifies a specific source location within a translation unit.

Use clang_getExpansionLocation() or clang_getSpellingLocation() to map a source location to a particular file, line, and column.

Represents the C struct CXSourceLocation.

func GetNullLocation 

func GetNullLocation() SourceLocation

Retrieve a NULL (invalid) source location.

Wraps the C function clang_getNullLocation.

func (SourceLocation) EqualLocations 

func (loc1 SourceLocation) EqualLocations(loc2 SourceLocation) uint32

Determine whether two source locations, which must refer into the same translation unit, refer to exactly the same point in the source code.

Wraps the C function clang_equalLocations.

func (SourceLocation) ExpansionLocation 

func (location SourceLocation) ExpansionLocation() (File, uint32, uint32, uint32)

Retrieve the file, line, column, and offset represented by the given source location.

If the location refers into a macro expansion, retrieves the location of the macro expansion.

Wraps the C function clang_getExpansionLocation.

func (SourceLocation) FileLocation 

func (location SourceLocation) FileLocation() (File, uint32, uint32, uint32)

Retrieve the file, line, column, and offset represented by the given source location.

If the location refers into a macro expansion, return where the macro was expanded or where the macro argument was written, if the location points at a macro argument.

Wraps the C function clang_getFileLocation.

func (SourceLocation) InstantiationLocation 

func (location SourceLocation) InstantiationLocation() (File, uint32, uint32, uint32)

Legacy API to retrieve the file, line, column, and offset represented by the given source location.

This interface has been replaced by the newer interface #clang_getExpansionLocation(). See that interface's documentation for details.

Wraps the C function clang_getInstantiationLocation.

func (SourceLocation) IsBeforeInTranslationUnit 

func (loc1 SourceLocation) IsBeforeInTranslationUnit(loc2 SourceLocation) uint32

Determine for two source locations if the first comes strictly before the second one in the source code.

Wraps the C function clang_isBeforeInTranslationUnit.

func (SourceLocation) Location_isFromMainFile 

func (location SourceLocation) Location_isFromMainFile() int32

Returns non-zero if the given source location is in the main file of the corresponding translation unit.

Wraps the C function clang_Location_isFromMainFile.

func (SourceLocation) Location_isInSystemHeader 

func (location SourceLocation) Location_isInSystemHeader() int32

Returns non-zero if the given source location is in a system header.

Wraps the C function clang_Location_isInSystemHeader.

func (SourceLocation) PresumedLocation 

func (location SourceLocation) PresumedLocation() (string, uint32, uint32)

Retrieve the file, line and column represented by the given source location, as specified in a # line directive.

Example: given the following source code in a file somefile.c

the location information returned by this function would be

File: dummy.c Line: 124 Column: 12

whereas clang_getExpansionLocation would have returned

File: somefile.c Line: 3 Column: 12

Wraps the C function clang_getPresumedLocation.

func (SourceLocation) Range 

func (begin SourceLocation) Range(end SourceLocation) SourceRange

Retrieve a source range given the beginning and ending source locations.

Wraps the C function clang_getRange.

func (SourceLocation) SpellingLocation 

func (location SourceLocation) SpellingLocation() (File, uint32, uint32, uint32)

Retrieve the file, line, column, and offset represented by the given source location.

If the location refers into a macro instantiation, return where the location was originally spelled in the source file.

Wraps the C function clang_getSpellingLocation.

type SourceRange 

type SourceRange struct {
	Ptr_data       [16]byte // const void *[2]
	Begin_int_data uint32
	End_int_data   uint32
	// contains filtered or unexported fields
}

Identifies a half-open character range in the source code.

Use clang_getRangeStart() and clang_getRangeEnd() to retrieve the starting and end locations from a source range, respectively.

Represents the C struct CXSourceRange.

func GetNullRange 

func GetNullRange() SourceRange

Retrieve a NULL (invalid) source range.

Wraps the C function clang_getNullRange.

func (SourceRange) EqualRanges 

func (range1 SourceRange) EqualRanges(range2 SourceRange) uint32

Determine whether two ranges are equivalent.

Wraps the C function clang_equalRanges.

func (SourceRange) RangeEnd 

func (range_ SourceRange) RangeEnd() SourceLocation

Retrieve a source location representing the last character within a source range.

Wraps the C function clang_getRangeEnd.

func (SourceRange) RangeStart 

func (range_ SourceRange) RangeStart() SourceLocation

Retrieve a source location representing the first character within a source range.

Wraps the C function clang_getRangeStart.

func (SourceRange) Range_isNull 

func (range_ SourceRange) Range_isNull() int32

Returns non-zero if range is null.

Wraps the C function clang_Range_isNull.

type SourceRangeList 

type SourceRangeList struct {

	// The number of ranges in the ranges array.
	Count uint32

	// An array of CXSourceRanges.
	Ranges *SourceRange
	// contains filtered or unexported fields
}

Identifies an array of ranges.

Represents the C struct CXSourceRangeList.

func (*SourceRangeList) DisposeSourceRangeList 

func (ranges *SourceRangeList) DisposeSourceRangeList()

Destroy the given CXSourceRangeList.

Wraps the C function clang_disposeSourceRangeList.

type StorageClass 

type StorageClass uint32

Represents the storage classes as declared in the source. CX_SC_Invalid was added for the case that the passed cursor in not a declaration.

Represents the C enum CX_StorageClass. 

const (
	SC_Invalid              StorageClass = 0
	SC_None                 StorageClass = 1
	SC_Extern               StorageClass = 2
	SC_Static               StorageClass = 3
	SC_PrivateExtern        StorageClass = 4
	SC_OpenCLWorkGroupLocal StorageClass = 5
	SC_Auto                 StorageClass = 6
	SC_Register             StorageClass = 7
)

type StringSet 

type StringSet struct {
	Strings *string_
	Count   uint32
	// contains filtered or unexported fields
}

Represents the C struct CXStringSet.

func (*StringSet) DisposeStringSet 

func (set *StringSet) DisposeStringSet()

Free the given string set.

Wraps the C function clang_disposeStringSet.

type SymbolRole 

type SymbolRole uint32

Roles that are attributed to symbol occurrences.

Internal: this currently mirrors low 9 bits of clang::index::SymbolRole with higher bits zeroed. These high bits may be exposed in the future.

Represents the C enum CXSymbolRole. 

const (
	SymbolRole_None        SymbolRole = 0
	SymbolRole_Declaration SymbolRole = 1
	SymbolRole_Definition  SymbolRole = 2
	SymbolRole_Reference   SymbolRole = 4
	SymbolRole_Read        SymbolRole = 8
	SymbolRole_Write       SymbolRole = 16
	SymbolRole_Call        SymbolRole = 32
	SymbolRole_Dynamic     SymbolRole = 64
	SymbolRole_AddressOf   SymbolRole = 128
	SymbolRole_Implicit    SymbolRole = 256
)

type TLSKind 

type TLSKind uint32

Describe the "thread-local storage (TLS) kind" of the declaration referred to by a cursor.

Represents the C enum CXTLSKind. 

const (
	TLS_None    TLSKind = 0
	TLS_Dynamic TLSKind = 1
	TLS_Static  TLSKind = 2
)

type TUResourceUsage 

type TUResourceUsage struct {
	NumEntries uint32

	Entries *TUResourceUsageEntry
	// contains filtered or unexported fields
}

The memory usage of a CXTranslationUnit, broken into categories.

Represents the C struct CXTUResourceUsage.

func (TUResourceUsage) DisposeCXTUResourceUsage 

func (usage TUResourceUsage) DisposeCXTUResourceUsage()

Wraps the C function clang_disposeCXTUResourceUsage.

type TUResourceUsageEntry 

type TUResourceUsageEntry struct {
	Kind TUResourceUsageKind

	Amount uint64
	// contains filtered or unexported fields
}

Represents the C struct CXTUResourceUsageEntry.

type TUResourceUsageKind 

type TUResourceUsageKind uint32

Categorizes how memory is being used by a translation unit.

Represents the C enum CXTUResourceUsageKind. 

const (
	TUResourceUsage_AST                                TUResourceUsageKind = 1
	TUResourceUsage_Identifiers                        TUResourceUsageKind = 2
	TUResourceUsage_Selectors                          TUResourceUsageKind = 3
	TUResourceUsage_GlobalCompletionResults            TUResourceUsageKind = 4
	TUResourceUsage_SourceManagerContentCache          TUResourceUsageKind = 5
	TUResourceUsage_AST_SideTables                     TUResourceUsageKind = 6
	TUResourceUsage_SourceManager_Membuffer_Malloc     TUResourceUsageKind = 7
	TUResourceUsage_SourceManager_Membuffer_MMap       TUResourceUsageKind = 8
	TUResourceUsage_ExternalASTSource_Membuffer_Malloc TUResourceUsageKind = 9
	TUResourceUsage_ExternalASTSource_Membuffer_MMap   TUResourceUsageKind = 10
	TUResourceUsage_Preprocessor                       TUResourceUsageKind = 11
	TUResourceUsage_PreprocessingRecord                TUResourceUsageKind = 12
	TUResourceUsage_SourceManager_DataStructures       TUResourceUsageKind = 13
	TUResourceUsage_Preprocessor_HeaderSearch          TUResourceUsageKind = 14
	TUResourceUsage_MEMORY_IN_BYTES_BEGIN              TUResourceUsageKind = 1
	TUResourceUsage_MEMORY_IN_BYTES_END                TUResourceUsageKind = 14
	TUResourceUsage_First                              TUResourceUsageKind = 1
	TUResourceUsage_Last                               TUResourceUsageKind = 14
)

func (TUResourceUsageKind) TUResourceUsageName 

func (kind TUResourceUsageKind) TUResourceUsageName() string

Returns the human-readable null-terminated C string that represents the name of the memory category. This string should never be freed.

Wraps the C function clang_getTUResourceUsageName.

type TargetInfo 

type TargetInfo struct {
	// contains filtered or unexported fields
}

An opaque type representing target information for a given translation unit.

Represents the C type CXTargetInfo.

func (TargetInfo) Dispose 

func (info TargetInfo) Dispose()

Destroy the CXTargetInfo object.

Wraps the C function clang_TargetInfo_dispose.

func (TargetInfo) PointerWidth 

func (info TargetInfo) PointerWidth() int32

Get the pointer width of the target in bits.

Returns -1 in case of error.

Wraps the C function clang_TargetInfo_getPointerWidth.

func (TargetInfo) Triple 

func (info TargetInfo) Triple() string

Get the normalized target triple as a string.

Returns the empty string in case of any error.

Wraps the C function clang_TargetInfo_getTriple.

type TargetInfoImpl 

type TargetInfoImpl struct {
	// contains filtered or unexported fields
}

Represents the C struct CXTargetInfoImpl.

type TemplateArgumentKind 

type TemplateArgumentKind uint32

Describes the kind of a template argument.

See the definition of llvm::clang::TemplateArgument::ArgKind for full element descriptions.

Represents the C enum CXTemplateArgumentKind. 

const (
	TemplateArgumentKind_Null              TemplateArgumentKind = 0
	TemplateArgumentKind_Type              TemplateArgumentKind = 1
	TemplateArgumentKind_Declaration       TemplateArgumentKind = 2
	TemplateArgumentKind_NullPtr           TemplateArgumentKind = 3
	TemplateArgumentKind_Integral          TemplateArgumentKind = 4
	TemplateArgumentKind_Template          TemplateArgumentKind = 5
	TemplateArgumentKind_TemplateExpansion TemplateArgumentKind = 6
	TemplateArgumentKind_Expression        TemplateArgumentKind = 7
	TemplateArgumentKind_Pack              TemplateArgumentKind = 8
	TemplateArgumentKind_Invalid           TemplateArgumentKind = 9
)

type Token 

type Token struct {
	Int_data [16]byte // unsigned int[4]
	// contains filtered or unexported fields
}

Describes a single preprocessing token.

Represents the C struct CXToken.

func (Token) TokenKind 

func (p0 Token) TokenKind() TokenKind

Determine the kind of the given token.

Wraps the C function clang_getTokenKind.

type TokenKind 

type TokenKind uint32

Describes a kind of token.

Represents the C enum CXTokenKind. 

const (
	// A token that contains some kind of punctuation.
	Token_Punctuation TokenKind = 0
	// A language keyword.
	Token_Keyword TokenKind = 1
	// An identifier (that is not a keyword).
	Token_Identifier TokenKind = 2
	// A numeric, string, or character literal.
	Token_Literal TokenKind = 3
	// A comment.
	Token_Comment TokenKind = 4
)

type TranslationUnit 

type TranslationUnit struct {
	// contains filtered or unexported fields
}

A single translation unit, which resides in an index.

Represents the C type CXTranslationUnit.

func (TranslationUnit) AllSkippedRanges 

func (tu TranslationUnit) AllSkippedRanges() *SourceRangeList

Retrieve all ranges from all files that were skipped by the preprocessor.

The preprocessor will skip lines when they are surrounded by an if/ifdef/ifndef directive whose condition does not evaluate to true.

Wraps the C function clang_getAllSkippedRanges.

func (TranslationUnit) AnnotateTokens 

func (tU TranslationUnit) AnnotateTokens(numTokens uint32) (Token, Cursor)

Annotate the given set of tokens by providing cursors for each token that can be mapped to a specific entity within the abstract syntax tree.

This token-annotation routine is equivalent to invoking clang_getCursor() for the source locations of each of the tokens. The cursors provided are filtered, so that only those cursors that have a direct correspondence to the token are accepted. For example, given a function call f(x), clang_getCursor() would provide the following cursors:

* when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'. * when the cursor is over the '(' or the ')', a CallExpr referring to 'f'. * when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'.

Only the first and last of these cursors will occur within the annotate, since the tokens "f" and "x' directly refer to a function and a variable, respectively, but the parentheses are just a small part of the full syntax of the function call expression, which is not provided as an annotation.

Wraps the C function clang_annotateTokens.

func (TranslationUnit) CodeCompleteAt 

func (tU TranslationUnit) CodeCompleteAt(complete_filename string, complete_line uint32, complete_column uint32, unsaved_files []UnsavedFile, options uint32) *CodeCompleteResults

Perform code completion at a given location in a translation unit.

This function performs code completion at a particular file, line, and column within source code, providing results that suggest potential code snippets based on the context of the completion. The basic model for code completion is that Clang will parse a complete source file, performing syntax checking up to the location where code-completion has been requested. At that point, a special code-completion token is passed to the parser, which recognizes this token and determines, based on the current location in the C/Objective-C/C++ grammar and the state of semantic analysis, what completions to provide. These completions are returned via a new CXCodeCompleteResults structure.

Code completion itself is meant to be triggered by the client when the user types punctuation characters or whitespace, at which point the code-completion location will coincide with the cursor. For example, if p is a pointer, code-completion might be triggered after the "-" and then after the ">" in p->. When the code-completion location is after the ">", the completion results will provide, e.g., the members of the struct that "p" points to. The client is responsible for placing the cursor at the beginning of the token currently being typed, then filtering the results based on the contents of the token. For example, when code-completing for the expression p->get, the client should provide the location just after the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the client can filter the results based on the current token text ("get"), only showing those results that start with "get". The intent of this interface is to separate the relatively high-latency acquisition of code-completion results from the filtering of results on a per-character basis, which must have a lower latency.

Wraps the C function clang_codeCompleteAt.

func (TranslationUnit) CreateAPISet 

func (tu TranslationUnit) CreateAPISet() (APISet, ErrorCode)

Traverses the translation unit to create a CXAPISet.

Wraps the C function clang_createAPISet.

func (TranslationUnit) Cursor 

func (p0 TranslationUnit) Cursor(p1 SourceLocation) Cursor

Map a source location to the cursor that describes the entity at that location in the source code.

clang_getCursor() maps an arbitrary source location within a translation unit down to the most specific cursor that describes the entity at that location. For example, given an expression x + y, invoking clang_getCursor() with a source location pointing to "x" will return the cursor for "x"; similarly for "y". If the cursor points anywhere between "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor() will return a cursor referring to the "+" expression.

Wraps the C function clang_getCursor.

func (TranslationUnit) DefaultReparseOptions 

func (tU TranslationUnit) DefaultReparseOptions() uint32

Returns the set of flags that is suitable for reparsing a translation unit.

The set of flags returned provide options for clang_reparseTranslationUnit() by default. The returned flag set contains an unspecified set of optimizations geared toward common uses of reparsing. The set of optimizations enabled may change from one version to the next.

Wraps the C function clang_defaultReparseOptions.

func (TranslationUnit) DefaultSaveOptions 

func (tU TranslationUnit) DefaultSaveOptions() uint32

Returns the set of flags that is suitable for saving a translation unit.

The set of flags returned provide options for clang_saveTranslationUnit() by default. The returned flag set contains an unspecified set of options that save translation units with the most commonly-requested data.

Wraps the C function clang_defaultSaveOptions.

func (TranslationUnit) Diagnostic 

func (unit TranslationUnit) Diagnostic(index uint32) Diagnostic

Retrieve a diagnostic associated with the given translation unit.

Wraps the C function clang_getDiagnostic.

func (TranslationUnit) DiagnosticSetFromTU 

func (unit TranslationUnit) DiagnosticSetFromTU() DiagnosticSet

Retrieve the complete set of diagnostics associated with a translation unit.

Wraps the C function clang_getDiagnosticSetFromTU.

func (TranslationUnit) DisposeTokens 

func (tU TranslationUnit) DisposeTokens(numTokens uint32) Token

Free the given set of tokens.

Wraps the C function clang_disposeTokens.

func (TranslationUnit) DisposeTranslationUnit 

func (p0 TranslationUnit) DisposeTranslationUnit()

Destroy the specified CXTranslationUnit object.

Wraps the C function clang_disposeTranslationUnit.

func (TranslationUnit) File 

func (tu TranslationUnit) File(file_name string) File

Retrieve a file handle within the given translation unit.

Wraps the C function clang_getFile.

func (TranslationUnit) FindIncludesInFile 

func (tU TranslationUnit) FindIncludesInFile(file File, visitor CursorAndRangeVisitor) Result

Find #import/#include directives in a specific file.

Wraps the C function clang_findIncludesInFile.

func (TranslationUnit) FindIncludesInFileWithBlock 

func (p0 TranslationUnit) FindIncludesInFileWithBlock(p1 File, p2 CursorAndRangeVisitorBlock) Result

Wraps the C function clang_findIncludesInFileWithBlock.

func (TranslationUnit) Inclusions 

func (tu TranslationUnit) Inclusions(visitor InclusionVisitor, client_data ClientData)

Visit the set of preprocessor inclusions in a translation unit. The visitor function is called with the provided data for every included file. This does not include headers included by the PCH file (unless one is inspecting the inclusions in the PCH file itself).

Wraps the C function clang_getInclusions.

func (TranslationUnit) IsFileMultipleIncludeGuarded 

func (tu TranslationUnit) IsFileMultipleIncludeGuarded(file File) uint32

Determine whether the given header is guarded against multiple inclusions, either with the conventional #ifndef/#define/#endif macro guards or with #pragma once.

Wraps the C function clang_isFileMultipleIncludeGuarded.

func (TranslationUnit) Location 

func (tu TranslationUnit) Location(file File, line uint32, column uint32) SourceLocation

Retrieves the source location associated with a given file/line/column in a particular translation unit.

Wraps the C function clang_getLocation.

func (TranslationUnit) LocationForOffset 

func (tu TranslationUnit) LocationForOffset(file File, offset uint32) SourceLocation

Retrieves the source location associated with a given character offset in a particular translation unit.

Wraps the C function clang_getLocationForOffset.

func (TranslationUnit) ModuleForFile 

func (p0 TranslationUnit) ModuleForFile(p1 File) Module

Given a CXFile header file, return the module that contains it, if one exists.

Wraps the C function clang_getModuleForFile.

func (TranslationUnit) ModuleNumTopLevelHeaders 

func (p0 TranslationUnit) ModuleNumTopLevelHeaders(module Module) uint32

Wraps the C function clang_Module_getNumTopLevelHeaders.

func (TranslationUnit) ModuleTopLevelHeader 

func (p0 TranslationUnit) ModuleTopLevelHeader(module Module, index uint32) File

Wraps the C function clang_Module_getTopLevelHeader.

func (TranslationUnit) NumDiagnostics 

func (unit TranslationUnit) NumDiagnostics() uint32

Determine the number of diagnostics produced for the given translation unit.

Wraps the C function clang_getNumDiagnostics.

func (TranslationUnit) ReparseTranslationUnit 

func (tU TranslationUnit) ReparseTranslationUnit(unsaved_files []UnsavedFile, options uint32) int32

Reparse the source files that produced this translation unit.

This routine can be used to re-parse the source files that originally created the given translation unit, for example because those source files have changed (either on disk or as passed via unsaved_files). The source code will be reparsed with the same command-line options as it was originally parsed.

Reparsing a translation unit invalidates all cursors and source locations that refer into that translation unit. This makes reparsing a translation unit semantically equivalent to destroying the translation unit and then creating a new translation unit with the same command-line arguments. However, it may be more efficient to reparse a translation unit using this routine.

Wraps the C function clang_reparseTranslationUnit.

func (TranslationUnit) SaveTranslationUnit 

func (tU TranslationUnit) SaveTranslationUnit(fileName string, options uint32) int32

Saves a translation unit into a serialized representation of that translation unit on disk.

Any translation unit that was parsed without error can be saved into a file. The translation unit can then be deserialized into a new CXTranslationUnit with clang_createTranslationUnit() or, if it is an incomplete translation unit that corresponds to a header, used as a precompiled header when parsing other translation units.

Wraps the C function clang_saveTranslationUnit.

func (TranslationUnit) SkippedRanges 

func (tu TranslationUnit) SkippedRanges(file File) *SourceRangeList

Retrieve all ranges that were skipped by the preprocessor.

The preprocessor will skip lines when they are surrounded by an if/ifdef/ifndef directive whose condition does not evaluate to true.

Wraps the C function clang_getSkippedRanges.

func (TranslationUnit) SuspendTranslationUnit 

func (p0 TranslationUnit) SuspendTranslationUnit() uint32

Suspend a translation unit in order to free memory associated with it.

A suspended translation unit uses significantly less memory but on the other side does not support any other calls than clang_reparseTranslationUnit to resume it or clang_disposeTranslationUnit to dispose it completely.

Wraps the C function clang_suspendTranslationUnit.

func (TranslationUnit) TUResourceUsage 

func (tU TranslationUnit) TUResourceUsage() TUResourceUsage

Return the memory usage of a translation unit. This object should be released with clang_disposeCXTUResourceUsage().

Wraps the C function clang_getCXTUResourceUsage.

func (TranslationUnit) Token 

func (tU TranslationUnit) Token(location SourceLocation) *Token

Get the raw lexical token starting with the given location.

Wraps the C function clang_getToken.

func (TranslationUnit) TokenExtent 

func (p0 TranslationUnit) TokenExtent(p1 Token) SourceRange

Retrieve a source range that covers the given token.

Wraps the C function clang_getTokenExtent.

func (TranslationUnit) TokenLocation 

func (p0 TranslationUnit) TokenLocation(p1 Token) SourceLocation

Retrieve the source location of the given token.

Wraps the C function clang_getTokenLocation.

func (TranslationUnit) TokenSpelling 

func (p0 TranslationUnit) TokenSpelling(p1 Token) string

Determine the spelling of the given token.

The spelling of a token is the textual representation of that token, e.g., the text of an identifier or keyword.

Wraps the C function clang_getTokenSpelling.

func (TranslationUnit) TranslationUnitCursor 

func (p0 TranslationUnit) TranslationUnitCursor() Cursor

Retrieve the cursor that represents the given translation unit.

The translation unit cursor can be used to start traversing the various declarations within the given translation unit.

Wraps the C function clang_getTranslationUnitCursor.

func (TranslationUnit) TranslationUnitSpelling 

func (cTUnit TranslationUnit) TranslationUnitSpelling() string

Get the original translation unit source file name.

Wraps the C function clang_getTranslationUnitSpelling.

func (TranslationUnit) TranslationUnitTargetInfo 

func (cTUnit TranslationUnit) TranslationUnitTargetInfo() TargetInfo

Get target information for this translation unit.

The CXTargetInfo object cannot outlive the CXTranslationUnit object.

Wraps the C function clang_getTranslationUnitTargetInfo.

type TranslationUnitImpl 

type TranslationUnitImpl struct {
	// contains filtered or unexported fields
}

Represents the C struct CXTranslationUnitImpl.

type TranslationUnit_Flags 

type TranslationUnit_Flags uint32

Flags that control the creation of translation units.

The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when constructing the translation unit.

Represents the C enum CXTranslationUnit_Flags. 

const (
	// Used to indicate that no special translation-unit options are needed.
	TranslationUnit_None TranslationUnit_Flags = 0
	/*
	   Used to indicate that the parser should construct a "detailed" preprocessing record, including all macro definitions and instantiations.

	   Constructing a detailed preprocessing record requires more memory and time to parse, since the information contained in the record is usually not retained. However, it can be useful for applications that require more detailed information about the behavior of the preprocessor.
	*/
	TranslationUnit_DetailedPreprocessingRecord TranslationUnit_Flags = 1
	/*
	   Used to indicate that the translation unit is incomplete.

	   When a translation unit is considered "incomplete", semantic analysis that is typically performed at the end of the translation unit will be suppressed. For example, this suppresses the completion of tentative declarations in C and of instantiation of implicitly-instantiation function templates in C++. This option is typically used when parsing a header with the intent of producing a precompiled header.
	*/
	TranslationUnit_Incomplete TranslationUnit_Flags = 2
	/*
	   Used to indicate that the translation unit should be built with an implicit precompiled header for the preamble.

	   An implicit precompiled header is used as an optimization when a particular translation unit is likely to be reparsed many times when the sources aren't changing that often. In this case, an implicit precompiled header will be built containing all of the initial includes at the top of the main file (what we refer to as the "preamble" of the file). In subsequent parses, if the preamble or the files in it have not changed, clang_reparseTranslationUnit() will re-use the implicit precompiled header to improve parsing performance.
	*/
	TranslationUnit_PrecompiledPreamble TranslationUnit_Flags = 4
	/*
	   Used to indicate that the translation unit should cache some code-completion results with each reparse of the source file.

	   Caching of code-completion results is a performance optimization that introduces some overhead to reparsing but improves the performance of code-completion operations.
	*/
	TranslationUnit_CacheCompletionResults TranslationUnit_Flags = 8
	/*
	   Used to indicate that the translation unit will be serialized with clang_saveTranslationUnit.

	   This option is typically used when parsing a header with the intent of producing a precompiled header.
	*/
	TranslationUnit_ForSerialization TranslationUnit_Flags = 16
	/*
	   DEPRECATED: Enabled chained precompiled preambles in C++.

	   Note: this is a *temporary* option that is available only while we are testing C++ precompiled preamble support. It is deprecated.
	*/
	TranslationUnit_CXXChainedPCH TranslationUnit_Flags = 32
	/*
	   Used to indicate that function/method bodies should be skipped while parsing.

	   This option can be used to search for declarations/definitions while ignoring the usages.
	*/
	TranslationUnit_SkipFunctionBodies TranslationUnit_Flags = 64
	// Used to indicate that brief documentation comments should be included into the set of code completions returned from this translation unit.
	TranslationUnit_IncludeBriefCommentsInCodeCompletion TranslationUnit_Flags = 128
	// Used to indicate that the precompiled preamble should be created on the first parse. Otherwise it will be created on the first reparse. This trades runtime on the first parse (serializing the preamble takes time) for reduced runtime on the second parse (can now reuse the preamble).
	TranslationUnit_CreatePreambleOnFirstParse TranslationUnit_Flags = 256
	/*
	   Do not stop processing when fatal errors are encountered.

	   When fatal errors are encountered while parsing a translation unit, semantic analysis is typically stopped early when compiling code. A common source for fatal errors are unresolvable include files. For the purposes of an IDE, this is undesirable behavior and as much information as possible should be reported. Use this flag to enable this behavior.
	*/
	TranslationUnit_KeepGoing TranslationUnit_Flags = 512
	// Sets the preprocessor in a mode for parsing a single file only.
	TranslationUnit_SingleFileParse TranslationUnit_Flags = 1024
	/*
	   Used in combination with CXTranslationUnit_SkipFunctionBodies to constrain the skipping of function bodies to the preamble.

	   The function bodies of the main file are not skipped.
	*/
	TranslationUnit_LimitSkipFunctionBodiesToPreamble TranslationUnit_Flags = 2048
	// Used to indicate that attributed types should be included in CXType.
	TranslationUnit_IncludeAttributedTypes TranslationUnit_Flags = 4096
	// Used to indicate that implicit attributes should be visited.
	TranslationUnit_VisitImplicitAttributes TranslationUnit_Flags = 8192
	/*
	   Used to indicate that non-errors from included files should be ignored.

	   If set, clang_getDiagnosticSetFromTU() will not report e.g. warnings from included files anymore. This speeds up clang_getDiagnosticSetFromTU() for the case where these warnings are not of interest, as for an IDE for example, which typically shows only the diagnostics in the main file.
	*/
	TranslationUnit_IgnoreNonErrorsFromIncludedFiles TranslationUnit_Flags = 16384
	// Tells the preprocessor not to skip excluded conditional blocks.
	TranslationUnit_RetainExcludedConditionalBlocks TranslationUnit_Flags = 32768
)

type Type 

type Type struct {
	Kind TypeKind

	Data [16]byte // void *[2]
	// contains filtered or unexported fields
}

The type of an element in the abstract syntax tree.

Represents the C struct CXType.

func (Type) AddressSpace 

func (t Type) AddressSpace() uint32

Returns the address space of the given type.

Wraps the C function clang_getAddressSpace.

func (Type) AlignOf 

func (t Type) AlignOf() int64

Return the alignment of a type in bytes as per C++[expr.alignof] standard.

If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete is returned. If the type declaration is a dependent type, CXTypeLayoutError_Dependent is returned. If the type declaration is not a constant size type, CXTypeLayoutError_NotConstantSize is returned.

Wraps the C function clang_Type_getAlignOf.

func (Type) ArgType 

func (t Type) ArgType(i uint32) Type

Retrieve the type of a parameter of a function type.

If a non-function type is passed in or the function does not have enough parameters, an invalid type is returned.

Wraps the C function clang_getArgType.

func (Type) ArrayElementType 

func (t Type) ArrayElementType() Type

Return the element type of an array type.

If a non-array type is passed in, an invalid type is returned.

Wraps the C function clang_getArrayElementType.

func (Type) ArraySize 

func (t Type) ArraySize() int64

Return the array size of a constant array.

If a non-array type is passed in, -1 is returned.

Wraps the C function clang_getArraySize.

func (Type) CanonicalType 

func (t Type) CanonicalType() Type

Return the canonical type for a CXType.

Clang's type system explicitly models typedefs and all the ways a specific type can be represented. The canonical type is the underlying type with all the "sugar" removed. For example, if 'T' is a typedef for 'int', the canonical type for 'T' would be 'int'.

Wraps the C function clang_getCanonicalType.

func (Type) ClassType 

func (t Type) ClassType() Type

Return the class type of an member pointer type.

If a non-member-pointer type is passed in, an invalid type is returned.

Wraps the C function clang_Type_getClassType.

func (Type) ElementType 

func (t Type) ElementType() Type

Return the element type of an array, complex, or vector type.

If a type is passed in that is not an array, complex, or vector type, an invalid type is returned.

Wraps the C function clang_getElementType.

func (Type) EqualTypes 

func (a Type) EqualTypes(b Type) uint32

Determine whether two CXTypes represent the same type.

Wraps the C function clang_equalTypes.

func (Type) ExceptionSpecificationType 

func (t Type) ExceptionSpecificationType() int32

Retrieve the exception specification type associated with a function type. This is a value of type CXCursor_ExceptionSpecificationKind.

If a non-function type is passed in, an error code of -1 is returned.

Wraps the C function clang_getExceptionSpecificationType.

func (Type) FullyQualifiedName 

func (cT Type) FullyQualifiedName(policy PrintingPolicy, withGlobalNsPrefix uint32) string

Get the fully qualified name for a type.

This includes full qualification of all template parameters.

Policy - Further refine the type formatting WithGlobalNsPrefix - If non-zero, function will prepend a '::' to qualified names

Wraps the C function clang_getFullyQualifiedName.

func (Type) FunctionTypeCallingConv 

func (t Type) FunctionTypeCallingConv() CallingConv

Retrieve the calling convention associated with a function type.

If a non-function type is passed in, CXCallingConv_Invalid is returned.

Wraps the C function clang_getFunctionTypeCallingConv.

func (Type) IsConstQualifiedType 

func (t Type) IsConstQualifiedType() uint32

Determine whether a CXType has the "const" qualifier set, without looking through typedefs that may have added "const" at a different level.

Wraps the C function clang_isConstQualifiedType.

func (Type) IsFunctionTypeVariadic 

func (t Type) IsFunctionTypeVariadic() uint32

Return 1 if the CXType is a variadic function type, and 0 otherwise.

Wraps the C function clang_isFunctionTypeVariadic.

func (Type) IsPODType 

func (t Type) IsPODType() uint32

Return 1 if the CXType is a POD (plain old data) type, and 0 otherwise.

Wraps the C function clang_isPODType.

func (Type) IsRestrictQualifiedType 

func (t Type) IsRestrictQualifiedType() uint32

Determine whether a CXType has the "restrict" qualifier set, without looking through typedefs that may have added "restrict" at a different level.

Wraps the C function clang_isRestrictQualifiedType.

func (Type) IsTransparentTagTypedef 

func (t Type) IsTransparentTagTypedef() uint32

Determine if a typedef is 'transparent' tag.

A typedef is considered 'transparent' if it shares a name and spelling location with its underlying tag type, as is the case with the NS_ENUM macro.

Wraps the C function clang_Type_isTransparentTagTypedef.

func (Type) IsVolatileQualifiedType 

func (t Type) IsVolatileQualifiedType() uint32

Determine whether a CXType has the "volatile" qualifier set, without looking through typedefs that may have added "volatile" at a different level.

Wraps the C function clang_isVolatileQualifiedType.

func (Type) ModifiedType 

func (t Type) ModifiedType() Type

Return the type that was modified by this attributed type.

If the type is not an attributed type, an invalid type is returned.

Wraps the C function clang_Type_getModifiedType.

func (Type) NamedType 

func (t Type) NamedType() Type

Retrieve the type named by the qualified-id.

If a non-elaborated type is passed in, an invalid type is returned.

Wraps the C function clang_Type_getNamedType.

func (Type) NonReferenceType 

func (cT Type) NonReferenceType() Type

For reference types (e.g., "const int&"), returns the type that the reference refers to (e.g "const int").

Otherwise, returns the type itself.

A type that has kind CXType_LValueReference or CXType_RValueReference is a reference type.

Wraps the C function clang_getNonReferenceType.

func (Type) Nullability 

func (t Type) Nullability() TypeNullabilityKind

Retrieve the nullability kind of a pointer type.

Wraps the C function clang_Type_getNullability.

func (Type) NumArgTypes 

func (t Type) NumArgTypes() int32

Retrieve the number of non-variadic parameters associated with a function type.

If a non-function type is passed in, -1 is returned.

Wraps the C function clang_getNumArgTypes.

func (Type) NumElements 

func (t Type) NumElements() int64

Return the number of elements of an array or vector type.

If a type is passed in that is not an array or vector type, -1 is returned.

Wraps the C function clang_getNumElements.

func (Type) NumObjCProtocolRefs 

func (t Type) NumObjCProtocolRefs() uint32

Retrieve the number of protocol references associated with an ObjC object/id.

If the type is not an ObjC object, 0 is returned.

Wraps the C function clang_Type_getNumObjCProtocolRefs.

func (Type) NumObjCTypeArgs 

func (t Type) NumObjCTypeArgs() uint32

Retrieve the number of type arguments associated with an ObjC object.

If the type is not an ObjC object, 0 is returned.

Wraps the C function clang_Type_getNumObjCTypeArgs.

func (Type) NumTemplateArguments 

func (t Type) NumTemplateArguments() int32

Returns the number of template arguments for given template specialization, or -1 if type T is not a template specialization.

Wraps the C function clang_Type_getNumTemplateArguments.

func (Type) ObjCEncoding 

func (type_ Type) ObjCEncoding() string

Returns the Objective-C type encoding for the specified CXType.

Wraps the C function clang_Type_getObjCEncoding.

func (Type) ObjCObjectBaseType 

func (t Type) ObjCObjectBaseType() Type

Retrieves the base type of the ObjCObjectType.

If the type is not an ObjC object, an invalid type is returned.

Wraps the C function clang_Type_getObjCObjectBaseType.

func (Type) ObjCProtocolDecl 

func (t Type) ObjCProtocolDecl(i uint32) Cursor

Retrieve the decl for a protocol reference for an ObjC object/id.

If the type is not an ObjC object or there are not enough protocol references, an invalid cursor is returned.

Wraps the C function clang_Type_getObjCProtocolDecl.

func (Type) ObjCTypeArg 

func (t Type) ObjCTypeArg(i uint32) Type

Retrieve a type argument associated with an ObjC object.

If the type is not an ObjC or the index is not valid, an invalid type is returned.

Wraps the C function clang_Type_getObjCTypeArg.

func (Type) OffsetOf 

func (t Type) OffsetOf(s string) int64

Return the offset of a field named S in a record of type T in bits as it would be returned by __offsetof__ as per C++11[18.2p4]

If the cursor is not a record field declaration, CXTypeLayoutError_Invalid is returned. If the field's type declaration is an incomplete type, CXTypeLayoutError_Incomplete is returned. If the field's type declaration is a dependent type, CXTypeLayoutError_Dependent is returned. If the field's name S is not found, CXTypeLayoutError_InvalidFieldName is returned.

Wraps the C function clang_Type_getOffsetOf.

func (Type) PointeeType 

func (t Type) PointeeType() Type

For pointer types, returns the type of the pointee.

Wraps the C function clang_getPointeeType.

func (Type) ResultType 

func (t Type) ResultType() Type

Retrieve the return type associated with a function type.

If a non-function type is passed in, an invalid type is returned.

Wraps the C function clang_getResultType.

func (Type) SizeOf 

func (t Type) SizeOf() int64

Return the size of a type in bytes as per C++[expr.sizeof] standard.

If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete is returned. If the type declaration is a dependent type, CXTypeLayoutError_Dependent is returned.

Wraps the C function clang_Type_getSizeOf.

func (Type) TemplateArgumentAsType 

func (t Type) TemplateArgumentAsType(i uint32) Type

Returns the type template argument of a template class specialization at given index.

This function only returns template type arguments and does not handle template template arguments or variadic packs.

Wraps the C function clang_Type_getTemplateArgumentAsType.

func (Type) TypeDeclaration 

func (t Type) TypeDeclaration() Cursor

Return the cursor for the declaration of the given type.

Wraps the C function clang_getTypeDeclaration.

func (Type) TypePrettyPrinted 

func (cT Type) TypePrettyPrinted(cxPolicy PrintingPolicy) string

Pretty-print the underlying type using a custom printing policy.

If the type is invalid, an empty string is returned.

Wraps the C function clang_getTypePrettyPrinted.

func (Type) TypeSpelling 

func (cT Type) TypeSpelling() string

Pretty-print the underlying type using the rules of the language of the translation unit from which it came.

If the type is invalid, an empty string is returned.

Wraps the C function clang_getTypeSpelling.

func (Type) TypedefName 

func (cT Type) TypedefName() string

Returns the typedef name of the given type.

Wraps the C function clang_getTypedefName.

func (Type) UnqualifiedType 

func (cT Type) UnqualifiedType() Type

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

For example, given the following series of typedefs:

Executing clang_getUnqualifiedType() on a CXType that represents DifferenceType, will desugar to a type representing Integer, that has no qualifiers.

And, executing clang_getUnqualifiedType() on the type of the first argument of the following function declaration:

Will return a type representing int, removing the const qualifier.

Sugar over array types is not desugared.

A type can be checked for qualifiers with clang_isConstQualifiedType(), clang_isVolatileQualifiedType() and clang_isRestrictQualifiedType().

A type that resulted from a call to clang_getUnqualifiedType will return false for all of the above calls.

Wraps the C function clang_getUnqualifiedType.

func (Type) ValueType 

func (cT Type) ValueType() Type

Gets the type contained by this atomic type.

If a non-atomic type is passed in, an invalid type is returned.

Wraps the C function clang_Type_getValueType.

func (Type) VisitCXXBaseClasses 

func (t Type) VisitCXXBaseClasses(visitor FieldVisitor, client_data ClientData) uint32

Visit the base classes of a type.

This function visits all the direct base classes of a the given cursor, invoking the given visitor function with the cursors of each visited base. The traversal may be ended prematurely, if the visitor returns CXFieldVisit_Break.

Wraps the C function clang_visitCXXBaseClasses.

func (Type) VisitCXXMethods 

func (t Type) VisitCXXMethods(visitor FieldVisitor, client_data ClientData) uint32

Visit the class methods of a type.

This function visits all the methods of the given cursor, invoking the given visitor function with the cursors of each visited method. The traversal may be ended prematurely, if the visitor returns CXFieldVisit_Break.

Wraps the C function clang_visitCXXMethods.

func (Type) VisitFields 

func (t Type) VisitFields(visitor FieldVisitor, client_data ClientData) uint32

Visit the fields of a particular type.

This function visits all the direct fields of the given cursor, invoking the given visitor function with the cursors of each visited field. The traversal may be ended prematurely, if the visitor returns CXFieldVisit_Break.

Wraps the C function clang_Type_visitFields.

func (Type) XRefQualifier 

func (t Type) XRefQualifier() RefQualifierKind

Retrieve the ref-qualifier kind of a function or method.

The ref-qualifier is returned for C++ functions or methods. For other types or non-C++ declarations, CXRefQualifier_None is returned.

Wraps the C function clang_Type_getCXXRefQualifier.

type TypeKind 

type TypeKind uint32

Describes the kind of type

Represents the C enum CXTypeKind. 

const (
	// Represents an invalid type (e.g., where no type is available).
	Type_Invalid TypeKind = 0
	// A type whose specific kind is not exposed via this interface.
	Type_Unexposed TypeKind = 1
	// A type whose specific kind is not exposed via this interface.
	Type_Void TypeKind = 2
	// A type whose specific kind is not exposed via this interface.
	Type_Bool TypeKind = 3
	// A type whose specific kind is not exposed via this interface.
	Type_Char_U TypeKind = 4
	// A type whose specific kind is not exposed via this interface.
	Type_UChar TypeKind = 5
	// A type whose specific kind is not exposed via this interface.
	Type_Char16 TypeKind = 6
	// A type whose specific kind is not exposed via this interface.
	Type_Char32 TypeKind = 7
	// A type whose specific kind is not exposed via this interface.
	Type_UShort TypeKind = 8
	// A type whose specific kind is not exposed via this interface.
	Type_UInt TypeKind = 9
	// A type whose specific kind is not exposed via this interface.
	Type_ULong TypeKind = 10
	// A type whose specific kind is not exposed via this interface.
	Type_ULongLong TypeKind = 11
	// A type whose specific kind is not exposed via this interface.
	Type_UInt128 TypeKind = 12
	// A type whose specific kind is not exposed via this interface.
	Type_Char_S TypeKind = 13
	// A type whose specific kind is not exposed via this interface.
	Type_SChar TypeKind = 14
	// A type whose specific kind is not exposed via this interface.
	Type_WChar TypeKind = 15
	// A type whose specific kind is not exposed via this interface.
	Type_Short TypeKind = 16
	// A type whose specific kind is not exposed via this interface.
	Type_Int TypeKind = 17
	// A type whose specific kind is not exposed via this interface.
	Type_Long TypeKind = 18
	// A type whose specific kind is not exposed via this interface.
	Type_LongLong TypeKind = 19
	// A type whose specific kind is not exposed via this interface.
	Type_Int128 TypeKind = 20
	// A type whose specific kind is not exposed via this interface.
	Type_Float TypeKind = 21
	// A type whose specific kind is not exposed via this interface.
	Type_Double TypeKind = 22
	// A type whose specific kind is not exposed via this interface.
	Type_LongDouble TypeKind = 23
	// A type whose specific kind is not exposed via this interface.
	Type_NullPtr TypeKind = 24
	// A type whose specific kind is not exposed via this interface.
	Type_Overload TypeKind = 25
	// A type whose specific kind is not exposed via this interface.
	Type_Dependent TypeKind = 26
	// A type whose specific kind is not exposed via this interface.
	Type_ObjCId TypeKind = 27
	// A type whose specific kind is not exposed via this interface.
	Type_ObjCClass TypeKind = 28
	// A type whose specific kind is not exposed via this interface.
	Type_ObjCSel TypeKind = 29
	// A type whose specific kind is not exposed via this interface.
	Type_Float128 TypeKind = 30
	// A type whose specific kind is not exposed via this interface.
	Type_Half TypeKind = 31
	// A type whose specific kind is not exposed via this interface.
	Type_Float16 TypeKind = 32
	// A type whose specific kind is not exposed via this interface.
	Type_ShortAccum TypeKind = 33
	// A type whose specific kind is not exposed via this interface.
	Type_Accum TypeKind = 34
	// A type whose specific kind is not exposed via this interface.
	Type_LongAccum TypeKind = 35
	// A type whose specific kind is not exposed via this interface.
	Type_UShortAccum TypeKind = 36
	// A type whose specific kind is not exposed via this interface.
	Type_UAccum TypeKind = 37
	// A type whose specific kind is not exposed via this interface.
	Type_ULongAccum TypeKind = 38
	// A type whose specific kind is not exposed via this interface.
	Type_BFloat16 TypeKind = 39
	// A type whose specific kind is not exposed via this interface.
	Type_Ibm128 TypeKind = 40
	// A type whose specific kind is not exposed via this interface.
	Type_FirstBuiltin TypeKind = 2
	// A type whose specific kind is not exposed via this interface.
	Type_LastBuiltin TypeKind = 40
	// A type whose specific kind is not exposed via this interface.
	Type_Complex TypeKind = 100
	// A type whose specific kind is not exposed via this interface.
	Type_Pointer TypeKind = 101
	// A type whose specific kind is not exposed via this interface.
	Type_BlockPointer TypeKind = 102
	// A type whose specific kind is not exposed via this interface.
	Type_LValueReference TypeKind = 103
	// A type whose specific kind is not exposed via this interface.
	Type_RValueReference TypeKind = 104
	// A type whose specific kind is not exposed via this interface.
	Type_Record TypeKind = 105
	// A type whose specific kind is not exposed via this interface.
	Type_Enum TypeKind = 106
	// A type whose specific kind is not exposed via this interface.
	Type_Typedef TypeKind = 107
	// A type whose specific kind is not exposed via this interface.
	Type_ObjCInterface TypeKind = 108
	// A type whose specific kind is not exposed via this interface.
	Type_ObjCObjectPointer TypeKind = 109
	// A type whose specific kind is not exposed via this interface.
	Type_FunctionNoProto TypeKind = 110
	// A type whose specific kind is not exposed via this interface.
	Type_FunctionProto TypeKind = 111
	// A type whose specific kind is not exposed via this interface.
	Type_ConstantArray TypeKind = 112
	// A type whose specific kind is not exposed via this interface.
	Type_Vector TypeKind = 113
	// A type whose specific kind is not exposed via this interface.
	Type_IncompleteArray TypeKind = 114
	// A type whose specific kind is not exposed via this interface.
	Type_VariableArray TypeKind = 115
	// A type whose specific kind is not exposed via this interface.
	Type_DependentSizedArray TypeKind = 116
	// A type whose specific kind is not exposed via this interface.
	Type_MemberPointer TypeKind = 117
	// A type whose specific kind is not exposed via this interface.
	Type_Auto TypeKind = 118
	/*
	   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.
	*/
	Type_Elaborated TypeKind = 119
	/*
	   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.
	*/
	Type_Pipe TypeKind = 120
	/*
	   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.
	*/
	Type_OCLImage1dRO TypeKind = 121
	/*
	   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.
	*/
	Type_OCLImage1dArrayRO TypeKind = 122
	/*
	   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.
	*/
	Type_OCLImage1dBufferRO TypeKind = 123
	/*
	   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.
	*/
	Type_OCLImage2dRO TypeKind = 124
	/*
	   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.
	*/
	Type_OCLImage2dArrayRO TypeKind = 125
	/*
	   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.
	*/
	Type_OCLImage2dDepthRO TypeKind = 126
	/*
	   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.
	*/
	Type_OCLImage2dArrayDepthRO TypeKind = 127
	/*
	   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.
	*/
	Type_OCLImage2dMSAARO TypeKind = 128
	/*
	   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.
	*/
	Type_OCLImage2dArrayMSAARO TypeKind = 129
	/*
	   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.
	*/
	Type_OCLImage2dMSAADepthRO TypeKind = 130
	/*
	   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.
	*/
	Type_OCLImage2dArrayMSAADepthRO TypeKind = 131
	/*
	   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.
	*/
	Type_OCLImage3dRO TypeKind = 132
	/*
	   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.
	*/
	Type_OCLImage1dWO TypeKind = 133
	/*
	   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.
	*/
	Type_OCLImage1dArrayWO TypeKind = 134
	/*
	   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.
	*/
	Type_OCLImage1dBufferWO TypeKind = 135
	/*
	   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.
	*/
	Type_OCLImage2dWO TypeKind = 136
	/*
	   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.
	*/
	Type_OCLImage2dArrayWO TypeKind = 137
	/*
	   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.
	*/
	Type_OCLImage2dDepthWO TypeKind = 138
	/*
	   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.
	*/
	Type_OCLImage2dArrayDepthWO TypeKind = 139
	/*
	   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.
	*/
	Type_OCLImage2dMSAAWO TypeKind = 140
	/*
	   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.
	*/
	Type_OCLImage2dArrayMSAAWO TypeKind = 141
	/*
	   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.
	*/
	Type_OCLImage2dMSAADepthWO TypeKind = 142
	/*
	   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.
	*/
	Type_OCLImage2dArrayMSAADepthWO TypeKind = 143
	/*
	   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.
	*/
	Type_OCLImage3dWO TypeKind = 144
	/*
	   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.
	*/
	Type_OCLImage1dRW TypeKind = 145
	/*
	   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.
	*/
	Type_OCLImage1dArrayRW TypeKind = 146
	/*
	   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.
	*/
	Type_OCLImage1dBufferRW TypeKind = 147
	/*
	   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.
	*/
	Type_OCLImage2dRW TypeKind = 148
	/*
	   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.
	*/
	Type_OCLImage2dArrayRW TypeKind = 149
	/*
	   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.
	*/
	Type_OCLImage2dDepthRW TypeKind = 150
	/*
	   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.
	*/
	Type_OCLImage2dArrayDepthRW TypeKind = 151
	/*
	   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.
	*/
	Type_OCLImage2dMSAARW TypeKind = 152
	/*
	   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.
	*/
	Type_OCLImage2dArrayMSAARW TypeKind = 153
	/*
	   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.
	*/
	Type_OCLImage2dMSAADepthRW TypeKind = 154
	/*
	   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.
	*/
	Type_OCLImage2dArrayMSAADepthRW TypeKind = 155
	/*
	   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.
	*/
	Type_OCLImage3dRW TypeKind = 156
	/*
	   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.
	*/
	Type_OCLSampler TypeKind = 157
	/*
	   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.
	*/
	Type_OCLEvent TypeKind = 158
	/*
	   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.
	*/
	Type_OCLQueue TypeKind = 159
	/*
	   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.
	*/
	Type_OCLReserveID TypeKind = 160
	/*
	   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.
	*/
	Type_ObjCObject TypeKind = 161
	/*
	   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.
	*/
	Type_ObjCTypeParam TypeKind = 162
	/*
	   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.
	*/
	Type_Attributed TypeKind = 163
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCMcePayload TypeKind = 164
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImePayload TypeKind = 165
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCRefPayload TypeKind = 166
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCSicPayload TypeKind = 167
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCMceResult TypeKind = 168
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeResult TypeKind = 169
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCRefResult TypeKind = 170
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCSicResult TypeKind = 171
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeResultSingleReferenceStreamout TypeKind = 172
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeResultDualReferenceStreamout TypeKind = 173
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeSingleReferenceStreamin TypeKind = 174
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeDualReferenceStreamin TypeKind = 175
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeResultSingleRefStreamout TypeKind = 172
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeResultDualRefStreamout TypeKind = 173
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeSingleRefStreamin TypeKind = 174
	/*
	   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.
	*/
	Type_OCLIntelSubgroupAVCImeDualRefStreamin TypeKind = 175
	/*
	   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.
	*/
	Type_ExtVector TypeKind = 176
	/*
	   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.
	*/
	Type_Atomic TypeKind = 177
	/*
	   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.
	*/
	Type_BTFTagAttributed TypeKind = 178
	/*
	   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.
	*/
	Type_HLSLResource TypeKind = 179
	/*
	   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.
	*/
	Type_HLSLAttributedResource TypeKind = 180
	/*
	   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.
	*/
	Type_HLSLInlineSpirv TypeKind = 181
)

func (TypeKind) TypeKindSpelling 

func (k TypeKind) TypeKindSpelling() string

Retrieve the spelling of a given CXTypeKind.

Wraps the C function clang_getTypeKindSpelling.

type TypeLayoutError 

type TypeLayoutError int32

List the possible error codes for clang_Type_getSizeOf, clang_Type_getAlignOf, clang_Type_getOffsetOf, clang_Cursor_getOffsetOf, and clang_getOffsetOfBase.

A value of this enumeration type can be returned if the target type is not a valid argument to sizeof, alignof or offsetof.

Represents the C enum CXTypeLayoutError. 

const (
	// Type is of kind CXType_Invalid.
	TypeLayoutError_Invalid TypeLayoutError = -1
	// The type is an incomplete Type.
	TypeLayoutError_Incomplete TypeLayoutError = -2
	// The type is a dependent Type.
	TypeLayoutError_Dependent TypeLayoutError = -3
	// The type is not a constant size type.
	TypeLayoutError_NotConstantSize TypeLayoutError = -4
	// The Field name is not valid for this record.
	TypeLayoutError_InvalidFieldName TypeLayoutError = -5
	// The type is undeduced.
	TypeLayoutError_Undeduced TypeLayoutError = -6
)

type TypeNullabilityKind 

type TypeNullabilityKind uint32

Represents the C enum CXTypeNullabilityKind. 

const (
	// Values of this type can never be null.
	TypeNullability_NonNull TypeNullabilityKind = 0
	// Values of this type can be null.
	TypeNullability_Nullable TypeNullabilityKind = 1
	// Whether values of this type can be null is (explicitly) unspecified. This captures a (fairly rare) case where we can't conclude anything about the nullability of the type even though it has been considered.
	TypeNullability_Unspecified TypeNullabilityKind = 2
	// Nullability is not applicable to this type.
	TypeNullability_Invalid TypeNullabilityKind = 3
	// Generally behaves like Nullable, except when used in a block parameter that was imported into a swift async method. There, swift will assume that the parameter can get null even if no error occurred. _Nullable parameters are assumed to only get null on error.
	TypeNullability_NullableResult TypeNullabilityKind = 4
)

type UnaryOperatorKind 

type UnaryOperatorKind uint32

Describes the kind of unary operators.

Represents the C enum CXUnaryOperatorKind. 

const (
	// This value describes cursors which are not unary operators.
	UnaryOperator_Invalid UnaryOperatorKind = 0
	// Postfix increment operator.
	UnaryOperator_PostInc UnaryOperatorKind = 1
	// Postfix decrement operator.
	UnaryOperator_PostDec UnaryOperatorKind = 2
	// Prefix increment operator.
	UnaryOperator_PreInc UnaryOperatorKind = 3
	// Prefix decrement operator.
	UnaryOperator_PreDec UnaryOperatorKind = 4
	// Address of operator.
	UnaryOperator_AddrOf UnaryOperatorKind = 5
	// Dereference operator.
	UnaryOperator_Deref UnaryOperatorKind = 6
	// Plus operator.
	UnaryOperator_Plus UnaryOperatorKind = 7
	// Minus operator.
	UnaryOperator_Minus UnaryOperatorKind = 8
	// Not operator.
	UnaryOperator_Not UnaryOperatorKind = 9
	// LNot operator.
	UnaryOperator_LNot UnaryOperatorKind = 10
	// "__real expr" operator.
	UnaryOperator_Real UnaryOperatorKind = 11
	// "__imag expr" operator.
	UnaryOperator_Imag UnaryOperatorKind = 12
	// __extension__ marker operator.
	UnaryOperator_Extension UnaryOperatorKind = 13
	// C++ co_await operator.
	UnaryOperator_Coawait UnaryOperatorKind = 14
	// C++ co_await operator.
	UnaryOperator_Last UnaryOperatorKind = 14
)

func (UnaryOperatorKind) UnaryOperatorKindSpelling 

func (kind UnaryOperatorKind) UnaryOperatorKindSpelling() string

Retrieve the spelling of a given CXUnaryOperatorKind.

Wraps the C function clang_getUnaryOperatorKindSpelling.

type UnsavedFile 

type UnsavedFile struct {

	// The length of the unsaved contents of this buffer.
	Length uint64
	// contains filtered or unexported fields
}

Provides the contents of a file that has not yet been saved to disk.

Each CXUnsavedFile instance provides the name of a file on the system along with the current contents of that file that have not yet been saved to disk.

Represents the C struct CXUnsavedFile.

func (*UnsavedFile) Contents 

func (s *UnsavedFile) Contents() string

A buffer containing the unsaved contents of this file.

func (*UnsavedFile) Filename 

func (s *UnsavedFile) Filename() string

The file whose contents have not yet been saved.

This file must already exist in the file system.

func (*UnsavedFile) SetContents 

func (s *UnsavedFile) SetContents(str string) (free func())

A buffer containing the unsaved contents of this file.

A C string will be allocated on the C heap. A function is returned that when called will free the C string's memory.

func (*UnsavedFile) SetFilename 

func (s *UnsavedFile) SetFilename(str string) (free func())

The file whose contents have not yet been saved.

This file must already exist in the file system.

A C string will be allocated on the C heap. A function is returned that when called will free the C string's memory.

type Version 

type Version struct {

	// The major version number, e.g., the '10' in '10.7.3'. A negative value indicates that there is no version number at all.
	Major int32
	// The minor version number, e.g., the '7' in '10.7.3'. This value will be negative if no minor version number was provided, e.g., for version '10'.
	Minor int32
	// The subminor version number, e.g., the '3' in '10.7.3'. This value will be negative if no minor or subminor version number was provided, e.g., in version '10' or '10.7'.
	Subminor int32
	// contains filtered or unexported fields
}

Describes a version number of the form major.minor.subminor.

Represents the C struct CXVersion.

type VirtualFileOverlay 

type VirtualFileOverlay struct {
	// contains filtered or unexported fields
}

Object encapsulating information about overlaying virtual file/directories over the real file system.

Represents the C type CXVirtualFileOverlay.

func VirtualFileOverlay_create 

func VirtualFileOverlay_create(options uint32) VirtualFileOverlay

Create a CXVirtualFileOverlay object. Must be disposed with clang_VirtualFileOverlay_dispose().

Wraps the C function clang_VirtualFileOverlay_create.

func (VirtualFileOverlay) AddFileMapping 

func (p0 VirtualFileOverlay) AddFileMapping(virtualPath string, realPath string) ErrorCode

Map an absolute virtual file path to an absolute real one. The virtual path must be canonicalized (not contain "."/"..").

Wraps the C function clang_VirtualFileOverlay_addFileMapping.

func (VirtualFileOverlay) Dispose 

func (p0 VirtualFileOverlay) Dispose()

Dispose a CXVirtualFileOverlay object.

Wraps the C function clang_VirtualFileOverlay_dispose.

func (VirtualFileOverlay) SetCaseSensitivity 

func (p0 VirtualFileOverlay) SetCaseSensitivity(caseSensitive int32) ErrorCode

Set the case sensitivity for the CXVirtualFileOverlay object. The CXVirtualFileOverlay object is case-sensitive by default, this option can be used to override the default.

Wraps the C function clang_VirtualFileOverlay_setCaseSensitivity.

type VirtualFileOverlayImpl 

type VirtualFileOverlayImpl struct {
	// contains filtered or unexported fields
}

Represents the C struct CXVirtualFileOverlayImpl.

type VisibilityKind 

type VisibilityKind uint32

Represents the C enum CXVisibilityKind. 

const (
	// This value indicates that no visibility information is available for a provided CXCursor.
	Visibility_Invalid VisibilityKind = 0
	// Symbol not seen by the linker.
	Visibility_Hidden VisibilityKind = 1
	// Symbol seen by the linker but resolves to a symbol inside this object.
	Visibility_Protected VisibilityKind = 2
	// Symbol seen by the linker and acts like a normal symbol.
	Visibility_Default VisibilityKind = 3
)

type VisitorResult 

type VisitorResult uint32

@{

Represents the C enum CXVisitorResult. 

const (
	Visit_Break    VisitorResult = 0
	Visit_Continue VisitorResult = 1
)

Source Files

View all Source files

Directories

Path Synopsis
example
simple command
internal
generate
generate/cmd command
lib
libc

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.