Enum Lang 

pub enum Lang {
    Rust,
    Python,
    TypeScript,
    Tsx,
    JavaScript,
    Jsx,
    Kotlin,
    Zig,
    Bash,
    Go,
    GdScript,
    Markdown,
}

Variants

Rust

Python

TypeScript

Tsx

JavaScript

Jsx

Kotlin

Zig

Bash

Go

GdScript

Markdown

Implementations

impl Lang

pub fn from_extension(ext: &str) -> Option<Self>

pub fn tree_sitter_language(&self) -> Language

Examples found in repository

examples/dump_ast.rs (line 6)

fn dump(lang_name: &str, lang: Lang, source: &str, _depth: usize) {
    let mut parser = Parser::new();
    parser.set_language(&lang.tree_sitter_language()).unwrap();
    let tree = parser.parse(source.as_bytes(), None).unwrap();
    println!("=== {} ===", lang_name);
    println!("Source:\n{}\n", source);
    fn walk(node: tree_sitter::Node, source: &str, indent: usize) {
        let text = &source[node.byte_range()];
        let short = if text.len() > 60 { &text[..60] } else { text };
        let short = short.replace('\n', "\\n");
        println!(
            "{}{} [{}-{}] {:?}",
            "  ".repeat(indent),
            node.kind(),
            node.start_position().row,
            node.end_position().row,
            short
        );
        let mut cursor = node.walk();
        if cursor.goto_first_child() {
            loop {
                walk(cursor.node(), source, indent + 1);
                if !cursor.goto_next_sibling() {
                    break;
                }
            }
        }
    }
    walk(tree.root_node(), source, 0);
    println!();
}

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

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

pub fn call_query(&self) -> Option<&'static str>

pub fn extract_symbols(&self, source: &[u8]) -> Result<Vec<Symbol>>

pub fn all() -> Vec<Self>

pub fn is_document(&self) -> bool

Whether this language is prose rather than code. A document language is parsed into structural nodes — headings, list items, fenced blocks — that are useful for navigation but are not symbols: they have no callers, no callees, and no identity a caller can look up by name. Consumers that report “symbols” must budget and label document nodes separately (#docsym).

Trait Implementations

impl Clone for Lang

fn clone(&self) -> Lang

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Lang

impl Debug for Lang

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

Formats the value using the given formatter.

impl Eq for Lang

impl Hash for Lang

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 Lang

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Lang