crates/biome_module_graph/src/js_module_info/collector.rs (1)

577-599: TODO comment flags incomplete migration — consider tracking this.

The comment on lines 578-582 explains that type inference still uses the collector's temporary scopes rather than the semantic model directly. This is a reasonable incremental approach, but the TODO should be tracked to avoid becoming stale.

Would you like me to open an issue to track refactoring type inference to use semantic_model's scopes directly?

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/biome_module_graph/src/js_module_info/collector.rs` around lines 577 -
599, The TODO in infer_all_types indicates a needed refactor to use
semantic_model scopes but isn’t tracked; create a formal issue describing
migrating infer_all_types to use semantic_model scopes (mention
scope_range_by_start, scope_by_range, scope_id_for_range, binding_node_by_start,
infer_type) and then update the TODO comment to reference that issue ID/URL (or
add a TODO/FIXME with the issue number) so the work is discoverable and won't go
stale.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_module_graph/src/js_module_info/module_resolver.rs (1)

165-168: Consider using the global scope's ID directly.

The _global_scope variable is fetched but never used. If global_scope() returns something with an accessible ID, you could use that instead of hardcoding ScopeId::new(0).

🔧 Potential simplification

If the semantic model's Scope type exposes its ID, consider:

-        let _global_scope = module.0.semantic_model.global_scope();
-        // We need the internal ScopeId to pass to find_binding_in_scope
-        // SAFETY: The global scope is always at index 0
-        let scope_id = biome_js_semantic::ScopeId::new(0);
+        let scope_id = module.0.semantic_model.global_scope().id();

Otherwise, if this is intentional due to API limitations, removing the unused _global_scope assignment would tidy things up.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/biome_module_graph/src/js_module_info/module_resolver.rs` around lines
165 - 168, The code fetches module.0.semantic_model.global_scope() into
_global_scope but then hardcodes biome_js_semantic::ScopeId::new(0) for
scope_id; either remove the unused _global_scope binding or, if the Scope object
exposes its id, derive scope_id from that global scope (use the global scope's
id instead of ScopeId::new(0)) so find_binding_in_scope gets the actual global
scope id; update the code around module.0.semantic_model.global_scope(),
scope_id, and the call to find_binding_in_scope accordingly.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_module_graph/src/js_module_info.rs (1)

304-324: Consider extracting the scope-walk helper.
The parent-scope traversal is duplicated in is_binding_imported; a shared helper would reduce drift.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/biome_module_graph/src/js_module_info.rs` around lines 304 - 324, The
scope-parent traversal logic in find_binding_in_scope is duplicated in
is_binding_imported; extract a shared helper (e.g., iterate_scope_chain or
find_in_scope_chain) that accepts a starting ScopeId and a closure/predicate to
run against each Scope, then refactor find_binding_in_scope to call that helper
and refactor is_binding_imported to use the same helper to check parent scopes;
reference the existing symbols find_binding_in_scope and is_binding_imported and
ensure the helper returns either the predicate result (Option<TextRange> for the
binding case or bool for imported check) or a common enum/Result that both
callers can use.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

crates/biome_service/src/workspace/server.rs (1)

1030-1033: Add a debug breadcrumb when JS graph updates are skipped.

Line 1031 silently returns defaults; a small debug log here would save future “why didn’t it index?” archaeology.

🔎 Tiny observability tweak

                     } else {
-                        // No semantic model available - return empty result
+                        tracing::debug!(
+                            path = %path,
+                            "Skipping JS module graph update: semantic model unavailable"
+                        );
                         Default::default()
                     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/biome_service/src/workspace/server.rs` around lines 1030 - 1033, Add a
debug breadcrumb before the silent return in the else branch that currently
returns Default::default() so skipped JS graph updates are logged; locate the
branch in workspace/server.rs where the code returns Default::default() for "No
semantic model available" (the JS graph update path) and call the project's
logger (e.g., tracing::debug! or log::debug!) with a short message like
"Skipping JS graph update: no semantic model" and any contextual identifiers
(workspace id, file path, or request id) available in scope to aid future
debugging.

crates/biome_module_graph/src/js_module_info/collector.rs (2)

1135-1158: _semantic_model is a forward-declared parameter with no current use.

The method builds BindingTypeData purely from self.bindings and never touches _semantic_model. The _ prefix suppresses the warning, which is fine for now — but consider dropping the parameter until it's actually needed, to avoid misleading callers about what drives the output.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/biome_module_graph/src/js_module_info/collector.rs` around lines 1135
- 1158, The build_binding_type_data method on JsModuleInfoCollector currently
takes an unused parameter _semantic_model; remove the unused parameter from the
function signature (change fn build_binding_type_data(&self, _semantic_model:
&biome_js_semantic::SemanticModel) -> ... to fn build_binding_type_data(&self)
-> ...) and update all callers to call build_binding_type_data() without the
extra argument; keep the body that maps self.bindings into BindingTypeData (ty,
jsdoc, export_ranges) unchanged so behavior is preserved.

---

577-599: Acknowledged interim duplication — TODO is clear, just ensure it's tracked.

infer_all_types rebuilds a Lapper from scope_range_by_start on every call while a SemanticModel (which already holds this data) is passed but ignored. The TODO comment is clear, but this means scope_range_by_start (and all its memory) is still being kept alive for each module even though the semantic model holds equivalent scope data.

Worth filing a follow-up issue to track the migration so it doesn't linger.

Want me to open a tracking issue for the TODO: Refactor type inference to use semantic_model's scopes directly?

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/biome_module_graph/src/js_module_info/collector.rs` around lines 577 -
599, infer_all_types currently rebuilds a Lapper from the collector's
scope_range_by_start each call even though a SemanticModel is passed in and
contains equivalent scope data; file a follow-up issue tracking the TODO and
update infer_all_types to use the scopes provided by the SemanticModel (use
semantic_model's scope data instead of scope_range_by_start), remove/stop
retaining collector-level scope_range_by_start where redundant, and update calls
that rely on scope_id_for_range to accept the semantic_model-backed Lapper or
lookup so the type inference (infer_type) uses the semantic model's scopes
directly.

crates/biome_module_graph/src/js_module_info/scope.rs (1)

14-27: pub range annotated dead — consider pub(crate) or removing the field for now.

A pub field with #[expect(dead_code)] is a contradiction: public to the world, but nothing reads it. If it's genuinely unused externally too, pub(crate) is a better fit until the "future scope analysis" materialises.

♻️ Suggested change

 pub struct JsScopeData {
-    #[expect(dead_code, reason = "May be used in future for scope analysis")]
-    pub range: TextRange,
+    pub(crate) range: TextRange,

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/biome_module_graph/src/js_module_info/scope.rs` around lines 14 - 27,
The field JsScopeData::range is publicly exported but annotated
#[expect(dead_code)] — change its visibility to pub(crate) (or remove the field
if you prefer) to avoid exposing an unused public API; locate the struct
JsScopeData and update the range field's declaration (currently typed TextRange
and carrying the expect attribute) to use pub(crate) instead of pub, and remove
the expect(dead_code) attribute if you keep it as pub(crate).

crates/biome_module_graph/src/js_module_info.rs (1)

306-348: Duplicated scope-walking loop — extract a shared private helper.

find_binding_in_scope and is_binding_imported share the exact same loop structure: start at scope_from_id, call get_binding(name), fall back to parent(). The only difference is what they do with the Binding once found.

♻️ Suggested refactor

+    /// Looks up a binding by name starting from `scope_id` and walking up the scope chain.
+    fn lookup_binding_in_scope(
+        &self,
+        name: &str,
+        scope_id: ScopeId,
+    ) -> Option<biome_js_semantic::Binding> {
+        let mut scope = self.semantic_model.scope_from_id(scope_id);
+        loop {
+            if let Some(binding) = scope.get_binding(name) {
+                return Some(binding);
+            }
+            match scope.parent() {
+                Some(parent) => scope = parent,
+                None => return None,
+            }
+        }
+    }
+
     fn find_binding_in_scope(&self, name: &str, scope_id: ScopeId) -> Option<TextRange> {
-        let mut scope = self.semantic_model.scope_from_id(scope_id);
-        loop {
-            if let Some(binding) = scope.get_binding(name) {
-                return Some(binding.syntax().text_trimmed_range());
-            }
-            match scope.parent() {
-                Some(parent) => scope = parent,
-                None => break,
-            }
-        }
-        None
+        self.lookup_binding_in_scope(name, scope_id)
+            .map(|b| b.syntax().text_trimmed_range())
     }

     fn is_binding_imported(&self, name: &str, scope_id: ScopeId) -> bool {
-        let mut scope = self.semantic_model.scope_from_id(scope_id);
-        loop {
-            if let Some(binding) = scope.get_binding(name) {
-                return binding.is_imported();
-            }
-            match scope.parent() {
-                Some(parent) => scope = parent,
-                None => break,
-            }
-        }
-        false
+        self.lookup_binding_in_scope(name, scope_id)
+            .is_some_and(|b| b.is_imported())
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/biome_module_graph/src/js_module_info.rs` around lines 306 - 348, Both
find_binding_in_scope and is_binding_imported repeat the same scope-walking
loop; extract a private helper (e.g., walk_binding_in_scope or find_binding)
that takes (&self, name: &str, scope_id: ScopeId) and returns Option<Binding>
(or a reference/handle to the Binding) by starting from
self.semantic_model.scope_from_id(scope_id), calling get_binding(name) and
following parent() until None. Replace the loop in find_binding_in_scope to call
the helper and then return binding.syntax().text_trimmed_range() mapped into
Option<TextRange>, and replace the loop in is_binding_imported to call the
helper and return binding.is_imported() or false if None. Ensure the helper and
callers use the same Binding type and visibility (private) so behavior is
unchanged.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro