Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

14.4 KB
Raw Blame
//! The table of bundled tree-sitter grammars and their per-language tuning.

use tree_sitter_language::LanguageFn;

/// Static description of one bundled grammar.
pub(crate) struct Spec {
    /// Grammar name, as referenced by `tree-sitter = "<name>"` in `languages/*.toml`.
    pub name: &'static str,
    pub language: LanguageFn,
    /// `queries/<name>/outline.scm`; see `queries/README.md` for the capture vocabulary.
    pub outline: &'static str,
    /// The grammar's `highlights.scm`, for languages without a CodeMirror mode.
    pub highlights: Option<Highlights>,
    /// Node kinds folded when they span several lines (in addition to every
    /// bracket-delimited node, which is folded generically).
    pub fold_nodes: &'static [&'static str],
    /// Indentation bodies (Python `block`, ...) folded from their parent's first line.
    pub fold_bodies: &'static [&'static str],
    /// Import-like statements; consecutive runs fold as [`crate::FoldKind::Imports`].
    pub imports: &'static [&'static str],
    /// Function names that are constructors when declared inside a type.
    pub constructors: &'static [&'static str],
}

/// A highlights query and how its patterns rank against each other.
pub(crate) struct Highlights {
    pub query: &'static str,
    /// For the same node, the first matching pattern wins (tree-sitter CLI /
    /// GitHub queries) instead of the last one (nvim / Zed queries).
    pub first_wins: bool,
}

/// Our own `queries/<name>/highlights.scm`, for grammars that ship none.
macro_rules! highlights {
    ($name:literal) => {
        include_str!(concat!("../../queries/", $name, "/highlights.scm"))
    };
}

macro_rules! outline {
    ($name:literal) => {
        include_str!(concat!("../../queries/", $name, "/outline.scm"))
    };
}

const NONE: &[&str] = &[];

pub(crate) static SPECS: &[Spec] = &[
    Spec {
        name: "rust",
        language: tree_sitter_rust::LANGUAGE,
        outline: outline!("rust"),
        highlights: None,
        fold_nodes: NONE,
        fold_bodies: NONE,
        imports: &["use_declaration", "extern_crate_declaration"],
        constructors: NONE,
    },
    Spec {
        name: "typescript",
        language: tree_sitter_typescript::LANGUAGE_TYPESCRIPT,
        outline: outline!("typescript"),
        highlights: None,
        fold_nodes: &["template_string"],
        fold_bodies: NONE,
        imports: &["import_statement"],
        constructors: &["constructor"],
    },
    Spec {
        name: "tsx",
        language: tree_sitter_typescript::LANGUAGE_TSX,
        outline: outline!("typescript"),
        highlights: None,
        fold_nodes: &["template_string", "jsx_element"],
        fold_bodies: NONE,
        imports: &["import_statement"],
        constructors: &["constructor"],
    },
    Spec {
        name: "javascript",
        language: tree_sitter_javascript::LANGUAGE,
        outline: outline!("javascript"),
        highlights: None,
        fold_nodes: &["template_string", "jsx_element"],
        fold_bodies: NONE,
        imports: &["import_statement"],
        constructors: &["constructor"],
    },
    Spec {
        name: "python",
        language: tree_sitter_python::LANGUAGE,
        outline: outline!("python"),
        highlights: None,
        fold_nodes: &["string"],
        fold_bodies: &["block"],
        imports: &["import_statement", "import_from_statement", "future_import_statement"],
        constructors: &["__init__"],
    },
    Spec {
        name: "go",
        language: tree_sitter_go::LANGUAGE,
        outline: outline!("go"),
        highlights: None,
        fold_nodes: &["raw_string_literal"],
        fold_bodies: NONE,
        imports: &["import_declaration"],
        constructors: NONE,
    },
    Spec {
        name: "java",
        language: tree_sitter_java::LANGUAGE,
        outline: outline!("java"),
        highlights: None,
        fold_nodes: &["text_block"],
        fold_bodies: NONE,
        imports: &["import_declaration"],
        constructors: NONE,
    },
    Spec {
        name: "kotlin",
        language: tree_sitter_kotlin_ng::LANGUAGE,
        outline: outline!("kotlin"),
        highlights: Some(Highlights { query: highlights!("kotlin"), first_wins: false }),
        fold_nodes: &["string_literal"],
        fold_bodies: NONE,
        imports: &["import"],
        constructors: NONE,
    },
    Spec {
        name: "scala",
        language: tree_sitter_scala::LANGUAGE,
        outline: outline!("scala"),
        highlights: None,
        fold_nodes: &["string"],
        fold_bodies: &["indented_block", "template_body"],
        imports: &["import_declaration"],
        constructors: NONE,
    },
    Spec {
        name: "c",
        language: tree_sitter_c::LANGUAGE,
        outline: outline!("c"),
        highlights: None,
        fold_nodes: &["preproc_if", "preproc_ifdef", "preproc_function_def"],
        fold_bodies: NONE,
        imports: &["preproc_include"],
        constructors: NONE,
    },
    Spec {
        name: "cpp",
        language: tree_sitter_cpp::LANGUAGE,
        outline: outline!("cpp"),
        highlights: None,
        fold_nodes: &["preproc_if", "preproc_ifdef", "preproc_function_def", "raw_string_literal"],
        fold_bodies: NONE,
        imports: &["preproc_include", "using_declaration"],
        constructors: NONE,
    },
    Spec {
        name: "csharp",
        language: tree_sitter_c_sharp::LANGUAGE,
        outline: outline!("csharp"),
        highlights: None,
        fold_nodes: &["preproc_region", "raw_string_literal", "verbatim_string_literal"],
        fold_bodies: NONE,
        imports: &["using_directive"],
        constructors: NONE,
    },
    Spec {
        name: "swift",
        language: tree_sitter_swift::LANGUAGE,
        outline: outline!("swift"),
        highlights: None,
        // Control-flow statements hold `{ statements }` without a block node of their own.
        fold_nodes: &[
            "multi_line_string_literal",
            "if_statement",
            "guard_statement",
            "for_statement",
            "while_statement",
            "repeat_while_statement",
            "switch_statement",
            "do_statement",
        ],
        fold_bodies: NONE,
        imports: &["import_declaration"],
        constructors: NONE,
    },
    Spec {
        name: "ruby",
        language: tree_sitter_ruby::LANGUAGE,
        outline: outline!("ruby"),
        highlights: None,
        fold_nodes: &[
            "method",
            "singleton_method",
            "class",
            "module",
            "singleton_class",
            "do_block",
            "if",
            "unless",
            "case",
            "while",
            "until",
            "for",
            "begin",
            "heredoc_body",
            "lambda",
        ],
        fold_bodies: NONE,
        imports: NONE,
        constructors: &["initialize"],
    },
    Spec {
        name: "php",
        language: tree_sitter_php::LANGUAGE_PHP,
        outline: outline!("php"),
        highlights: None,
        fold_nodes: &["heredoc", "nowdoc"],
        fold_bodies: NONE,
        imports: &["namespace_use_declaration"],
        constructors: &["__construct"],
    },
    Spec {
        name: "lua",
        language: tree_sitter_lua::LANGUAGE,
        outline: outline!("lua"),
        highlights: None,
        fold_nodes: &[
            "function_declaration",
            "function_definition",
            "if_statement",
            "for_statement",
            "while_statement",
            "repeat_statement",
            "do_statement",
            "string",
        ],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "dart",
        language: tree_sitter_dart::LANGUAGE,
        outline: outline!("dart"),
        highlights: None,
        fold_nodes: NONE,
        fold_bodies: NONE,
        imports: &["import_or_export", "library_name", "part_directive", "part_of_directive"],
        constructors: NONE,
    },
    Spec {
        name: "zig",
        language: tree_sitter_zig::LANGUAGE,
        outline: outline!("zig"),
        highlights: Some(Highlights { query: tree_sitter_zig::HIGHLIGHTS_QUERY, first_wins: false }),
        fold_nodes: NONE,
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "elixir",
        language: tree_sitter_elixir::LANGUAGE,
        outline: outline!("elixir"),
        highlights: Some(Highlights { query: tree_sitter_elixir::HIGHLIGHTS_QUERY, first_wins: false }),
        fold_nodes: &["do_block", "anonymous_function", "string", "sigil"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "haskell",
        language: tree_sitter_haskell::LANGUAGE,
        outline: outline!("haskell"),
        highlights: None,
        // `bind`: equations without arguments (`main = do …`).
        fold_nodes: &["function", "bind", "data_type", "newtype", "class", "instance", "signature"],
        fold_bodies: NONE,
        imports: &["import"],
        constructors: NONE,
    },
    Spec {
        name: "ocaml",
        language: tree_sitter_ocaml::LANGUAGE_OCAML,
        outline: outline!("ocaml"),
        highlights: None,
        fold_nodes: &[
            "value_definition",
            "type_definition",
            "module_definition",
            "structure",
            "signature",
            "match_expression",
            "class_definition",
        ],
        fold_bodies: NONE,
        imports: &["open_module"],
        constructors: NONE,
    },
    Spec {
        name: "ocaml_interface",
        language: tree_sitter_ocaml::LANGUAGE_OCAML_INTERFACE,
        outline: outline!("ocaml_interface"),
        highlights: None,
        fold_nodes: &["module_definition", "module_type_definition", "signature", "type_definition"],
        fold_bodies: NONE,
        imports: &["open_module"],
        constructors: NONE,
    },
    Spec {
        name: "bash",
        language: tree_sitter_bash::LANGUAGE,
        outline: outline!("bash"),
        highlights: None,
        fold_nodes: &["do_group", "if_statement", "case_statement", "heredoc_body"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "html",
        language: tree_sitter_html::LANGUAGE,
        outline: outline!("html"),
        highlights: None,
        fold_nodes: &["element", "script_element", "style_element"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "xml",
        language: tree_sitter_xml::LANGUAGE_XML,
        outline: outline!("xml"),
        highlights: None,
        fold_nodes: &["element", "CDSect"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "css",
        language: tree_sitter_css::LANGUAGE,
        outline: outline!("css"),
        highlights: None,
        fold_nodes: NONE,
        fold_bodies: NONE,
        imports: &["import_statement"],
        constructors: NONE,
    },
    Spec {
        name: "json",
        language: tree_sitter_json::LANGUAGE,
        outline: outline!("json"),
        highlights: None,
        fold_nodes: NONE,
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "yaml",
        language: tree_sitter_yaml::LANGUAGE,
        outline: outline!("yaml"),
        highlights: None,
        fold_nodes: &["block_mapping_pair", "block_sequence_item", "block_scalar"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "toml",
        language: tree_sitter_toml_ng::LANGUAGE,
        outline: outline!("toml"),
        highlights: None,
        fold_nodes: &["table", "table_array_element", "string"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "markdown",
        language: tree_sitter_md::LANGUAGE,
        outline: outline!("markdown"),
        highlights: None,
        fold_nodes: &["section", "fenced_code_block", "list", "block_quote", "html_block"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "hcl",
        language: tree_sitter_hcl::LANGUAGE,
        outline: outline!("hcl"),
        highlights: Some(Highlights { query: highlights!("hcl"), first_wins: false }),
        fold_nodes: &["block", "heredoc_template"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "nix",
        language: tree_sitter_nix::LANGUAGE,
        outline: outline!("nix"),
        highlights: Some(Highlights { query: tree_sitter_nix::HIGHLIGHTS_QUERY, first_wins: true }),
        fold_nodes: &["let_expression", "indented_string_expression"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "proto",
        language: tree_sitter_proto::LANGUAGE,
        outline: outline!("proto"),
        highlights: None,
        fold_nodes: NONE,
        fold_bodies: NONE,
        imports: &["import"],
        constructors: NONE,
    },
    Spec {
        name: "graphql",
        language: tree_sitter_graphql::LANGUAGE,
        outline: outline!("graphql"),
        highlights: Some(Highlights { query: highlights!("graphql"), first_wins: false }),
        fold_nodes: NONE,
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "make",
        language: tree_sitter_make::LANGUAGE,
        outline: outline!("make"),
        highlights: Some(Highlights { query: tree_sitter_make::HIGHLIGHTS_QUERY, first_wins: false }),
        fold_nodes: &["rule", "conditional", "define_directive"],
        fold_bodies: NONE,
        imports: &["include_directive"],
        constructors: NONE,
    },
    Spec {
        name: "cmake",
        language: tree_sitter_cmake::LANGUAGE,
        outline: outline!("cmake"),
        highlights: None,
        fold_nodes: &["function_def", "macro_def", "if_condition", "foreach_loop", "while_loop", "block_def"],
        fold_bodies: NONE,
        imports: NONE,
        constructors: NONE,
    },
    Spec {
        name: "gdscript",
        language: tree_sitter_gdscript::LANGUAGE,
        outline: outline!("gdscript"),
        highlights: Some(Highlights { query: highlights!("gdscript"), first_wins: false }),
        fold_nodes: &["string"],
        fold_bodies: &["body", "class_body", "match_body"],
        imports: NONE,
        constructors: &["_init"],
    },
];