jj-lib=0.41.0

Author: gulbanana

Cargo.lock

@@ -45,7 +45,7 @@ tauri-build = { version = "2.0.0", features = ["config-toml"] }
 [dev-dependencies]
 assert_matches = "1.5"
 http-body-util = "0.1.3"
-tempfile = "3.26"
+tempfile = "3.27"
 tower = "0.5.2"
 zip = "6.0"
 
@@ -63,8 +63,8 @@ tauri-plugin-shell = "2.0.0"
 tauri-plugin-window-state = "2.0.0"
 tauri-plugin-log = "2.0.0"
 
-jj-lib = { version = "0.39.0", features = ["watchman"] }
-jj-cli = "0.39.0"
+jj-lib = { version = "0.41.0", features = ["watchman"] }
+jj-cli = "0.41.0"
 
 # deps shared with JJ, which we try to keep on the same version
 anyhow = "1.0.100"
@@ -78,18 +78,18 @@ config = { version = "0.13.4", default-features = false, features = ["toml"] }
 etcetera = "0.11.0"
 dunce = "1.0.5"
 itertools = "0.14"
-indexmap = "2.13"
-gix = { version = "0.80.0", default-features = false, features = [
+indexmap = "2.14"
+gix = { version = "0.83.0", default-features = false, features = [
     "index",
     "max-performance-safe",
     "blob-diff",
 ] }
 async-trait = "0.1.89"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.149"
-tempfile = "3.26"
-tokio = { version = "1.49.0", features = ["io-util"] }
-toml_edit = { version = "0.24", features = ["serde"] }
+tempfile = "3.27"
+tokio = { version = "1.52.0", features = ["io-util"] }
+toml_edit = { version = "0.25", features = ["serde"] }
 thiserror = "2.0.18"
 
 # deps used by JJ but with different features
@@ -98,6 +98,7 @@ chrono = { version = "0.4.44", features = ["serde"] }
 # extra deps not used by JJ
 log = "0.4"
 futures-util = "0.3.31"
+pollster = "0.4.0"
 humantime = "2"
 ts-rs = { version = "7.1.1", features = ["chrono-impl"], optional = true }
 axum = "0.8.8"

Cargo.toml

@@ -12,6 +12,7 @@ use std::{
 
 use anyhow::{Context, Error, Result, anyhow};
 use chrono::TimeZone;
+use futures_util::TryStreamExt;
 use itertools::Itertools;
 use jj_cli::{
     cli_util::{default_ignored_remote_name, short_operation_hash},
@@ -38,7 +39,7 @@ use jj_lib::{
     repo_path::{RepoPath, RepoPathUiConverter},
     revset::{
         self, Revset, RevsetAliasesMap, RevsetDiagnostics, RevsetEvaluationError, RevsetExpression,
-        RevsetExtensions, RevsetIteratorExt, RevsetParseContext, RevsetResolutionError,
+        RevsetExtensions, RevsetParseContext, RevsetResolutionError, RevsetStreamExt,
         RevsetWorkspaceContext, SymbolResolverExtension, UserRevsetExpression,
     },
     rewrite,
@@ -49,6 +50,7 @@ use jj_lib::{
     workspace::{self, DefaultWorkspaceLoaderFactory, Workspace, WorkspaceLoaderFactory},
     workspace_store::{SimpleWorkspaceStore, WorkspaceStore as _},
 };
+use pollster::FutureExt as _;
 use thiserror::Error;
 
 use super::{WorkerSession, git_util::get_git_remote_names};
@@ -276,7 +278,7 @@ impl WorkspaceSession<'_> {
         let repo_path = self.workspace.repo_path().to_owned();
         let is_colocated = self.is_colocated;
 
-        let mut locked_ws = self.workspace.start_working_copy_mutation()?;
+        let mut locked_ws = self.workspace.start_working_copy_mutation().await?;
 
         locked_ws.locked_wc().rename_workspace(new_name.clone());
         tx.repo_mut()
@@ -299,7 +301,9 @@ impl WorkspaceSession<'_> {
             ))
             .await?,
         );
-        locked_ws.finish(self.operation.repo.op_id().clone())?;
+        locked_ws
+            .finish(self.operation.repo.op_id().clone())
+            .await?;
 
         Ok(Some(self.format_status()))
     }
@@ -407,13 +411,12 @@ impl WorkspaceSession<'_> {
         &'op self,
         revset: T,
     ) -> Result<Option<Commit>, RevsetError> {
-        let mut iter = revset
-            .as_ref()
-            .iter()
-            .commits(self.operation.repo.store())
-            .fuse();
-        match (iter.next(), iter.next()) {
-            (Some(commit), None) => Ok(Some(commit?)),
+        let store = self.operation.repo.store();
+        let mut stream = revset.as_ref().stream().commits(store);
+        let first = stream.try_next().block_on()?;
+        let second = stream.try_next().block_on()?;
+        match (first, second) {
+            (Some(commit), None) => Ok(Some(commit)),
             (None, _) => Ok(None),
             (Some(_), Some(_)) => Err(RevsetError::Other(anyhow!(
                 r#"Revset "{:?}" resolved to more than one revision"#,
@@ -452,23 +455,18 @@ impl WorkspaceSession<'_> {
             Err(err) => return Err(err),
         };
 
-        let mut change_iter = change_revset
-            .as_ref()
-            .iter()
-            .commits(self.operation.repo.store())
-            .fuse();
-        match (change_iter.next(), change_iter.next()) {
-            (Some(commit), None) => Ok(Some(commit?)),
+        let store = self.operation.repo.store();
+        let mut change_stream = change_revset.as_ref().stream().commits(store);
+        let first = change_stream.try_next().block_on()?;
+        let second = change_stream.try_next().block_on()?;
+        match (first, second) {
+            (Some(commit), None) => Ok(Some(commit)),
             (None, _) => Ok(None),
             (Some(_), Some(_)) => {
                 let commit_revset = self.evaluate_revset_commits(slice::from_ref(&id.commit))?;
-                let mut commit_iter = commit_revset
-                    .as_ref()
-                    .iter()
-                    .commits(self.operation.repo.store())
-                    .fuse();
-                match commit_iter.next() {
-                    Some(commit) => Ok(Some(commit?)),
+                let mut commit_stream = commit_revset.as_ref().stream().commits(store);
+                match commit_stream.try_next().block_on()? {
+                    Some(commit) => Ok(Some(commit)),
                     None => Ok(None),
                 }
             }
@@ -507,13 +505,12 @@ impl WorkspaceSession<'_> {
     pub(crate) fn resolve_change_id(&self, id: &RevId) -> Result<Commit, RevsetError> {
         let id_str = Self::format_id_str(id);
         let revset = self.evaluate_revset_str(&id_str)?;
-        let mut iter = revset
-            .as_ref()
-            .iter()
-            .commits(self.operation.repo.store())
-            .fuse();
-        let optional_change = match (iter.next(), iter.next()) {
-            (Some(commit), None) => Some(commit?),
+        let store = self.operation.repo.store();
+        let mut stream = revset.as_ref().stream().commits(store);
+        let first = stream.try_next().block_on()?;
+        let second = stream.try_next().block_on()?;
+        let optional_change = match (first, second) {
+            (Some(commit), None) => Some(commit),
             (None, _) => None,
             (Some(_), Some(_)) => Some(self.resolve_commit_id(&id.commit)?),
         };
@@ -578,11 +575,14 @@ impl WorkspaceSession<'_> {
         &'op self,
         revset: T,
     ) -> Result<Vec<Commit>, RevsetError> {
-        let commits = revset
+        let store = self.operation.repo.store();
+        let commits: Vec<Commit> = revset
             .as_ref()
-            .iter()
-            .commits(self.operation.repo.store())
-            .collect::<Result<Vec<Commit>, RevsetEvaluationError>>()?;
+            .stream()
+            .commits(store)
+            .try_collect()
+            .block_on()
+            .map_err(RevsetError::from)?;
         Ok(commits)
     }
 
@@ -850,9 +850,7 @@ impl WorkspaceSession<'_> {
         let intersection_revset = check_revset.intersection(&immutable_revset);
 
         let immutable_revs = self.evaluate_revset_expr(repo, intersection_revset)?;
-        let first = immutable_revs.iter().next();
-
-        Ok(first.is_some())
+        Ok(!immutable_revs.is_empty())
     }
 
     /// checks if any commit in an iterator is immutable
@@ -866,8 +864,9 @@ impl WorkspaceSession<'_> {
     pub(crate) fn check_immutable_revset(&self, revset: &dyn Revset) -> Result<bool> {
         let immutable_revset = self.evaluate_immutable()?;
         let contains = immutable_revset.containing_fn();
-        for id in revset.iter() {
-            if contains(&id?)? {
+        let mut stream = revset.stream();
+        while let Some(id) = stream.try_next().block_on()? {
+            if contains(&id)? {
                 return Ok(true);
             }
         }
@@ -946,7 +945,7 @@ impl WorkspaceSession<'_> {
             .transpose()?;
         if self.is_colocated {
             if let Some(wc_commit) = &maybe_new_wc_commit {
-                git::reset_head(tx.repo_mut(), wc_commit)?;
+                git::reset_head(tx.repo_mut(), wc_commit).await?;
             }
             git::export_refs(tx.repo_mut())?;
         }
@@ -1008,13 +1007,15 @@ impl WorkspaceSession<'_> {
             .base_ignores(self.workspace.workspace_root())?;
 
         // Compare working-copy tree and operation with repo's, and reload as needed.
-        let mut locked_ws = self.workspace.start_working_copy_mutation()?;
+        let mut locked_ws = self.workspace.start_working_copy_mutation().await?;
         let old_op_id = locked_ws.locked_wc().old_operation_id().clone();
         let (repo, wc_commit) = match WorkingCopyFreshness::check_stale(
             locked_ws.locked_wc(),
             &wc_commit,
             &repo,
-        )? {
+        )
+        .await?
+        {
             WorkingCopyFreshness::Fresh => (repo, wc_commit),
             WorkingCopyFreshness::Updated(wc_operation) => {
                 let repo = repo.reload_at(&wc_operation).await?;
@@ -1053,7 +1054,7 @@ impl WorkspaceSession<'_> {
                 self.workspace
                     .check_out(repo.op_id().clone(), old_tree.as_ref(), &new_wc_commit)
                     .await?;
-                locked_ws = self.workspace.start_working_copy_mutation()?;
+                locked_ws = self.workspace.start_working_copy_mutation().await?;
 
                 (repo, new_wc_commit)
             }
@@ -1110,7 +1111,9 @@ impl WorkspaceSession<'_> {
             );
         }
 
-        locked_ws.finish(self.operation.repo.op_id().clone())?;
+        locked_ws
+            .finish(self.operation.repo.op_id().clone())
+            .await?;
 
         Ok(did_anything)
     }
@@ -1134,16 +1137,18 @@ impl WorkspaceSession<'_> {
                         .await?,
                 )
             } else {
-                let locked_ws = self.workspace.start_working_copy_mutation()?;
-                locked_ws.finish(self.operation.repo.op_id().clone())?;
+                let locked_ws = self.workspace.start_working_copy_mutation().await?;
+                locked_ws
+                    .finish(self.operation.repo.op_id().clone())
+                    .await?;
                 None
             },
         )
     }
 
     async fn import_git_head(&mut self) -> Result<()> {
         let mut tx = self.operation.repo.start_transaction();
-        git::import_head(tx.repo_mut())?;
+        git::import_head(tx.repo_mut()).await?;
         if !tx.repo().has_changes() {
             return Ok(());
         }
@@ -1164,7 +1169,7 @@ impl WorkspaceSession<'_> {
                 .check_out(workspace_name.clone(), &new_git_head_commit)
                 .await?;
 
-            let mut locked_ws = self.workspace.start_working_copy_mutation()?;
+            let mut locked_ws = self.workspace.start_working_copy_mutation().await?;
 
             locked_ws.locked_wc().reset(&new_git_head_commit).await?;
             tx.repo_mut().rebase_descendants().await?;
@@ -1175,7 +1180,9 @@ impl WorkspaceSession<'_> {
                 tx.commit("import git head").await?,
             );
 
-            locked_ws.finish(self.operation.repo.op_id().clone())?;
+            locked_ws
+                .finish(self.operation.repo.op_id().clone())
+                .await?;
         } else {
             self.finish_transaction(tx, "import git head").await?;
         }
@@ -1189,6 +1196,7 @@ impl WorkspaceSession<'_> {
             .map_err(|e| Error::new(e.error))?;
         let mut tx = self.operation.repo.start_transaction();
         let stats = git::import_refs(tx.repo_mut(), &import_options)
+            .await
             .context("automated import failed despite reserved remote name")?;
         if !tx.repo().has_changes() {
             return Ok(());
@@ -1319,14 +1327,16 @@ impl OperationData {
             if let Some(excludes_file_path) =
                 get_excludes_file_path(git_repo.config_snapshot().plumbing())
             {
-                git_ignores = git_ignores.chain_with_file("", excludes_file_path)?;
+                git_ignores = git_ignores.chain_with_file(RepoPath::root(), excludes_file_path)?;
             }
-            git_ignores = git_ignores
-                .chain_with_file("", git_backend.git_repo_path().join("info").join("exclude"))?;
+            git_ignores = git_ignores.chain_with_file(
+                RepoPath::root(),
+                git_backend.git_repo_path().join("info").join("exclude"),
+            )?;
         } else if let Ok(git_config) = gix::config::File::from_globals()
             && let Some(excludes_file_path) = get_excludes_file_path(&git_config)
         {
-            git_ignores = git_ignores.chain_with_file("", excludes_file_path)?;
+            git_ignores = git_ignores.chain_with_file(RepoPath::root(), excludes_file_path)?;
         }
         Ok(git_ignores)
     }

src/worker/gui_util.rs

@@ -234,7 +234,6 @@ impl WorkerSession {
                 source_url,
                 None, // push_url = fetch_url
                 gix::remote::fetch::Tags::Included,
-                &StringExpression::all(),
             )
             .context("add_remote(origin)")?;
             tx.commit("add git remote origin").await?;
@@ -277,7 +276,7 @@ impl WorkerSession {
                     .fetch(remote_name, refspecs, cb, None, None)
                     .context("Failed to fetch from remote")?;
 
-                fetcher.import_refs().context("Failed to import refs")?;
+                pollster::block_on(fetcher.import_refs()).context("Failed to import refs")?;
 
                 // find HEAD if at all possible
                 let workspace_name = workspace.workspace_name().to_owned();