task: Add task contexts (#8675)

This PR supplements tasks with additional environment variables; ideally
we'll be able to write a task like:
`cargo test -p $ZED_CURRENT_PACKAGE -- $ZED_CURRENT_FUNCTION`
- [x] Flesh out multibuffer interactions
- [x] Add ZED_SYMBOL detection based on tree-sitter queries
- [ ] Add release note and demo
- [x] Figure out a solution for rerun dilemma - should `task: rerun`
reevaluate contexts for tasks?

This PR introduced the following variables:
- ZED_COLUMN - current line column
- ZED_ROW - current line row
and the following, which are available for buffers with associated
files:
- ZED_WORKTREE_ROOT - absolute path to the root of the current worktree.
- ZED_FILE - absolute path to the file
- ZED_SYMBOL - currently selected symbol; should match the last symbol
shown in a symbol breadcrumb (e.g. `mod tests > fn test_task_contexts`
should be equal to ZED_SYMBOL of `test_task_contexts`). Note that this
isn't necessarily a test function or a function at all.

Also, you can use them in `cwd` field of definitions (note though that
we're using https://docs.rs/subst/latest/subst/#features for that, so
don't expect a full shell functionality to work); the syntax should
match up with your typical Unix shell.


Release Notes:

- Added task contexts, which are additional environment variables set by
Zed for task execution; task content is dependent on the state of the
editor at the time the task is spawned.

---------

Co-authored-by: Anthony <anthonyeid7@protonmail.com>

crates/language/src/language.rs

@@ -120,6 +120,46 @@ pub struct Location {
     pub range: Range<Anchor>,
 }
 
+pub struct LanguageContext {
+    pub package: Option<String>,
+    pub symbol: Option<String>,
+}
+
+pub trait LanguageContextProvider: Send + Sync {
+    fn build_context(&self, location: Location, cx: &mut AppContext) -> Result<LanguageContext>;
+}
+
+/// A context provider that fills out LanguageContext without inspecting the contents.
+pub struct DefaultContextProvider;
+
+impl LanguageContextProvider for DefaultContextProvider {
+    fn build_context(
+        &self,
+        location: Location,
+        cx: &mut AppContext,
+    ) -> gpui::Result<LanguageContext> {
+        let symbols = location
+            .buffer
+            .read(cx)
+            .snapshot()
+            .symbols_containing(location.range.start, None);
+        let symbol = symbols.and_then(|symbols| {
+            symbols.last().map(|symbol| {
+                let range = symbol
+                    .name_ranges
+                    .last()
+                    .cloned()
+                    .unwrap_or(0..symbol.text.len());
+                symbol.text[range].to_string()
+            })
+        });
+        Ok(LanguageContext {
+            package: None,
+            symbol,
+        })
+    }
+}
+
 /// Represents a Language Server, with certain cached sync properties.
 /// Uses [`LspAdapter`] under the hood, but calls all 'static' methods
 /// once at startup, and caches the results.
@@ -727,6 +767,7 @@ pub struct Language {
     pub(crate) id: LanguageId,
     pub(crate) config: LanguageConfig,
     pub(crate) grammar: Option<Arc<Grammar>>,
+    pub(crate) context_provider: Option<Arc<dyn LanguageContextProvider>>,
 }
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
@@ -841,9 +882,18 @@ impl Language {
                     highlight_map: Default::default(),
                 })
             }),
+            context_provider: None,
         }
     }
 
+    pub fn with_context_provider(
+        mut self,
+        provider: Option<Arc<dyn LanguageContextProvider>>,
+    ) -> Self {
+        self.context_provider = provider;
+        self
+    }
+
     pub fn with_queries(mut self, queries: LanguageQueries) -> Result<Self> {
         if let Some(query) = queries.highlights {
             self = self
@@ -1139,6 +1189,10 @@ impl Language {
         self.config.name.clone()
     }
 
+    pub fn context_provider(&self) -> Option<Arc<dyn LanguageContextProvider>> {
+        self.context_provider.clone()
+    }
+
     pub fn highlight_text<'a>(
         self: &'a Arc<Self>,
         text: &'a Rope,

crates/language/src/language_registry.rs

@@ -1,6 +1,6 @@
 use crate::{
-    CachedLspAdapter, Language, LanguageConfig, LanguageId, LanguageMatcher, LanguageServerName,
-    LspAdapter, LspAdapterDelegate, PARSER, PLAIN_TEXT,
+    CachedLspAdapter, Language, LanguageConfig, LanguageContextProvider, LanguageId,
+    LanguageMatcher, LanguageServerName, LspAdapter, LspAdapterDelegate, PARSER, PLAIN_TEXT,
 };
 use anyhow::{anyhow, Context as _, Result};
 use collections::{hash_map, HashMap};
@@ -78,6 +78,7 @@ struct AvailableLanguage {
     matcher: LanguageMatcher,
     load: Arc<dyn Fn() -> Result<(LanguageConfig, LanguageQueries)> + 'static + Send + Sync>,
     loaded: bool,
+    context_provider: Option<Arc<dyn LanguageContextProvider>>,
 }
 
 enum AvailableGrammar {
@@ -188,6 +189,7 @@ impl LanguageRegistry {
             config.name.clone(),
             config.grammar.clone(),
             config.matcher.clone(),
+            None,
             move || Ok((config.clone(), Default::default())),
         )
     }
@@ -237,6 +239,7 @@ impl LanguageRegistry {
         name: Arc<str>,
         grammar_name: Option<Arc<str>>,
         matcher: LanguageMatcher,
+        context_provider: Option<Arc<dyn LanguageContextProvider>>,
         load: impl Fn() -> Result<(LanguageConfig, LanguageQueries)> + 'static + Send + Sync,
     ) {
         let load = Arc::new(load);
@@ -257,6 +260,8 @@ impl LanguageRegistry {
             grammar: grammar_name,
             matcher,
             load,
+
+            context_provider,
             loaded: false,
         });
         state.version += 1;
@@ -422,6 +427,7 @@ impl LanguageRegistry {
                             .spawn(async move {
                                 let id = language.id;
                                 let name = language.name.clone();
+                                let provider = language.context_provider.clone();
                                 let language = async {
                                     let (config, queries) = (language.load)()?;
 
@@ -431,7 +437,9 @@ impl LanguageRegistry {
                                         None
                                     };
 
-                                    Language::new_with_id(id, config, grammar).with_queries(queries)
+                                    Language::new_with_id(id, config, grammar)
+                                        .with_context_provider(provider)
+                                        .with_queries(queries)
                                 }
                                 .await;