Add semantic tokens for undef and unused labels

Author: pfoerster

Cargo.lock

@@ -36,7 +36,7 @@ doctest = false
 [dependencies]
 anyhow = "1.0.69"
 chrono = { version = "0.4.23", default-features = false, features = ["std"] }
-clap = { version = "4.1.6", features = ["derive"] }
+clap = { version = "4.1.8", features = ["derive"] }
 crossbeam-channel = "0.5.6"
 dashmap = "5.4.0"
 dirs = "4.0.0"
@@ -69,6 +69,7 @@ thiserror = "1.0.38"
 threadpool = "1.8.1"
 titlecase = "2.2.1"
 unicode-normalization = "0.1.22"
+bitflags = "2.0.1"
 
 [dependencies.salsa]
 git = "https://github.com/salsa-rs/salsa"

Cargo.toml

@@ -10,5 +10,6 @@ pub mod inlay_hint;
 pub mod link;
 pub mod reference;
 pub mod rename;
+pub mod semantic_tokens;
 pub mod symbol;
 pub mod workspace_command;

src/features.rs

@@ -0,0 +1,109 @@
+mod label;
+
+use bitflags::bitflags;
+use lsp_types::{
+    Position, Range, SemanticToken, SemanticTokenModifier, SemanticTokenType, SemanticTokens,
+    SemanticTokensLegend, Url,
+};
+use rowan::TextRange;
+
+use crate::{
+    db::Workspace,
+    util::{line_index::LineIndex, line_index_ext::LineIndexExt},
+    Db,
+};
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
+#[repr(u32)]
+pub enum TokenKind {
+    Label = 0,
+}
+
+bitflags! {
+    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
+    pub struct TokenModifiers: u32 {
+        const NONE = 0;
+        const UNDEFINED = 1;
+        const UNUSED = 2;
+    }
+}
+
+pub fn legend() -> SemanticTokensLegend {
+    SemanticTokensLegend {
+        token_types: vec![SemanticTokenType::new("label")],
+        token_modifiers: vec![
+            SemanticTokenModifier::new("undefined"),
+            SemanticTokenModifier::new("unused"),
+        ],
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
+pub struct Token {
+    pub range: TextRange,
+    pub kind: TokenKind,
+    pub modifiers: TokenModifiers,
+}
+
+#[derive(Debug, Default)]
+pub struct TokenBuilder {
+    tokens: Vec<Token>,
+}
+
+impl TokenBuilder {
+    pub fn push(&mut self, token: Token) {
+        self.tokens.push(token);
+    }
+
+    pub fn finish(mut self, line_index: &LineIndex) -> SemanticTokens {
+        let mut data = Vec::new();
+
+        self.tokens.sort_by_key(|token| token.range.start());
+
+        let mut last_pos = Position::new(0, 0);
+        for token in self.tokens {
+            let range = line_index.line_col_lsp_range(token.range);
+            let length = range.end.character - range.start.character;
+            let token_type = token.kind as u32;
+            let token_modifiers_bitset = token.modifiers.bits();
+
+            if range.start.line > last_pos.line {
+                let delta_line = range.start.line - last_pos.line;
+                let delta_start = range.start.character;
+                data.push(SemanticToken {
+                    delta_line,
+                    delta_start,
+                    length,
+                    token_type,
+                    token_modifiers_bitset,
+                });
+            } else {
+                let delta_line = 0;
+                let delta_start = last_pos.character - range.start.character;
+                data.push(SemanticToken {
+                    delta_line,
+                    delta_start,
+                    length,
+                    token_type,
+                    token_modifiers_bitset,
+                });
+            }
+
+            last_pos = range.end;
+        }
+
+        SemanticTokens {
+            result_id: None,
+            data,
+        }
+    }
+}
+
+pub fn find_all(db: &dyn Db, uri: &Url, viewport: Range) -> Option<SemanticTokens> {
+    let workspace = Workspace::get(db);
+    let document = workspace.lookup_uri(db, uri)?;
+    let viewport = document.line_index(db).offset_lsp_range(viewport);
+    let mut builder = TokenBuilder::default();
+    label::find(db, document, viewport, &mut builder);
+    Some(builder.finish(document.line_index(db)))
+}

src/features/semantic_tokens.rs

@@ -0,0 +1,73 @@
+use rowan::TextRange;
+
+use crate::{
+    db::{analysis::label, Document, Workspace},
+    Db,
+};
+
+use super::{Token, TokenBuilder, TokenKind, TokenModifiers};
+
+pub fn find(
+    db: &dyn Db,
+    document: Document,
+    viewport: TextRange,
+    builder: &mut TokenBuilder,
+) -> Option<()> {
+    let labels = document.parse(db).as_tex()?.analyze(db).labels(db);
+    for label in labels
+        .iter()
+        .filter(|label| viewport.intersect(label.range(db)).is_some())
+    {
+        let name = label.name(db).text(db);
+        let modifiers = match label.origin(db) {
+            label::Origin::Definition(_) => {
+                if !is_label_referenced(db, document, name) {
+                    TokenModifiers::UNUSED
+                } else {
+                    TokenModifiers::NONE
+                }
+            }
+            label::Origin::Reference(_) | label::Origin::ReferenceRange(_) => {
+                if !is_label_defined(db, document, name) {
+                    TokenModifiers::UNDEFINED
+                } else {
+                    TokenModifiers::NONE
+                }
+            }
+        };
+
+        let range = label.range(db);
+        builder.push(Token {
+            range,
+            kind: TokenKind::Label,
+            modifiers,
+        });
+    }
+
+    Some(())
+}
+
+fn is_label_defined(db: &dyn Db, child: Document, name: &str) -> bool {
+    Workspace::get(db)
+        .related(db, child)
+        .iter()
+        .filter_map(|document| document.parse(db).as_tex())
+        .flat_map(|data| data.analyze(db).labels(db))
+        .filter(|label| matches!(label.origin(db), label::Origin::Definition(_)))
+        .any(|label| label.name(db).text(db) == name)
+}
+
+fn is_label_referenced(db: &dyn Db, child: Document, name: &str) -> bool {
+    Workspace::get(db)
+        .related(db, child)
+        .iter()
+        .filter_map(|document| document.parse(db).as_tex())
+        .flat_map(|data| data.analyze(db).labels(db))
+        .filter(|label| {
+            matches!(
+                label.origin(db),
+                label::Origin::Reference(_) | label::Origin::ReferenceRange(_)
+            )
+        })
+        .any(|label| label.name(db).text(db) == name)
+}

src/features/semantic_tokens/label.rs

@@ -28,7 +28,7 @@ use crate::{
         build::{self, BuildParams, BuildResult, BuildStatus},
         completion::{self, builder::CompletionItemData},
         definition, folding, formatting, forward_search, highlight, hover, inlay_hint, link,
-        reference, rename, symbol,
+        reference, rename, semantic_tokens, symbol,
         workspace_command::{change_environment, clean, dep_graph},
     },
     normalize_uri,
@@ -179,6 +179,14 @@ impl Server {
                 ..Default::default()
             }),
             inlay_hint_provider: Some(OneOf::Left(true)),
+            semantic_tokens_provider: Some(
+                SemanticTokensServerCapabilities::SemanticTokensOptions(SemanticTokensOptions {
+                    work_done_progress_options: Default::default(),
+                    legend: semantic_tokens::legend(),
+                    range: Some(true),
+                    full: Some(SemanticTokensFullOptions::Bool(false)),
+                }),
+            ),
             ..ServerCapabilities::default()
         }
     }
@@ -707,14 +715,6 @@ impl Server {
         Ok(())
     }
 
-    fn semantic_tokens_range(
-        &self,
-        _id: RequestId,
-        _params: SemanticTokensRangeParams,
-    ) -> Result<()> {
-        Ok(())
-    }
-
     fn build(&mut self, id: RequestId, params: BuildParams) -> Result<()> {
         let mut uri = params.text_document.uri;
         normalize_uri(&mut uri);
@@ -814,6 +814,18 @@ impl Server {
         Ok(())
     }
 
+    fn semantic_tokens_range(
+        &mut self,
+        id: RequestId,
+        params: SemanticTokensRangeParams,
+    ) -> Result<()> {
+        self.run_with_db(id, move |db| {
+            semantic_tokens::find_all(db, &params.text_document.uri, params.range)
+        });
+
+        Ok(())
+    }
+
     fn handle_file_event(&mut self, event: notify::Event) {
         let mut changed = false;