Struct PerlCode 

pub struct PerlCode { /* private fields */ }

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

Trait Implementations

impl Alterator for PerlCode

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 PerlCode

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

Spells a -bareword key whole (#1545). A key that is exactly a file test ((-x => 1)) has swallowed the => and the value into its node, so the key is the sign and the word after it; a -and / -not key gets back the sign its - token stopped billing, spelled the same however the two are spaced, since Perl keys (- not => 1) as "-not" too. The sign is read off the tree (perl_key_is_signed), not the byte before the key, which can equally be an infix - or the end of a comment.

Any other -bareword key ((-name => 1), $h{-name}) bills its word spelled from the sign (#1572). That is a source slice, so a sign spaced off its word ((- name => 1), rare) keeps the space, and a comment between the two ((- # c⏎ name => 1)) is carried along in it: one operand, distinct from name, but not merged with -name, and listed by bca ops as written.

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

Folds paired delimiters to one glyph, and names the two pattern operations after their source spelling.

Hand-written rather than get_operator!(Perl) because SubstitutionPatternS and TransliterationTrOrY are named nodes rather than punctuation tokens (#1314): the macro’s fallback renders a kind’s own name, so bca ops would list substitution_pattern_s and transliteration_tr_or_y among the operators, which reads as a bug rather than as s///. tr/// covers y/// too — one kind, one glyph, because they are synonyms. => is the named fat_comma node for the same reason.

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_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_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_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_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 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 PerlCode

type BaseLang = Perl

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

fn lang() -> LANG

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