Enum CodeNodeKind 

pub enum CodeNodeKind {
    File,
    Module,
    Class,
    Function,
    Method,
    Parameter,
    Variable,
    Test,
    Type,
    Constant,
    Import,
    RustFn,
    RustMethod,
    RustImpl,
    RustTrait,
    RustStruct,
    RustEnum,
    RustMod,
    RustMacro,
    RustUse,
    RustConst,
    RustStatic,
    RustTypeAlias,
    RustAttribute,
    RustLifetime,
    RustTest,
    PythonFunction,
    PythonMethod,
    PythonClass,
    PythonDecorator,
    PythonImport,
    PythonModule,
    PythonLambda,
    PythonAsync,
    PythonProperty,
}

Kind of code object.

Variants are stored as Arrow Dictionary<Int8, Utf8> for efficient memory use.

Variant groups

Language-agnostic (original set — used by the Python parser): File, Module, Class, Function, Method, Parameter, Variable, Test

Generic (EX-3168 / V12a-1 — language-independent additions): Type, Constant, Import

Rust-specific (EX-3168 / V12a-1 — populated by tree-sitter parser in EX-3120): RustFn, RustMethod, RustImpl, RustTrait, RustStruct, RustEnum, RustMod, RustMacro, RustUse, RustConst, RustStatic, RustTypeAlias, RustAttribute, RustLifetime, RustTest

Python-specific (EX-3172 / V12b-1 — populated by PythonParser with position metadata): PythonFunction, PythonMethod, PythonClass, PythonDecorator, PythonImport, PythonModule, PythonLambda, PythonAsync, PythonProperty

Variants

File

Module

Class

Function

Method

Parameter

Variable

Test

Type

Named type (struct, class, enum — language-agnostic abstraction)

Constant

Compile-time or declaration-time constant value

Import

Module import / use declaration

RustFn

fn foo() — free function

RustMethod

fn method(&self) inside an impl block

RustImpl

impl Foo { ... } or impl Trait for Foo { ... }

RustTrait

trait Foo { ... }

RustStruct

struct Foo { ... }

RustEnum

enum Foo { ... }

RustMod

mod foo { ... } or mod foo;

RustMacro

macro_rules! name { ... }

RustUse

use path::to::Item;

RustConst

const NAME: Type = value;

RustStatic

static NAME: Type = value;

RustTypeAlias

type Foo = Bar;

RustAttribute

#[derive(...)] or other attributes (stored separately from node)

RustLifetime

Lifetime parameter 'a in fn / struct / impl

RustTest

#[test] fn test_foo() { ... }

PythonFunction

def foo(...): — top-level function

PythonMethod

def method(self, ...): inside a class body

PythonClass

class Foo: — class definition

PythonDecorator

@dataclass, @property, @classmethod etc. — decorator node

PythonImport

import x or from x import y — import statement

PythonModule

Top-level file module (file as a Python module)

PythonLambda

lambda x: ... — anonymous function expression

PythonAsync

async def foo(): — async function or method

PythonProperty

Method decorated with @property

Implementations

impl CodeNodeKind

pub const ALL: [CodeNodeKind; 35]

All 35 variants in stable order — used to build the Arrow Dictionary<Int8, Utf8>. Int8 supports up to 127 unique values; 35 variants is well within range.

pub fn as_str(self) -> &'static str

pub fn parse(s: &str) -> Option<Self>

pub fn is_rust_specific(self) -> bool

Whether this kind is Rust-specific (introduced by EX-3168 / V12a-1).

pub fn is_python_specific(self) -> bool

Whether this kind is Python-specific (introduced by EX-3172 / V12b-1).

Trait Implementations

impl Clone for CodeNodeKind

fn clone(&self) -> CodeNodeKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CodeNodeKind

impl Debug for CodeNodeKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for CodeNodeKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for CodeNodeKind

impl Hash for CodeNodeKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CodeNodeKind

fn eq(&self, other: &CodeNodeKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CodeNodeKind