Struct RustCode 

pub struct RustCode { /* private fields */ }

Per-language code type tag for Rust; carries no data.

Trait Implementations

impl Alterator for RustCode

fn alterate( node: &Node<'_>, code: &[u8], span: bool, field_name: Option<&'static str>, children: Vec<AstNode>, ) -> AstNode

Creates a new AST node containing the code associated to the node, its span, the grammar field name through which the parent reaches it (if any), and its children.

fn get_text_span( node: &Node<'_>, code: &[u8], span: bool, text: bool, ) -> (String, Option<Span>)

Gets the code as text and the span associated to a node.

fn get_default( node: &Node<'_>, code: &[u8], span: bool, field_name: Option<&'static str>, children: Vec<AstNode>, ) -> AstNode

Gets a default AST node containing the code associated to the node, its span, its grammar field name (if any), and its children.

fn keeps_children<'a>( _node: &Node<'a>, _code: &[u8], _ancestors: Ancestors<'a, '_>, ) -> bool

Whether node must keep its children even though Self::alterate would flatten it into a verbatim leaf.

fn get_ast_node<'a>( node: &Node<'a>, code: &[u8], span: bool, comment: bool, field_name: Option<&'static str>, children: Vec<AstNode>, ancestors: Ancestors<'a, '_>, ) -> Option<AstNode>

Gets a new AST node if and only if the code is not a comment, otherwise None is returned.

impl Getter for RustCode

fn get_func_space_name<'a, 'tree>( node: &Node<'tree>, code: &'a [u8], _ancestors: Ancestors<'tree, '_>, ) -> Option<&'a str>

Names the space node opens.

fn get_space_kind(node: &Node<'_>) -> SpaceKind

The kind of space node opens, or SpaceKind::Unknown when it opens none.

fn get_op_type<'a>(node: &Node<'a>, ancestors: Ancestors<'a, '_>) -> TokenRole

Classifies node as a Halstead operator, operand, or neither.

fn get_operator_spelling<'a>( node: &Node<'a>, ancestors: Ancestors<'a, '_>, ) -> Option<&'static str>

The fixed spelling an operator node is keyed under in place of its kind id, for a token whose kind the grammar shares with a different operator; None keys it by kind. A generic list’s < is the case (#1559): it has the comparison’s kind but is keyed as the "<>" pair, as (), [] and {} are. Consulted only for a node get_op_type_with_code calls an operator.

fn get_operator_id_as_str(id: u16) -> &'static str

The grammar’s name for the operator kind id, used to render a Halstead operator; empty for languages that do not report them.

fn get_func_name<'a, 'tree>( node: &Node<'tree>, code: &'a [u8], ancestors: Ancestors<'tree, '_>, ) -> Option<&'a str>

Names the function node declares. Defaults to get_func_space_name.

fn get_space_kind_with_code<'a>( node: &Node<'a>, _code: &[u8], _ancestors: Ancestors<'a, '_>, ) -> SpaceKind

Source-aware variant of get_space_kind. The default forwards to the byte-less classifier; languages whose space kinds are encoded in macro identifier text (Elixir’s defmodule / def / defp / defmacro / defmacrop Calls) override this so the walker can attribute the correct SpaceKind to each promoted func space (#275).

fn get_op_type_with_code<'a>( node: &Node<'a>, _code: &[u8], ancestors: Ancestors<'a, '_>, ) -> TokenRole

Source-aware variant of get_op_type. The default forwards to the byte-less classifier; languages whose Halstead operand classification depends on token text override this. Kotlin uses it to recover the variable in a short-form string template ("Hi $name"), which the grammar emits as bare string_content tokens with no structured interpolation node — the distinction between an interpolated $name and a literal $5 is only visible in the source bytes (#454).

fn get_operand_id<'a>( node: &Node<'a>, code: &'a [u8], _ancestors: Ancestors<'a, '_>, ) -> &'a [u8]

Returns the source-byte slice used to key a Halstead operand. The default keys on the operand node’s full byte range. Kotlin overrides this to narrow a short-interpolation name token ($name) to its leading identifier prefix, because the grammar glues trailing inter-segment text onto the name token ("$a $b" → "a "); keying the raw bytes would record a distinct "a " operand and break parity with the long ${a} form (#454).

fn string_operand_type(node: &Node<'_>, interp_kinds: &[u16]) -> TokenRole

Classifies a string-literal node as a single Halstead operand, unless it wraps an interpolation child drawn from interp_kinds — in which case the wrapper yields TokenRole::Unknown because the inner expressions are walked and counted separately. Counting the wrapper too would double-count their contribution to N2.

fn is_subsumed_braced_word<'a>( node: &Node<'a>, ancestors: Ancestors<'a, '_>, kinds: &BracedWordKinds, ) -> bool

Whether node is a fragment of a Tcl-family braced word rather than a token of its own, and so contributes no operand (#1354).

fn generic_argument_command<'tree, 'chain>( word: &Node<'tree>, ancestors: Ancestors<'tree, 'chain>, kinds: &BracedWordKinds, ) -> Option<(Node<'tree>, Ancestors<'tree, 'chain>)>

The generic command node word is an argument of, paired with that command’s own ancestry — or None when word instead fills a slot of a construct the grammar models, and so is a script by construction.

fn is_value_braced_word<'a>( word: &Node<'a>, code: &[u8], ancestors: Ancestors<'a, '_>, kinds: &BracedWordKinds, ) -> bool

Whether a braced script-kind word is really a plain value — the literal {a b} of lappend x {a b} rather than the block of eval {…} (#1318).

fn is_braced_script_word<'a>( node: &Node<'a>, code: &[u8], ancestors: Ancestors<'a, '_>, kinds: &BracedWordKinds, ) -> bool

Whether node is a Tcl-family braced script — a proc or if body, an iRules when handler — rather than a braced literal (#1381).

fn is_braced_literal_slot<'a>( word: &Node<'a>, code: &[u8], ancestors: Ancestors<'a, '_>, kinds: &BracedWordKinds, ) -> bool

Whether word, a braced word is_value_braced_word calls a script, fills a slot whose documented syntax takes a value.

fn is_switch_arm_body(word: &Node<'_>, command: &Node<'_>) -> bool

Whether word, an argument of a switch arm command (is_switch_arm), sits in a body position rather than a pattern position.

fn command_leading_word<'c>( command: &Node<'_>, code: &'c [u8], kinds: &BracedWordKinds, ) -> Option<&'c str>

A command’s leading word, when it is a statically resolvable simple_word.

fn is_switch_arm<'a>( command: &Node<'a>, code: &[u8], ancestors: Ancestors<'a, '_>, kinds: &BracedWordKinds, ) -> bool

Whether command is really one pattern body pair of a Tcl switch arm list rather than a command of its own.

fn braced_word_op_type<'a>( node: &Node<'a>, code: &[u8], ancestors: Ancestors<'a, '_>, kinds: &BracedWordKinds, ) -> TokenRole

Whether the { of node’s parent braced word opens a block, or merely quotes a literal (#1318).

impl LanguageInfo for RustCode

type BaseLang = Rust

Tree-sitter base language enum carried by this code tag.

fn lang() -> LANG

Returns the workspace-level LANG variant for this code tag.