refactor(core): semantic model in collector (#9905)

Author: ematipico

Cargo.lock

@@ -161,9 +161,8 @@ impl Visitor for JsDocTypeCollectorVisitor {
 }
 
 fn load_jsdoc_types_from_node(model: &mut JsDocTypeModel, node: &SyntaxNode<JsLanguage>) {
-    JsdocComment::for_each(node, |comment| {
-        load_jsdoc_types_from_jsdoc_comment(model, comment)
-    });
+    JsdocComment::get_jsdocs(node)
+        .for_each(|comment| load_jsdoc_types_from_jsdoc_comment(model, comment.as_str()));
 }
 
 static JSDOC_INLINE_TAG_REGEX: LazyLock<Regex> = LazyLock::new(|| {

crates/biome_js_analyze/src/lint/correctness/no_unused_imports.rs

@@ -12,17 +12,19 @@ categories.workspace = true
 publish              = true
 
 [dependencies]
-biome_formatter = { workspace = true }
-biome_js_syntax = { workspace = true }
-biome_rowan     = { workspace = true }
-rust-lapper     = { workspace = true }
-rustc-hash      = { workspace = true }
-smallvec        = { workspace = true }
+biome_formatter     = { workspace = true }
+biome_js_syntax     = { workspace = true }
+biome_jsdoc_comment = { workspace = true }
+biome_rowan         = { workspace = true }
+rust-lapper         = { workspace = true }
+rustc-hash          = { workspace = true }
+smallvec            = { workspace = true }
 
 [dev-dependencies]
 biome_console     = { path = "../biome_console" }
 biome_diagnostics = { path = "../biome_diagnostics" }
 biome_js_parser   = { path = "../biome_js_parser" }
+insta             = { workspace = true }
 
 [lints]
 workspace = true

crates/biome_js_semantic/Cargo.toml

@@ -1,3 +1,4 @@
+use crate::{Binding, BindingId, JsDeclarationKind, Scope, ScopeId, SemanticModel};
 use biome_formatter::prelude::*;
 use biome_formatter::{
     FormatContext, FormatOptions, IndentStyle, IndentWidth, LineEnding, LineWidth,
@@ -6,8 +7,6 @@ use biome_formatter::{
 use biome_formatter::{format_args, write};
 use biome_js_syntax::TextSize;
 
-use crate::{Binding, BindingId, Scope, ScopeId, SemanticModel};
-
 pub struct FormatSemanticModelOptions;
 
 impl FormatOptions for FormatSemanticModelOptions {
@@ -141,19 +140,41 @@ impl Format<FormatSemanticModelContext> for Scope {
 
 impl Format<FormatSemanticModelContext> for Binding {
     fn fmt(&self, f: &mut Formatter<FormatSemanticModelContext>) -> FormatResult<()> {
+        let is_imported = format_with(|f| {
+            if self.is_imported() {
+                write!(f, [token("Imported: true"), hard_line_break()])
+            } else {
+                write!(f, [token("Imported: false"), hard_line_break()])
+            }
+        });
+
+        let is_exported = format_with(|f| {
+            if self.is_exported() {
+                write!(f, [token("Exported: true"), hard_line_break()])
+            } else {
+                write!(f, [token("Exported: false"), hard_line_break()])
+            }
+        });
+
         let formatted_binding_info = format_with(|f| {
             let range = std::format!("{:?}", self.syntax().text_trimmed_range());
+
             write!(
                 f,
                 [
-                    token("id: "),
+                    token("Id: "),
                     self.id,
                     token(" @ "),
                     text(range.as_str(), TextSize::default()),
                     hard_line_break()
                 ]
             )?;
-            write!(f, [token("scope: "), self.scope().id, hard_line_break()])?;
+            write!(f, [token("Scope: "), self.scope().id, hard_line_break()])?;
+            write!(f, [is_imported, is_exported])?;
+            write!(
+                f,
+                [token("Kind: "), self.declaration_kind(), hard_line_break()]
+            )?;
             let full_text = self.syntax().text_trimmed().into_text();
             write!(
                 f,
@@ -163,6 +184,17 @@ impl Format<FormatSemanticModelContext> for Binding {
                     hard_line_break()
                 ]
             )?;
+
+            if let Some(jsdoc) = self.to_fmt_jsonc() {
+                write!(
+                    f,
+                    [
+                        token("JsDoc Comments: "),
+                        text(jsdoc.as_str(), TextSize::default())
+                    ]
+                )?;
+            }
+
             Ok(())
         });
         write!(
@@ -192,3 +224,10 @@ impl Format<FormatSemanticModelContext> for BindingId {
         write!(f, [text(binding_text.as_str(), TextSize::default())])
     }
 }
+
+impl Format<FormatSemanticModelContext> for JsDeclarationKind {
+    fn fmt(&self, f: &mut Formatter<FormatSemanticModelContext>) -> FormatResult<()> {
+        let text_kind = std::format!("{:?}", self);
+        write!(f, [text(text_kind.as_str(), TextSize::default())])
+    }
+}

crates/biome_js_semantic/src/format_semantic_model.rs

@@ -4,6 +4,7 @@ use biome_js_syntax::{
     AnyJsDeclaration, JsImport, JsVariableKind, TextRange, TsTypeParameter, TsTypeParameterName,
     binding_ext::AnyJsIdentifierBinding,
 };
+use biome_jsdoc_comment::JsdocComment;
 use std::fmt::{Display, Formatter};
 use std::sync::Arc;
 
@@ -457,9 +458,11 @@ pub(crate) struct SemanticModelBindingData {
     pub(crate) range: TextRange,
     pub(crate) references: Vec<SemanticModelReference>,
     // We use a SmallVec because most of the time a binding is expected once.
-    pub(crate) export_by_start: smallvec::SmallVec<[TextSize; 4]>,
+    pub(crate) export_ranges: smallvec::SmallVec<[TextRange; 4]>,
     /// The kind of declaration that introduced this binding.
     pub(crate) declaration_kind: JsDeclarationKind,
+    /// JSDoc comment associated with the binding.
+    pub(crate) jsdoc: Option<JsdocComment>,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -596,14 +599,39 @@ impl Binding {
     /// itself an `export` statement) or an identifier usage.
     pub fn exports(&self) -> impl Iterator<Item = JsSyntaxNode> + '_ {
         let binding = self.data.binding(self.id);
-        binding.export_by_start.iter().map(|export_start| {
-            self.data.binding_node_by_start[export_start].to_node(self.data.to_root().syntax())
+        binding.export_ranges.iter().filter_map(|export_start| {
+            self.data
+                .binding_node_by_start
+                .get(&export_start.start())
+                .map(|ptr| ptr.to_node(self.data.to_root().syntax()))
         })
     }
 
     pub fn is_imported(&self) -> bool {
         super::is_imported(&self.syntax())
     }
+
+    pub fn is_exported(&self) -> bool {
+        self.data.is_exported(self.syntax().text_trimmed_range())
+    }
+
+    /// Returns the JSDoc comment associated with this binding, if any.
+    pub fn jsdoc(&self) -> Option<&JsdocComment> {
+        let binding = self.data.binding(self.id);
+        binding.jsdoc.as_ref()
+    }
+
+    /// Returns the formatted JsDoc comment
+    pub fn to_fmt_jsonc(&self) -> Option<String> {
+        let binding = self.data.binding(self.id);
+        binding.jsdoc.clone().map(|jsdoc| jsdoc.to_string())
+    }
+
+    /// Returns the text ranges of all export sites for this binding.
+    pub fn export_ranges(&self) -> &[TextRange] {
+        let binding = self.data.binding(self.id);
+        binding.export_ranges.as_slice()
+    }
 }
 
 impl PartialEq for Binding {

crates/biome_js_semantic/src/semantic_model/binding.rs

@@ -1,5 +1,9 @@
 use super::*;
-use biome_js_syntax::{AnyJsRoot, JsSyntaxNode, TextRange, TsConditionalType, TsTypeParameterName};
+use biome_js_syntax::{
+    AnyJsDeclaration, AnyJsRoot, JsExport, JsSyntaxNode, TextRange, TsConditionalType,
+    TsTypeParameterName,
+};
+use biome_jsdoc_comment::JsdocComment;
 use biome_rowan::SyntaxNodePtr;
 use rustc_hash::{FxHashMap, FxHashSet};
 use std::collections::hash_map::Entry;
@@ -27,6 +31,7 @@ pub struct SemanticModelBuilder {
     declared_at_by_start: FxHashMap<TextSize, BindingId>,
     exported: FxHashSet<TextSize>,
     unresolved_references: Vec<SemanticModelUnresolvedReference>,
+    pub(crate) export_jsdoc_by_range: FxHashMap<TextRange, JsdocComment>,
 }
 
 impl SemanticModelBuilder {
@@ -45,6 +50,7 @@ impl SemanticModelBuilder {
             declared_at_by_start: FxHashMap::default(),
             exported: FxHashSet::default(),
             unresolved_references: Vec::new(),
+            export_jsdoc_by_range: FxHashMap::default(),
         }
     }
 
@@ -113,6 +119,12 @@ impl SemanticModelBuilder {
                 self.scope_node_by_range
                     .insert(node.text_trimmed_range(), node.clone());
             }
+            JS_EXPORT => {
+                if let Ok(jsdoc) = JsdocComment::try_from(node) {
+                    self.export_jsdoc_by_range
+                        .insert(node.text_trimmed_range(), jsdoc);
+                }
+            }
             _ => {
                 if let Some(conditional_type) = TsConditionalType::cast_ref(node)
                     && let Ok(conditional_true_type) = conditional_type.true_type()
@@ -181,11 +193,16 @@ impl SemanticModelBuilder {
                 debug_assert!((binding_scope_id.index()) < self.scopes.len());
 
                 let binding_id = BindingId::new(self.bindings.len());
+                let jsdoc = self
+                    .binding_node_by_start
+                    .get(&range.start())
+                    .and_then(find_jsdoc);
                 self.bindings.push(SemanticModelBindingData {
                     range,
                     references: Vec::new(),
-                    export_by_start: smallvec::SmallVec::new(),
+                    export_ranges: smallvec::SmallVec::new(),
                     declaration_kind,
+                    jsdoc,
                 });
                 self.bindings_by_start.insert(range.start(), binding_id);
 
@@ -345,7 +362,7 @@ impl SemanticModelBuilder {
 
                 let binding_id = self.bindings_by_start[&declaration_at];
                 let binding = &mut self.bindings[binding_id.index()];
-                binding.export_by_start.push(range.start());
+                binding.export_ranges.push(range);
             }
         }
     }
@@ -379,7 +396,20 @@ impl SemanticModelBuilder {
             exported: self.exported,
             unresolved_references: self.unresolved_references,
             globals: self.globals,
+            export_jsdoc_by_range: self.export_jsdoc_by_range,
         };
         SemanticModel::new(data)
     }
 }
+
+fn find_jsdoc(node: &JsSyntaxNode) -> Option<JsdocComment> {
+    node.ancestors().find_map(|ancestor| {
+        if let Some(export) = JsExport::cast_ref(&ancestor) {
+            JsdocComment::try_from(export.syntax()).ok()
+        } else if let Some(decl) = AnyJsDeclaration::cast(ancestor) {
+            JsdocComment::try_from(decl.syntax()).ok()
+        } else {
+            None
+        }
+    })
+}

crates/biome_js_semantic/src/semantic_model/builder.rs

@@ -1,5 +1,6 @@
 use super::*;
 use biome_js_syntax::{AnyJsFunction, AnyJsRoot, JsSyntaxNodePtr};
+use biome_jsdoc_comment::JsdocComment;
 use biome_rowan::SendNode;
 use std::sync::Arc;
 
@@ -93,6 +94,8 @@ pub(crate) struct SemanticModelData {
     pub(crate) unresolved_references: Vec<SemanticModelUnresolvedReference>,
     /// All globals references
     pub(crate) globals: Vec<SemanticModelGlobalBindingData>,
+    /// JSDoc comments attached to export statements (keyed by the JsExport node's range).
+    pub(crate) export_jsdoc_by_range: FxHashMap<TextRange, JsdocComment>,
 }
 
 impl SemanticModelData {
@@ -513,4 +516,27 @@ impl SemanticModel {
                 .all_reads(self),
         })
     }
+
+    /// Returns a [Binding] for the declaration at the given range if one exists.
+    pub fn as_binding_by_range(&self, range: TextRange) -> Option<Binding> {
+        let binding_id = self.data.bindings_by_start.get(&range.start())?;
+        Some(Binding {
+            data: self.data.clone(),
+            id: *binding_id,
+        })
+    }
+
+    /// Returns a [Binding] for the declaration at the given start range
+    pub fn as_binding_by_range_start(&self, range: TextSize) -> Option<Binding> {
+        let binding_id = self.data.bindings_by_start.get(&range)?;
+        Some(Binding {
+            data: self.data.clone(),
+            id: *binding_id,
+        })
+    }
+
+    /// Returns the JSDoc comment attached to the export statement at `range`, if any.
+    pub fn export_jsdoc(&self, range: TextRange) -> Option<&JsdocComment> {
+        self.data.export_jsdoc_by_range.get(&range)
+    }
 }