feat(rome_js_analyze): analyzer metadata (#4368)

CHANGELOG.md

@@ -14,13 +14,15 @@
 + import "module" with {}
 ```
 - Fix an issue where JSON formatter does not respect `lineWidth` for arrays [#4351](https://github.com/rome/tools/issues/4351)
+
 ### Linter
 
 #### Other changes
 
 - Code actions are formatted using Rome's formatter. If the formatter is disabled,
 the code action is not formatted.
-- Fixed an issue that [`useShorthandArrayType`](https://docs.rome.tools/lint/rules/useShorthandArrayType) rule did not handle nested ReadonlyArray types correctly and erroneously reported TsObjectType [#4354](https://github.com/rome/tools/issues/4353)
+- Fixed an issue that [`useShorthandArrayType`](https://docs.rome.tools/lint/rules/useShorthandArrayType) rule did not handle nested ReadonlyArray types correctly and erroneously reported TsObjectType [#4354](https://github.com/rome/tools/issues/4353).
+- [`noUndeclaredVariables`](https://docs.rome.tools/lint/rules/noUndeclaredVariables) detects globals based on the file type.
 
 - Fix an issue when `noUndeclaredVariables` incorrectly identifies `AggregateError` as an undeclared variable. [#4365](https://github.com/rome/tools/issues/4365)
 #### New rules

crates/rome_analyze/src/context.rs

@@ -1,6 +1,7 @@
 use crate::{registry::RuleRoot, FromServices, Queryable, Rule, RuleKey, ServiceBag};
 use rome_diagnostics::{Error, Result};
 use std::ops::Deref;
+use std::path::Path;
 
 type RuleQueryResult<R> = <<R as Rule>::Query as Queryable>::Output;
 type RuleServiceBag<R> = <<R as Rule>::Query as Queryable>::Services;
@@ -17,6 +18,7 @@ where
     bag: &'a ServiceBag,
     services: RuleServiceBag<R>,
     globals: &'a [&'a str],
+    file_path: &'a Path,
 }
 
 impl<'a, R> RuleContext<'a, R>
@@ -28,6 +30,7 @@ where
         root: &'a RuleRoot<R>,
         services: &'a ServiceBag,
         globals: &'a [&'a str],
+        file_path: &'a Path,
     ) -> Result<Self, Error> {
         let rule_key = RuleKey::rule::<R>();
         Ok(Self {
@@ -36,6 +39,7 @@ where
             bag: services,
             services: FromServices::from_services(&rule_key, services)?,
             globals,
+            file_path,
         })
     }
 
@@ -97,6 +101,18 @@ where
     pub fn is_global(&self, text: &str) -> bool {
         self.globals.contains(&text)
     }
+
+    /// Returns the source type of the current file
+    pub fn source_type<T: 'static>(&self) -> &T {
+        self.bag
+            .get_service::<T>()
+            .expect("Source type is not registered")
+    }
+
+    /// The file path of the current file
+    pub fn file_path(&self) -> &Path {
+        self.file_path
+    }
 }
 
 impl<'a, R> Deref for RuleContext<'a, R>

crates/rome_analyze/src/lib.rs

@@ -5,6 +5,7 @@ use std::cmp::Ordering;
 use std::collections::{BTreeMap, BinaryHeap};
 use std::fmt::{Debug, Display, Formatter};
 use std::ops;
+use std::path::Path;
 
 mod categories;
 pub mod context;
@@ -77,6 +78,7 @@ pub struct AnalyzerContext<'a, L: Language> {
     pub services: ServiceBag,
     pub range: Option<TextRange>,
     pub globals: &'a [&'a str],
+    pub file_path: &'a Path,
 }
 
 impl<'analyzer, L, Matcher, Break, Diag> Analyzer<'analyzer, L, Matcher, Break, Diag>
@@ -142,6 +144,7 @@ where
                 range: ctx.range,
                 globals: ctx.globals,
                 apply_suppression_comment,
+                file_path: ctx.file_path,
             };
 
             // The first phase being run will inspect the tokens and parse the
@@ -220,6 +223,8 @@ struct PhaseRunner<'analyzer, 'phase, L: Language, Matcher, Break, Diag> {
     range: Option<TextRange>,
     /// Options passed to the analyzer
     globals: &'phase [&'phase str],
+    /// The [Path] of the current file
+    file_path: &'phase Path,
 }
 
 /// Single entry for a suppression comment in the `line_suppressions` buffer
@@ -279,6 +284,7 @@ where
                     signal_queue: &mut self.signal_queue,
                     apply_suppression_comment: self.apply_suppression_comment,
                     globals: self.globals,
+                    file_path: self.file_path,
                 };
 
                 visitor.visit(&node_event, ctx);
@@ -304,6 +310,7 @@ where
                     signal_queue: &mut self.signal_queue,
                     apply_suppression_comment: self.apply_suppression_comment,
                     globals: self.globals,
+                    file_path: self.file_path,
                 };
 
                 visitor.visit(&event, ctx);

crates/rome_analyze/src/matcher.rs

@@ -3,6 +3,7 @@ use crate::{
     SuppressionCommentEmitter,
 };
 use rome_rowan::{Language, TextRange};
+use std::path::Path;
 use std::{
     any::{Any, TypeId},
     cmp::Ordering,
@@ -27,6 +28,7 @@ pub struct MatchQueryParams<'phase, 'query, L: Language> {
     pub signal_queue: &'query mut BinaryHeap<SignalEntry<'phase, L>>,
     pub apply_suppression_comment: SuppressionCommentEmitter<L>,
     pub globals: &'phase [&'phase str],
+    pub file_path: &'phase Path,
 }
 
 /// Wrapper type for a [QueryMatch]
@@ -197,6 +199,7 @@ where
 #[cfg(test)]
 mod tests {
     use std::convert::Infallible;
+    use std::path::Path;
 
     use rome_diagnostics::{category, DiagnosticExt};
     use rome_diagnostics::{Diagnostic, Severity};
@@ -381,6 +384,7 @@ mod tests {
             range: None,
             services: ServiceBag::default(),
             globals: &[],
+            file_path: Path::new(""),
         };
 
         let result: Option<Never> = analyzer.run(ctx);

crates/rome_analyze/src/options.rs

@@ -1,9 +1,11 @@
 use crate::RuleKey;
 use serde::Deserialize;
 use std::collections::HashMap;
+use std::fmt::Debug;
+use std::path::PathBuf;
 
 /// A convenient new type data structure to store the options that belong to a rule
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Default, Deserialize)]
 pub struct RuleOptions(String);
 
 impl RuleOptions {
@@ -19,7 +21,7 @@ impl RuleOptions {
 }
 
 /// A convenient new type data structure to insert and get rules
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Default)]
 pub struct AnalyzerRules(HashMap<RuleKey, RuleOptions>);
 
 impl AnalyzerRules {
@@ -35,7 +37,7 @@ impl AnalyzerRules {
 }
 
 /// A data structured derived from the `rome.json` file
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Default)]
 pub struct AnalyzerConfiguration {
     /// A list of rules and their options
     pub rules: AnalyzerRules,
@@ -47,8 +49,11 @@ pub struct AnalyzerConfiguration {
 }
 
 /// A set of information useful to the analyzer infrastructure
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Default)]
 pub struct AnalyzerOptions {
     /// A data structured derived from the [`rome.json`] file
     pub configuration: AnalyzerConfiguration,
+
+    /// The file that is being analyzed
+    pub file_path: PathBuf,
 }

crates/rome_analyze/src/registry.rs

@@ -426,12 +426,16 @@ impl<L: Language + Default> RegistryRule<L> {
             // if the query doesn't match
             let query_result = params.query.downcast_ref().unwrap();
             let query_result = <R::Query as Queryable>::unwrap_match(params.services, query_result);
-            let ctx =
-                match RuleContext::new(&query_result, params.root, params.services, params.globals)
-                {
-                    Ok(ctx) => ctx,
-                    Err(error) => return Err(error),
-                };
+            let ctx = match RuleContext::new(
+                &query_result,
+                params.root,
+                params.services,
+                params.globals,
+                params.file_path,
+            ) {
+                Ok(ctx) => ctx,
+                Err(error) => return Err(error),
+            };
 
             for result in R::run(&ctx) {
                 let text_range =
@@ -446,6 +450,7 @@ impl<L: Language + Default> RegistryRule<L> {
                     params.services,
                     params.apply_suppression_comment,
                     params.globals,
+                    params.file_path,
                 ));
 
                 params.signal_queue.push(SignalEntry {

crates/rome_analyze/src/signals.rs

@@ -12,6 +12,7 @@ use rome_rowan::{BatchMutation, Language};
 use std::borrow::Cow;
 use std::iter::FusedIterator;
 use std::marker::PhantomData;
+use std::path::Path;
 use std::vec::IntoIter;
 
 /// Event raised by the analyzer when a [Rule](crate::Rule)
@@ -245,6 +246,7 @@ pub(crate) struct RuleSignal<'phase, R: Rule> {
     apply_suppression_comment: SuppressionCommentEmitter<RuleLanguage<R>>,
     /// A list of strings that are considered "globals" inside the analyzer
     globals: &'phase [&'phase str],
+    file_path: &'phase Path,
 }
 
 impl<'phase, R> RuleSignal<'phase, R>
@@ -260,6 +262,7 @@ where
             <<R as Rule>::Query as Queryable>::Language,
         >,
         globals: &'phase [&'phase str],
+        file_path: &'phase Path,
     ) -> Self {
         Self {
             root,
@@ -268,6 +271,7 @@ where
             services,
             apply_suppression_comment,
             globals,
+            file_path,
         }
     }
 }
@@ -277,14 +281,27 @@ where
     R: Rule + 'static,
 {
     fn diagnostic(&self) -> Option<AnalyzerDiagnostic> {
-        let ctx =
-            RuleContext::new(&self.query_result, self.root, self.services, self.globals).ok()?;
+        let ctx = RuleContext::new(
+            &self.query_result,
+            self.root,
+            self.services,
+            self.globals,
+            self.file_path,
+        )
+        .ok()?;
 
         R::diagnostic(&ctx, &self.state).map(AnalyzerDiagnostic::from)
     }
 
     fn actions(&self) -> AnalyzerActionIter<RuleLanguage<R>> {
-        let ctx = RuleContext::new(&self.query_result, self.root, self.services, self.globals).ok();
+        let ctx = RuleContext::new(
+            &self.query_result,
+            self.root,
+            self.services,
+            self.globals,
+            self.file_path,
+        )
+        .ok();
         if let Some(ctx) = ctx {
             let mut actions = Vec::new();
             if let Some(action) = R::action(&ctx, &self.state) {

crates/rome_analyze/src/syntax.rs

@@ -98,6 +98,7 @@ mod tests {
         AstNode, SyntaxNode,
     };
     use std::convert::Infallible;
+    use std::path::Path;
 
     use crate::{
         matcher::MatchQueryParams, registry::Phases, Analyzer, AnalyzerContext, AnalyzerSignal,
@@ -165,6 +166,7 @@ mod tests {
             range: None,
             services: ServiceBag::default(),
             globals: &[],
+            file_path: Path::new(""),
         };
 
         let result: Option<Never> = analyzer.run(ctx);

crates/rome_analyze/src/visitor.rs

@@ -1,4 +1,5 @@
 use std::collections::BinaryHeap;
+use std::path::Path;
 
 use rome_rowan::{AstNode, Language, SyntaxNode, TextRange, WalkEvent};
 
@@ -18,6 +19,7 @@ pub struct VisitorContext<'phase, 'query, L: Language> {
     pub(crate) signal_queue: &'query mut BinaryHeap<SignalEntry<'phase, L>>,
     pub apply_suppression_comment: SuppressionCommentEmitter<L>,
     pub globals: &'phase [&'phase str],
+    pub file_path: &'phase Path,
 }
 
 impl<'phase, 'query, L: Language> VisitorContext<'phase, 'query, L> {
@@ -30,6 +32,7 @@ impl<'phase, 'query, L: Language> VisitorContext<'phase, 'query, L> {
             signal_queue: self.signal_queue,
             apply_suppression_comment: self.apply_suppression_comment,
             globals: self.globals,
+            file_path: self.file_path,
         })
     }
 }