chore: expose schema_cache & file_context in lint rules (#449)

Author: juleswritescode

Cargo.lock

@@ -13,10 +13,11 @@ version              = "0.0.0"
 
 
 [dependencies]
-pgt_console.workspace     = true
-pgt_diagnostics.workspace = true
-pgt_query_ext.workspace   = true
-rustc-hash                = { workspace = true }
+pgt_console.workspace      = true
+pgt_diagnostics.workspace  = true
+pgt_query_ext.workspace    = true
+pgt_schema_cache.workspace = true
+rustc-hash                 = { workspace = true }
 
 biome_deserialize        = { workspace = true, optional = true }
 biome_deserialize_macros = { workspace = true, optional = true }

crates/pgt_analyse/Cargo.toml

@@ -0,0 +1,7 @@
+#[derive(Default)]
+pub struct AnalysedFileContext {}
+
+impl AnalysedFileContext {
+    #[allow(unused)]
+    pub fn update_from(&mut self, stmt_root: &pgt_query_ext::NodeEnum) {}
+}

crates/pgt_analyse/src/analysed_file_context.rs

@@ -1,20 +1,35 @@
+use pgt_schema_cache::SchemaCache;
+
 use crate::{
+    AnalysedFileContext,
     categories::RuleCategory,
     rule::{GroupCategory, Rule, RuleGroup, RuleMetadata},
 };
 
 pub struct RuleContext<'a, R: Rule> {
     stmt: &'a pgt_query_ext::NodeEnum,
     options: &'a R::Options,
+    schema_cache: Option<&'a SchemaCache>,
+    file_context: &'a AnalysedFileContext,
 }
 
 impl<'a, R> RuleContext<'a, R>
 where
     R: Rule + Sized + 'static,
 {
     #[allow(clippy::too_many_arguments)]
-    pub fn new(stmt: &'a pgt_query_ext::NodeEnum, options: &'a R::Options) -> Self {
-        Self { stmt, options }
+    pub fn new(
+        stmt: &'a pgt_query_ext::NodeEnum,
+        options: &'a R::Options,
+        schema_cache: Option<&'a SchemaCache>,
+        file_context: &'a AnalysedFileContext,
+    ) -> Self {
+        Self {
+            stmt,
+            options,
+            schema_cache,
+            file_context,
+        }
     }
 
     /// Returns the group that belongs to the current rule
@@ -32,6 +47,14 @@ where
         self.stmt
     }
 
+    pub fn file_context(&self) -> &AnalysedFileContext {
+        self.file_context
+    }
+
+    pub fn schema_cache(&self) -> Option<&SchemaCache> {
+        self.schema_cache
+    }
+
     /// Returns the metadata of the rule
     ///
     /// The metadata contains information about the rule, such as the name, version, language, and whether it is recommended.

crates/pgt_analyse/src/context.rs

@@ -1,3 +1,4 @@
+mod analysed_file_context;
 mod categories;
 pub mod context;
 mod filter;
@@ -9,6 +10,7 @@ mod rule;
 // Re-exported for use in the `declare_group` macro
 pub use pgt_diagnostics::category_concat;
 
+pub use crate::analysed_file_context::AnalysedFileContext;
 pub use crate::categories::{
     ActionCategory, RefactorKind, RuleCategories, RuleCategoriesBuilder, RuleCategory,
     SUPPRESSION_ACTION_CATEGORY, SourceActionKind,

crates/pgt_analyse/src/lib.rs

@@ -2,6 +2,7 @@ use std::{borrow, collections::BTreeSet};
 
 use crate::{
     AnalyserOptions,
+    analysed_file_context::AnalysedFileContext,
     context::RuleContext,
     filter::{AnalysisFilter, GroupKey, RuleKey},
     rule::{GroupCategory, Rule, RuleDiagnostic, RuleGroup},
@@ -158,6 +159,8 @@ impl RuleRegistry {
 pub struct RegistryRuleParams<'a> {
     pub root: &'a pgt_query_ext::NodeEnum,
     pub options: &'a AnalyserOptions,
+    pub analysed_file_context: &'a AnalysedFileContext,
+    pub schema_cache: Option<&'a pgt_schema_cache::SchemaCache>,
 }
 
 /// Executor for rule as a generic function pointer
@@ -174,7 +177,14 @@ impl RegistryRule {
             R: Rule<Options: Default> + 'static,
         {
             let options = params.options.rule_options::<R>().unwrap_or_default();
-            let ctx = RuleContext::new(params.root, &options);
+
+            let ctx = RuleContext::new(
+                params.root,
+                &options,
+                params.schema_cache,
+                params.analysed_file_context,
+            );
+
             R::run(&ctx)
         }
 

crates/pgt_analyse/src/registry.rs

@@ -102,7 +102,8 @@ pub trait GroupCategory {
 pub trait Rule: RuleMeta + Sized {
     type Options: Default + Clone + Debug;
 
-    fn run(ctx: &RuleContext<Self>) -> Vec<RuleDiagnostic>;
+    /// `schema_cache` will only be available if the user has a working database connection.
+    fn run(rule_context: &RuleContext<Self>) -> Vec<RuleDiagnostic>;
 }
 
 /// Diagnostic object returned by a single analysis rule
@@ -208,6 +209,12 @@ impl RuleDiagnostic {
         self
     }
 
+    /// Sets the span of this diagnostic.
+    pub fn span(mut self, span: TextRange) -> Self {
+        self.span = Some(span);
+        self
+    }
+
     /// Marks this diagnostic as unnecessary code, which will
     /// be displayed in the language server.
     ///

crates/pgt_analyse/src/rule.rs

@@ -12,11 +12,13 @@ repository.workspace = true
 version              = "0.0.0"
 
 [dependencies]
-pgt_analyse     = { workspace = true }
-pgt_console     = { workspace = true }
-pgt_diagnostics = { workspace = true }
-pgt_query_ext   = { workspace = true }
-serde           = { workspace = true }
+pgt_analyse      = { workspace = true }
+pgt_console      = { workspace = true }
+pgt_diagnostics  = { workspace = true }
+pgt_query_ext    = { workspace = true }
+pgt_schema_cache = { workspace = true }
+pgt_text_size    = { workspace = true }
+serde            = { workspace = true }
 
 [dev-dependencies]
 insta           = { version = "1.42.1" }

crates/pgt_analyser/Cargo.toml

@@ -1,8 +1,8 @@
 use std::{ops::Deref, sync::LazyLock};
 
 use pgt_analyse::{
-    AnalyserOptions, AnalysisFilter, MetadataRegistry, RegistryRuleParams, RuleDiagnostic,
-    RuleRegistry,
+    AnalysedFileContext, AnalyserOptions, AnalysisFilter, MetadataRegistry, RegistryRuleParams,
+    RuleDiagnostic, RuleRegistry,
 };
 pub use registry::visit_registry;
 
@@ -30,8 +30,15 @@ pub struct Analyser<'a> {
     registry: RuleRegistry,
 }
 
-pub struct AnalyserContext<'a> {
-    pub root: &'a pgt_query_ext::NodeEnum,
+#[derive(Debug)]
+pub struct AnalysableStatement {
+    pub root: pgt_query_ext::NodeEnum,
+    pub range: pgt_text_size::TextRange,
+}
+
+pub struct AnalyserParams<'a> {
+    pub stmts: Vec<AnalysableStatement>,
+    pub schema_cache: Option<&'a pgt_schema_cache::SchemaCache>,
 }
 
 pub struct AnalyserConfig<'a> {
@@ -52,17 +59,31 @@ impl<'a> Analyser<'a> {
         }
     }
 
-    pub fn run(&self, ctx: AnalyserContext) -> Vec<RuleDiagnostic> {
-        let params = RegistryRuleParams {
-            root: ctx.root,
-            options: self.options,
-        };
+    pub fn run(&self, params: AnalyserParams) -> Vec<RuleDiagnostic> {
+        let mut diagnostics = vec![];
+
+        let mut file_context = AnalysedFileContext::default();
+
+        for stmt in params.stmts {
+            let rule_params = RegistryRuleParams {
+                root: &stmt.root,
+                options: self.options,
+                analysed_file_context: &file_context,
+                schema_cache: params.schema_cache,
+            };
 
-        self.registry
-            .rules
-            .iter()
-            .flat_map(|rule| (rule.run)(&params))
-            .collect::<Vec<_>>()
+            diagnostics.extend(
+                self.registry
+                    .rules
+                    .iter()
+                    .flat_map(|rule| (rule.run)(&rule_params))
+                    .map(|r| r.span(stmt.range)),
+            );
+
+            file_context.update_from(&stmt.root);
+        }
+
+        diagnostics
     }
 }
 
@@ -77,9 +98,10 @@ mod tests {
         markup,
     };
     use pgt_diagnostics::PrintDiagnostic;
+    use pgt_text_size::TextRange;
     use termcolor::NoColor;
 
-    use crate::Analyser;
+    use crate::{AnalysableStatement, Analyser};
 
     #[ignore]
     #[test]
@@ -102,6 +124,7 @@ mod tests {
         };
 
         let ast = pgt_query_ext::parse(SQL).expect("failed to parse SQL");
+        let range = TextRange::new(0.into(), u32::try_from(SQL.len()).unwrap().into());
 
         let options = AnalyserOptions::default();
 
@@ -110,7 +133,10 @@ mod tests {
             filter,
         });
 
-        let results = analyser.run(crate::AnalyserContext { root: &ast });
+        let results = analyser.run(crate::AnalyserParams {
+            stmts: vec![AnalysableStatement { root: ast, range }],
+            schema_cache: None,
+        });
 
         println!("*******************");
         for result in &results {

crates/pgt_analyser/src/lib.rs

@@ -2,7 +2,7 @@ use core::slice;
 use std::{fmt::Write, fs::read_to_string, path::Path};
 
 use pgt_analyse::{AnalyserOptions, AnalysisFilter, RuleDiagnostic, RuleFilter};
-use pgt_analyser::{Analyser, AnalyserConfig, AnalyserContext};
+use pgt_analyser::{AnalysableStatement, Analyser, AnalyserConfig, AnalyserParams};
 use pgt_console::StdDisplay;
 use pgt_diagnostics::PrintDiagnostic;
 
@@ -32,7 +32,15 @@ fn rule_test(full_path: &'static str, _: &str, _: &str) {
         filter,
     });
 
-    let results = analyser.run(AnalyserContext { root: &ast });
+    let stmt = AnalysableStatement {
+        root: ast,
+        range: pgt_text_size::TextRange::new(0.into(), u32::try_from(query.len()).unwrap().into()),
+    };
+
+    let results = analyser.run(AnalyserParams {
+        stmts: vec![stmt],
+        schema_cache: None,
+    });
 
     let mut snapshot = String::new();
     write_snapshot(&mut snapshot, query.as_str(), results.as_slice());