Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
language: Support emitting multiple runnables from a single tree-sitter match (#57276)
Smit Barmase6396a9b4d346
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rsindex f517f8a99e0..ae98ef1e28b 100644--- a/crates/language/src/buffer.rs+++ b/crates/language/src/buffer.rs@@ -2,16 +2,16 @@ pub mod row_chunk;use crate::{ByteContent, DebuggerTextObject, LanguageScope, ModelineSettings, Outline, OutlineConfig,- PLAIN_TEXT, RunnableCapture, RunnableTag, TextObject, TreeSitterOptions, analyze_byte_content,+ PLAIN_TEXT, RunnableTag, TextObject, TreeSitterOptions, analyze_byte_content,diagnostic_set::{DiagnosticEntry, DiagnosticEntryRef, DiagnosticGroup},language_settings::{AutoIndentMode, LanguageSettings},outline::OutlineItem,row_chunk::RowChunks,+ runnable::{self, RunnableRange},syntax_map::{MAX_BYTES_TO_QUERY, SyntaxLayer, SyntaxMap, SyntaxMapCapture, SyntaxMapCaptures,SyntaxMapMatch, SyntaxMapMatches, SyntaxSnapshot, ToTreeSitterPoint,},- task_context::RunnableRange,text_diff::text_diff,unified_diff_with_offsets,};@@ -5186,105 +5186,7 @@ impl BufferSnapshot {&self,offset_range: Range<usize>,) -> impl Iterator<Item = RunnableRange> + '_ {- let mut syntax_matches = self.syntax.matches(offset_range, self, |grammar| {- grammar.runnable_config.as_ref().map(|config| &config.query)- });-- let test_configs = syntax_matches- .grammars()- .iter()- .map(|grammar| grammar.runnable_config.as_ref())- .collect::<Vec<_>>();-- iter::from_fn(move || {- loop {- let mat = syntax_matches.peek()?;-- let test_range = test_configs[mat.grammar_index].and_then(|test_configs| {- let mut run_range = None;- let full_range = mat.captures.iter().fold(- Range {- start: usize::MAX,- end: 0,- },- |mut acc, next| {- let byte_range = next.node.byte_range();- if acc.start > byte_range.start {- acc.start = byte_range.start;- }- if acc.end < byte_range.end {- acc.end = byte_range.end;- }- acc- },- );- if full_range.start > full_range.end {- // We did not find a full spanning range of this match.- return None;- }- let extra_captures: SmallVec<[_; 1]> =- SmallVec::from_iter(mat.captures.iter().filter_map(|capture| {- test_configs- .extra_captures- .get(capture.index as usize)- .cloned()- .and_then(|tag_name| match tag_name {- RunnableCapture::Named(name) => {- Some((capture.node.byte_range(), name))- }- RunnableCapture::Run => {- let _ = run_range.insert(capture.node.byte_range());- None- }- })- }));- let run_range = run_range?;- let tags = test_configs- .query- .property_settings(mat.pattern_index)- .iter()- .filter_map(|property| {- if *property.key == *"tag" {- property- .value- .as_ref()- .map(|value| RunnableTag(value.to_string().into()))- } else {- None- }- })- .collect();- let extra_captures = extra_captures- .into_iter()- .map(|(range, name)| {- (- name.to_string(),- self.text_for_range(range).collect::<String>(),- )- })- .collect();- // All tags should have the same range.- Some(RunnableRange {- run_range,- full_range,- runnable: Runnable {- tags,- language: mat.language,- buffer: self.remote_id(),- },- extra_captures,- buffer_id: self.remote_id(),- })- });-- syntax_matches.advance();- if test_range.is_some() {- // It's fine for us to short-circuit on .peek()? returning None. We don't want to return None from this iter if we- // had a capture that did not contain a run marker, hence we'll just loop around for the next capture.- return test_range;- }- }- })+ runnable::runnable_ranges(self, offset_range)}/// Returns selections for remote peers intersecting the given range.diff --git a/crates/language/src/language.rs b/crates/language/src/language.rsindex 7182a0cdfe9..6a799b62d32 100644--- a/crates/language/src/language.rs+++ b/crates/language/src/language.rs@@ -17,6 +17,7 @@ mod manifest;pub mod modeline;mod outline;pub mod proto;+mod runnable;mod syntax_map;mod task_context;mod text_diff;@@ -62,6 +63,7 @@ pub use manifest::{ManifestDelegate, ManifestName, ManifestProvider, ManifestQuepub use modeline::{ModelineSettings, parse_modeline};use parking_lot::Mutex;use regex::Regex;+pub use runnable::{ResolvedRunnable, RunnableMatchCapture, RunnableRange, RunnableResolver};use semver::Version;use serde_json::Value;use settings::WorktreeId;@@ -77,7 +79,7 @@ use std::{};use syntax_map::{QueryCursorHandle, SyntaxSnapshot};use task::RunnableTag;-pub use task_context::{ContextLocation, ContextProvider, RunnableRange};+pub use task_context::{ContextLocation, ContextProvider};pub use text_diff::{DiffOptions, apply_diff_patch, apply_reversed_diff_patch, char_diff, line_diff, text_diff,text_diff_with_options, unified_diff, unified_diff_with_context, unified_diff_with_offsets,@@ -106,7 +108,7 @@ pub use syntax_map::{OwnedSyntaxLayer, SyntaxLayer, SyntaxMapMatches, ToTreeSitterPoint, TreeSitterOptions,};pub use text::{AnchorRangeExt, LineEnding};-pub use tree_sitter::{Node, Parser, Tree, TreeCursor};+pub use tree_sitter::{Node, Parser, QueryCapture, Tree, TreeCursor};pub(crate) fn to_settings_soft_wrap(value: language_core::SoftWrap) -> settings::SoftWrap {match value {diff --git a/crates/language/src/runnable.rs b/crates/language/src/runnable.rsnew file mode 100644index 00000000000..a49bf42aae7--- /dev/null+++ b/crates/language/src/runnable.rs@@ -0,0 +1,756 @@+use std::{cmp::Reverse, iter, ops::Range, sync::Arc};++use collections::HashMap;+use smallvec::SmallVec;+use text::BufferId;+use tree_sitter::QueryCapture;+use util::RangeExt;++use crate::{BufferSnapshot, Language, Runnable, RunnableCapture, RunnableConfig, RunnableTag};++pub struct RunnableRange {+ pub buffer_id: BufferId,+ pub run_range: Range<usize>,+ pub full_range: Range<usize>,+ pub runnable: Runnable,+ pub extra_captures: HashMap<String, String>,+}++#[derive(Clone, Debug)]+pub struct RunnableMatchCapture {+ range: Range<usize>,+ capture: ResolverCapture,+}++/// The subset of `RunnableCapture` that's meaningful to resolvers.+#[derive(Clone, Debug)]+enum ResolverCapture {+ Run,+ Named(String),+}++impl RunnableMatchCapture {+ pub fn range(&self) -> Range<usize> {+ self.range.clone()+ }++ pub fn is_run(&self) -> bool {+ matches!(self.capture, ResolverCapture::Run)+ }++ pub fn name(&self) -> Option<&str> {+ match &self.capture {+ ResolverCapture::Named(name) => Some(name.as_str()),+ ResolverCapture::Run => None,+ }+ }+}++pub struct ResolvedRunnable {+ pub run_range: Range<usize>,+ pub extra_captures: SmallVec<[(String, String); 2]>,+}++pub trait RunnableResolver: Send + Sync {+ fn resolve(+ &self,+ local_captures: &[RunnableMatchCapture],+ shared_captures: &[RunnableMatchCapture],+ buffer: &BufferSnapshot,+ ) -> Option<ResolvedRunnable>;+}++pub(crate) fn runnable_ranges(+ buffer: &BufferSnapshot,+ offset_range: Range<usize>,+) -> impl Iterator<Item = RunnableRange> + '_ {+ let mut syntax_matches = buffer.matches(offset_range.clone(), |grammar| {+ grammar.runnable_config.as_ref().map(|config| &config.query)+ });++ let runnable_configs = syntax_matches+ .grammars()+ .iter()+ .map(|grammar| grammar.runnable_config.as_ref())+ .collect::<Vec<_>>();++ iter::from_fn(move || -> Option<SmallVec<[RunnableRange; 1]>> {+ let mat = syntax_matches.peek()?;++ let ranges = match runnable_configs[mat.grammar_index] {+ Some(runnable_config) => {+ let is_grouped = runnable_config.supports_grouped_runnables+ && mat.captures.iter().any(|capture| {+ matches!(+ runnable_config.extra_captures.get(capture.index as usize),+ Some(RunnableCapture::RunItem)+ )+ });+ if is_grouped {+ runnable_ranges_from_grouped_matches(+ buffer,+ mat.captures,+ runnable_config,+ mat.pattern_index,+ mat.language.clone(),+ offset_range.clone(),+ )+ } else {+ runnable_range_from_captures(+ buffer,+ mat.captures,+ runnable_config,+ mat.pattern_index,+ mat.language,+ )+ .into_iter()+ .collect()+ }+ }+ None => SmallVec::new(),+ };++ syntax_matches.advance();+ Some(ranges)+ })+ .flatten()+}++type RunnableMatchCaptures = SmallVec<[RunnableMatchCapture; 4]>;++struct RunnableMatchGroup {+ range: Range<usize>,+ captures: RunnableMatchCaptures,+}++struct GroupedRunnableMatches {+ groups: SmallVec<[RunnableMatchGroup; 1]>,+ shared_captures: RunnableMatchCaptures,+}++fn runnable_tags_from_pattern(+ query: &tree_sitter::Query,+ pattern_index: usize,+) -> SmallVec<[RunnableTag; 1]> {+ query+ .property_settings(pattern_index)+ .iter()+ .filter_map(|property| {+ (*property.key == *"tag")+ .then(|| {+ property+ .value+ .as_ref()+ .map(|value| RunnableTag(value.to_string().into()))+ })+ .flatten()+ })+ .collect()+}++/// `overlaps` rejects empty ranges, so handle a zero-width `offset_range` (cursor) separately.+fn range_overlaps_or_contains(range: &Range<usize>, offset_range: &Range<usize>) -> bool {+ if offset_range.is_empty() {+ range.contains(&offset_range.start)+ } else {+ range.overlaps(offset_range)+ }+}++fn group_runnable_matches(+ captures: &[QueryCapture<'_>],+ runnable_config: &RunnableConfig,+ offset_range: Range<usize>,+) -> GroupedRunnableMatches {+ let mut sorted: SmallVec<[&QueryCapture<'_>; 16]> = captures.iter().collect();+ sorted.sort_by_key(|capture| {+ let range = capture.node.byte_range();+ (range.start, Reverse(range.end))+ });++ let mut groups = SmallVec::new();+ let mut shared_captures = SmallVec::new();+ let mut current_group: Option<RunnableMatchGroup> = None;+ let mut current_in_offset = false;++ for capture in sorted {+ let range = capture.node.byte_range();+ let Some(kind) = runnable_config.extra_captures.get(capture.index as usize) else {+ continue;+ };++ let resolver_capture = match kind {+ RunnableCapture::RunItem => {+ if let Some(group) = current_group.take()+ && current_in_offset+ {+ groups.push(group);+ }+ current_in_offset = range_overlaps_or_contains(&range, &offset_range);+ current_group = Some(RunnableMatchGroup {+ range,+ captures: SmallVec::new(),+ });+ continue;+ }+ RunnableCapture::Run => ResolverCapture::Run,+ RunnableCapture::Named(name) => ResolverCapture::Named(name.to_string()),+ };++ let match_capture = RunnableMatchCapture {+ range: range.clone(),+ capture: resolver_capture,+ };++ match current_group.as_mut() {+ Some(group) if group.range.contains_inclusive(&range) => {+ if current_in_offset {+ group.captures.push(match_capture);+ }+ }+ _ => {+ if let Some(group) = current_group.take()+ && current_in_offset+ {+ groups.push(group);+ }+ shared_captures.push(match_capture);+ }+ }+ }+ if let Some(group) = current_group.take()+ && current_in_offset+ {+ groups.push(group);+ }++ GroupedRunnableMatches {+ groups,+ shared_captures,+ }+}++fn runnable_ranges_from_grouped_matches(+ buffer: &BufferSnapshot,+ captures: &[QueryCapture<'_>],+ runnable_config: &RunnableConfig,+ pattern_index: usize,+ language: Arc<Language>,+ offset_range: Range<usize>,+) -> SmallVec<[RunnableRange; 1]> {+ let GroupedRunnableMatches {+ groups,+ shared_captures,+ } = group_runnable_matches(captures, runnable_config, offset_range);++ let shared_extras: SmallVec<[(String, String); 4]> = shared_captures+ .iter()+ .filter_map(|capture| {+ capture.name().map(|name| {+ (+ name.to_string(),+ buffer.text_for_range(capture.range()).collect::<String>(),+ )+ })+ })+ .collect();++ let Some(resolver) = language+ .context_provider()+ .and_then(|provider| provider.runnable_resolver())+ else {+ return SmallVec::new();+ };+ let mut runnable_ranges = SmallVec::with_capacity(groups.len());++ let tags = runnable_tags_from_pattern(&runnable_config.query, pattern_index);+ let buffer_id = buffer.remote_id();+ for group in groups {+ let Some(ResolvedRunnable {+ run_range,+ extra_captures: local_extras,+ }) = resolver.resolve(&group.captures, &shared_captures, buffer)+ else {+ continue;+ };++ let extra_captures = shared_extras.iter().cloned().chain(local_extras).collect();++ runnable_ranges.push(RunnableRange {+ run_range,+ full_range: group.range,+ runnable: Runnable {+ tags: tags.clone(),+ language: language.clone(),+ buffer: buffer_id,+ },+ extra_captures,+ buffer_id,+ });+ }++ runnable_ranges+}++fn runnable_range_from_captures(+ buffer: &BufferSnapshot,+ captures: &[QueryCapture<'_>],+ runnable_config: &RunnableConfig,+ pattern_index: usize,+ language: Arc<Language>,+) -> Option<RunnableRange> {+ let mut run_range = None;+ let first_capture = captures.first()?;+ let full_range =+ captures+ .iter()+ .skip(1)+ .fold(first_capture.node.byte_range(), |mut acc, next| {+ let byte_range = next.node.byte_range();+ if acc.start > byte_range.start {+ acc.start = byte_range.start;+ }+ if acc.end < byte_range.end {+ acc.end = byte_range.end;+ }+ acc+ });++ let extra_captures: SmallVec<[_; 1]> =+ SmallVec::from_iter(captures.iter().filter_map(|capture| {+ runnable_config+ .extra_captures+ .get(capture.index as usize)+ .cloned()+ .and_then(|tag_name| match tag_name {+ RunnableCapture::Named(name) => Some((capture.node.byte_range(), name)),+ RunnableCapture::Run => {+ let _ = run_range.insert(capture.node.byte_range());+ None+ }+ RunnableCapture::RunItem => None,+ })+ }));+ let run_range = run_range?;+ let tags = runnable_tags_from_pattern(&runnable_config.query, pattern_index);+ let extra_captures = extra_captures+ .into_iter()+ .map(|(range, name)| {+ (+ name.to_string(),+ buffer.text_for_range(range).collect::<String>(),+ )+ })+ .collect();++ // A runnable has one range, even when its query pattern contributes multiple tags.+ let buffer_id = buffer.remote_id();+ Some(RunnableRange {+ run_range,+ full_range,+ runnable: Runnable {+ tags,+ language,+ buffer: buffer_id,+ },+ extra_captures,+ buffer_id,+ })+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{+ Buffer, ContextProvider, Language, LanguageConfig, LanguageMatcher, LanguageQueries,+ };+ use gpui::{AppContext as _, TestAppContext};+ use indoc::indoc;+ use std::{borrow::Cow, sync::Arc};++ struct TestContextProvider {+ resolver: Arc<dyn RunnableResolver>,+ }++ impl ContextProvider for TestContextProvider {+ fn runnable_resolver(&self) -> Option<Arc<dyn RunnableResolver>> {+ Some(self.resolver.clone())+ }+ }++ fn make_language(+ runnables_query: &'static str,+ resolver: Option<Arc<dyn RunnableResolver>>,+ ) -> Arc<Language> {+ let language = Language::new(+ LanguageConfig {+ name: "Rust".into(),+ matcher: LanguageMatcher {+ path_suffixes: vec!["rs".to_string()],+ ..Default::default()+ },+ ..Default::default()+ },+ Some(tree_sitter_rust::LANGUAGE.into()),+ )+ .with_queries(LanguageQueries {+ runnables: Some(Cow::Borrowed(runnables_query)),+ ..Default::default()+ })+ .expect("parse runnables query");+ let context_provider = resolver+ .map(|resolver| Arc::new(TestContextProvider { resolver }) as Arc<dyn ContextProvider>);+ Arc::new(language.with_context_provider(context_provider))+ }++ fn collect_runnables(+ cx: &mut TestAppContext,+ source: &str,+ runnables_query: &'static str,+ resolver: Option<Arc<dyn RunnableResolver>>,+ ) -> Vec<RunnableRange> {+ collect_runnables_in(cx, source, runnables_query, resolver, None)+ }++ fn collect_runnables_in(+ cx: &mut TestAppContext,+ source: &str,+ runnables_query: &'static str,+ resolver: Option<Arc<dyn RunnableResolver>>,+ offset_range: Option<Range<usize>>,+ ) -> Vec<RunnableRange> {+ let language = make_language(runnables_query, resolver);+ let source_owned = source.to_string();+ let buffer = cx+ .new(|cx| Buffer::local(source_owned.clone(), cx).with_language(language.clone(), cx));+ cx.executor().run_until_parked();+ let range = offset_range.unwrap_or(0..source_owned.len());+ buffer.update(cx, |buffer, _| {+ buffer.snapshot().runnable_ranges(range).collect()+ })+ }++ fn text_at(buffer: &BufferSnapshot, range: Range<usize>) -> String {+ buffer.text_for_range(range).collect()+ }++ /// Picks the first `@run` capture, attaches no extras.+ struct FirstRunResolver;++ impl RunnableResolver for FirstRunResolver {+ fn resolve(+ &self,+ local_captures: &[RunnableMatchCapture],+ _shared_captures: &[RunnableMatchCapture],+ _buffer: &BufferSnapshot,+ ) -> Option<ResolvedRunnable> {+ let run = local_captures.iter().find(|capture| capture.is_run())?;+ Some(ResolvedRunnable {+ run_range: run.range(),+ extra_captures: SmallVec::new(),+ })+ }+ }++ /// Picks the first `@run` and surfaces every local named capture as an extra.+ struct LocalExtrasResolver;++ impl RunnableResolver for LocalExtrasResolver {+ fn resolve(+ &self,+ local_captures: &[RunnableMatchCapture],+ _shared_captures: &[RunnableMatchCapture],+ buffer: &BufferSnapshot,+ ) -> Option<ResolvedRunnable> {+ let run = local_captures.iter().find(|capture| capture.is_run())?;+ let extras = local_captures+ .iter()+ .filter_map(|capture| {+ capture+ .name()+ .map(|name| (name.to_string(), text_at(buffer, capture.range())))+ })+ .collect();+ Some(ResolvedRunnable {+ run_range: run.range(),+ extra_captures: extras,+ })+ }+ }++ /// Skips groups whose `@run` text equals `skip_text`; otherwise picks the first `@run`.+ struct SkipByTextResolver {+ skip_text: &'static str,+ }++ impl RunnableResolver for SkipByTextResolver {+ fn resolve(+ &self,+ local_captures: &[RunnableMatchCapture],+ _shared_captures: &[RunnableMatchCapture],+ buffer: &BufferSnapshot,+ ) -> Option<ResolvedRunnable> {+ let run = local_captures.iter().find(|capture| capture.is_run())?;+ if text_at(buffer, run.range()) == self.skip_text {+ return None;+ }+ Some(ResolvedRunnable {+ run_range: run.range(),+ extra_captures: SmallVec::new(),+ })+ }+ }++ /// Always emits `_outer = LOCAL` as a local extra (to exercise the shared/local merge).+ struct OverrideSharedResolver;++ impl RunnableResolver for OverrideSharedResolver {+ fn resolve(+ &self,+ local_captures: &[RunnableMatchCapture],+ _shared_captures: &[RunnableMatchCapture],+ _buffer: &BufferSnapshot,+ ) -> Option<ResolvedRunnable> {+ let run = local_captures.iter().find(|capture| capture.is_run())?;+ let mut extras: SmallVec<[(String, String); 2]> = SmallVec::new();+ extras.push(("_outer".to_string(), "LOCAL".to_string()));+ Some(ResolvedRunnable {+ run_range: run.range(),+ extra_captures: extras,+ })+ }+ }++ const GROUPED_QUERY: &str = indoc! {r#"+ (function_item+ name: (identifier) @_outer+ body: (block+ ((expression_statement+ (call_expression+ function: (identifier) @run @_call)) @run_item)+))+ "#};++ const GROUPED_SOURCE: &str = indoc! {r#"+ fn outer() {+ alpha();+ beta();+ gamma();+ }+ "#};++ #[gpui::test]+ fn test_single_match_emits_one_runnable_per_match(cx: &mut TestAppContext) {+ let query = indoc! {r#"+ ((function_item+ name: (identifier) @run+ (#match? @run "^test_")) @_decl)+ "#};+ let source = indoc! {r#"+ fn test_alpha() {}+ fn helper() {}+ fn test_beta() {}+ "#};++ let runnables = collect_runnables(cx, source, query, None);+ let run_texts: Vec<String> = runnables+ .iter()+ .map(|range| source[range.run_range.clone()].to_string())+ .collect();+ assert_eq!(run_texts, vec!["test_alpha", "test_beta"]);++ let decls: Vec<&str> = runnables+ .iter()+ .filter_map(|range| range.extra_captures.get("_decl").map(String::as_str))+ .collect();+ assert_eq!(decls, vec!["fn test_alpha() {}", "fn test_beta() {}"]);+ }++ #[gpui::test]+ fn test_single_match_without_run_capture_skipped(cx: &mut TestAppContext) {+ // Pattern with only a named capture and no `@run`: should silently produce nothing.+ let query = indoc! {r#"+ (function_item) @_decl+ "#};+ let source = indoc! {r#"+ fn helper() {}+ fn another() {}+ "#};++ let runnables = collect_runnables(cx, source, query, None);+ assert!(+ runnables.is_empty(),+ "matches without @run should produce no runnables, got {}",+ runnables.len()+ );+ }++ #[gpui::test]+ fn test_match_with_no_runnable_does_not_terminate_iteration(cx: &mut TestAppContext) {+ // A syntax match yielding no runnable must not terminate the+ // outer iterator before later matches that DO have `@run` are visited.+ let query = indoc! {r#"+ ((function_item+ name: (identifier) @_helper+ (#match? @_helper "^helper")) @_decl_no_run)++ ((function_item+ name: (identifier) @run+ (#match? @run "^test_")) @_decl)+ "#};+ let source = indoc! {r#"+ fn helper() {}+ fn test_alpha() {}+ "#};++ let runnables = collect_runnables(cx, source, query, None);+ let run_texts: Vec<String> = runnables+ .iter()+ .map(|range| source[range.run_range.clone()].to_string())+ .collect();+ assert_eq!(+ run_texts,+ vec!["test_alpha"],+ "syntax matches that produce no runnable must not terminate iteration"+ );+ }++ #[gpui::test]+ fn test_grouped_match_without_resolver_emits_nothing(cx: &mut TestAppContext) {+ // `@run_item` is present but no resolver is registered on the language.+ let runnables = collect_runnables(cx, GROUPED_SOURCE, GROUPED_QUERY, None);+ assert!(+ runnables.is_empty(),+ "grouped path with no resolver should emit nothing, got {}",+ runnables.len()+ );+ }++ #[gpui::test]+ fn test_grouped_match_emits_one_runnable_per_run_item(cx: &mut TestAppContext) {+ let resolver: Arc<dyn RunnableResolver> = Arc::new(FirstRunResolver);+ let runnables = collect_runnables(cx, GROUPED_SOURCE, GROUPED_QUERY, Some(resolver));++ let run_texts: Vec<String> = runnables+ .iter()+ .map(|range| GROUPED_SOURCE[range.run_range.clone()].to_string())+ .collect();+ assert_eq!(run_texts, vec!["alpha", "beta", "gamma"]);+ }++ #[gpui::test]+ fn test_grouped_match_shared_captures_propagate(cx: &mut TestAppContext) {+ let resolver: Arc<dyn RunnableResolver> = Arc::new(FirstRunResolver);+ let runnables = collect_runnables(cx, GROUPED_SOURCE, GROUPED_QUERY, Some(resolver));++ for range in &runnables {+ assert_eq!(+ range.extra_captures.get("_outer").map(String::as_str),+ Some("outer"),+ "every grouped runnable should inherit the shared `_outer` capture"+ );+ }+ assert_eq!(runnables.len(), 3);+ }++ #[gpui::test]+ fn test_grouped_match_local_extras_are_per_group(cx: &mut TestAppContext) {+ let resolver: Arc<dyn RunnableResolver> = Arc::new(LocalExtrasResolver);+ let runnables = collect_runnables(cx, GROUPED_SOURCE, GROUPED_QUERY, Some(resolver));++ let calls: Vec<&str> = runnables+ .iter()+ .filter_map(|range| range.extra_captures.get("_call").map(String::as_str))+ .collect();+ assert_eq!(+ calls,+ vec!["alpha", "beta", "gamma"],+ "each group's local `_call` capture should come from that row only"+ );+ }++ #[gpui::test]+ fn test_grouped_match_resolver_returning_none_skips_group(cx: &mut TestAppContext) {+ let source = indoc! {r#"+ fn outer() {+ alpha();+ skip_me();+ gamma();+ }+ "#};+ let resolver: Arc<dyn RunnableResolver> = Arc::new(SkipByTextResolver {+ skip_text: "skip_me",+ });+ let runnables = collect_runnables(cx, source, GROUPED_QUERY, Some(resolver));++ let run_texts: Vec<String> = runnables+ .iter()+ .map(|range| source[range.run_range.clone()].to_string())+ .collect();+ assert_eq!(run_texts, vec!["alpha", "gamma"]);+ }++ #[gpui::test]+ fn test_grouped_match_offset_range_filters_groups(cx: &mut TestAppContext) {+ let resolver: Arc<dyn RunnableResolver> = Arc::new(FirstRunResolver);+ let beta_offset = GROUPED_SOURCE+ .find("beta()")+ .expect("source should contain `beta()`");+ let runnables = collect_runnables_in(+ cx,+ GROUPED_SOURCE,+ GROUPED_QUERY,+ Some(resolver),+ Some(beta_offset..beta_offset + "beta".len()),+ );++ let run_texts: Vec<String> = runnables+ .iter()+ .map(|range| GROUPED_SOURCE[range.run_range.clone()].to_string())+ .collect();+ assert_eq!(+ run_texts,+ vec!["beta"],+ "offset_range should restrict emitted groups to those overlapping it"+ );+ }++ #[gpui::test]+ fn test_grouped_match_zero_width_offset_at_group_start(cx: &mut TestAppContext) {+ let resolver: Arc<dyn RunnableResolver> = Arc::new(FirstRunResolver);+ let alpha_offset = GROUPED_SOURCE+ .find("alpha()")+ .expect("source should contain `alpha()`");+ let runnables = collect_runnables_in(+ cx,+ GROUPED_SOURCE,+ GROUPED_QUERY,+ Some(resolver),+ Some(alpha_offset..alpha_offset),+ );++ let run_texts: Vec<String> = runnables+ .iter()+ .map(|range| GROUPED_SOURCE[range.run_range.clone()].to_string())+ .collect();+ assert_eq!(+ run_texts,+ vec!["alpha"],+ "zero-width offset_range at the start of a group should include that group"+ );+ }++ #[gpui::test]+ fn test_local_extras_override_shared_extras_with_same_key(cx: &mut TestAppContext) {+ let resolver: Arc<dyn RunnableResolver> = Arc::new(OverrideSharedResolver);+ let runnables = collect_runnables(cx, GROUPED_SOURCE, GROUPED_QUERY, Some(resolver));++ for range in &runnables {+ assert_eq!(+ range.extra_captures.get("_outer").map(String::as_str),+ Some("LOCAL"),+ "local extras should override shared extras with the same key"+ );+ }+ assert_eq!(runnables.len(), 3);+ }+}diff --git a/crates/language/src/task_context.rs b/crates/language/src/task_context.rsindex dc59d21bd73..071e961508b 100644--- a/crates/language/src/task_context.rs+++ b/crates/language/src/task_context.rs@@ -1,6 +1,6 @@-use std::{ops::Range, path::PathBuf, sync::Arc};+use std::{path::PathBuf, sync::Arc};-use crate::{Buffer, LanguageToolchainStore, Location, Runnable};+use crate::{Buffer, LanguageToolchainStore, Location, RunnableResolver};use anyhow::Result;use collections::HashMap;@@ -8,15 +8,6 @@ use fs::Fs;use gpui::{App, Entity, Task};use lsp::LanguageServerName;use task::{TaskTemplates, TaskVariables};-use text::BufferId;--pub struct RunnableRange {- pub buffer_id: BufferId,- pub run_range: Range<usize>,- pub full_range: Range<usize>,- pub runnable: Runnable,- pub extra_captures: HashMap<String, String>,-}/// Language Contexts are used by Zed tasks to extract information about the source file where the tasks are supposed to be scheduled from./// Multiple context providers may be used together: by default, Zed provides a base [`BasicContextProvider`] context that fills all non-custom [`VariableName`] variants.@@ -45,6 +36,13 @@ pub trait ContextProvider: Send + Sync {fn lsp_task_source(&self) -> Option<LanguageServerName> {None}++ /// A resolver for runnable queries that group captures with `@run_item`.+ /// For each group, the resolver picks which `@run` range and extra captures+ /// to surface. Without a resolver, grouped matches emit no runnables.+ fn runnable_resolver(&self) -> Option<Arc<dyn RunnableResolver>> {+ None+ }}/// Metadata about the place in the project we gather the context for.diff --git a/crates/language_core/src/grammar.rs b/crates/language_core/src/grammar.rsindex 44f73ac6dea..d81ced4420a 100644--- a/crates/language_core/src/grammar.rs+++ b/crates/language_core/src/grammar.rs@@ -137,14 +137,25 @@ pub struct RedactionConfig {#[derive(Clone, Debug, PartialEq)]pub enum RunnableCapture {- Named(SharedString),+ /// `@run` — marks the node that identifies the runnable (e.g. the test+ /// function name, the subtest string literal).Run,+ /// `@run_item` — marks one candidate runnable inside a larger grammar+ /// match. Used by the per-match dispatch pipeline so a single tree-sitter+ /// match can produce multiple runnables (e.g. Go table-test rows).+ RunItem,+ /// Any other named capture, exposed by name to language resolvers and used+ /// to populate `RunnableRange::extra_captures`.+ Named(SharedString),}pub struct RunnableConfig {pub query: Query,/// A mapping from capture index to capture kindpub extra_captures: Vec<RunnableCapture>,+ /// `true` if the query uses `@run_item`, the marker for matches that+ /// emit multiple runnables.+ pub supports_grouped_runnables: bool,}pub struct OverrideConfig {@@ -388,13 +399,18 @@ impl Grammar {.iter().map(|&name| match name {"run" => RunnableCapture::Run,+ "run_item" => RunnableCapture::RunItem,name => RunnableCapture::Named(name.to_string().into()),}).collect();+ let supports_grouped_runnables = extra_captures+ .iter()+ .any(|capture| matches!(capture, RunnableCapture::RunItem));self.runnable_config = Some(RunnableConfig {extra_captures,query,+ supports_grouped_runnables,});Ok(self)