refactor: apply project refresh briefly and warm queries off-lock

Author: joshuadavidthomas

crates/djls-db/src/db.rs

@@ -570,6 +570,40 @@ mod invalidation_tests {
         );
     }
 
+    #[test]
+    fn tagspecs_settings_change_reports_semantic_change() {
+        let tempdir = tempdir().unwrap();
+        let root = Utf8PathBuf::from_path_buf(tempdir.path().to_path_buf()).unwrap();
+        std::fs::write(
+            root.join("djls.toml").as_std_path(),
+            r#"
+[tagspecs]
+version = "0.6.0"
+
+[[tagspecs.libraries]]
+module = "myapp.templatetags.custom"
+
+[[tagspecs.libraries.tags]]
+name = "switch"
+type = "block"
+"#,
+        )
+        .unwrap();
+
+        let mut db = DjangoDatabase::new(
+            Arc::new(InMemoryFileSystem::new()),
+            &Settings::default(),
+            Some(root.as_path()),
+        );
+        let settings = Settings::new(root.as_path(), None).unwrap();
+
+        let update = db.set_settings(settings);
+
+        assert!(!update.env_changed);
+        assert!(!update.diagnostics_changed);
+        assert!(update.semantic_changed);
+    }
+
     #[test]
     fn tagspecs_change_invalidates_compute_tag_specs() {
         let (mut db, event_log) = test_db_with_project();

crates/djls-db/src/settings.rs

@@ -11,6 +11,7 @@ use crate::db::DjangoDatabase;
 pub struct SettingsUpdate {
     pub env_changed: bool,
     pub diagnostics_changed: bool,
+    pub semantic_changed: bool,
 }
 
 impl DjangoDatabase {
@@ -37,29 +38,32 @@ impl DjangoDatabase {
         let previous = self.settings();
         *self.settings.lock().unwrap() = settings;
 
-        let diagnostics_changed = previous.diagnostics() != self.settings().diagnostics();
+        let current = self.settings();
+        let diagnostics_changed = previous.diagnostics() != current.diagnostics();
+        let semantic_changed = previous.tagspecs() != current.tagspecs();
 
         if self.project().is_some() {
-            let settings = self.settings();
-            let env_changed = self.update_project_from_settings(&settings);
+            let env_changed = self.update_project_from_settings(&current);
             return SettingsUpdate {
                 env_changed,
                 diagnostics_changed,
+                semantic_changed,
             };
         }
 
         SettingsUpdate {
             env_changed: false,
             diagnostics_changed,
+            semantic_changed,
         }
     }
 
     /// Update an existing project's fields from new settings, only calling
     /// Salsa setters when values actually change (Ruff/RA pattern).
     ///
     /// Returns `true` if environment-related fields changed (`interpreter`,
-    /// `django_settings_module`, `pythonpath`), indicating project data should
-    /// be refreshed.
+    /// `django_settings_module`, `pythonpath`, `env_vars`), indicating project
+    /// data should be refreshed by the caller.
     pub(crate) fn update_project_from_settings(&mut self, settings: &Settings) -> bool {
         let Some(project) = self.project() else {
             return false;
@@ -106,10 +110,6 @@ impl DjangoDatabase {
             project.set_tagspecs(self).to(new_tagspecs);
         }
 
-        if env_changed {
-            project.refresh_source_roots(self);
-        }
-
         env_changed
     }
 }

crates/djls-project/src/lib.rs

@@ -84,6 +84,8 @@ pub use symbols::TemplateLibraries;
 pub use symbols::TemplateLibrary;
 pub use symbols::TemplateSymbol;
 pub use symbols::TemplateSymbolKind;
+pub use sync::apply_refresh;
+pub use sync::compute_refresh;
 pub use sync::refresh_external_data;
 pub use templates::FindTemplateResult;
 pub use templates::ProjectTemplateFile;

crates/djls-project/src/project.rs

@@ -7,7 +7,6 @@ use djls_conf::TagSpecDef;
 use djls_source::File;
 use djls_source::FileSystem;
 use salsa::Durability;
-use salsa::Setter;
 
 use crate::db::Db as ProjectDb;
 use crate::names::ModulePath;
@@ -88,19 +87,6 @@ pub struct Project {
 }
 
 impl Project {
-    pub fn refresh_source_roots(self, db: &mut dyn ProjectDb) {
-        let search_paths = SearchPaths::from_project_settings(
-            db.file_system(),
-            self.root(db),
-            self.interpreter(db),
-            self.pythonpath(db),
-        );
-        search_paths.register_roots(db);
-        if self.search_paths(db) != &search_paths {
-            self.set_search_paths(db).to(search_paths);
-        }
-    }
-
     pub(crate) fn touch_search_path_roots(self, db: &dyn ProjectDb) {
         for search_path in self.search_paths(db).iter() {
             if let Some(root) = db.files().root(db, search_path.path()) {

crates/djls-project/src/sync.rs

@@ -4,9 +4,12 @@
 //! Django, Python, and the filesystem for facts, then writes changed facts to
 //! the `Project` input. Pure semantic derivation stays in tracked queries.
 
+use camino::Utf8PathBuf;
+use salsa::Setter;
+
 use crate::db::Db as ProjectDb;
 use crate::environment::templatetag_candidate_paths;
-use crate::project::Project;
+use crate::resolve::SearchPaths;
 use crate::resolve::model_modules;
 use crate::resolve::templatetag_modules;
 use crate::settings::settings_source_files;
@@ -18,33 +21,32 @@ use crate::settings::settings_source_files;
 /// into the `Project` input, then lets tracked semantic queries handle editor
 /// file contents and downstream derivations.
 pub fn refresh_external_data(db: &mut dyn ProjectDb) {
-    let Some(project) = db.project() else {
+    let Some(refresh) = compute_refresh(db) else {
         return;
     };
-
-    project.refresh_source_roots(db);
-    refresh_python_modules(db, project);
+    apply_refresh(db, refresh);
 }
 
-fn refresh_python_modules(db: &mut dyn ProjectDb, project: Project) {
-    // The LSP currently has no watched-file stream for dependency roots. Treat
-    // an explicit refresh as the freshness boundary for module discovery and
-    // currently discovered Python files.
-    let roots: Vec<_> = project
-        .search_paths(db)
-        .iter()
-        .filter_map(|search_path| db.files().root(db, search_path.path()))
-        .collect();
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RefreshData {
+    search_paths: SearchPaths,
+    file_paths: Vec<Utf8PathBuf>,
+}
 
-    for root in roots {
-        db.bump_file_root_revision(root);
-    }
+pub fn compute_refresh(db: &dyn ProjectDb) -> Option<RefreshData> {
+    let project = db.project()?;
+    let search_paths = SearchPaths::from_project_settings(
+        db.file_system(),
+        project.root(db),
+        project.interpreter(db),
+        project.pythonpath(db),
+    );
 
-    for file in settings_source_files(db, project) {
-        db.bump_file_revision(file);
-    }
+    let mut file_paths: Vec<_> = settings_source_files(db, project)
+        .into_iter()
+        .map(|file| file.path(db).to_path_buf())
+        .collect();
 
-    let mut file_paths = Vec::new();
     file_paths.extend(
         model_modules(db, project)
             .iter()
@@ -61,6 +63,39 @@ fn refresh_python_modules(db: &mut dyn ProjectDb, project: Project) {
     file_paths.sort();
     file_paths.dedup();
 
+    Some(RefreshData {
+        search_paths,
+        file_paths,
+    })
+}
+
+pub fn apply_refresh(db: &mut dyn ProjectDb, refresh: RefreshData) {
+    let Some(project) = db.project() else {
+        return;
+    };
+    let RefreshData {
+        search_paths,
+        file_paths,
+    } = refresh;
+
+    search_paths.register_roots(db);
+    if project.search_paths(db) != &search_paths {
+        project.set_search_paths(db).to(search_paths);
+    }
+
+    // The LSP currently has no watched-file stream for dependency roots. Treat
+    // an explicit refresh as the freshness boundary for module discovery and
+    // currently discovered Python files.
+    let roots: Vec<_> = project
+        .search_paths(db)
+        .iter()
+        .filter_map(|search_path| db.files().root(db, search_path.path()))
+        .collect();
+
+    for root in roots {
+        db.bump_file_root_revision(root);
+    }
+
     for path in file_paths {
         let file = db.get_or_create_file(&path);
         db.bump_file_revision(file);

crates/djls-project/tests/resolve.rs

@@ -693,6 +693,37 @@ fn refresh_external_data_discovers_site_packages_created_after_bootstrap() {
     assert!(graph.get("VenvArticle").is_some());
 }
 
+#[test]
+fn compute_and_apply_refresh_discovers_site_packages_created_after_bootstrap() {
+    let mut db = TestDatabase::new();
+    let search_paths = SearchPaths::from_project_settings(
+        db.file_system(),
+        Utf8Path::new("/project"),
+        &Interpreter::Auto,
+        &[],
+    );
+    search_paths.register_roots(&db);
+    let project = ProjectFixture::new("/project")
+        .search_paths(search_paths)
+        .interpreter(Interpreter::Auto)
+        .register_roots(false)
+        .install(&mut db);
+
+    db.add_file(
+        "/project/.venv/lib/python3.12/site-packages/blog/models.py",
+        "from django.db import models\nclass VenvArticle(models.Model):\n    pass\n",
+    );
+
+    let refresh = compute_refresh(&db).expect("project should be configured");
+    apply_refresh(&mut db, refresh);
+
+    assert!(project.search_paths(&db).iter().any(|search_path| {
+        search_path.path() == Utf8Path::new("/project/.venv/lib/python3.12/site-packages")
+    }));
+    let graph = compute_model_graph(&db, project);
+    assert!(graph.get("VenvArticle").is_some());
+}
+
 #[test]
 fn discover_external_model_files_finds_models() {
     let tmp = tempfile::TempDir::new().unwrap();