record TCursor

Determine whether two cursors are equivalent.

Compute a hash value for the given cursor.

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

Returns

Global and platform-specific availibility

Determine the set of methods that are overridden by the given method.

In both Objective-C and C++, a method (aka virtual member function, in C++) can override a virtual method in a base class. For Objective-C, a method is said to override any method in the class's base class, its protocols, or its categories' protocols, that has the same selector and is of the same kind (class or instance). If no such method exists, the search continues to the class's superclass, its protocols, and its categories, and so on. A method from an Objective-C implementation is considered to override the same methods as its corresponding method in the interface.

For C++, a virtual member function overrides any virtual member function with the same signature that occurs in its base classes. With multiple inheritance, a virtual member function can override several virtual member functions coming from different base classes.

In all cases, this function determines the immediate overridden method, rather than all of the overridden methods. For example, if a method is originally declared in a class A, then overridden in B (which in inherits from A) and also in C (which inherited from B), then the only overridden method returned from this function when invoked on C's method will be B's method. The client may then invoke this function again, given the previously-found overridden methods, to map out the complete method-override set.

Returns

List of cursors, representing the set of overridden methods, or nil if there are no overridden methods.

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.

Parameters

APieceIndex

the index of the spelling name piece.

Returns

The source range. If APieceIndex is greater than the actual number of pieces, it will return a NullL (invalid) range.

Returns True if the cursor points to a symbol marked with external_source_symbol attribute.

Parameters

ALanguage

if the attribute is present, will be set to the 'language' string from the attribute.

ADefinedIn

if the attribute is present, will be set to the 'definedIn' string from the attribute.

AIsGenerated

if the attribute is present, will be set to True if the 'generated_declaration' is set in the attribute.

Returns

True if the cursor points to a symbol marked with external_source_symbol attribute.

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

Parameters

AFlags

configuration flags.

APieceIndex

for contiguous names or when passing the flag WantSinglePiece, only one piece with index 0 is available. When the WantSinglePiece flag is not passed for a non-contiguous names, this index can be used to retrieve the individual pieces of the name.

Returns

The piece of the name pointed to by the given cursor. If there is no name, or if APieceIndex is out-of-range, a Null-cursor will be returned.

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

The Null cursor, which represents no entity.

The kind of the cursor.

True if this is a Null cursor.

Whether the cursor represents a declaration.

Whether the cursor represents a simple reference.

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

Whether the cursor represents an expression.

Whether the cursor represents a statement.

Whether the cursor represents an attribute.

Whether the cursor has any attributes.

Whether the cursor represents an invalid cursor.

Whether the cursor represents a translation unit.

Whether the cursor represents a preprocessing element, such as a preprocessor directive or macro instantiation.

Determine whether the cursor represents a currently unexposed piece of the AST (e.g., TCursorKind.UnexposedStmt).

The linkage of the entity referred to by the cursor.

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.

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

The "language" of the entity referred to by the cursor.

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

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 LexicalParent). They diverge when declarations or definitions are provided out-of-line. For example:

        class C {
         void f();
        };
        void C::f() { }
      

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.

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 SemanticParent). They diverge when declarations or definitions are provided out-of-line. For example:

        class C {
         void f();
        };

        void C::f() { }
      

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.

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

The physical location of the source constructor referenced by the 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.

The physical extent of the source construct referenced by the 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).

The type of the Cursor (if any).

The underlying type of a typedef declaration.

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

The integer type of an enum declaration.

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

The integer value of an enum constant declaration as a signed Int64.

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

The integer value of an enum constant declaration as an UInt64.

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

The bit width of a bit field declaration as an integer. If a cursor that is not a bit field declaration is passed in, -1 is returned.

The number of non-variadic arguments associated with the 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.

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.

The number of template args of a function 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 property.

The kind of the I'th template argument of the cursor.

If the argument cursor does not represent a FunctionDecl, 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.

The type of a TemplateArgument of a function decl representing a template specialization.

If the argument cursor does not represent a FunctionDecl 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.

The value of an Integral TemplateArgument (of a function decl representing a template specialization) as a signed Int64.

It is undefined to call this function on a cursor that does not represent a FunctionDecl 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, -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.

The value of an Integral TemplateArgument (of a function decl representing a template specialization) as an UInt64.

It is undefined to call this function on a cursor that does not represent a FunctionDecl 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.

Whether the cursor that is a macro, is function like.

Whether the cursor that is a macro, is a builtin one.

Whether the cursor that is a function declaration, is an inline declaration.

The Objective-C type encoding for the specified declaration.

The return type associated with a given cursor.

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

The exception specification type associated with a given cursor.

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

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, TYPE_LAYOUT_ERROR_INVALID is returned.

• If the field's type declaration is an incomplete type, TYPE_LAYOUT_ERROR_INCOMPLETE is returned.

• If the field's type declaration is a dependent type, TYPE_LAYOUT_ERROR_DEPENDENT is returned.

• If the field's name is not found, TYPE_LAYOUT_ERROR_INVALID_FIELDNAME is returned.

Whether the cursor represents an anonymous record declaration.

Whether the cursor specifies a Record member that is a bitfield.

Whether the base class specified by the cursor with kind CXXBaseSpecifier is virtual.

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.

The storage class for a function or variable declaration.

If the cursor is not a function or variable declaration, Invalid is returned else the storage class.

The number of overloaded declarations referenced by a OverloadedDeclRef cursor. If it is not a OverloadedDeclRef cursor, returns 0.

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

If the cursor does not have an associated set of overloaded declarations, or if the index is out of bounds, TCursor.Null.

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

The 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.

The name for the entity referenced by this cursor.

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.

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.

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:

        int f(int, int);
        int g(int x, int y) { return f(x, y); }
        int f(int a, int b) { return a + b; }
        int f(int, int);
      

there are three declarations of the function "f", but only the second one is a definition. The Definition property 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.

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

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:

        struct X;
        struct X;
        struct X {
          int member;
        };
      

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.

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

After getting a curso, this can be called to determine if the location points to a selector identifier.

Given a cursor pointing to a C++ method call or an Objective-C message, returns True 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 False.

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

Given a cursor that represents a property declaration, return the associated property attributes.

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.

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

True if the cursor is a variadic function or method.

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.

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

Given a cursor that represents a documentable entity (e.g., declaration), return the associated "brief" paragraph; otherwise return the first paragraph.

The mangled name of the cursor.

The mangled symbols of the C++ constructor or destructor at the cursor.

The mangled symbols of the ObjC class interface or implementation at the cursor.

Given a ModuleImportDecl cursor, return the associated module.

Whether a C++ constructor is a converting constructor.

Whether a C++ constructor is a copy constructor.

Whether a C++ constructor is the default constructor.

Whether a C++ constructor is a move constructor.

Whether a C++ field is declared 'mutable'.

Whether a C++ method is declared '= default'.

Whether a C++ member function or member function template is pure virtual.

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

Whether 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.

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

Whether an enum declaration refers to a scoped enum.

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

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

This property 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".

If the cursor is not a template, returns NoDeclFound.

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.

If the cursor is NOT a specialization or instantiation of a template or a member thereof, returns a Null cursor.

A non-context-sensitive completion string for declaration and macro definition cursors, or a Null string for other kinds of cursors.

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

Internal handle to C API