Initial work towards prefixes for custom label commands.

crates/base-db/src/document.rs

@@ -56,7 +56,10 @@ impl Document {
             Language::Tex => {
                 let green = parser::parse_latex(&text, &params.config.syntax);
                 let mut semantics = semantics::tex::Semantics::default();
-                semantics.process_root(&latex::SyntaxNode::new_root(green.clone()));
+                semantics.process_root(
+                    &params.config.syntax,
+                    &latex::SyntaxNode::new_root(green.clone()),
+                );
                 DocumentData::Tex(TexDocumentData { green, semantics })
             }
             Language::Bib => {

crates/base-db/src/semantics/tex.rs

@@ -1,9 +1,26 @@
 use rowan::{ast::AstNode, TextRange};
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::latex::{self, HasBrack, HasCurly};
 use titlecase::titlecase;
 
+use parser::SyntaxConfig;
+
 use super::Span;
+use crate::semantics::tex::latex::SyntaxToken;
+
+fn maybe_prepend_prefix(
+    map: &FxHashMap<String, String>,
+    command: &Option<SyntaxToken>,
+    name: &Span,
+) -> Span {
+    match command {
+        Some(x) => Span::new(
+            map.get(&x.text()[1..]).unwrap_or(&String::new()).to_owned() + &name.text,
+            name.range,
+        ),
+        None => name.clone(),
+    }
+}
 
 #[derive(Debug, Clone, Default)]
 pub struct Semantics {
@@ -19,11 +36,11 @@ pub struct Semantics {
 }
 
 impl Semantics {
-    pub fn process_root(&mut self, root: &latex::SyntaxNode) {
+    pub fn process_root(&mut self, conf: &SyntaxConfig, root: &latex::SyntaxNode) {
         for node in root.descendants_with_tokens() {
             match node {
                 latex::SyntaxElement::Node(node) => {
-                    self.process_node(&node);
+                    self.process_node(conf, &node);
                 }
                 latex::SyntaxElement::Token(token) => {
                     if token.kind() == latex::COMMAND_NAME {
@@ -40,17 +57,17 @@ impl Semantics {
                 .any(|link| link.kind == LinkKind::Cls && link.path.text == "subfiles");
     }
 
-    fn process_node(&mut self, node: &latex::SyntaxNode) {
+    fn process_node(&mut self, conf: &SyntaxConfig, node: &latex::SyntaxNode) {
         if let Some(include) = latex::Include::cast(node.clone()) {
             self.process_include(include);
         } else if let Some(import) = latex::Import::cast(node.clone()) {
             self.process_import(import);
         } else if let Some(label) = latex::LabelDefinition::cast(node.clone()) {
-            self.process_label_definition(label);
+            self.process_label_definition(conf, label);
         } else if let Some(label) = latex::LabelReference::cast(node.clone()) {
-            self.process_label_reference(label);
+            self.process_label_reference(conf, label);
         } else if let Some(label) = latex::LabelReferenceRange::cast(node.clone()) {
-            self.process_label_reference_range(label);
+            self.process_label_reference_range(conf, label);
         } else if let Some(citation) = latex::Citation::cast(node.clone()) {
             self.process_citation(citation);
         } else if let Some(environment) = latex::Environment::cast(node.clone()) {
@@ -111,7 +128,7 @@ impl Semantics {
         });
     }
 
-    fn process_label_definition(&mut self, label: latex::LabelDefinition) {
+    fn process_label_definition(&mut self, conf: &SyntaxConfig, label: latex::LabelDefinition) {
         let Some(name) = label.name().and_then(|group| group.key()) else {
             return;
         };
@@ -190,13 +207,13 @@ impl Semantics {
 
         self.labels.push(Label {
             kind: LabelKind::Definition,
-            name,
+            name: maybe_prepend_prefix(&conf.label_definition_prefixes, &label.command(), &name),
             targets: objects,
             full_range,
         });
     }
 
-    fn process_label_reference(&mut self, label: latex::LabelReference) {
+    fn process_label_reference(&mut self, conf: &SyntaxConfig, label: latex::LabelReference) {
         let Some(name_list) = label.name_list() else {
             return;
         };
@@ -207,22 +224,34 @@ impl Semantics {
             if !name.text.contains('#') {
                 self.labels.push(Label {
                     kind: LabelKind::Reference,
-                    name,
+                    name: maybe_prepend_prefix(
+                        &conf.label_reference_prefixes,
+                        &label.command(),
+                        &name,
+                    ),
                     targets: Vec::new(),
                     full_range,
                 });
             }
         }
     }
 
-    fn process_label_reference_range(&mut self, label: latex::LabelReferenceRange) {
+    fn process_label_reference_range(
+        &mut self,
+        conf: &SyntaxConfig,
+        label: latex::LabelReferenceRange,
+    ) {
         let full_range = latex::small_range(&label);
         if let Some(from) = label.from().and_then(|group| group.key()) {
             let name = Span::from(&from);
             if !name.text.contains('#') {
                 self.labels.push(Label {
                     kind: LabelKind::ReferenceRange,
-                    name,
+                    name: maybe_prepend_prefix(
+                        &conf.label_reference_prefixes,
+                        &label.command(),
+                        &name,
+                    ),
                     targets: Vec::new(),
                     full_range,
                 });
@@ -234,7 +263,11 @@ impl Semantics {
             if !name.text.contains('#') {
                 self.labels.push(Label {
                     kind: LabelKind::ReferenceRange,
-                    name,
+                    name: maybe_prepend_prefix(
+                        &conf.label_reference_prefixes,
+                        &label.command(),
+                        &name,
+                    ),
                     targets: Vec::new(),
                     full_range,
                 });

crates/completion/Cargo.toml

@@ -22,6 +22,7 @@ criterion = "0.5.1"
 distro = { path = "../distro" }
 expect-test = "1.5.0"
 test-utils = { path = "../test-utils" }
+parser = { path = "../parser" }
 
 [lib]
 doctest = false

crates/completion/src/lib.rs

@@ -72,7 +72,7 @@ impl<'a> CompletionItemData<'a> {
             Self::Citation(data) => &data.entry.name.text,
             Self::Environment(data) => data.name,
             Self::GlossaryEntry(data) => &data.name,
-            Self::Label(data) => data.name,
+            Self::Label(data) => &data.name,
             Self::Color(name) => name,
             Self::ColorModel(name) => name,
             Self::File(name) => name,
@@ -165,7 +165,7 @@ pub struct GlossaryEntryData {
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct LabelData<'a> {
-    pub name: &'a str,
+    pub name: String,
     pub header: Option<String>,
     pub footer: Option<&'a str>,
     pub object: Option<RenderedObject<'a>>,

crates/completion/src/providers/label_def.rs

@@ -36,7 +36,7 @@ pub fn complete_label_definitions<'a>(
         };
 
         let data = crate::LabelData {
-            name: label,
+            name: label.to_string(),
             header: None,
             footer: None,
             object: None,

crates/completion/src/providers/label_ref.rs

@@ -11,12 +11,31 @@ use crate::{
     CompletionItem, CompletionItemData, CompletionParams,
 };
 
+fn trim_prefix(prefix: Option<&String>, text: &String) -> String {
+    if let Some(pref) = prefix {
+        if text.starts_with(pref) {
+            return text[pref.len()..].to_string();
+        }
+    }
+    text.clone()
+}
+
 pub fn complete_label_references<'a>(
     params: &'a CompletionParams<'a>,
     builder: &mut CompletionBuilder<'a>,
 ) -> Option<()> {
-    let FindResult { cursor, is_math } =
-        find_reference(params).or_else(|| find_reference_range(params))?;
+    let FindResult {
+        cursor,
+        is_math,
+        command,
+    } = find_reference(params).or_else(|| find_reference_range(params))?;
+    let ref_pref = params
+        .feature
+        .workspace
+        .config()
+        .syntax
+        .label_reference_prefixes
+        .get(&command);
 
     for document in &params.feature.project.documents {
         let DocumentData::Tex(data) = &document.data else {
@@ -29,6 +48,7 @@ pub fn complete_label_references<'a>(
             .iter()
             .filter(|label| label.kind == LabelKind::Definition)
         {
+            let labeltext = trim_prefix(ref_pref, &label.name.text);
             match render_label(params.feature.workspace, &params.feature.project, label) {
                 Some(rendered_label) => {
                     if is_math && !matches!(rendered_label.object, RenderedObject::Equation) {
@@ -41,11 +61,12 @@ pub fn complete_label_references<'a>(
                         _ => None,
                     };
 
-                    let keywords = format!("{} {}", label.name.text, rendered_label.reference());
+                    let keywords = format!("{} {}", labeltext, rendered_label.reference());
 
                     if let Some(score) = builder.matcher.score(&keywords, &cursor.text) {
+                        let name = trim_prefix(ref_pref, &label.name.text);
                         let data = CompletionItemData::Label(crate::LabelData {
-                            name: &label.name.text,
+                            name,
                             header,
                             footer,
                             object: Some(rendered_label.object),
@@ -59,12 +80,13 @@ pub fn complete_label_references<'a>(
                 }
                 None => {
                     if let Some(score) = builder.matcher.score(&label.name.text, &cursor.text) {
+                        let name = trim_prefix(ref_pref, &label.name.text);
                         let data = CompletionItemData::Label(crate::LabelData {
-                            name: &label.name.text,
+                            name,
                             header: None,
                             footer: None,
                             object: None,
-                            keywords: label.name.text.clone(),
+                            keywords: labeltext,
                         });
 
                         builder
@@ -82,20 +104,26 @@ pub fn complete_label_references<'a>(
 struct FindResult {
     cursor: Span,
     is_math: bool,
+    command: String,
 }
 
 fn find_reference(params: &CompletionParams) -> Option<FindResult> {
     let (cursor, group) = find_curly_group_word_list(params)?;
     let reference = latex::LabelReference::cast(group.syntax().parent()?)?;
     let is_math = reference.command()?.text() == "\\eqref";
-    Some(FindResult { cursor, is_math })
+    Some(FindResult {
+        cursor,
+        is_math,
+        command: reference.command()?.text()[1..].to_string(),
+    })
 }
 
 fn find_reference_range(params: &CompletionParams) -> Option<FindResult> {
     let (cursor, group) = find_curly_group_word(params)?;
-    latex::LabelReferenceRange::cast(group.syntax().parent()?)?;
+    let refrange = latex::LabelReferenceRange::cast(group.syntax().parent()?)?;
     Some(FindResult {
         cursor,
         is_math: false,
+        command: refrange.command()?.text()[1..].to_string(),
     })
 }