Use new scope_is_eager() function from rebase

Author: lionel-

crates/oak_db/src/file_imports.rs

@@ -283,7 +283,10 @@ impl File {
         let (collation, attaches) = if index.scope_is_eager(cursor_scope) {
             (CollationView::Eager, AttachView::Eager(offset))
         } else {
-            (CollationView::Lazy, AttachView::Lazy(offset))
+            (CollationView::Lazy, AttachView::Lazy {
+                offset,
+                scope_id: cursor_scope,
+            })
         };
 
         let own = self.attach_layers(db, attaches);

crates/oak_db/src/file_resolve.rs

@@ -105,15 +105,14 @@ impl<'db> File {
         }
 
         // Nothing local reaches the use, so resolve across files.
-        let file_scope = ScopeId::from(0);
-        if use_scope != file_scope {
-            // Function body: the lazy / end-of-file view the body sees at run time.
+        if !index.scope_is_eager(use_scope) {
+            // Lazy body: the end-of-file view it sees when it actually runs.
             return self.resolve(db, name);
         }
 
-        // Top level: collation predecessors / other visible files (exports-only
-        // chase, same as `resolve`'s per-context walk). Avoids the sibling
-        // cycle and matches R's namespace semantics.
+        // Eager scope: collation predecessors / other visible files
+        // (exports-only chase, same as `resolve`'s per-context walk). Avoids
+        // the sibling cycle and matches R's namespace semantics.
         resolve_per_sourcing_file(db, &self.imports_by_sourcing_file_at(db, offset), name)
     }
 

crates/oak_db/src/tests/file_resolve_at.rs

@@ -590,6 +590,44 @@ fn test_conditional_library_resolves_only_inside_its_branch() {
     assert!(script.resolve_at(&db, after).is_empty());
 }
 
+#[test]
+fn test_local_block_does_not_see_a_library_call_after_it() {
+    // `local()` runs at its call site, so a cursor inside it sees the search
+    // path as of that point: `library(mypkg)` hasn't run yet, so `foo` isn't
+    // attached.
+    let mut db = TestDb::new();
+    install_library_package(&mut db, "mypkg", &["foo"], &[(
+        "library/mypkg/R/a.R",
+        "foo <- function() 42\n",
+    )]);
+
+    let (_ws_root, files) = setup_workspace_scripts(&mut db, "ws", &[(
+        "ws/script.R",
+        "local({\n  foo\n})\nlibrary(mypkg)\n",
+    )]);
+    let script = files[0];
+    let source = script.source_text(&db).clone();
+
+    let offset = TextSize::from(source.find("  foo").unwrap() as u32 + 2);
+    assert!(script.resolve_at(&db, offset).is_empty());
+}
+
+#[test]
+fn test_local_block_sees_a_file_scope_binding_before_it() {
+    // A binding made before the block is already in place by the time
+    // `local()` runs, same as for a use at file scope.
+    let mut db = TestDb::new();
+    let source = "x <- 1\nlocal({\n  x\n})\n";
+    let file = make_file(&mut db, "a.R", source);
+
+    let offset = TextSize::from(source.rfind('x').unwrap() as u32);
+    let def = resolve_one(&db, file, offset);
+
+    assert_eq!(def.file(&db), file);
+    let range = def.name_range(&db).expect("local has a name range");
+    assert_eq!(usize::from(range.start()), 0);
+}
+
 /// A workspace holding `main.R`, which sources `helpers.R`, plus whatever else
 /// the caller lists. Returns the files in the given order.
 fn setup_sourced(db: &mut TestDb, files: &[(&str, &str)]) -> Vec<File> {

crates/oak_semantic/src/builder.rs

@@ -294,6 +294,20 @@ impl<R: ImportsResolver> SemanticIndexBuilder<R> {
         Some(scope)
     }
 
+    /// The scan unit that controls when code in `scope` runs: that scope itself
+    /// when lazy, otherwise its nearest lazy ancestor. `None` means the code
+    /// runs while the file loads.
+    ///
+    /// Mid-build twin of [`SemanticIndex::enclosing_lazy_scope`], reading the
+    /// arena the walk is still filling in.
+    fn enclosing_lazy_scope(&self, scope: ScopeId) -> Option<ScopeId> {
+        let mut current = scope;
+        while !self.scopes[current].kind.is_lazy() {
+            current = self.scopes[current].parent?;
+        }
+        Some(current)
+    }
+
     /// Whether `scope` binds `name` anywhere, regardless of flow position: an
     /// already-recorded `IS_BOUND` definition or a pre-scanned assignment. The
     /// pre-scan covers definitions the walk hasn't reached yet in this scope.

crates/oak_semantic/src/builder/walk.rs

@@ -39,7 +39,6 @@ use crate::effects::ResolvedArgumentEffect;
 use crate::effects::ResolvedArgumentEffects;
 use crate::effects::TargetAccess;
 use crate::resolver::ImportsResolver;
-use crate::semantic_index::scope_is_top_level;
 use crate::semantic_index::AttachRegion;
 use crate::semantic_index::Definition;
 use crate::semantic_index::DefinitionKind;
@@ -563,7 +562,7 @@ impl<R: ImportsResolver> SemanticIndexBuilder<R> {
         // run, or might run after the rest of this file, so we record
         // nothing there and let the sourced file fall back to whole-file
         // exports.
-        if scope_is_top_level(&self.scopes, self.current_scope) {
+        if self.enclosing_lazy_scope(self.current_scope).is_none() {
             let file_scope = ScopeId::from(0);
             let symbols = &self.walk.symbol_tables[file_scope];
             let visible = self.walk.use_def_maps[file_scope].bound_names(symbols);

crates/oak_semantic/src/semantic_index.rs

@@ -229,7 +229,8 @@ impl SemanticIndex {
     }
 
     /// Whether `scope` runs during the file's own top-level execution, i.e. no
-    /// enclosing scope is lazy.
+    /// enclosing scope is lazy. Wider than "is the file scope", since a
+    /// `local()` or `test_that()` body runs at its call site.
     pub fn scope_is_eager(&self, scope_id: ScopeId) -> bool {
         self.enclosing_lazy_scope(scope_id).is_none()
     }
@@ -262,15 +263,6 @@ impl SemanticIndex {
         &self.diagnostics
     }
 
-    /// Whether code in `scope` runs during a top-level evaluation of the file.
-    ///
-    /// Wider than "is the file scope": an eager scope like `local()` or
-    /// `test_that()` body runs at its call site. A single lazy scope anywhere
-    /// in the parent chain of `scope` makes it lazy.
-    pub fn is_top_level(&self, scope: ScopeId) -> bool {
-        scope_is_top_level(&self.scopes, scope)
-    }
-
     /// The file-scope names bound by the time the `source()` call at `offset`
     /// runs, or `None` if that call sits in a lazy context (a function body),
     /// where nothing pins down when it runs.
@@ -449,25 +441,6 @@ impl SemanticIndex {
     }
 }
 
-/// Whether `scope` runs during a top-level evaluation of the file: no scope
-/// from `scope` out to the file root is lazy.
-///
-/// Shared by [`SemanticIndex::is_top_level`] (post-build) and the builder,
-/// which needs the same walk over its own scope arena mid-build to decide
-/// whether a `source()` call runs at load time.
-pub(crate) fn scope_is_top_level(scopes: &IndexVec<ScopeId, Scope>, scope: ScopeId) -> bool {
-    let mut current = scope;
-    loop {
-        if scopes[current].kind.is_lazy() {
-            return false;
-        }
-        match scopes[current].parent {
-            Some(parent) => current = parent,
-            None => return true,
-        }
-    }
-}
-
 /// Key for looking up an enclosing snapshot. Keyed by the nested scope and the
 /// `UseId` of the free variable in that scope, so consumers do an O(1) lookup
 /// straight from a use without re-walking the ancestor chain.