Enum Language 

pub enum Language {
    Harn,
    TypeScript,
    Tsx,
    JavaScript,
    Jsx,
    Python,
    Go,
    Rust,
    Java,
    C,
    Cpp,
    CSharp,
    Ruby,
    Kotlin,
    Php,
    Scala,
    Bash,
    Swift,
    Zig,
    Elixir,
    Lua,
    Haskell,
    R,
    Json,
    Yaml,
    Toml,
    Css,
    Html,
    Sql,
    Markdown,
}

Languages with tree-sitter grammar support.

The string returned by Language::name is the canonical wire name; callers (and the JSON schemas) refer to languages by that string. The trailing group (Json..Markdown) are data/markup/config grammars: they support the query-driven edit primitives but have no symbol-graph projection (see Language::edit_capabilities).

Variants

Harn

TypeScript

Tsx

JavaScript

Jsx

Python

Go

Rust

Java

C

Cpp

CSharp

Ruby

Kotlin

Php

Scala

Bash

Swift

Zig

Elixir

Lua

Haskell

R

Json

Yaml

Toml

Css

Html

Sql

Markdown

Implementations

impl Language

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

Canonical wire name.

pub fn ts_language(self) -> Option<TsLanguage>

Tree-sitter grammar handle, or None when this build was not compiled with the grammar family that backs self.

Each arm is gated on its grammar-* family feature, so a trimmed build only links the grammars it asked for. The name/extension/ detection metadata above stays complete regardless of features — a lean build still recognizes a .py file, it just returns None here and the edit primitives degrade to the text fallback. The full (default) build enables every family, so None never occurs there. Cheap when present; the underlying LANGUAGE constants are static.

pub fn from_name(name: &str) -> Option<Self>

Resolve a language from its canonical wire name. Accepts a few historical aliases (ts, js, c++, …) so users don’t have to memorize the exact spelling.

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

Resolve a language from a file extension.

pub fn detect(path: &Path, language_hint: Option<&str>) -> Option<Self>

Resolve from a file path: prefer explicit language_hint if supplied, otherwise fall back to extension-based detection.

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

A representative file extension for the language (no leading dot). Used by docs and the onboarding probe; not necessarily the only extension Language::from_extension accepts.

pub fn rename_identifier_kinds(self) -> Option<&'static [&'static str]>

Per-language allow-list of tree-sitter node kinds that represent an identifier token bound to a name (variables, functions, types, fields). This is the symbol-graph projection that drives rename_symbol: anything not in this table is treated as a literal or punctuation node and left alone, which keeps a rename out of comments and string bodies even though those contain identifier substrings. None means the language has no rename projection yet.

pub fn supports_rename(self) -> bool

Whether rename_symbol can operate on this language (i.e. it has a Language::rename_identifier_kinds projection).

pub fn supports_symbol_extraction(self) -> bool

Whether symbols/outline produce meaningful results. Data/markup grammars parse and edit fine but expose no symbol projection.

pub fn edit_capabilities(self) -> EditCapabilities

The AST-precise edit capability matrix for this language. See EditCapabilities.

pub fn all() -> &'static [Language]

Every language we ship support for. Useful for tests + introspection.

Trait Implementations

impl Clone for Language

fn clone(&self) -> Language

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Language

impl Debug for Language

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

Formats the value using the given formatter.

impl Eq for Language

impl Hash for Language

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 Language

fn eq(&self, other: &Language) -> 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 Language