feat: Use Oak to get more semantic information

Cargo.toml

@@ -15,6 +15,16 @@ air_fs = { package = "fs", git = "https://github.com/etiennebacher/air_pratt" }
 air_r_parser = { git = "https://github.com/etiennebacher/air_pratt" }
 air_r_syntax = { git = "https://github.com/etiennebacher/air_pratt" }
 air_workspace = { package = "workspace", git = "https://github.com/etiennebacher/air_pratt" }
+aether_path = { git = "https://github.com/etiennebacher/ark", branch = "bump-air-commit" }
+oak_core = { git = "https://github.com/etiennebacher/ark", branch = "bump-air-commit" }
+oak_db = { git = "https://github.com/etiennebacher/ark", branch = "bump-air-commit" }
+oak_ide = { git = "https://github.com/etiennebacher/ark", branch = "bump-air-commit" }
+oak_index_vec = { git = "https://github.com/etiennebacher/ark", branch = "bump-air-commit" }
+oak_package_metadata = { git = "https://github.com/etiennebacher/ark", branch = "bump-air-commit" }
+oak_scan = { git = "https://github.com/etiennebacher/ark", branch = "bump-air-commit" }
+oak_semantic = { git = "https://github.com/etiennebacher/ark", branch = "bump-air-commit" }
+salsa = "0.26.2"
+url = "2.5"
 anyhow = "1.0.94"
 biome_formatter = { git = "https://github.com/lionel-/biome", rev = "a1296ea6ba363d8b8d8f02181b2a4ce9315c5ef9" }
 biome_rowan = { git = "https://github.com/lionel-/biome", rev = "a1296ea6ba363d8b8d8f02181b2a4ce9315c5ef9" }
@@ -25,6 +35,7 @@ insta = { version = "1.47.2", features = ["yaml", "filters"] }
 etcetera = "0.11.0"
 jarl-core = { path = "crates/jarl-core" }
 jarl-lsp = { path = "crates/jarl-lsp" }
+jarl-semantic = { path = "crates/jarl-semantic" }
 path-absolutize = "3.1.1"
 rayon = "1.12.0"
 regex = { version = "1.11.1", default-features = false, features = ["std"] }
@@ -38,6 +49,13 @@ tempfile = "3.27.0"
 toml = "0.8.23"
 tracing = "0.1.41"
 
+# The oak crates (from the ark fork) declare their air dependencies against
+# posit-dev/air; redirect them to the same Pratt-parser fork used by jarl so a
+# single copy of the syntax/parser crates exists in the graph.
+[patch."https://github.com/posit-dev/air"]
+air_r_parser = { git = "https://github.com/etiennebacher/air_pratt" }
+air_r_syntax = { git = "https://github.com/etiennebacher/air_pratt" }
+
 [profile.release]
 lto = true
 

crates/jarl-core/Cargo.toml

@@ -23,6 +23,21 @@ air_fs.workspace = true
 biome_rowan.workspace = true
 biome_formatter.workspace = true
 
+# Semantic analysis (per-file scopes, definitions, uses, use-def map)
+aether_path.workspace = true
+oak_core.workspace = true
+oak_db.workspace = true
+oak_ide.workspace = true
+oak_index_vec.workspace = true
+oak_package_metadata.workspace = true
+oak_scan.workspace = true
+oak_semantic.workspace = true
+salsa.workspace = true
+url.workspace = true
+
+# Per-file semantic info (used by semantic-aware lints)
+jarl-semantic.workspace = true
+
 # Serialization and data structures
 serde.workspace = true
 toml.workspace = true

crates/jarl-core/src/analyze/document.rs

@@ -1,10 +1,12 @@
 use air_r_syntax::{RExpressionList, RSyntaxNode};
 use biome_rowan::{AstNode, AstNodeList};
+use oak_semantic::semantic_index::SemanticIndex;
 
 use crate::checker::Checker;
 use crate::diagnostic::*;
 use crate::lints::base::empty_file::empty_file::empty_file;
 use crate::lints::base::unreachable_code::unreachable_code::unreachable_code_top_level;
+use crate::lints::base::unused_object::unused_object::unused_object;
 use crate::lints::comments::blanket_suppression::blanket_suppression::blanket_suppression;
 use crate::lints::comments::invalid_chunk_suppression::invalid_chunk_suppression::invalid_chunk_suppression;
 use crate::lints::comments::misnamed_suppression::misnamed_suppression::misnamed_suppression;
@@ -15,14 +17,15 @@ use crate::lints::comments::unexplained_suppression::unexplained_suppression::un
 use crate::lints::comments::unmatched_range_suppression::unmatched_range_suppression::{
     unmatched_range_suppression_end, unmatched_range_suppression_start,
 };
+use crate::package::PackageFileAnalysis;
 use crate::rule_set::Rule;
 
 pub(crate) fn check_document(
     expressions: &RExpressionList,
     syntax: &RSyntaxNode,
     checker: &mut Checker,
-    duplicate_assignments: &[(String, biome_rowan::TextRange, String)],
-    unused_functions: &[(String, biome_rowan::TextRange, String)],
+    package: &PackageFileAnalysis,
+    semantic: Option<&SemanticIndex>,
 ) -> anyhow::Result<()> {
     // --- Document-level analysis ---
 
@@ -35,6 +38,13 @@ pub(crate) fn check_document(
         }
     }
 
+    // Check for unused local objects via the semantic index.
+    if checker.is_rule_enabled(Rule::UnusedObject)
+        && let Some(semantic) = semantic
+    {
+        unused_object(&expressions, semantic, &package.cross_file_used, checker)?;
+    }
+
     // --- Comment/suppression checks ---
 
     // Report blanket suppression comments (file-level, done once)
@@ -104,7 +114,7 @@ pub(crate) fn check_document(
     // Emit package-level diagnostics before suppression filtering so that
     // # jarl-ignore and # jarl-ignore-file comments can suppress them.
     if checker.is_rule_enabled(Rule::DuplicatedFunctionDefinition) {
-        for (name, range, help) in duplicate_assignments {
+        for (name, range, help) in &package.duplicate_assignments {
             checker.report_diagnostic(Some(Diagnostic::new(
                 ViolationData::new(
                     "duplicated_function_definition".to_string(),
@@ -118,7 +128,7 @@ pub(crate) fn check_document(
     }
 
     if checker.is_rule_enabled(Rule::UnusedFunction) {
-        for (name, range, help) in unused_functions {
+        for (name, range, help) in &package.unused_functions {
             checker.report_diagnostic(Some(Diagnostic::new(
                 ViolationData::new(
                     "unused_function".to_string(),

crates/jarl-core/src/check.rs

@@ -1,14 +1,14 @@
 use crate::error::ParseError;
 use crate::package::{
-    FilePackageInfo, FileScope, PackageAnalysis, PackageContext, make_package_analysis,
-    summarize_package_info,
+    FilePackageInfo, FileScope, PackageAnalysis, PackageContext, PackageFileAnalysis,
+    make_package_analysis, summarize_package_info,
 };
 use crate::roxygen::{extract_roxygen_examples, remap_roxygen_fix, remap_roxygen_range};
 use crate::suppression::SuppressionManager;
 use crate::vcs::check_version_control;
 use air_fs::relativize_path;
 use air_r_parser::RParserOptions;
-use air_r_syntax::{RExpressionList, RSyntaxNode};
+use air_r_syntax::RSyntaxNode;
 use anyhow::{Context, Result};
 use rayon::prelude::*;
 use std::collections::HashMap;
@@ -126,6 +126,8 @@ pub fn lint_only(
         &pkg,
         &pkg_contexts,
         &file_pkg_info,
+        // lint-only: on-disk contents match the cached index, so reuse it.
+        true,
     )
     .with_context(|| format!("Failed to get checks for file: {path}"))?;
 
@@ -164,6 +166,10 @@ pub fn lint_fix(
             &pkg,
             &pkg_contexts,
             &file_pkg_info,
+            // Fix mode rewrites the file between iterations, so the on-disk
+            // contents (and the index the pre-pass cached from them) drift from
+            // the in-memory `contents`; rebuild the index rather than reuse it.
+            false,
         )
         .with_context(|| format!("Failed to get checks for file: {path}",))?;
 
@@ -200,6 +206,7 @@ pub fn get_checks(
     pkg: &PackageAnalysis,
     pkg_contexts: &HashMap<PathBuf, PackageContext>,
     file_pkg_info: &HashMap<PathBuf, FilePackageInfo>,
+    use_cached_index: bool,
 ) -> Result<Vec<Diagnostic>> {
     if crate::fs::has_rmd_extension(file) {
         return get_checks_rmd(contents, file, config);
@@ -224,23 +231,48 @@ pub fn get_checks(
     checker.rule_set = effective_rules_for_file(config, file);
     checker.minimum_r_version = config.minimum_r_version;
 
+    // Build the semantic index for use-def-based rules. `source("path")`
+    // calls inject `DefinitionKind::Import` entries via JarlImportsResolver;
+    // the complementary "names read by sourced files" path is still handled
+    // inside `SemanticInfo`.
+    //
+    // When `unused_object` runs, the cross-file pre-pass already built this
+    // file's index (with the same resolver) and stored it in `pkg.file_indices`;
+    // reuse it rather than rebuilding. The pre-pass reads from disk, so the
+    // cache is only valid in lint-only mode — fix mode rewrites the file
+    // between passes, so it always rebuilds from the in-memory contents.
+    //
+    // Building (when not cached) happens here, in the parallel per-file pass,
+    // rather than via the shared `AnalysisDb`: oak's salsa database is `Send`
+    // but not `Sync`, so it can't be borrowed across rayon worker threads.
+    let owned_semantic;
+    let semantic: &oak_semantic::semantic_index::SemanticIndex = match use_cached_index
+        .then(|| pkg.file_indices.get(file))
+        .flatten()
+    {
+        Some(cached) => cached,
+        None => {
+            owned_semantic = oak_semantic::build_index(
+                &parsed.tree(),
+                jarl_semantic::JarlImportsResolver::new(file),
+            );
+            &owned_semantic
+        }
+    };
+    checker.file_path = file.to_path_buf();
+
     // Wire up package context for package-specific rules.
     get_package_info(
         &mut checker,
         file,
-        expressions,
+        semantic,
         config,
         pkg_contexts,
         file_pkg_info,
     );
 
     // Look up per-file data from PackageAnalysis
-    let duplicate_assignments = pkg
-        .duplicate_assignments
-        .get(file)
-        .cloned()
-        .unwrap_or_default();
-    let unused_functions = pkg.unused_functions.get(file).cloned().unwrap_or_default();
+    let package_file = PackageFileAnalysis::for_file(pkg, file);
 
     // We run checks at expression-level. This gathers all violations, no matter
     // whether they are suppressed or not. They are filtered out in the next
@@ -274,8 +306,8 @@ pub fn get_checks(
         expressions,
         syntax,
         &mut checker,
-        &duplicate_assignments,
-        &unused_functions,
+        &package_file,
+        Some(semantic),
     )?;
 
     // Some rules have a fix available in their implementation but do not have
@@ -335,11 +367,12 @@ pub fn get_checks(
 /// Populate package context on the checker from pre-computed data.
 ///
 /// For files inside an R package, copies the pre-computed `PackageContext`
-/// fields. For scripts, scans for `library()`/`require()` calls.
+/// fields. For scripts, harvests `library()`/`require()` calls from the
+/// semantic index.
 fn get_package_info(
     checker: &mut Checker,
     file: &Path,
-    expressions: &RExpressionList,
+    semantic: &oak_semantic::semantic_index::SemanticIndex,
     config: &Config,
     pkg_contexts: &HashMap<PathBuf, PackageContext>,
     file_pkg_info: &HashMap<PathBuf, FilePackageInfo>,
@@ -357,13 +390,38 @@ fn get_package_info(
                 .iter()
                 .map(|s| s.to_string())
                 .collect();
-            packages.extend(crate::library_calls::extract_library_calls(expressions));
+            packages.extend(top_level_attached_packages(semantic));
             checker.loaded_packages = packages;
         }
     }
     checker.package_cache = config.package_cache.clone();
 }
 
+/// Collect package names from top-level `library()`/`require()` calls in
+/// load order, deduplicated. Calls inside nested function bodies are
+/// excluded because their attachment isn't statically guaranteed; calls
+/// inside top-level `if`/loops are included because oak scopes them to the
+/// file (R sequential execution makes their effect visible to subsequent
+/// top-level code if the branch runs).
+fn top_level_attached_packages(
+    semantic: &oak_semantic::semantic_index::SemanticIndex,
+) -> Vec<String> {
+    use oak_semantic::semantic_index::SemanticCallKind;
+    let top_level = oak_semantic::ScopeId::from(0);
+    let mut out: Vec<String> = Vec::new();
+    for call in semantic.semantic_calls() {
+        if call.scope() != top_level {
+            continue;
+        }
+        if let SemanticCallKind::Attach { package } = call.kind()
+            && !out.iter().any(|p| p == package)
+        {
+            out.push(package.clone());
+        }
+    }
+    out
+}
+
 /// Lint R code inside roxygen `@examples` and `@examplesIf` sections.
 ///
 /// Each examples section is extracted, parsed as standalone R code, and linted.
@@ -403,7 +461,13 @@ fn get_checks_roxygen(
         // otherwise unnecessary here (no package-level analysis, no
         // suppression-related diagnostics to report).
         if has_suppressions {
-            check_document(expressions, &syntax, &mut checker, &[], &[])?;
+            check_document(
+                expressions,
+                &syntax,
+                &mut checker,
+                &PackageFileAnalysis::default(),
+                None,
+            )?;
         }
 
         for mut d in checker.diagnostics {
@@ -453,8 +517,14 @@ fn get_checks_rmd(contents: &str, file: &Path, config: &Config) -> Result<Vec<Di
     }
     // check_document runs suppression filtering internally, so
     // checker.diagnostics is the post-suppression list after this call.
-    // Rmd chunks don't participate in package-level analysis, so pass empty slices.
-    check_document(expressions, &syntax, &mut checker, &[], &[])?;
+    // Rmd chunks don't participate in package-level analysis.
+    check_document(
+        expressions,
+        &syntax,
+        &mut checker,
+        &PackageFileAnalysis::default(),
+        None,
+    )?;
 
     // Remap ranges from virtual-string offsets to original Rmd file offsets.
     let diagnostics: Vec<Diagnostic> = checker

crates/jarl-core/src/checker.rs

@@ -74,6 +74,10 @@ pub struct Checker {
     // `S3method()`, etc.).  Used to suppress false positives in rules
     // like `unused_object` — exported names are "used" by definition.
     pub namespace_exports: HashSet<String>,
+    // Path of the file being checked. Used by rules that need to resolve
+    // paths relative to the current file (e.g. `unused_object` resolving
+    // `source("...")` arguments).
+    pub file_path: std::path::PathBuf,
 }
 
 impl Checker {
@@ -91,6 +95,7 @@ impl Checker {
             package_cache: None,
             import_from: HashMap::new(),
             namespace_exports: HashSet::new(),
+            file_path: std::path::PathBuf::new(),
         }
     }