- "getrandom 0.3.1",

- "ahash",

- "hashbrown 0.14.5",

- "tree-sitter",

- "libloading",

- "tree-sitter",

-name = "tree-sitter"

-version = "0.22.6"

-checksum = "df7cc499ceadd4dcdf7ec6d4cbc34ece92c3fa07821e287aedecd4416c516dca"

- "cc",

-tree-sitter = { version = "0.22" }

-tree-sitter.workspace = true

-ahash = "0.8.12"

-hashbrown = { version = "0.14.5", features = ["raw"] }

-use tree_sitter::{Query, QueryCursor, QueryPredicateArg};

- syntax::{

- config::{IndentationHeuristic, LanguageConfiguration},

- RopeProvider, Syntax,

- tree_sitter::Node,

- Position, Rope, RopeSlice, Tendril,

-fn is_first_in_line(node: Node, text: RopeSlice, new_line_byte_pos: Option<usize>) -> bool {

- let mut line_start_byte_pos = text.line_to_byte(node.start_position().row);

- text.byte_slice(line_start_byte_pos..node.start_byte())

-fn get_node_start_line(node: Node, new_line_byte_pos: Option<usize>) -> usize {

- let mut node_line = node.start_position().row;

-fn get_node_end_line(node: Node, new_line_byte_pos: Option<usize>) -> usize {

- let mut node_line = node.end_position().row;

- query: &Query,

- cursor: &mut QueryCursor,

- range: std::ops::Range<usize>,

- new_line_byte_pos: Option<usize>,

- for m in cursor.matches(query, syntax.tree().root_node(), RopeProvider(text)) {

- if !query.general_predicates(m.pattern_index).iter().all(|pred| {

- match pred.operator.as_ref() {

- "not-kind-eq?" => match (pred.args.first(), pred.args.get(1)) {

- (

- Some(QueryPredicateArg::Capture(capture_idx)),

- Some(QueryPredicateArg::String(kind)),

- ) => {

- let node = m.nodes_for_capture_index(*capture_idx).next();

- match node {

- Some(node) => node.kind()!=kind.as_ref(),

- _ => true,

- }

- }

- _ => {

- panic!("Invalid indent query: Arguments to \"not-kind-eq?\" must be a capture and a string");

- }

- },

- "same-line?" | "not-same-line?" => {

- match (pred.args.first(), pred.args.get(1)) {

- (

- Some(QueryPredicateArg::Capture(capt1)),

- Some(QueryPredicateArg::Capture(capt2))

- ) => {

- let n1 = m.nodes_for_capture_index(*capt1).next();

- let n2 = m.nodes_for_capture_index(*capt2).next();

- match (n1, n2) {

- (Some(n1), Some(n2)) => {

- let n1_line = get_node_start_line(n1, new_line_byte_pos);

- let n2_line = get_node_start_line(n2, new_line_byte_pos);

- let same_line = n1_line == n2_line;

- same_line==(pred.operator.as_ref()=="same-line?")

- }

- _ => true,

- }

- }

- _ => {

- panic!("Invalid indent query: Arguments to \"{}\" must be 2 captures", pred.operator);

- }

- }

- }

- "one-line?" | "not-one-line?" => match pred.args.first() {

- Some(QueryPredicateArg::Capture(capture_idx)) => {

- let node = m.nodes_for_capture_index(*capture_idx).next();

-

- match node {

- Some(node) => {

- let (start_line, end_line) = (get_node_start_line(node,new_line_byte_pos), get_node_end_line(node, new_line_byte_pos));

- let one_line = end_line == start_line;

- one_line != (pred.operator.as_ref() == "not-one-line?")

- },

- _ => true,

- }

- }

- _ => {

- panic!("Invalid indent query: Arguments to \"not-kind-eq?\" must be a capture and a string");

- }

- },

- _ => {

- panic!(

- "Invalid indent query: Unknown predicate (\"{}\")",

- pred.operator

- );

- }

- }

- }) {

- let mut anchor: Option<tree_sitter::Node> = None;

- for capture in m.captures {

- let capture_name = query.capture_names()[capture.index as usize];

- let capture_type = match capture_name {

- "indent" => IndentCaptureType::Indent,

- "indent.always" => IndentCaptureType::IndentAlways,

- "outdent" => IndentCaptureType::Outdent,

- "outdent.always" => IndentCaptureType::OutdentAlways,

- // The alignment will be updated to the correct value at the end, when the anchor is known.

- "align" => IndentCaptureType::Align(RopeSlice::from("")),

- "anchor" => {

- if anchor.is_some() {

- log::error!("Invalid indent query: Encountered more than one @anchor in the same match.")

- } else {

- anchor = Some(capture.node);

- }

- continue;

- }

- "extend" => {

- extend_captures

- .entry(capture.node.id())

- .or_insert_with(|| Vec::with_capacity(1))

- .push(ExtendCapture::Extend);

- continue;

- }

- "extend.prevent-once" => {

- extend_captures

- .entry(capture.node.id())

- .or_insert_with(|| Vec::with_capacity(1))

- .push(ExtendCapture::PreventOnce);

- continue;

- }

- _ => {

- // Ignore any unknown captures (these may be needed for predicates such as #match?)

- continue;

- let scope = capture_type.default_scope();

- let mut indent_capture = IndentCapture {

- // Apply additional settings for this capture

- for property in query.property_settings(m.pattern_index) {

- match property.key.as_ref() {

- "scope" => {

- indent_capture.scope = match property.value.as_deref() {

- Some("all") => IndentScope::All,

- Some("tail") => IndentScope::Tail,

- Some(s) => {

- panic!("Invalid indent query: Unknown value for \"scope\" property (\"{}\")", s);

- }

- None => {

- panic!(

- "Invalid indent query: Missing value for \"scope\" property"

- );

- }

- }

- }

- _ => {

- panic!(

- "Invalid indent query: Unknown property \"{}\"",

- property.key

- );

- }

- }

- }

- added_indent_captures.push((capture.node.id(), indent_capture))

- let anchor = match anchor {

- None => {

- log::error!(

- "Invalid indent query: @align requires an accompanying @anchor."

- );

- continue;

- }

- Some(anchor) => anchor,

- text.line(anchor.start_position().row)

- .byte_slice(0..anchor.start_position().column),

- if deepest_preceding.end_position().row == line {

- text.line(deepest_preceding.start_position().row),

- *node = deepest_preceding;

- query: &Query,

- byte_pos: usize,

- new_line_byte_pos: Option<usize>,

- // computation. It may change if some predeceding node is extended

- let mut tree_cursor = node.walk();

- for child in node.children(&mut tree_cursor) {

- deepest_preceding = Some(child);

- prec = prec.child(prec.child_count() - 1).unwrap();

- crate::syntax::PARSER.with(|ts_parser| {

- let mut ts_parser = ts_parser.borrow_mut();

- let mut cursor = ts_parser.cursors.pop().unwrap_or_default();

- let query_result = query_indents(

- query,

- syntax,

- &mut cursor,

- text,

- query_range,

- new_line_byte_pos,

- );

- ts_parser.cursors.push(cursor);

- (query_result, deepest_preceding)

- })

- query: &Query,

- let byte_pos = text.char_to_byte(pos);

- let is_first = is_first_in_line(node, text, new_line_byte_pos);

- let node_line = get_node_start_line(node, new_line_byte_pos);

- let parent_line = get_node_start_line(parent, new_line_byte_pos);

- if (node.start_position().row < line)

- || (new_line && node.start_position().row == line && node.start_byte() < byte_pos)

- language_config: Option<&LanguageConfiguration>,

- language_config.and_then(|config| config.indent_query()),

-pub fn get_scopes(syntax: Option<&Syntax>, text: RopeSlice, pos: usize) -> Vec<&'static str> {

- let pos = text.char_to_byte(pos);

-pub use {regex, tree_sitter};

-use tree_sitter::Node;

- let pos = doc.char_to_byte(pos_);

- return doc.try_byte_to_char(sibling.start_byte()).ok();

- let node_start = doc.byte_to_char(node.start_byte());

- find_matching_bracket_plaintext(doc.byte_slice(node.byte_range()), pos_ - node_start)

- .map(|pos| pos + node_start)

- let pos = doc.try_byte_to_char(node.start_byte()).ok()?;

-use std::{cmp::Reverse, iter};

-use tree_sitter::{Node, QueryCursor};

- syntax::config::LanguageConfiguration,

- slice_tree: Node,

- lang_config: &LanguageConfiguration,

- let mut cursor = QueryCursor::new();

- let nodes = lang_config.textobject_query()?.capture_nodes_any(

- &mut cursor,

-fn find_parent_start(mut node: Node) -> Option<Node> {

- node = node.parent()?;

- Some(node)

- let start_from = text.char_to_byte(range.from());

- let start_to = text.char_to_byte(range.to());

- Direction::Forward => text.byte_to_char(node.end_byte()),

- let end_head = text.byte_to_char(node.start_byte());

- node = find_parent_start(node).unwrap_or(node);

- text.byte_to_char(node.start_byte())

- let from = text.char_to_byte(range.from());

- let to = text.char_to_byte(range.to());

- let from = text.byte_to_char(node.start_byte());

- let to = text.byte_to_char(node.end_byte());

- selection.transform_iter(|range| {

- let mut cursor = syntax.walk();

- cursor.reset_to_byte_range(from, to);

- selection.transform_iter(|range| {

- let mut cursor = syntax.walk();

- cursor.reset_to_byte_range(from, to);

-fn select_children<'n>(

- cursor: &'n mut TreeCursor<'n>,

- text: RopeSlice,

- range: Range,

-) -> Vec<Range> {

- .named_children()

- while !cursor.goto_prev_sibling() {

- let from = text.char_to_byte(range.from());

- let to = text.char_to_byte(range.to());

- let from = text.byte_to_char(node.start_byte());

- let to = text.byte_to_char(node.end_byte());

-impl From<Position> for tree_sitter::Point {

- fn from(pos: Position) -> Self {

- Self::new(pos.row, pos.col)

- }

-}

-use tree_sitter::Node;

- let from = text.byte_to_char(node.start_byte());

- let to = text.byte_to_char(node.end_byte());

-use hashbrown::HashSet;

- active_tabstops: HashSet::new(),

-mod tree_cursor;

-

-use crate::{

- chars::char_is_line_ending,

- regex::Regex,

- transaction::{ChangeSet, Operation},

- RopeSlice, Tendril,

-};

-

-use ahash::RandomState;

-use arc_swap::{ArcSwap, Guard};

-use bitflags::bitflags;

-use config::{Configuration, FileType, LanguageConfiguration, LanguageServerConfiguration};

-use hashbrown::raw::RawTable;

-use helix_stdx::rope::{self, RopeSliceExt};

-use slotmap::{DefaultKey as LayerId, HopSlotMap};

- cell::RefCell,

- collections::{HashMap, VecDeque},

- fmt::{self, Write},

- hash::{Hash, Hasher},

- mem::replace,

-use once_cell::sync::Lazy;

-

-use helix_loader::grammar::{get_language, load_runtime_file};

-pub use tree_cursor::TreeCursor;

-#[derive(Debug)]

-pub struct TextObjectQuery {

- pub query: Query,

-}

-pub enum CapturedNode<'a> {

- Single(Node<'a>),

- /// Guaranteed to be not empty

- Grouped(Vec<Node<'a>>),

-impl CapturedNode<'_> {

- pub fn start_byte(&self) -> usize {

- match self {

- Self::Single(n) => n.start_byte(),

- Self::Grouped(ns) => ns[0].start_byte(),

- }

- }

-

- pub fn end_byte(&self) -> usize {

- match self {

- Self::Single(n) => n.end_byte(),

- Self::Grouped(ns) => ns.last().unwrap().end_byte(),

- pub fn byte_range(&self) -> std::ops::Range<usize> {

- self.start_byte()..self.end_byte()

- }

-}

-

-/// The maximum number of in-progress matches a TS cursor can consider at once.

-/// This is set to a constant in order to avoid performance problems for medium to large files. Set with `set_match_limit`.

-/// Using such a limit means that we lose valid captures, so there is fundamentally a tradeoff here.

-///

-///

-/// Old tree sitter versions used a limit of 32 by default until this limit was removed in version `0.19.5` (must now be set manually).

-/// However, this causes performance issues for medium to large files.

-/// In helix, this problem caused treesitter motions to take multiple seconds to complete in medium-sized rust files (3k loc).

-///

-///

-/// Neovim also encountered this problem and reintroduced this limit after it was removed upstream

-/// (see <https://github.com/neovim/neovim/issues/14897> and <https://github.com/neovim/neovim/pull/14915>).

-/// The number used here is fundamentally a tradeoff between breaking some obscure edge cases and performance.

-///

-///

-/// Neovim chose 64 for this value somewhat arbitrarily (<https://github.com/neovim/neovim/pull/18397>).

-/// 64 is too low for some languages though. In particular, it breaks some highlighting for record fields in Erlang record definitions.

-/// This number can be increased if new syntax highlight breakages are found, as long as the performance penalty is not too high.

-const TREE_SITTER_MATCH_LIMIT: u32 = 256;

-

-impl TextObjectQuery {

- /// Run the query on the given node and return sub nodes which match given

- /// capture ("function.inside", "class.around", etc).

- ///

- /// Captures may contain multiple nodes by using quantifiers (+, *, etc),

- /// and support for this is partial and could use improvement.

- ///

- /// ```query

- /// (comment)+ @capture

- ///

- /// ; OR

- /// (

- /// (comment)*

- /// .

- /// (function)

- /// ) @capture

- /// ```

- pub fn capture_nodes<'a>(

- &'a self,

- capture_name: &str,

- node: Node<'a>,

- slice: RopeSlice<'a>,

- cursor: &'a mut QueryCursor,

- ) -> Option<impl Iterator<Item = CapturedNode<'a>>> {

- self.capture_nodes_any(&[capture_name], node, slice, cursor)

- /// Find the first capture that exists out of all given `capture_names`

- /// and return sub nodes that match this capture.

- pub fn capture_nodes_any<'a>(

- &'a self,

- capture_names: &[&str],

- node: Node<'a>,

- slice: RopeSlice<'a>,

- cursor: &'a mut QueryCursor,

- ) -> Option<impl Iterator<Item = CapturedNode<'a>>> {

- let capture_idx = capture_names

- .iter()

- .find_map(|cap| self.query.capture_index_for_name(cap))?;

-

- cursor.set_match_limit(TREE_SITTER_MATCH_LIMIT);

- let nodes = cursor

- .captures(&self.query, node, RopeProvider(slice))

- .filter_map(move |(mat, _)| {

- let nodes: Vec<_> = mat

- .captures

- .iter()

- .filter_map(|cap| (cap.index == capture_idx).then_some(cap.node))

- .collect();

-

- if nodes.len() > 1 {

- Some(CapturedNode::Grouped(nodes))

- } else {

- nodes.into_iter().map(CapturedNode::Single).next()

- }

- });

- Some(nodes)

-}

-

-pub fn read_query(language: &str, filename: &str) -> String {

- static INHERITS_REGEX: Lazy<Regex> =

- Lazy::new(|| Regex::new(r";+\s*inherits\s*:?\s*([a-z_,()-]+)\s*").unwrap());

-

- let query = load_runtime_file(language, filename).unwrap_or_default();

-

- // replaces all "; inherits <language>(,<language>)*" with the queries of the given language(s)

- INHERITS_REGEX

- .replace_all(&query, |captures: &regex::Captures| {

- captures[1]

- .split(',')

- .fold(String::new(), |mut output, language| {

- // `write!` to a String cannot fail.

- write!(output, "\n{}\n", read_query(language, filename)).unwrap();

- output

- })

- })

- .to_string()

-}

-

-impl config::LanguageConfiguration {

- fn initialize_highlight(&self, scopes: &[String]) -> Option<Arc<HighlightConfiguration>> {

- let highlights_query = read_query(&self.language_id, "highlights.scm");

- // always highlight syntax errors

- // highlights_query += "\n(ERROR) @error";

- let injections_query = read_query(&self.language_id, "injections.scm");

- let locals_query = read_query(&self.language_id, "locals.scm");

-

- if highlights_query.is_empty() {

- None

- } else {

- let language = get_language(self.grammar.as_deref().unwrap_or(&self.language_id))

- .map_err(|err| {

- log::error!(

- "Failed to load tree-sitter parser for language {:?}: {:#}",

- self.language_id,

- err

- )

- })

- .ok()?;

- let config = HighlightConfiguration::new(

- language,

- &highlights_query,

- &injections_query,

- &locals_query,

- )

- .map_err(|err| log::error!("Could not parse queries for language {:?}. Are your grammars out of sync? Try running 'hx --grammar fetch' and 'hx --grammar build'. This query could not be parsed: {:?}", self.language_id, err))

- .ok()?;

-

- config.configure(scopes);

- Some(Arc::new(config))

- }

- pub fn reconfigure(&self, scopes: &[String]) {

- if let Some(Some(config)) = self.highlight_config.get() {

- config.configure(scopes);

- pub fn highlight_config(&self, scopes: &[String]) -> Option<Arc<HighlightConfiguration>> {

- self.highlight_config

- .get_or_init(|| self.initialize_highlight(scopes))

- .clone()

- }

-

- pub fn is_highlight_initialized(&self) -> bool {

- self.highlight_config.get().is_some()

- }

-

- pub fn indent_query(&self) -> Option<&Query> {

- .get_or_init(|| self.load_query("indents.scm"))

- .as_ref()

- }

-

- pub fn textobject_query(&self) -> Option<&TextObjectQuery> {

- self.textobject_query

- self.load_query("textobjects.scm")

- .map(|query| TextObjectQuery { query })

- pub fn scope(&self) -> &str {

- &self.scope

- }

-

- fn load_query(&self, kind: &str) -> Option<Query> {

- let query_text = read_query(&self.language_id, kind);

- if query_text.is_empty() {

- return None;

- let lang = &self.highlight_config.get()?.as_ref()?.language;

- Query::new(lang, &query_text)

- .map_err(|e| {

- log::error!(

- "Failed to parse {} queries for {}: {}",

- kind,

- self.language_id,

- e

- )

- })

- .ok()

-}

-

-#[derive(Debug)]

-struct FileTypeGlob {

- glob: globset::Glob,

- language_id: usize,

-}

-impl FileTypeGlob {

- fn new(glob: globset::Glob, language_id: usize) -> Self {

- Self { glob, language_id }

-}

-#[derive(Debug)]

-struct FileTypeGlobMatcher {

- matcher: globset::GlobSet,

- file_types: Vec<FileTypeGlob>,

-}

-

-impl Default for FileTypeGlobMatcher {

- fn default() -> Self {

- Self {

- matcher: globset::GlobSet::empty(),

- file_types: Default::default(),

-impl FileTypeGlobMatcher {

- fn new(file_types: Vec<FileTypeGlob>) -> Result<Self, globset::Error> {

- let mut builder = globset::GlobSetBuilder::new();

- for file_type in &file_types {

- builder.add(file_type.glob.clone());

-

- Ok(Self {

- matcher: builder.build()?,

- file_types,

- })

- }

-

- fn language_id_for_path(&self, path: &Path) -> Option<&usize> {

- self.matcher

- .matches(path)

- .iter()

- .filter_map(|idx| self.file_types.get(*idx))

- .max_by_key(|file_type| file_type.glob.glob().len())

- .map(|file_type| &file_type.language_id)

- }

-// Expose loader as Lazy<> global since it's always static?

- // highlight_names ?

- language_configs: Vec<Arc<LanguageConfiguration>>,

- language_config_ids_by_extension: HashMap<String, usize>, // Vec<usize>

- language_config_ids_glob_matcher: FileTypeGlobMatcher,

- language_config_ids_by_shebang: HashMap<String, usize>,

-

-

- let mut language_configs = Vec::new();

- let mut language_config_ids_by_extension = HashMap::new();

- let mut language_config_ids_by_shebang = HashMap::new();

- for config in config.language {

- // get the next id

- let language_id = language_configs.len();

- // entry().or_insert(Vec::new).push(language_id);

- language_config_ids_by_extension.insert(extension.clone(), language_id);

- file_type_globs.push(FileTypeGlob::new(glob.to_owned(), language_id));

- language_config_ids_by_shebang.insert(shebang.clone(), language_id);

- language_configs.push(Arc::new(config));

- language_configs,

- language_config_ids_by_extension,

- language_config_ids_glob_matcher: FileTypeGlobMatcher::new(file_type_globs)?,

- language_config_ids_by_shebang,

- pub fn language_config_for_file_name(&self, path: &Path) -> Option<Arc<LanguageConfiguration>> {

- // Find all the language configurations that match this file name

- // or a suffix of the file name.

- let configuration_id = self

- .language_config_ids_glob_matcher

- .language_id_for_path(path)

- .or_else(|| {

- path.extension()

- .and_then(|extension| extension.to_str())

- .and_then(|extension| self.language_config_ids_by_extension.get(extension))

- });

-

- configuration_id.and_then(|&id| self.language_configs.get(id).cloned())

-

- // TODO: content_regex handling conflict resolution

- pub fn language_config_for_shebang(

- &self,

- source: RopeSlice,

- ) -> Option<Arc<LanguageConfiguration>> {

- let line = Cow::from(source.line(0));

- static SHEBANG_REGEX: Lazy<Regex> =

- Lazy::new(|| Regex::new(&["^", SHEBANG].concat()).unwrap());

- let configuration_id = SHEBANG_REGEX

- .captures(&line)

- .and_then(|cap| self.language_config_ids_by_shebang.get(&cap[1]));

- configuration_id.and_then(|&id| self.language_configs.get(id).cloned())

- pub fn language_config_for_scope(&self, scope: &str) -> Option<Arc<LanguageConfiguration>> {

- self.language_configs

- .iter()

- .find(|config| config.scope == scope)

- .cloned()

- pub fn language_config_for_language_id(

- &self,

- id: impl PartialEq<String>,

- ) -> Option<Arc<LanguageConfiguration>> {

- self.language_configs

- .iter()

- .find(|config| id.eq(&config.language_id))

- .cloned()

- /// Unlike `language_config_for_language_id`, which only returns Some for an exact id, this

- /// function will perform a regex match on the given string to find the closest language match.

- pub fn language_config_for_name(&self, slice: RopeSlice) -> Option<Arc<LanguageConfiguration>> {

- let shortcircuit = self.language_config_for_language_id(slice);

- for (i, configuration) in self.language_configs.iter().enumerate() {

- if let Some(injection_regex) = &configuration.injection_regex {

- if let Some(mat) = injection_regex.find(slice.regex_input()) {

- best_match_position = Some(i);

- best_match_position.map(|i| self.language_configs[i].clone())

- pub fn language_configuration_for_injection_string(

- &self,

- capture: &InjectionLanguageMarker,

- ) -> Option<Arc<LanguageConfiguration>> {

- match capture {

- InjectionLanguageMarker::LanguageId(id) => self.language_config_for_language_id(*id),

- InjectionLanguageMarker::Name(name) => self.language_config_for_name(*name),

- InjectionLanguageMarker::Filename(file) => {

- let path_str: Cow<str> = (*file).into();

- self.language_config_for_file_name(Path::new(path_str.as_ref()))

- }

- InjectionLanguageMarker::Shebang(shebang) => {

- let shebang_str: Cow<str> = (*shebang).into();

- self.language_config_ids_by_shebang

- .get(shebang_str.as_ref())

- .and_then(|&id| self.language_configs.get(id).cloned())

- }

- }

- pub fn language_configs(&self) -> impl Iterator<Item = &Arc<LanguageConfiguration>> {

- self.language_configs.iter()

- for config in self

- .language_configs

- .iter()

- .filter(|cfg| cfg.is_highlight_initialized())

- {

- config.reconfigure(&self.scopes());

- pub fn scopes(&self) -> Guard<Arc<Vec<String>>> {

- self.scopes.load()

-pub struct TsParser {

- parser: tree_sitter::Parser,

- pub cursors: Vec<QueryCursor>,

-// could also just use a pool, or a single instance?

-thread_local! {

- pub static PARSER: RefCell<TsParser> = RefCell::new(TsParser {

- parser: Parser::new(),

- cursors: Vec::new(),

- })

-pub struct Syntax {

- layers: HopSlotMap<LayerId, LanguageLayer>,

- root: LayerId,

- loader: Arc<ArcSwap<Loader>>,

-fn byte_range_to_str(range: std::ops::Range<usize>, source: RopeSlice) -> Cow<str> {

- Cow::from(source.byte_slice(range))

-impl Syntax {

- pub fn new(

- source: RopeSlice,

- config: Arc<HighlightConfiguration>,

- loader: Arc<ArcSwap<Loader>>,

- ) -> Option<Self> {

- let root_layer = LanguageLayer {

- tree: None,

- config,

- depth: 0,

- flags: LayerUpdateFlags::empty(),

- ranges: vec![Range {

- start_byte: 0,

- end_byte: usize::MAX,

- start_point: Point::new(0, 0),

- end_point: Point::new(usize::MAX, usize::MAX),

- }],

- parent: None,

- };

- // track scope_descriptor: a Vec of scopes for item in tree

- let mut layers = HopSlotMap::default();

- let root = layers.insert(root_layer);

- let mut syntax = Self {

- root,

- layers,

- loader,

- };

- let res = syntax.update(source, source, &ChangeSet::new(source));

- if res.is_err() {

- log::error!("TS parser failed, disabling TS for the current buffer: {res:?}");

- return None;

- }

- Some(syntax)

- let mut queue = VecDeque::new();

- queue.push_back(self.root);

-

- let loader = self.loader.load();

- let scopes = loader.scopes.load();

- let injection_callback = |language: &InjectionLanguageMarker| {

- loader

- .language_configuration_for_injection_string(language)

- .and_then(|language_config| language_config.highlight_config(&scopes))

- };

-

- // Convert the changeset into tree sitter edits.

-

- // This table allows inverse indexing of `layers`.

- // That is by hashing a `Layer` you can find

- // the `LayerId` of an existing equivalent `Layer` in `layers`.

- //

- // It is used to determine if a new layer exists for an injection

- // or if an existing layer needs to be updated.

- let mut layers_table = RawTable::with_capacity(self.layers.len());

- let layers_hasher = RandomState::new();

- // Use the edits to update all layers markers

- fn point_add(a: Point, b: Point) -> Point {

- if b.row > 0 {

- Point::new(a.row.saturating_add(b.row), b.column)

- } else {

- Point::new(0, a.column.saturating_add(b.column))

- }

- }

- fn point_sub(a: Point, b: Point) -> Point {

- if a.row > b.row {

- Point::new(a.row.saturating_sub(b.row), a.column)

- } else {

- Point::new(0, a.column.saturating_sub(b.column))

- }

- }

-

- for (layer_id, layer) in self.layers.iter_mut() {

- // The root layer always covers the whole range (0..usize::MAX)

- if layer.depth == 0 {

- layer.flags = LayerUpdateFlags::MODIFIED;

- continue;

- }

-

- if !edits.is_empty() {

- for range in &mut layer.ranges {

- // Roughly based on https://github.com/tree-sitter/tree-sitter/blob/ddeaa0c7f534268b35b4f6cb39b52df082754413/lib/src/subtree.c#L691-L720

- for edit in edits.iter().rev() {

- let is_pure_insertion = edit.old_end_byte == edit.start_byte;

-

- // if edit is after range, skip

- if edit.start_byte > range.end_byte {

- // TODO: || (is_noop && edit.start_byte == range.end_byte)

- continue;

- }

-

- // if edit is before range, shift entire range by len

- if edit.old_end_byte < range.start_byte {

- range.start_byte =

- edit.new_end_byte + (range.start_byte - edit.old_end_byte);

- range.start_point = point_add(

- edit.new_end_position,

- point_sub(range.start_point, edit.old_end_position),

- );

-

- range.end_byte = edit

- .new_end_byte

- .saturating_add(range.end_byte - edit.old_end_byte);

- range.end_point = point_add(

- edit.new_end_position,

- point_sub(range.end_point, edit.old_end_position),

- );

-

- layer.flags |= LayerUpdateFlags::MOVED;

- }

- // if the edit starts in the space before and extends into the range

- else if edit.start_byte < range.start_byte {

- range.start_byte = edit.new_end_byte;

- range.start_point = edit.new_end_position;

-

- range.end_byte = range

- .end_byte

- .saturating_sub(edit.old_end_byte)

- .saturating_add(edit.new_end_byte);

- range.end_point = point_add(

- edit.new_end_position,

- point_sub(range.end_point, edit.old_end_position),

- );

- layer.flags = LayerUpdateFlags::MODIFIED;

- }

- // If the edit is an insertion at the start of the tree, shift

- else if edit.start_byte == range.start_byte && is_pure_insertion {

- range.start_byte = edit.new_end_byte;

- range.start_point = edit.new_end_position;

- layer.flags |= LayerUpdateFlags::MOVED;

- } else {

- range.end_byte = range

- .end_byte

- .saturating_sub(edit.old_end_byte)

- .saturating_add(edit.new_end_byte);

- range.end_point = point_add(

- edit.new_end_position,

- point_sub(range.end_point, edit.old_end_position),

- );

- layer.flags = LayerUpdateFlags::MODIFIED;

- }

- }

- }

- }

-

- let hash = layers_hasher.hash_one(layer);

- // Safety: insert_no_grow is unsafe because it assumes that the table

- // has enough capacity to hold additional elements.

- // This is always the case as we reserved enough capacity above.

- unsafe { layers_table.insert_no_grow(hash, layer_id) };

- }

-

- PARSER.with(|ts_parser| {

- let ts_parser = &mut ts_parser.borrow_mut();

- ts_parser.parser.set_timeout_micros(1000 * 500); // half a second is pretty generours

- let mut cursor = ts_parser.cursors.pop().unwrap_or_default();

- // TODO: might need to set cursor range

- cursor.set_byte_range(0..usize::MAX);

- cursor.set_match_limit(TREE_SITTER_MATCH_LIMIT);

-

- let source_slice = source.slice(..);

-

- while let Some(layer_id) = queue.pop_front() {

- let layer = &mut self.layers[layer_id];

-

- // Mark the layer as touched

- layer.flags |= LayerUpdateFlags::TOUCHED;

-

- // If a tree already exists, notify it of changes.

- if let Some(tree) = &mut layer.tree {

- if layer

- .flags

- .intersects(LayerUpdateFlags::MODIFIED | LayerUpdateFlags::MOVED)

- {

- for edit in edits.iter().rev() {

- // Apply the edits in reverse.

- // If we applied them in order then edit 1 would disrupt the positioning of edit 2.

- tree.edit(edit);

- }

- }

-

- if layer.flags.contains(LayerUpdateFlags::MODIFIED) {

- // Re-parse the tree.

- layer.parse(&mut ts_parser.parser, source)?;

- }

- } else {

- // always parse if this layer has never been parsed before

- layer.parse(&mut ts_parser.parser, source)?;

- }

-

- // Switch to an immutable borrow.

- let layer = &self.layers[layer_id];

-

- // Process injections.

- let matches = cursor.matches(

- &layer.config.injections_query,

- layer.tree().root_node(),

- RopeProvider(source_slice),

- );

- let mut combined_injections = vec![

- (None, Vec::new(), IncludedChildren::default());

- layer.config.combined_injections_patterns.len()

- ];

- let mut injections = Vec::new();

- let mut last_injection_end = 0;

- for mat in matches {

- let (injection_capture, content_node, included_children) = layer

- .config

- .injection_for_match(&layer.config.injections_query, &mat, source_slice);

-

- // in case this is a combined injection save it for more processing later

- if let Some(combined_injection_idx) = layer

- .config

- .combined_injections_patterns

- .iter()

- .position(|&pattern| pattern == mat.pattern_index)

- {

- let entry = &mut combined_injections[combined_injection_idx];

- if injection_capture.is_some() {

- entry.0 = injection_capture;

- }

- if let Some(content_node) = content_node {

- if content_node.start_byte() >= last_injection_end {

- entry.1.push(content_node);

- last_injection_end = content_node.end_byte();

- }

- }

- entry.2 = included_children;

- continue;

- }

-

- // Explicitly remove this match so that none of its other captures will remain

- // in the stream of captures.

- mat.remove();

-

- // If a language is found with the given name, then add a new language layer

- // to the highlighted document.

- if let (Some(injection_capture), Some(content_node)) =

- (injection_capture, content_node)

- {

- if let Some(config) = (injection_callback)(&injection_capture) {

- let ranges =

- intersect_ranges(&layer.ranges, &[content_node], included_children);

-

- if !ranges.is_empty() {

- if content_node.start_byte() < last_injection_end {

- continue;

- }

- last_injection_end = content_node.end_byte();

- injections.push((config, ranges));

- }

- }

- }

- }

-

- for (lang_name, content_nodes, included_children) in combined_injections {

- if let (Some(lang_name), false) = (lang_name, content_nodes.is_empty()) {

- if let Some(config) = (injection_callback)(&lang_name) {

- let ranges =

- intersect_ranges(&layer.ranges, &content_nodes, included_children);

- if !ranges.is_empty() {

- injections.push((config, ranges));

- }

- }

- }

- }

-

- let depth = layer.depth + 1;

- // TODO: can't inline this since matches borrows self.layers

- for (config, ranges) in injections {

- let parent = Some(layer_id);

- let new_layer = LanguageLayer {

- tree: None,

- config,

- depth,

- ranges,

- flags: LayerUpdateFlags::empty(),

- parent: None,

- };

-

- // Find an identical existing layer

- let layer = layers_table

- .get(layers_hasher.hash_one(&new_layer), |&it| {

- self.layers[it] == new_layer

- })

- .copied();

-

- // ...or insert a new one.

- let layer_id = layer.unwrap_or_else(|| self.layers.insert(new_layer));

- self.layers[layer_id].parent = parent;

-

- queue.push_back(layer_id);

- }

-

- // TODO: pre-process local scopes at this time, rather than highlight?

- // would solve problems with locals not working across boundaries

- }

-

- // Return the cursor back in the pool.

- ts_parser.cursors.push(cursor);

-

- // Reset all `LayerUpdateFlags` and remove all untouched layers

- self.layers.retain(|_, layer| {

- replace(&mut layer.flags, LayerUpdateFlags::empty())

- .contains(LayerUpdateFlags::TOUCHED)

- });

-

- })

- pub fn tree(&self) -> &Tree {

- self.layers[self.root].tree()

- /// Iterate over the highlighted regions for a given slice of source code.

- pub fn highlight_iter<'a>(

- &'a self,

- source: RopeSlice<'a>,

- range: Option<std::ops::Range<usize>>,

- cancellation_flag: Option<&'a AtomicUsize>,

- ) -> impl Iterator<Item = Result<HighlightEvent, Error>> + 'a {

- let mut layers = self

- .layers

- .iter()

- .filter_map(|(_, layer)| {

- // TODO: if range doesn't overlap layer range, skip it

-

- // Reuse a cursor from the pool if available.

- let mut cursor = PARSER.with(|ts_parser| {

- let highlighter = &mut ts_parser.borrow_mut();

- highlighter.cursors.pop().unwrap_or_default()

- });

-

- // The `captures` iterator borrows the `Tree` and the `QueryCursor`, which

- // prevents them from being moved. But both of these values are really just

- // pointers, so it's actually ok to move them.

- let cursor_ref = unsafe {

- mem::transmute::<&mut tree_sitter::QueryCursor, &mut tree_sitter::QueryCursor>(

- &mut cursor,

- )

- };

-

- // if reusing cursors & no range this resets to whole range

- cursor_ref.set_byte_range(range.clone().unwrap_or(0..usize::MAX));

- cursor_ref.set_match_limit(TREE_SITTER_MATCH_LIMIT);

-

- let mut captures = cursor_ref

- .captures(

- &layer.config.query,

- layer.tree().root_node(),

- RopeProvider(source),

- )

- .peekable();

-

- // If there's no captures, skip the layer

- captures.peek()?;

-

- Some(HighlightIterLayer {

- highlight_end_stack: Vec::new(),

- scope_stack: vec![LocalScope {

- inherits: false,

- range: 0..usize::MAX,

- local_defs: Vec::new(),

- }],

- cursor,

- _tree: None,

- captures: RefCell::new(captures),

- config: layer.config.as_ref(), // TODO: just reuse `layer`

- depth: layer.depth, // TODO: just reuse `layer`

- })

- })

- .collect::<Vec<_>>();

-

- layers.sort_unstable_by_key(|layer| layer.sort_key());

-

- let mut result = HighlightIter {

- source,

- byte_offset: range.map_or(0, |r| r.start),

- cancellation_flag,

- iter_count: 0,

- layers,

- next_event: None,

- last_highlight_range: None,

- };

- result.sort_layers();

- result

- pub fn tree_for_byte_range(&self, start: usize, end: usize) -> &Tree {

- let mut container_id = self.root;

-

- for (layer_id, layer) in self.layers.iter() {

- if layer.depth > self.layers[container_id].depth

- && layer.contains_byte_range(start, end)

- {

- container_id = layer_id;

- }

- }

-

- self.layers[container_id].tree()

- pub fn named_descendant_for_byte_range(&self, start: usize, end: usize) -> Option<Node<'_>> {

- self.tree_for_byte_range(start, end)

- .root_node()

- .named_descendant_for_byte_range(start, end)

- pub fn descendant_for_byte_range(&self, start: usize, end: usize) -> Option<Node<'_>> {

- self.tree_for_byte_range(start, end)

- .root_node()

- .descendant_for_byte_range(start, end)

- pub fn walk(&self) -> TreeCursor<'_> {

- // data structure to find the smallest range that contains a point

- // when some of the ranges in the structure can overlap.

- TreeCursor::new(&self.layers, self.root)

- // Commenting

- // comment_strings_for_pos

- // is_commented

-

- // Indentation

- // suggested_indent_for_line_at_buffer_row

- // suggested_indent_for_buffer_row

- // indent_level_for_line

-

- // TODO: Folding

-}

-

-bitflags! {

- /// Flags that track the status of a layer

- /// in the `Sytaxn::update` function

- #[derive(Debug)]

- struct LayerUpdateFlags : u32{

- const MODIFIED = 0b001;

- const MOVED = 0b010;

- const TOUCHED = 0b100;

-}

-

-#[derive(Debug)]

-pub struct LanguageLayer {

- // mode

- // grammar

- pub config: Arc<HighlightConfiguration>,

- pub(crate) tree: Option<Tree>,

- pub ranges: Vec<Range>,

- pub depth: u32,

- flags: LayerUpdateFlags,

- parent: Option<LayerId>,

-}

-/// This PartialEq implementation only checks if that

-/// two layers are theoretically identical (meaning they highlight the same text range with the same language).

-/// It does not check whether the layers have the same internal treesitter

-/// state.

-impl PartialEq for LanguageLayer {

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

- self.depth == other.depth

- && self.config.language == other.config.language

- && self.ranges == other.ranges

-}

-/// Hash implementation belongs to PartialEq implementation above.

-/// See its documentation for details.

-impl Hash for LanguageLayer {

- fn hash<H: Hasher>(&self, state: &mut H) {

- self.depth.hash(state);

- self.config.language.hash(state);

- self.ranges.hash(state);

-}

-impl LanguageLayer {

- pub fn tree(&self) -> &Tree {

- // TODO: no unwrap

- self.tree.as_ref().unwrap()

- }

-

- fn parse(&mut self, parser: &mut Parser, source: RopeSlice) -> Result<(), Error> {

- parser

- .set_included_ranges(&self.ranges)

- .map_err(|_| Error::InvalidRanges)?;

-

- parser

- .set_language(&self.config.language)

- .map_err(|_| Error::InvalidLanguage)?;

-

- // unsafe { syntax.parser.set_cancellation_flag(cancellation_flag) };

- let tree = parser

- .parse_with(

- &mut |byte, _| {

- if byte <= source.len_bytes() {

- let (chunk, start_byte, _, _) = source.chunk_at_byte(byte);

- &chunk.as_bytes()[byte - start_byte..]

- } else {

- // out of range

- &[]

- }

- },

- self.tree.as_ref(),

- )

- .ok_or(Error::Cancelled)?;

- // unsafe { ts_parser.parser.set_cancellation_flag(None) };

- self.tree = Some(tree);

- Ok(())

- /// Whether the layer contains the given byte range.

- ///

- /// If the layer has multiple ranges (i.e. combined injections), the

- /// given range is considered contained if it is within the start and

- /// end bytes of the first and last ranges **and** if the given range

- /// starts or ends within any of the layer's ranges.

- fn contains_byte_range(&self, start: usize, end: usize) -> bool {

- let layer_start = self

- .ranges

- .first()

- .expect("ranges should not be empty")

- .start_byte;

- let layer_end = self

- .ranges

- .last()

- .expect("ranges should not be empty")

- .end_byte;

-

- layer_start <= start

- && layer_end >= end

- && self.ranges.iter().any(|range| {

- let byte_range = range.start_byte..range.end_byte;

- byte_range.contains(&start) || byte_range.contains(&end)

- })

-pub(crate) fn generate_edits(

- old_text: RopeSlice,

- changeset: &ChangeSet,

-) -> Vec<tree_sitter::InputEdit> {

- use Operation::*;

-

- fn point_at_pos(text: RopeSlice, pos: usize) -> (usize, Point) {

- let byte = text.char_to_byte(pos); // <- attempted to index past end

- let line = text.char_to_line(pos);

- let line_start_byte = text.line_to_byte(line);

- let col = byte - line_start_byte;

-

- (byte, Point::new(line, col))

- }

-

- fn traverse(point: Point, text: &Tendril) -> Point {

- let Point {

- mut row,

- mut column,

- } = point;

-

- // TODO: there should be a better way here.

- let mut chars = text.chars().peekable();

- while let Some(ch) = chars.next() {

- if char_is_line_ending(ch) && !(ch == '\r' && chars.peek() == Some(&'\n')) {

- row += 1;

- column = 0;

- } else {

- column += 1;

- }

- }

- Point { row, column }

- }

-

- let (start_byte, start_position) = point_at_pos(old_text, old_pos);

- let (old_end_byte, old_end_position) = point_at_pos(old_text, old_end);

- edits.push(tree_sitter::InputEdit {

- start_byte, // old_pos to byte

- old_end_byte, // old_end to byte

- new_end_byte: start_byte, // old_pos to byte

- start_position, // old pos to coords

- old_end_position, // old_end to coords

- new_end_position: start_position, // old pos to coords

- let (start_byte, start_position) = point_at_pos(old_text, old_pos);

- let (old_end_byte, old_end_position) = point_at_pos(old_text, old_end);

- edits.push(tree_sitter::InputEdit {

- start_byte, // old_pos to byte

- old_end_byte, // old_end to byte

- new_end_byte: start_byte + s.len(), // old_pos to byte + s.len()

- start_position, // old pos to coords

- old_end_position, // old_end to coords

- new_end_position: traverse(start_position, s), // old pos + chars, newlines matter too (iter over)

- edits.push(tree_sitter::InputEdit {

- start_byte, // old_pos to byte

- old_end_byte: start_byte, // same

- new_end_byte: start_byte + s.len(), // old_pos + s.len()

- start_position, // old pos to coords

- old_end_position: start_position, // same

- new_end_position: traverse(start_position, s), // old pos + chars, newlines matter too (iter over)

-use std::sync::atomic::{AtomicUsize, Ordering};

-use std::{iter, mem, ops, str};

-use tree_sitter::{

- Language as Grammar, Node, Parser, Point, Query, QueryCaptures, QueryCursor, QueryError,

- QueryMatch, Range, TextProvider, Tree,

-};

-

-const CANCELLATION_CHECK_INTERVAL: usize = 100;

-

-/// Indicates which highlight should be applied to a region of source code.

-#[derive(Copy, Clone, Debug, PartialEq, Eq)]

-pub struct Highlight(pub usize);

-

-/// Represents the reason why syntax highlighting failed.

-#[derive(Debug, PartialEq, Eq)]

-pub enum Error {

- Cancelled,

- InvalidLanguage,

- InvalidRanges,

- Unknown,

-}

-

-/// Represents a single step in rendering a syntax-highlighted document.

-#[derive(Copy, Clone, Debug)]

-pub enum HighlightEvent {

- Source { start: usize, end: usize },

- HighlightStart(Highlight),

- HighlightEnd,

-}

-

-/// Contains the data needed to highlight code written in a particular language.

-/// This struct is immutable and can be shared between threads.

-pub struct HighlightConfiguration {

- pub language: Grammar,

- pub query: Query,

- injections_query: Query,

- combined_injections_patterns: Vec<usize>,

- highlights_pattern_index: usize,

- highlight_indices: ArcSwap<Vec<Option<Highlight>>>,

- non_local_variable_patterns: Vec<bool>,

- injection_content_capture_index: Option<u32>,

- injection_language_capture_index: Option<u32>,

- injection_filename_capture_index: Option<u32>,

- injection_shebang_capture_index: Option<u32>,

- local_scope_capture_index: Option<u32>,

- local_def_capture_index: Option<u32>,

- local_def_value_capture_index: Option<u32>,

- local_ref_capture_index: Option<u32>,

-}

-

-#[derive(Debug)]

-struct LocalDef<'a> {

- name: Cow<'a, str>,

- value_range: ops::Range<usize>,

- highlight: Option<Highlight>,

-}

-

-#[derive(Debug)]

-struct LocalScope<'a> {

- inherits: bool,

- range: ops::Range<usize>,

- local_defs: Vec<LocalDef<'a>>,

-}

-

-#[derive(Debug)]

-struct HighlightIter<'a> {

- source: RopeSlice<'a>,

- byte_offset: usize,

- cancellation_flag: Option<&'a AtomicUsize>,

- layers: Vec<HighlightIterLayer<'a>>,

- iter_count: usize,

- next_event: Option<HighlightEvent>,

- last_highlight_range: Option<(usize, usize, u32)>,

-}

-

-// Adapter to convert rope chunks to bytes

-pub struct ChunksBytes<'a> {

- chunks: ropey::iter::Chunks<'a>,

-}

-impl<'a> Iterator for ChunksBytes<'a> {

- type Item = &'a [u8];

- fn next(&mut self) -> Option<Self::Item> {

- self.chunks.next().map(str::as_bytes)

- }

-pub struct RopeProvider<'a>(pub RopeSlice<'a>);

-impl<'a> TextProvider<&'a [u8]> for RopeProvider<'a> {

- type I = ChunksBytes<'a>;

-

- fn text(&mut self, node: Node) -> Self::I {

- let fragment = self.0.byte_slice(node.start_byte()..node.end_byte());

- ChunksBytes {

- chunks: fragment.chunks(),

-}

-

-struct HighlightIterLayer<'a> {

- _tree: Option<Tree>,

- cursor: QueryCursor,

- captures: RefCell<iter::Peekable<QueryCaptures<'a, 'a, RopeProvider<'a>, &'a [u8]>>>,

- config: &'a HighlightConfiguration,

- highlight_end_stack: Vec<usize>,

- scope_stack: Vec<LocalScope<'a>>,

- depth: u32,

-}

-impl fmt::Debug for HighlightIterLayer<'_> {

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

- f.debug_struct("HighlightIterLayer").finish()

-impl HighlightConfiguration {

- /// Creates a `HighlightConfiguration` for a given `Grammar` and set of highlighting

- /// queries.

- ///

- /// # Parameters

- /// * `language` - The Tree-sitter `Grammar` that should be used for parsing.

- /// * `highlights_query` - A string containing tree patterns for syntax highlighting. This

- /// should be non-empty, otherwise no syntax highlights will be added.

- /// * `injections_query` - A string containing tree patterns for injecting other languages

- /// into the document. This can be empty if no injections are desired.

- /// * `locals_query` - A string containing tree patterns for tracking local variable

- /// definitions and references. This can be empty if local variable tracking is not needed.

- /// Returns a `HighlightConfiguration` that can then be used with the `highlight` method.

- pub fn new(

- language: Grammar,

- highlights_query: &str,

- injection_query: &str,

- locals_query: &str,

- ) -> Result<Self, QueryError> {

- // Concatenate the query strings, keeping track of the start offset of each section.

- let mut query_source = String::new();

- query_source.push_str(locals_query);

- let highlights_query_offset = query_source.len();

- query_source.push_str(highlights_query);

-

- // Construct a single query by concatenating the three query strings, but record the

- // range of pattern indices that belong to each individual string.

- let query = Query::new(&language, &query_source)?;

- let mut highlights_pattern_index = 0;

- for i in 0..(query.pattern_count()) {

- let pattern_offset = query.start_byte_for_pattern(i);

- if pattern_offset < highlights_query_offset {

- highlights_pattern_index += 1;

- }

- }

-

- let injections_query = Query::new(&language, injection_query)?;

- let combined_injections_patterns = (0..injections_query.pattern_count())

- .filter(|&i| {

- injections_query

- .property_settings(i)

- .iter()

- .any(|s| &*s.key == "injection.combined")

- })

- .collect();

-

- // Find all of the highlighting patterns that are disabled for nodes that

- // have been identified as local variables.

- let non_local_variable_patterns = (0..query.pattern_count())

- .map(|i| {

- query

- .property_predicates(i)

- .iter()

- .any(|(prop, positive)| !*positive && prop.key.as_ref() == "local")

- })

- .collect();

-

- // Store the numeric ids for all of the special captures.

- let mut injection_content_capture_index = None;

- let mut injection_language_capture_index = None;

- let mut injection_filename_capture_index = None;

- let mut injection_shebang_capture_index = None;

- let mut local_def_capture_index = None;

- let mut local_def_value_capture_index = None;

- let mut local_ref_capture_index = None;

- let mut local_scope_capture_index = None;

- for (i, name) in query.capture_names().iter().enumerate() {

- let i = Some(i as u32);

- match *name {

- "local.definition" => local_def_capture_index = i,

- "local.definition-value" => local_def_value_capture_index = i,

- "local.reference" => local_ref_capture_index = i,

- "local.scope" => local_scope_capture_index = i,

- _ => {}

- }

- }

-

- for (i, name) in injections_query.capture_names().iter().enumerate() {

- let i = Some(i as u32);

- match *name {

- "injection.content" => injection_content_capture_index = i,

- "injection.language" => injection_language_capture_index = i,

- "injection.filename" => injection_filename_capture_index = i,

- "injection.shebang" => injection_shebang_capture_index = i,

- _ => {}

- }

- }

- let highlight_indices = ArcSwap::from_pointee(vec![None; query.capture_names().len()]);

- Ok(Self {

- language,

- query,

- injections_query,

- combined_injections_patterns,

- highlights_pattern_index,

- highlight_indices,

- non_local_variable_patterns,

- injection_content_capture_index,

- injection_language_capture_index,

- injection_filename_capture_index,

- injection_shebang_capture_index,

- local_scope_capture_index,

- local_def_capture_index,

- local_def_value_capture_index,

- local_ref_capture_index,

- /// Get a slice containing all of the highlight names used in the configuration.

- pub fn names(&self) -> &[&str] {

- self.query.capture_names()

- }

-

- /// Set the list of recognized highlight names.

- ///

- /// Tree-sitter syntax-highlighting queries specify highlights in the form of dot-separated

- /// highlight names like `punctuation.bracket` and `function.method.builtin`. Consumers of

- /// these queries can choose to recognize highlights with different levels of specificity.

- /// For example, the string `function.builtin` will match against `function.builtin.constructor`

- /// but will not match `function.method.builtin` and `function.method`.

- ///

- /// When highlighting, results are returned as `Highlight` values, which contain the index

- /// of the matched highlight this list of highlight names.

- pub fn configure(&self, recognized_names: &[String]) {

- let mut capture_parts = Vec::new();

- let indices: Vec<_> = self

- .query

- .capture_names()

- .iter()

- .map(move |capture_name| {

- capture_parts.clear();

- capture_parts.extend(capture_name.split('.'));

-

- let mut best_index = None;

- let mut best_match_len = 0;

- for (i, recognized_name) in recognized_names.iter().enumerate() {

- let mut len = 0;

- let mut matches = true;

- for (i, part) in recognized_name.split('.').enumerate() {

- match capture_parts.get(i) {

- Some(capture_part) if *capture_part == part => len += 1,

- _ => {

- matches = false;

- break;

- }

- }

- }

- if matches && len > best_match_len {

- best_index = Some(i);

- best_match_len = len;

- }

- }

- best_index.map(Highlight)

- })

- .collect();

-

- self.highlight_indices.store(Arc::new(indices));

- }

-

- fn injection_pair<'a>(

- &self,

- query_match: &QueryMatch<'a, 'a>,

- source: RopeSlice<'a>,

- ) -> (Option<InjectionLanguageMarker<'a>>, Option<Node<'a>>) {

- let mut injection_capture = None;

- let mut content_node = None;

-

- for capture in query_match.captures {

- let index = Some(capture.index);

- if index == self.injection_language_capture_index {

- injection_capture = Some(InjectionLanguageMarker::Name(

- source.byte_slice(capture.node.byte_range()),

- ));

- } else if index == self.injection_filename_capture_index {

- injection_capture = Some(InjectionLanguageMarker::Filename(

- source.byte_slice(capture.node.byte_range()),

- ));

- } else if index == self.injection_shebang_capture_index {

- let node_slice = source.byte_slice(capture.node.byte_range());

-

- // some languages allow space and newlines before the actual string content

- // so a shebang could be on either the first or second line

- let lines = if let Ok(end) = node_slice.try_line_to_byte(2) {

- node_slice.byte_slice(..end)

- } else {

- node_slice

- };

-

- static SHEBANG_REGEX: Lazy<rope::Regex> =

- Lazy::new(|| rope::Regex::new(SHEBANG).unwrap());

-

- injection_capture = SHEBANG_REGEX

- .captures_iter(lines.regex_input())

- .map(|cap| {

- let cap = lines.byte_slice(cap.get_group(1).unwrap().range());

- InjectionLanguageMarker::Shebang(cap)

- })

- .next()

- } else if index == self.injection_content_capture_index {

- content_node = Some(capture.node);

- }

- }

- (injection_capture, content_node)

- }

-

- fn injection_for_match<'a>(

- &self,

- query: &'a Query,

- query_match: &QueryMatch<'a, 'a>,

- source: RopeSlice<'a>,

- ) -> (

- Option<InjectionLanguageMarker<'a>>,

- Option<Node<'a>>,

- IncludedChildren,

- ) {

- let (mut injection_capture, content_node) = self.injection_pair(query_match, source);

-

- let mut included_children = IncludedChildren::default();

- for prop in query.property_settings(query_match.pattern_index) {

- match prop.key.as_ref() {

- // In addition to specifying the language name via the text of a

- // captured node, it can also be hard-coded via a `#set!` predicate

- // that sets the injection.language key.

- "injection.language" if injection_capture.is_none() => {

- injection_capture = prop

- .value

- .as_deref()

- .map(InjectionLanguageMarker::LanguageId);

- }

-

- // By default, injections do not include the *children* of an

- // `injection.content` node - only the ranges that belong to the

- // node itself. This can be changed using a `#set!` predicate that

- // sets the `injection.include-children` key.

- "injection.include-children" => included_children = IncludedChildren::All,

-

- // Some queries might only exclude named children but include unnamed

- // children in their `injection.content` node. This can be enabled using

- // a `#set!` predicate that sets the `injection.include-unnamed-children` key.

- "injection.include-unnamed-children" => {

- included_children = IncludedChildren::Unnamed

- }

- _ => {}

- }

-

- (injection_capture, content_node, included_children)

-}

-impl HighlightIterLayer<'_> {

- // First, sort scope boundaries by their byte offset in the document. At a

- // given position, emit scope endings before scope beginnings. Finally, emit

- // scope boundaries from deeper layers first.

- fn sort_key(&self) -> Option<(usize, bool, isize)> {

- let depth = -(self.depth as isize);

- let next_start = self

- .captures

- .borrow_mut()

- .peek()

- .map(|(m, i)| m.captures[*i].node.start_byte());

- let next_end = self.highlight_end_stack.last().cloned();

- match (next_start, next_end) {

- (Some(start), Some(end)) => {

- if start < end {

- Some((start, true, depth))

- } else {

- Some((end, false, depth))

- }

- (Some(i), None) => Some((i, true, depth)),

- (None, Some(j)) => Some((j, false, depth)),

- _ => None,

-#[derive(Clone)]

-enum IncludedChildren {

- None,

- All,

- Unnamed,

-}

-

-impl Default for IncludedChildren {

- fn default() -> Self {

- Self::None

- }

-// Compute the ranges that should be included when parsing an injection.

-// This takes into account three things:

-// * `parent_ranges` - The ranges must all fall within the *current* layer's ranges.

-// * `nodes` - Every injection takes place within a set of nodes. The injection ranges

-// are the ranges of those nodes.

-// * `includes_children` - For some injections, the content nodes' children should be

-// excluded from the nested document, so that only the content nodes' *own* content

-// is reparsed. For other injections, the content nodes' entire ranges should be

-// reparsed, including the ranges of their children.

-fn intersect_ranges(

- parent_ranges: &[Range],

- nodes: &[Node],

- included_children: IncludedChildren,

-) -> Vec<Range> {

- let mut cursor = nodes[0].walk();

- let mut result = Vec::new();

- let mut parent_range_iter = parent_ranges.iter();

- let mut parent_range = parent_range_iter

- .next()

- .expect("Layers should only be constructed with non-empty ranges vectors");

- for node in nodes.iter() {

- let mut preceding_range = Range {

- start_byte: 0,

- start_point: Point::new(0, 0),

- end_byte: node.start_byte(),

- end_point: node.start_position(),

- };

- let following_range = Range {

- start_byte: node.end_byte(),

- start_point: node.end_position(),

- end_byte: usize::MAX,

- end_point: Point::new(usize::MAX, usize::MAX),

- };

-

- for excluded_range in node

- .children(&mut cursor)

- .filter_map(|child| match included_children {

- IncludedChildren::None => Some(child.range()),

- IncludedChildren::All => None,

- IncludedChildren::Unnamed => {

- if child.is_named() {

- Some(child.range())

- } else {

- None

- }

- }

- })

- .chain([following_range].iter().cloned())

- {

- let mut range = Range {

- start_byte: preceding_range.end_byte,

- start_point: preceding_range.end_point,

- end_byte: excluded_range.start_byte,

- end_point: excluded_range.start_point,

- };

- preceding_range = excluded_range;

-

- if range.end_byte < parent_range.start_byte {

- continue;

- }

-

- while parent_range.start_byte <= range.end_byte {

- if parent_range.end_byte > range.start_byte {

- if range.start_byte < parent_range.start_byte {

- range.start_byte = parent_range.start_byte;

- range.start_point = parent_range.start_point;

- }

-

- if parent_range.end_byte < range.end_byte {

- if range.start_byte < parent_range.end_byte {

- result.push(Range {

- start_byte: range.start_byte,

- start_point: range.start_point,

- end_byte: parent_range.end_byte,

- end_point: parent_range.end_point,

- });

- }

- range.start_byte = parent_range.end_byte;

- range.start_point = parent_range.end_point;

- } else {

- if range.start_byte < range.end_byte {

- result.push(range);

- }

- break;

- }

- }

- if let Some(next_range) = parent_range_iter.next() {

- parent_range = next_range;

- } else {

- return result;

- }

- }

- result

-}

-impl HighlightIter<'_> {

- fn emit_event(

- &mut self,

- offset: usize,

- event: Option<HighlightEvent>,

- ) -> Option<Result<HighlightEvent, Error>> {

- let result;

- if self.byte_offset < offset {

- result = Some(Ok(HighlightEvent::Source {

- start: self.byte_offset,

- end: offset,

- }));

- self.byte_offset = offset;

- self.next_event = event;

- } else {

- result = event.map(Ok);

- }

- self.sort_layers();

- result

- }

-

- fn sort_layers(&mut self) {

- while !self.layers.is_empty() {

- if let Some(sort_key) = self.layers[0].sort_key() {

- let mut i = 0;

- while i + 1 < self.layers.len() {

- if let Some(next_offset) = self.layers[i + 1].sort_key() {

- if next_offset < sort_key {

- i += 1;

- continue;

- }

- } else {

- let layer = self.layers.remove(i + 1);

- PARSER.with(|ts_parser| {

- let highlighter = &mut ts_parser.borrow_mut();

- highlighter.cursors.push(layer.cursor);

- });

- }

- break;

- }

- if i > 0 {

- self.layers[0..(i + 1)].rotate_left(1);

- }

- break;

- } else {

- let layer = self.layers.remove(0);

- PARSER.with(|ts_parser| {

- let highlighter = &mut ts_parser.borrow_mut();

- highlighter.cursors.push(layer.cursor);

- });

- }

- }

-}

-

-impl Iterator for HighlightIter<'_> {

- type Item = Result<HighlightEvent, Error>;

-

- fn next(&mut self) -> Option<Self::Item> {

- 'main: loop {

- // If we've already determined the next highlight boundary, just return it.

- if let Some(e) = self.next_event.take() {

- return Some(Ok(e));

- }

-

- // Periodically check for cancellation, returning `Cancelled` error if the

- // cancellation flag was flipped.

- if let Some(cancellation_flag) = self.cancellation_flag {

- self.iter_count += 1;

- if self.iter_count >= CANCELLATION_CHECK_INTERVAL {

- self.iter_count = 0;

- if cancellation_flag.load(Ordering::Relaxed) != 0 {

- return Some(Err(Error::Cancelled));

- }

- }

- }

-

- // If none of the layers have any more highlight boundaries, terminate.

- if self.layers.is_empty() {

- let len = self.source.len_bytes();

- return if self.byte_offset < len {

- let result = Some(Ok(HighlightEvent::Source {

- start: self.byte_offset,

- end: len,

- }));

- self.byte_offset = len;

- result

- } else {

- None

- };

- }

-

- // Get the next capture from whichever layer has the earliest highlight boundary.

- let range;

- let layer = &mut self.layers[0];

- let captures = layer.captures.get_mut();

- if let Some((next_match, capture_index)) = captures.peek() {

- let next_capture = next_match.captures[*capture_index];

- range = next_capture.node.byte_range();

-

- // If any previous highlight ends before this node starts, then before

- // processing this capture, emit the source code up until the end of the

- // previous highlight, and an end event for that highlight.

- if let Some(end_byte) = layer.highlight_end_stack.last().cloned() {

- if end_byte <= range.start {

- layer.highlight_end_stack.pop();

- return self.emit_event(end_byte, Some(HighlightEvent::HighlightEnd));

- }

- }

- }

- // If there are no more captures, then emit any remaining highlight end events.

- // And if there are none of those, then just advance to the end of the document.

- else if let Some(end_byte) = layer.highlight_end_stack.last().cloned() {

- layer.highlight_end_stack.pop();

- return self.emit_event(end_byte, Some(HighlightEvent::HighlightEnd));

- } else {

- return self.emit_event(self.source.len_bytes(), None);

- };

-

- let (mut match_, capture_index) = captures.next().unwrap();

- let mut capture = match_.captures[capture_index];

-

- // Remove from the local scope stack any local scopes that have already ended.

- while range.start > layer.scope_stack.last().unwrap().range.end {

- layer.scope_stack.pop();

- }

-

- // If this capture is for tracking local variables, then process the

- // local variable info.

- let mut reference_highlight = None;

- let mut definition_highlight = None;

- while match_.pattern_index < layer.config.highlights_pattern_index {

- // If the node represents a local scope, push a new local scope onto

- // the scope stack.

- if Some(capture.index) == layer.config.local_scope_capture_index {

- definition_highlight = None;

- let mut scope = LocalScope {

- inherits: true,

- range: range.clone(),

- local_defs: Vec::new(),

- };

- for prop in layer.config.query.property_settings(match_.pattern_index) {

- if let "local.scope-inherits" = prop.key.as_ref() {

- scope.inherits =

- prop.value.as_ref().map_or(true, |r| r.as_ref() == "true");

- }

- }

- layer.scope_stack.push(scope);

- }

- // If the node represents a definition, add a new definition to the

- // local scope at the top of the scope stack.

- else if Some(capture.index) == layer.config.local_def_capture_index {

- reference_highlight = None;

- let scope = layer.scope_stack.last_mut().unwrap();

-

- let mut value_range = 0..0;

- for capture in match_.captures {

- if Some(capture.index) == layer.config.local_def_value_capture_index {

- value_range = capture.node.byte_range();

- }

- }

- let name = byte_range_to_str(range.clone(), self.source);

- scope.local_defs.push(LocalDef {

- name,

- value_range,

- highlight: None,

- });

- definition_highlight = scope.local_defs.last_mut().map(|s| &mut s.highlight);

- }

- // If the node represents a reference, then try to find the corresponding

- // definition in the scope stack.

- else if Some(capture.index) == layer.config.local_ref_capture_index

- && definition_highlight.is_none()

- definition_highlight = None;

- let name = byte_range_to_str(range.clone(), self.source);

- for scope in layer.scope_stack.iter().rev() {

- if let Some(highlight) = scope.local_defs.iter().rev().find_map(|def| {

- if def.name == name && range.start >= def.value_range.end {

- Some(def.highlight)

- } else {

- None

- }

- }) {

- reference_highlight = highlight;

- break;

- }

- if !scope.inherits {

- break;

- }

- }

- }

-

- // Continue processing any additional matches for the same node.

- if let Some((next_match, next_capture_index)) = captures.peek() {

- let next_capture = next_match.captures[*next_capture_index];

- if next_capture.node == capture.node {

- capture = next_capture;

- match_ = captures.next().unwrap().0;

- continue;

- }

- }

-

- self.sort_layers();

- continue 'main;

- }

-

- // Otherwise, this capture must represent a highlight.

- // If this exact range has already been highlighted by an earlier pattern, or by

- // a different layer, then skip over this one.

- if let Some((last_start, last_end, last_depth)) = self.last_highlight_range {

- if range.start == last_start && range.end == last_end && layer.depth < last_depth {

- self.sort_layers();

- continue 'main;

- // If the current node was found to be a local variable, then skip over any

- // highlighting patterns that are disabled for local variables.

- if definition_highlight.is_some() || reference_highlight.is_some() {

- while layer.config.non_local_variable_patterns[match_.pattern_index] {

- match_.remove();

- if let Some((next_match, next_capture_index)) = captures.peek() {

- let next_capture = next_match.captures[*next_capture_index];

- if next_capture.node == capture.node {

- capture = next_capture;

- match_ = captures.next().unwrap().0;

- continue;

- }

- }

-

- self.sort_layers();

- continue 'main;

- }

- }

- // Use the last capture found for the current node, skipping over any

- // highlight patterns that also match this node. Captures

- // for a given node are ordered by pattern index, so these subsequent

- // captures are guaranteed to be for highlighting, not injections or

- // local variables.

- while let Some((next_match, next_capture_index)) = captures.peek() {

- let next_capture = next_match.captures[*next_capture_index];

- if next_capture.node == capture.node {

- match_.remove();

- capture = next_capture;

- match_ = captures.next().unwrap().0;

- } else {

- break;

- }

- let current_highlight = layer.config.highlight_indices.load()[capture.index as usize];

- // If this node represents a local definition, then store the current

- // highlight value on the local scope entry representing this node.

- if let Some(definition_highlight) = definition_highlight {

- *definition_highlight = current_highlight;

- // Emit a scope start event and push the node's end position to the stack.

- if let Some(highlight) = reference_highlight.or(current_highlight) {

- self.last_highlight_range = Some((range.start, range.end, layer.depth));

- layer.highlight_end_stack.push(range.end);

- return self

- .emit_event(range.start, Some(HighlightEvent::HighlightStart(highlight)));

- }

-

- self.sort_layers();

- }

-}

-

-#[derive(Debug, Clone)]

-pub enum InjectionLanguageMarker<'a> {

- /// The language is specified by `LanguageConfiguration`'s `language_id` field.

- ///

- /// This marker is used when a pattern sets the `injection.language` property, for example

- /// `(#set! injection.language "rust")`.

- LanguageId(&'a str),

- /// The language is specified in the document and captured by `@injection.language`.

- ///

- /// This is used for markdown code fences for example. While the `LanguageId` variant can be

- /// looked up by finding the language config that sets an `language_id`, this variant contains

- /// text from the document being highlighted, so the text is checked against each language's

- /// `injection_regex`.

- Name(RopeSlice<'a>),

- Filename(RopeSlice<'a>),

- Shebang(RopeSlice<'a>),

-}

-const SHEBANG: &str = r"#!\s*(?:\S*[/\\](?:env\s+(?:\-\S+\s+)*)?)?([^\s\.\d]+)";

-

-pub struct Merge<I> {

- iter: I,

- spans: Box<dyn Iterator<Item = (usize, std::ops::Range<usize>)>>,

- next_event: Option<HighlightEvent>,

- next_span: Option<(usize, std::ops::Range<usize>)>,

- queue: Vec<HighlightEvent>,

-/// Merge a list of spans into the highlight event stream.

-pub fn merge<I: Iterator<Item = HighlightEvent>>(

- iter: I,

- spans: Vec<(usize, std::ops::Range<usize>)>,

-) -> Merge<I> {

- let spans = Box::new(spans.into_iter());

- let mut merge = Merge {

- iter,

- spans,

- next_event: None,

- next_span: None,

- queue: Vec::new(),

- };

- merge.next_event = merge.iter.next();

- merge.next_span = merge.spans.next();

- merge

-impl<I: Iterator<Item = HighlightEvent>> Iterator for Merge<I> {

- type Item = HighlightEvent;

- fn next(&mut self) -> Option<Self::Item> {

- use HighlightEvent::*;

- if let Some(event) = self.queue.pop() {

- return Some(event);

- loop {

- match (self.next_event, &self.next_span) {

- // this happens when range is partially or fully offscreen

- (Some(Source { start, .. }), Some((span, range))) if start > range.start => {

- if start > range.end {

- self.next_span = self.spans.next();

- } else {

- self.next_span = Some((*span, start..range.end));

- };

- }

- _ => break,

- }

- match (self.next_event, &self.next_span) {

- (Some(HighlightStart(i)), _) => {

- self.next_event = self.iter.next();

- Some(HighlightStart(i))

- }

- (Some(HighlightEnd), _) => {

- self.next_event = self.iter.next();

- Some(HighlightEnd)

- }

- (Some(Source { start, end }), Some((_, range))) if start < range.start => {

- let intersect = range.start.min(end);

- let event = Source {

- start,

- end: intersect,

- };

-

- if end == intersect {

- // the event is complete

- self.next_event = self.iter.next();

- } else {

- // subslice the event

- self.next_event = Some(Source {

- start: intersect,

- end,

- });

- };

-

- Some(event)

- }

- (Some(Source { start, end }), Some((span, range))) if start == range.start => {

- let intersect = range.end.min(end);

- let event = HighlightStart(Highlight(*span));

-

- // enqueue in reverse order

- self.queue.push(HighlightEnd);

- self.queue.push(Source {

- start,

- end: intersect,

- });

- if end == intersect {

- // the event is complete

- self.next_event = self.iter.next();

- } else {

- // subslice the event

- self.next_event = Some(Source {

- start: intersect,

- end,

- });

- };

- if intersect == range.end {

- self.next_span = self.spans.next();

- } else {

- self.next_span = Some((*span, intersect..range.end));

- }

- Some(event)

- }

- (Some(event), None) => {

- self.next_event = self.iter.next();

- Some(event)

- }

- // Can happen if cursor at EOF and/or diagnostic reaches past the end.

- // We need to actually emit events for the cursor-at-EOF situation,

- // even though the range is past the end of the text. This needs to be

- // handled appropriately by the drawing code by not assuming that

- // all `Source` events point to valid indices in the rope.

- (None, Some((span, range))) => {

- let event = HighlightStart(Highlight(*span));

- self.queue.push(HighlightEnd);

- self.queue.push(Source {

- start: range.start,

- end: range.end,

- });

- self.next_span = self.spans.next();

- Some(event)

- }

- (None, None) => None,

- e => unreachable!("{:?}", e),

- }

-}

-fn node_is_visible(node: &Node) -> bool {

- node.is_missing() || (node.is_named() && node.language().node_kind_is_visible(node.kind_id()))

-}

-fn format_anonymous_node_kind(kind: &str) -> Cow<str> {

- if kind.contains('"') {

- Cow::Owned(kind.replace('"', "\\\""))

- } else {

- Cow::Borrowed(kind)

- let loader = Loader::new(Configuration {

- language: vec![],

- language_server: HashMap::new(),

- })

- .unwrap();

- let language = get_language("rust").unwrap();

-

- let query = Query::new(&language, query_str).unwrap();

- let textobject = TextObjectQuery { query };

- let mut cursor = QueryCursor::new();

-

- let config = HighlightConfiguration::new(language, "", "", "").unwrap();

- let syntax = Syntax::new(

- source.slice(..),

- Arc::new(config),

- Arc::new(ArcSwap::from_pointee(loader)),

- )

- .unwrap();

- let mut test = |capture, range| {

- .capture_nodes(capture, root, source.slice(..), &mut cursor)

- fn test_parser() {

- let highlight_names: Vec<String> = [

- "attribute",

- "constant",

- "function.builtin",

- "function",

- "keyword",

- "operator",

- "property",

- "punctuation",

- "punctuation.bracket",

- "punctuation.delimiter",

- "string",

- "string.special",

- "tag",

- "type",

- "type.builtin",

- "variable",

- "variable.builtin",

- "variable.parameter",

- ]

- .iter()

- .cloned()

- .map(String::from)

- .collect();

-

- let loader = Loader::new(Configuration {

- language: vec![],

- language_server: HashMap::new(),

- })

- .unwrap();

-

- let language = get_language("rust").unwrap();

- let config = HighlightConfiguration::new(

- language,

- &std::fs::read_to_string("../runtime/grammars/sources/rust/queries/highlights.scm")

- .unwrap(),

- &std::fs::read_to_string("../runtime/grammars/sources/rust/queries/injections.scm")

- .unwrap(),

- "", // locals.scm

- )

- .unwrap();

- config.configure(&highlight_names);

-

- let source = Rope::from_str(

- "

- struct Stuff {}

- fn main() {}

- ",

- );

- let syntax = Syntax::new(

- source.slice(..),

- Arc::new(config),

- Arc::new(ArcSwap::from_pointee(loader)),

- )

- .unwrap();

- let tree = syntax.tree();

- let root = tree.root_node();

- assert_eq!(root.kind(), "source_file");

-

- assert_eq!(

- root.to_sexp(),

- concat!(

- "(source_file ",

- "(struct_item name: (type_identifier) body: (field_declaration_list)) ",

- "(function_item name: (identifier) parameters: (parameters) body: (block)))"

- )

- );

-

- let struct_node = root.child(0).unwrap();

- assert_eq!(struct_node.kind(), "struct_item");

- }

-

- #[test]

- use tree_sitter::InputEdit;

- start_position: Point { row: 0, column: 6 },

- old_end_position: Point { row: 0, column: 11 },

- new_end_position: Point { row: 0, column: 10 }

- start_position: Point { row: 0, column: 12 },

- old_end_position: Point { row: 1, column: 4 },

- new_end_position: Point { row: 0, column: 12 }

- start_position: Point { row: 0, column: 8 },

- old_end_position: Point { row: 0, column: 8 },

- new_end_position: Point { row: 0, column: 14 }

-

- let loader = Loader::new(Configuration {

- language: vec![],

- language_server: HashMap::new(),

- })

- .unwrap();

- let language = get_language(language_name).unwrap();

-

- let config = HighlightConfiguration::new(language, "", "", "").unwrap();

- let syntax = Syntax::new(

- source.slice(..),

- Arc::new(config),

- Arc::new(ArcSwap::from_pointee(loader)),

- )

- .unwrap();

- .descendant_for_byte_range(start, end)

-

- #[test]

- fn test_load_runtime_file() {

- // Test to make sure we can load some data from the runtime directory.

- let contents = load_runtime_file("rust", "indents.scm").unwrap();

- assert!(!contents.is_empty());

-

- let results = load_runtime_file("rust", "does-not-exist");

- assert!(results.is_err());

- }

-use crate::{auto_pairs::AutoPairs, diagnostic::Severity};

-use once_cell::sync::OnceCell;

- sync::Arc,

- #[serde(skip)]

- pub(crate) highlight_config: OnceCell<Option<Arc<super::HighlightConfiguration>>>,

- // tags_config OnceCell<> https://github.com/tree-sitter/tree-sitter/pull/583

- #[serde(skip)]

- pub(crate) indent_query: OnceCell<Option<tree_sitter::Query>>,

- #[serde(skip)]

- pub(crate) textobject_query: OnceCell<Option<super::TextObjectQuery>>,

-use std::{cmp::Reverse, ops::Range};

-

-use super::{LanguageLayer, LayerId};

-

-use slotmap::HopSlotMap;

-use tree_sitter::Node;

-

-/// The byte range of an injection layer.

-///

-/// Injection ranges may overlap, but all overlapping parts are subsets of their parent ranges.

-/// This allows us to sort the ranges ahead of time in order to efficiently find a range that

-/// contains a point with maximum depth.

-#[derive(Debug)]

-struct InjectionRange {

- start: usize,

- end: usize,

- layer_id: LayerId,

- depth: u32,

-}

-

-pub struct TreeCursor<'a> {

- layers: &'a HopSlotMap<LayerId, LanguageLayer>,

- root: LayerId,

- current: LayerId,

- injection_ranges: Vec<InjectionRange>,

- // TODO: Ideally this would be a `tree_sitter::TreeCursor<'a>` but

- // that returns very surprising results in testing.

- cursor: Node<'a>,

-}

-

-impl<'a> TreeCursor<'a> {

- pub(super) fn new(layers: &'a HopSlotMap<LayerId, LanguageLayer>, root: LayerId) -> Self {

- let mut injection_ranges = Vec::new();

-

- for (layer_id, layer) in layers.iter() {

- // Skip the root layer

- if layer.parent.is_none() {

- continue;

- }

- for byte_range in layer.ranges.iter() {

- let range = InjectionRange {

- start: byte_range.start_byte,

- end: byte_range.end_byte,

- layer_id,

- depth: layer.depth,

- };

- injection_ranges.push(range);

- }

- }

-

- injection_ranges.sort_unstable_by_key(|range| (range.end, Reverse(range.depth)));

-

- let cursor = layers[root].tree().root_node();

-

- Self {

- layers,

- root,

- current: root,

- injection_ranges,

- cursor,

- }

- }

-

- pub fn node(&self) -> Node<'a> {

- self.cursor

- }

-

- pub fn goto_parent(&mut self) -> bool {

- if let Some(parent) = self.node().parent() {

- self.cursor = parent;

- return true;

- }

-

- // If we are already on the root layer, we cannot ascend.

- if self.current == self.root {

- return false;

- }

-

- // Ascend to the parent layer.

- let range = self.node().byte_range();

- let parent_id = self.layers[self.current]

- .parent

- .expect("non-root layers have a parent");

- self.current = parent_id;

- let root = self.layers[self.current].tree().root_node();

- self.cursor = root

- .descendant_for_byte_range(range.start, range.end)

- .unwrap_or(root);

-

- true

- }

-

- pub fn goto_parent_with<P>(&mut self, predicate: P) -> bool

- where

- P: Fn(&Node) -> bool,

- {

- while self.goto_parent() {

- if predicate(&self.node()) {

- return true;

- }

- }

-

- false

- }

-

- /// Finds the injection layer that has exactly the same range as the given `range`.

- fn layer_id_of_byte_range(&self, search_range: Range<usize>) -> Option<LayerId> {

- let start_idx = self

- .injection_ranges

- .partition_point(|range| range.end < search_range.end);

-

- self.injection_ranges[start_idx..]

- .iter()

- .take_while(|range| range.end == search_range.end)

- .find_map(|range| (range.start == search_range.start).then_some(range.layer_id))

- }

-

- fn goto_first_child_impl(&mut self, named: bool) -> bool {

- // Check if the current node's range is an exact injection layer range.

- if let Some(layer_id) = self

- .layer_id_of_byte_range(self.node().byte_range())

- .filter(|&layer_id| layer_id != self.current)

- {

- // Switch to the child layer.

- self.current = layer_id;

- self.cursor = self.layers[self.current].tree().root_node();

- return true;

- }

-

- let child = if named {

- self.cursor.named_child(0)

- } else {

- self.cursor.child(0)

- };

-

- if let Some(child) = child {

- // Otherwise descend in the current tree.

- self.cursor = child;

- true

- } else {

- false

- }

- }

-

- pub fn goto_first_child(&mut self) -> bool {

- self.goto_first_child_impl(false)

- }

-

- pub fn goto_first_named_child(&mut self) -> bool {

- self.goto_first_child_impl(true)

- }

-

- fn goto_next_sibling_impl(&mut self, named: bool) -> bool {

- let sibling = if named {

- self.cursor.next_named_sibling()

- } else {

- self.cursor.next_sibling()

- };

-

- if let Some(sibling) = sibling {

- self.cursor = sibling;

- true

- } else {

- false

- }

- }

-

- pub fn goto_next_sibling(&mut self) -> bool {

- self.goto_next_sibling_impl(false)

- }

-

- pub fn goto_next_named_sibling(&mut self) -> bool {

- self.goto_next_sibling_impl(true)

- }

-

- fn goto_prev_sibling_impl(&mut self, named: bool) -> bool {

- let sibling = if named {

- self.cursor.prev_named_sibling()

- } else {

- self.cursor.prev_sibling()

- };

-

- if let Some(sibling) = sibling {

- self.cursor = sibling;

- true

- } else {

- false

- }

- }

-

- pub fn goto_prev_sibling(&mut self) -> bool {

- self.goto_prev_sibling_impl(false)

- }

-

- pub fn goto_prev_named_sibling(&mut self) -> bool {

- self.goto_prev_sibling_impl(true)

- }

-

- /// Finds the injection layer that contains the given start-end range.

- fn layer_id_containing_byte_range(&self, start: usize, end: usize) -> LayerId {

- let start_idx = self

- .injection_ranges

- .partition_point(|range| range.end < end);

-

- self.injection_ranges[start_idx..]

- .iter()

- .take_while(|range| range.start < end || range.depth > 1)

- .find_map(|range| (range.start <= start).then_some(range.layer_id))

- .unwrap_or(self.root)

- }

-

- pub fn reset_to_byte_range(&mut self, start: usize, end: usize) {

- self.current = self.layer_id_containing_byte_range(start, end);

- let root = self.layers[self.current].tree().root_node();

- self.cursor = root.descendant_for_byte_range(start, end).unwrap_or(root);

- }

-

- /// Returns an iterator over the children of the node the TreeCursor is on

- /// at the time this is called.

- pub fn children(&'a mut self) -> ChildIter<'a> {

- let parent = self.node();

-

- ChildIter {

- cursor: self,

- parent,

- named: false,

- }

- }

-

- /// Returns an iterator over the named children of the node the TreeCursor is on

- /// at the time this is called.

- pub fn named_children(&'a mut self) -> ChildIter<'a> {

- let parent = self.node();

-

- ChildIter {

- cursor: self,

- parent,

- named: true,

- }

- }

-}

-

-pub struct ChildIter<'n> {

- cursor: &'n mut TreeCursor<'n>,

- parent: Node<'n>,

- named: bool,

-}

-

-impl<'n> Iterator for ChildIter<'n> {

- type Item = Node<'n>;

-

- fn next(&mut self) -> Option<Self::Item> {

- // first iteration, just visit the first child

- if self.cursor.node() == self.parent {

- self.cursor

- .goto_first_child_impl(self.named)

- .then(|| self.cursor.node())

- } else {

- self.cursor

- .goto_next_sibling_impl(self.named)

- .then(|| self.cursor.node())

- }

- }

-}

-use crate::syntax::Highlight;

- pub fn collect_overlay_highlights(

- &self,

- char_range: Range<usize>,

- ) -> Vec<(usize, Range<usize>)> {

- highlights.push((highlight.0, char_idx..char_idx + 1))

- highlights

-use tree_sitter::{Node, QueryCursor};

-use crate::syntax::config::LanguageConfiguration;

- slice_tree: Node,

- lang_config: &LanguageConfiguration,

- let mut cursor = QueryCursor::new();

- let node = lang_config

- .textobject_query()?

- .capture_nodes(&capture_name, slice_tree, slice, &mut cursor)?

-use arc_swap::ArcSwap;

-use std::{ops::Range, path::PathBuf, process::Command, sync::Arc};

- let language_config = loader.language_config_for_scope(lang_scope).unwrap();

- let highlight_config = language_config.highlight_config(&[]).unwrap();

- let syntax = Syntax::new(

- text,

- highlight_config,

- Arc::new(ArcSwap::from_pointee(loader)),

- )

- .unwrap();

- let indent_query = language_config.indent_query().unwrap();

-tree-sitter.workspace = true

-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]

-libloading = "0.8"

-use tree_sitter::Language;

-pub fn get_language(name: &str) -> Result<Language> {

-pub fn get_language(name: &str) -> Result<Language> {

- use libloading::{Library, Symbol};

- let library = unsafe { Library::new(&library_path) }

- .with_context(|| format!("Error opening dynamic library {:?}", library_path))?;

- let language_fn_name = format!("tree_sitter_{}", name.replace('-', "_"));

- let language = unsafe {

- let language_fn: Symbol<unsafe extern "C" fn() -> Language> = library

- .get(language_fn_name.as_bytes())

- .with_context(|| format!("Failed to load symbol {}", language_fn_name))?;

- language_fn()

- };

- std::mem::forget(library);

- Ok(language)

- let language_config = doc.language_config();

- language_config,

- doc.language_config(),

- doc.language_config(),

- if let Some((lang_config, syntax)) = doc.language_config().zip(doc.syntax()) {

- text,

- range,

- object,

- direction,

- root,

- lang_config,

- count,

- let (lang_config, syntax) = match doc.language_config().zip(doc.syntax()) {

- Some(t) => t,

- None => return range,

- text,

- range,

- objtype,

- obj_name,

- syntax.tree().root_node(),

- lang_config,

- count,

- fn find_highlight_at_cursor(

- cx: &mut compositor::Context<'_>,

- ) -> Option<helix_core::syntax::Highlight> {

- use helix_core::syntax::HighlightEvent;

- let (view, doc) = current!(cx.editor);

- let byte = text.char_to_byte(cursor);

- let start = text.line_to_byte(row.min(last_line));

- let end = text.line_to_byte(last_visible_line + 1);

- let mut highlight = None;

- for event in syntax.highlight_iter(text, Some(range), None) {

- match event.unwrap() {

- HighlightEvent::Source { start, end }

- if start == node.start_byte() && end == node.end_byte() =>

- {

- return highlight;

- }

- HighlightEvent::HighlightStart(hl) => {

- highlight = Some(hl);

- }

- _ => (),

- let Some(highlight) = find_highlight_at_cursor(cx) else {

- let content = cx.editor.theme.scope(highlight.0).to_string();

- let from = text.char_to_byte(primary_selection.from());

- let to = text.char_to_byte(primary_selection.to());

-use helix_core::syntax::Highlight;

-use helix_core::syntax::HighlightEvent;

-#[derive(Debug, PartialEq, Eq, Clone, Copy)]

-enum StyleIterKind {

- /// base highlights (usually emitted by TS), byte indices (potentially not codepoint aligned)

- BaseHighlights,

- /// overlay highlights (emitted by custom code from selections), char indices

- Overlay,

-}

-

-/// A wrapper around a HighlightIterator

-/// that merges the layered highlights to create the final text style

-/// and yields the active text style and the char_idx where the active

-/// style will have to be recomputed.

-///

-/// TODO(ropey2): hopefully one day helix and ropey will operate entirely

-/// on byte ranges and we can remove this

-struct StyleIter<'a, H: Iterator<Item = HighlightEvent>> {

- text_style: Style,

- active_highlights: Vec<Highlight>,

- highlight_iter: H,

- kind: StyleIterKind,

- text: RopeSlice<'a>,

- theme: &'a Theme,

-}

-

-impl<H: Iterator<Item = HighlightEvent>> Iterator for StyleIter<'_, H> {

- type Item = (Style, usize);

- fn next(&mut self) -> Option<(Style, usize)> {

- while let Some(event) = self.highlight_iter.next() {

- match event {

- HighlightEvent::HighlightStart(highlights) => {

- self.active_highlights.push(highlights)

- }

- HighlightEvent::HighlightEnd => {

- self.active_highlights.pop();

- }

- HighlightEvent::Source { mut end, .. } => {

- let style = self

- .active_highlights

- .iter()

- .fold(self.text_style, |acc, span| {

- acc.patch(self.theme.highlight(span.0))

- });

- if self.kind == StyleIterKind::BaseHighlights {

- // Move the end byte index to the nearest character boundary (rounding up)

- // and convert it to a character index.

- end = self.text.byte_to_char(self.text.ceil_char_boundary(end));

- }

- return Some((style, end));

- }

- }

- }

- None

- }

-}

-

- syntax_highlight_iter: impl Iterator<Item = HighlightEvent>,

- overlay_highlight_iter: impl Iterator<Item = HighlightEvent>,

- syntax_highlight_iter,

- overlay_highlight_iter,

- syntax_highlight_iter: impl Iterator<Item = HighlightEvent>,

- overlay_highlight_iter: impl Iterator<Item = HighlightEvent>,

- let mut syntax_styles = StyleIter {

- text_style: renderer.text_style,

- active_highlights: Vec::with_capacity(64),

- highlight_iter: syntax_highlight_iter,

- kind: StyleIterKind::BaseHighlights,

- theme,

- text,

- };

- let mut overlay_styles = StyleIter {

- text_style: Style::default(),

- active_highlights: Vec::with_capacity(64),

- highlight_iter: overlay_highlight_iter,

- kind: StyleIterKind::Overlay,

- theme,

- text,

- };

- let mut syntax_style_span = syntax_styles

- .next()

- .unwrap_or_else(|| (Style::default(), usize::MAX));

- let mut overlay_style_span = overlay_styles

- .next()

- .unwrap_or_else(|| (Style::default(), usize::MAX));

- while grapheme.char_idx >= syntax_style_span.1 {

- syntax_style_span = syntax_styles

- .next()

- .unwrap_or((Style::default(), usize::MAX));

- while grapheme.char_idx >= overlay_style_span.1 {

- overlay_style_span = overlay_styles

- .next()

- .unwrap_or((Style::default(), usize::MAX));

- style = style.patch(theme.highlight(highlight.0));

- syntax_style: syntax_style_span.0,

- overlay_style: overlay_style_span.0,

- syntax::{self, HighlightEvent},

-use std::{mem::take, num::NonZeroUsize, path::PathBuf, rc::Rc};

- let syntax_highlights =

- Self::doc_syntax_highlights(doc, view_offset.anchor, inner.height, theme);

- let mut overlay_highlights =

- Self::empty_highlight_iter(doc, view_offset.anchor, inner.height);

- let overlay_syntax_highlights = Self::overlay_syntax_highlights(

- );

- if !overlay_syntax_highlights.is_empty() {

- overlay_highlights =

- Box::new(syntax::merge(overlay_highlights, overlay_syntax_highlights));

- }

- for diagnostic in Self::doc_diagnostics_highlights(doc, theme) {

- // Most of the `diagnostic` Vecs are empty most of the time. Skipping

- // a merge for any empty Vec saves a significant amount of work.

- if diagnostic.is_empty() {

- continue;

- }

- overlay_highlights = Box::new(syntax::merge(overlay_highlights, diagnostic));

- }

- overlay_highlights = Box::new(syntax::merge(overlay_highlights, tabstops));

- let highlights = syntax::merge(

- overlay_highlights,

- Self::doc_selection_highlights(

- editor.mode(),

- doc,

- view,

- theme,

- &config.cursor_shape,

- self.terminal_focused,

- ),

- );

- let focused_view_elements = Self::highlight_focused_view_elements(view, doc, theme);

- if focused_view_elements.is_empty() {

- overlay_highlights = Box::new(highlights)

- } else {

- overlay_highlights = Box::new(syntax::merge(highlights, focused_view_elements))

- syntax_highlights,

- overlay_highlights,

- pub fn empty_highlight_iter(

- doc: &Document,

- anchor: usize,

- height: u16,

- ) -> Box<dyn Iterator<Item = HighlightEvent>> {

- let text = doc.text().slice(..);

- let row = text.char_to_line(anchor.min(text.len_chars()));

-

- // Calculate viewport byte ranges:

- // Saturating subs to make it inclusive zero indexing.

- let range = Self::viewport_byte_range(text, row, height);

- Box::new(

- [HighlightEvent::Source {

- start: text.byte_to_char(range.start),

- end: text.byte_to_char(range.end),

- }]

- .into_iter(),

- )

- }

-

- /// Get syntax highlights for a document in a view represented by the first line

- pub fn doc_syntax_highlights<'doc>(

- doc: &'doc Document,

- _theme: &Theme,

- ) -> Box<dyn Iterator<Item = HighlightEvent> + 'doc> {

-

- match doc.syntax() {

- Some(syntax) => {

- let iter = syntax

- // TODO: range doesn't actually restrict source, just highlight range

- .highlight_iter(text.slice(..), Some(range), None)

- .map(|event| event.unwrap());

-

- Box::new(iter)

- }

- None => Box::new(

- [HighlightEvent::Source {

- start: range.start,

- end: range.end,

- }]

- .into_iter(),

- ),

- }

- ) -> Vec<(usize, std::ops::Range<usize>)> {

- pub fn doc_diagnostics_highlights(

- ) -> [Vec<(usize, std::ops::Range<usize>)>; 7] {

- .find_scope_index_exact(scope)

- // get one of the themes below as fallback values

- .or_else(|| theme.find_scope_index_exact("diagnostic"))

- .or_else(|| theme.find_scope_index_exact("ui.cursor"))

- .or_else(|| theme.find_scope_index_exact("ui.selection"))

- .expect(

- "at least one of the following scopes must be defined in the theme: `diagnostic`, `ui.cursor`, or `ui.selection`",

- )

- // basically just queries the theme color defined in the config

- let hint = get_scope_of("diagnostic.hint");

- let info = get_scope_of("diagnostic.info");

- let warning = get_scope_of("diagnostic.warning");

- let error = get_scope_of("diagnostic.error");

- let r#default = get_scope_of("diagnostic"); // this is a bit redundant but should be fine

-

- let unnecessary = theme.find_scope_index_exact("diagnostic.unnecessary");

- let deprecated = theme.find_scope_index_exact("diagnostic.deprecated");

- let mut default_vec: Vec<(usize, std::ops::Range<usize>)> = Vec::new();

- let push_diagnostic =

- |vec: &mut Vec<(usize, std::ops::Range<usize>)>, scope, range: Range| {

- // If any diagnostic overlaps ranges with the prior diagnostic,

- // merge the two together. Otherwise push a new span.

- match vec.last_mut() {

- Some((_, existing_range)) if range.start <= existing_range.end => {

- // This branch merges overlapping diagnostics, assuming that the current

- // diagnostic starts on range.start or later. If this assertion fails,

- // we will discard some part of `diagnostic`. This implies that

- // `doc.diagnostics()` is not sorted by `diagnostic.range`.

- debug_assert!(existing_range.start <= range.start);

- existing_range.end = range.end.max(existing_range.end)

- }

- _ => vec.push((scope, range.start..range.end)),

- };

- let (vec, scope) = match diagnostic.severity {

- Some(Severity::Info) => (&mut info_vec, info),

- Some(Severity::Hint) => (&mut hint_vec, hint),

- Some(Severity::Warning) => (&mut warning_vec, warning),

- Some(Severity::Error) => (&mut error_vec, error),

- _ => (&mut default_vec, r#default),

- push_diagnostic(vec, scope, diagnostic.range);

- if let Some(scope) = unnecessary {

- push_diagnostic(&mut unnecessary_vec, scope, diagnostic.range)

- if let Some(scope) = deprecated {

- push_diagnostic(&mut deprecated_vec, scope, diagnostic.range)

- [

- default_vec,

- unnecessary_vec,

- deprecated_vec,

- info_vec,

- hint_vec,

- warning_vec,

- error_vec,

- ]

- ) -> Vec<(usize, std::ops::Range<usize>)> {

- .find_scope_index_exact("ui.selection")

- .find_scope_index_exact("ui.selection.primary")

- .find_scope_index_exact("ui.cursor")

- .find_scope_index("ui.cursor.primary")

- Mode::Insert => theme.find_scope_index_exact("ui.cursor.insert"),

- Mode::Select => theme.find_scope_index_exact("ui.cursor.select"),

- Mode::Normal => theme.find_scope_index_exact("ui.cursor.normal"),

- Mode::Insert => theme.find_scope_index_exact("ui.cursor.primary.insert"),

- Mode::Select => theme.find_scope_index_exact("ui.cursor.primary.select"),

- Mode::Normal => theme.find_scope_index_exact("ui.cursor.primary.normal"),

- let mut spans: Vec<(usize, std::ops::Range<usize>)> = Vec::new();

- spans

- ) -> Vec<(usize, std::ops::Range<usize>)> {

- if let Some(syntax) = doc.syntax() {

- let text = doc.text().slice(..);

- use helix_core::match_brackets;

- let pos = doc.selection(view.id).primary().cursor(text);

-

- if let Some(pos) =

- match_brackets::find_matching_bracket(syntax, doc.text().slice(..), pos)

- {

- // ensure col is on screen

- if let Some(highlight) = theme.find_scope_index_exact("ui.cursor.match") {

- return vec![(highlight, pos..pos + 1)];

- }

- }

- }

- Vec::new()

- pub fn tabstop_highlights(

- doc: &Document,

- theme: &Theme,

- ) -> Option<Vec<(usize, std::ops::Range<usize>)>> {

- let highlight = theme.find_scope_index_exact("tabstop")?;

- let mut highlights = Vec::new();

- highlights.extend(

- tabstop

- .ranges

- .iter()

- .map(|range| (highlight, range.start..range.end)),

- );

- (!highlights.is_empty()).then_some(highlights)

-use helix_core::syntax;

- vec![(

- cx.editor

- .theme

- .find_scope_index_exact("ui.selection")

- .unwrap(),

- start..end,

- )]

- Arc::clone(&self.config_loader),

- Arc::clone(&self.config_loader),

- syntax::{self, HighlightEvent, InjectionLanguageMarker, Syntax},

- RopeSlice,

- config_loader: Arc<ArcSwap<syntax::Loader>>,

- additional_highlight_spans: Option<Vec<(usize, std::ops::Range<usize>)>>,

- let syntax = config_loader

- .load()

- .language_configuration_for_injection_string(&InjectionLanguageMarker::Name(

- language.into(),

- ))

- .and_then(|config| config.highlight_config(theme.scopes()))

- .and_then(|config| Syntax::new(ropeslice, config, Arc::clone(&config_loader)));

-

- let syntax = match syntax {

- Some(s) => s,

- None => return styled_multiline_text(text, code_style),

- let highlight_iter = syntax

- .highlight_iter(ropeslice, None, None)

- .map(|e| e.unwrap());

- let highlight_iter: Box<dyn Iterator<Item = HighlightEvent>> =

- if let Some(spans) = additional_highlight_spans {

- Box::new(helix_core::syntax::merge(highlight_iter, spans))

- } else {

- Box::new(highlight_iter)

- };

-

- let mut highlights = Vec::new();

- for event in highlight_iter {

- match event {

- HighlightEvent::HighlightStart(span) => {

- highlights.push(span);

- HighlightEvent::HighlightEnd => {

- highlights.pop();

- HighlightEvent::Source { start, end } => {

- let style = highlights

- .iter()

- .fold(text_style, |acc, span| acc.patch(theme.highlight(span.0)));

-

- let mut slice = &text[start..end];

- // TODO: do we need to handle all unicode line endings

- // here, or is just '\n' okay?

- while let Some(end) = slice.find('\n') {

- // emit span up to newline

- let text = &slice[..end];

- let text = text.replace('\t', " "); // replace tabs

- let span = Span::styled(text, style);

- spans.push(span);

-

- // truncate slice to after newline

- slice = &slice[end + 1..];

-

- // make a new line

- let spans = std::mem::take(&mut spans);

- lines.push(Spans::from(spans));

- }

- // if there's anything left, emit it too

- if !slice.is_empty() {

- let span = Span::styled(slice.replace('\t', " "), style);

- spans.push(span);

- }

- }

- Arc::clone(&self.config_loader),

- let syntax_highlights = EditorView::doc_syntax_highlights(

- offset.anchor,

- area.height,

- let mut overlay_highlights =

- EditorView::empty_highlight_iter(doc, offset.anchor, area.height);

- for spans in EditorView::doc_diagnostics_highlights(doc, &cx.editor.theme) {

- if spans.is_empty() {

- continue;

- }

- overlay_highlights = Box::new(helix_core::syntax::merge(overlay_highlights, spans));

- }

- syntax_highlights,

- let Some(language_config) = doc.detect_language_config(&editor.syn_loader.load())

- else {

- doc.language = Some(language_config.clone());

- let loader = editor.syn_loader.clone();

- let Some(syntax) = language_config

- .highlight_config(&loader.load().scopes())

- .and_then(|highlight_config| {

- helix_core::Syntax::new(text.slice(..), highlight_config, loader)

- })

- else {

- log::info!("highlighting picker item failed");

- return;

- loader.clone(),

-use helix_core::syntax::{config::LanguageServerFeature, Highlight};

- pub colors: Vec<Highlight>,

- config_loader: &syntax::Loader,

- config_loader

- .language_config_for_file_name(self.path.as_ref()?)

- .or_else(|| config_loader.language_config_for_shebang(self.text().slice(..)))

- self.syntax = self

- .language

- .as_ref()

- .and_then(|config| config.highlight_config(&loader.scopes()))

- .and_then(|highlight_config| {

- Syntax::new(

- self.text.slice(..),

- highlight_config,

- self.syn_loader.clone(),

- )

- });

- let language_config = loader

- .language_config_for_language_id(language_id)

- self.set_language(Some(language_config), loader);

- // TODO: no unwrap

- let res = syntax.update(

- );

- if res.is_err() {

- log::error!("TS parser failed, disabling TS for the current buffer: {res:?}");

- .and_then(|theme| theme.find_scope_index("ui.virtual.wrap"))

- .map(Highlight),

- if theme.find_scope_index_exact("ui.selection").is_none() {

- "Language server not found for `{}` {} {}", language.scope(), lang, err,

- language.scope(),

- /// we interpret the last 3 bytes of a `Highlight` as RGB colors.

- const RGB_START: usize = (usize::MAX << (8 + 8 + 8)) - 1;

- fn decode_rgb_highlight(rgb: usize) -> Option<(u8, u8, u8)> {

- (rgb > Self::RGB_START).then(|| {

- let [b, g, r, ..] = rgb.to_ne_bytes();

- Highlight(usize::from_ne_bytes([

- b,

- g,

- r,

- u8::MAX,

- u8::MAX,

- u8::MAX,

- u8::MAX,

- u8::MAX,

- ]))

- pub fn highlight(&self, index: usize) -> Style {

- if let Some((red, green, blue)) = Self::decode_rgb_highlight(index) {

- self.highlights[index]

- pub fn scope(&self, index: usize) -> &str {

- &self.scopes[index]

- pub fn find_scope_index_exact(&self, scope: &str) -> Option<usize> {

- self.scopes().iter().position(|s| s == scope)

- pub fn find_scope_index(&self, mut scope: &str) -> Option<usize> {

- if let Some(highlight) = self.find_scope_index_exact(scope) {

- assert_eq!(Theme::decode_rgb_highlight(highlight.0), Some((r, g, b)));

- /// ```

- /// FF FF FF FF FF FF FF FF

- /// xor

- /// FF FF FF FF FF 00 00 00

- /// =

- /// 00 00 00 00 00 FF FF FF

- /// ```

- ///

- /// where the ending `(FF, FF, FF)` represents `(r, g, b)`

- assert_eq!(usize::MAX ^ Theme::RGB_START, 256_usize.pow(3));

- assert_eq!(Theme::RGB_START + 256_usize.pow(3), usize::MAX);

- Theme::default().highlight(Theme::rgb_highlight(r, g, b).0),

- Theme::default().highlight(Theme::rgb_highlight(r, g, b).0),

- Theme::default().highlight(Theme::rgb_highlight(r, g, b).0),

- #[should_panic(

- expected = "index out of bounds: the len is 0 but the index is 18446744073692774399"

- )]

- let (r, g, b) = (0x00, 0x00, 0x00);

-

- Theme::default().highlight(Theme::rgb_highlight(r, g, b).0 - 1);

- syntax::Highlight,

- let style = theme

- .and_then(|t| t.find_scope_index("ui.virtual.jump-label"))

- .map(Highlight);

- let type_style = theme

- .and_then(|t| t.find_scope_index("ui.virtual.inlay-hint.type"))

- .map(Highlight);

- let parameter_style = theme

- .and_then(|t| t.find_scope_index("ui.virtual.inlay-hint.parameter"))

- .map(Highlight);

- let other_style = theme

- .and_then(|t| t.find_scope_index("ui.virtual.inlay-hint"))

- .map(Highlight);

-use helix_core::syntax::config::Configuration as LangConfig;

- use crate::helpers::lang_config;

- use helix_core::{syntax::read_query, tree_sitter::Query};

- use helix_loader::grammar::get_language;

-

- let query_files = [

- "highlights.scm",

- "locals.scm",

- "injections.scm",

- "textobjects.scm",

- "indents.scm",

- ];

-

- for language in lang_config().language {

- if !languages_to_check.is_empty() && !languages_to_check.contains(&language.language_id)

-

- let language_name = &language.language_id;

- let grammar_name = language.grammar.as_ref().unwrap_or(language_name);

- for query_file in query_files {

- let language = get_language(grammar_name);

- let query_text = read_query(language_name, query_file);

- if let Ok(lang) = language {

- if !query_text.is_empty() {

- if let Err(reason) = Query::new(&lang, &query_text) {

- return Err(format!(

- "Failed to parse {} queries for {}: {}",

- query_file, language_name, reason

- )

- .into());

- }

- }

- }

- }