operation: convert parents to async function

bnjmnt4n · bnjmnt4n · commit 84a317a457b1 · 2026-03-20T00:04:38.000+08:00
diff --git a/cli/src/commands/operation/abandon.rs b/cli/src/commands/operation/abandon.rs
@@ -81,7 +81,7 @@ pub async fn cmd_op_abandon(
             (root_op, head_ops)
         } else {
             let op = resolve_op(&args.operation).await?;
-            let parent_ops: Vec<_> = op.parents().try_collect()?;
+            let parent_ops: Vec<_> = op.parents().await?;
             let parent_op = match parent_ops.len() {
                 0 => return Err(user_error("Cannot abandon the root operation")),
                 1 => parent_ops.into_iter().next().unwrap(),
diff --git a/cli/src/commands/operation/diff.rs b/cli/src/commands/operation/diff.rs
@@ -101,7 +101,7 @@ pub async fn cmd_op_diff(
         to_op = workspace_command.resolve_single_op(args.to.as_deref().unwrap_or("@"))?;
     } else {
         to_op = workspace_command.resolve_single_op(args.operation.as_deref().unwrap_or("@"))?;
-        from_ops = to_op.parents().try_collect()?;
+        from_ops = to_op.parents().await?;
     }
     let graph_style = GraphStyle::from_settings(settings)?;
     let with_content_format = LogContentFormat::new(ui, settings)?;
diff --git a/cli/src/commands/operation/log.rs b/cli/src/commands/operation/log.rs
@@ -18,7 +18,6 @@ use clap_complete::ArgValueCandidates;
 use futures::StreamExt as _;
 use futures::stream;
 use futures::stream::BoxStream;
-use itertools::Itertools as _;
 use jj_lib::graph::GraphEdge;
 use jj_lib::graph::reverse_graph;
 use jj_lib::op_store::OpStoreError;
@@ -160,7 +159,7 @@ async fn do_op_log(
                                formatter: &mut dyn Formatter,
                                op: &Operation,
                                with_content_format: &LogContentFormat| {
-            let parent_ops: Vec<_> = op.parents().try_collect()?;
+            let parent_ops: Vec<_> = op.parents().await?;
             let merged_parent_op = repo_loader
                 .merge_operations(parent_ops.clone(), None)
                 .await?;
diff --git a/cli/src/commands/operation/revert.rs b/cli/src/commands/operation/revert.rs
@@ -58,8 +58,8 @@ pub async fn cmd_op_revert(
 ) -> Result<(), CommandError> {
     let mut workspace_command = command.workspace_helper(ui)?;
     let bad_op = workspace_command.resolve_single_op(&args.operation)?;
-    let parent_of_bad_op = match bad_op.parents().at_most_one() {
-        Ok(Some(parent_of_bad_op)) => parent_of_bad_op?,
+    let parent_of_bad_op = match bad_op.parents().await?.into_iter().at_most_one() {
+        Ok(Some(parent_of_bad_op)) => parent_of_bad_op,
         Ok(None) => return Err(user_error("Cannot revert root operation")),
         Err(_) => return Err(user_error("Cannot revert a merge operation")),
     };
diff --git a/cli/src/commands/operation/show.rs b/cli/src/commands/operation/show.rs
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 use clap_complete::ArgValueCandidates;
-use itertools::Itertools as _;
 use jj_lib::operation::Operation;
 
 use super::diff::show_op_diff;
@@ -81,7 +80,7 @@ pub async fn cmd_op_show(
     let repo_loader = workspace_command.workspace().repo_loader();
     let settings = workspace_command.settings();
     let op = workspace_command.resolve_single_op(&args.operation)?;
-    let parent_ops: Vec<_> = op.parents().try_collect()?;
+    let parent_ops: Vec<_> = op.parents().await?;
     let merged_parent_op = repo_loader
         .merge_operations(parent_ops.clone(), None)
         .await?;
diff --git a/cli/src/commands/redo.rs b/cli/src/commands/redo.rs
@@ -121,8 +121,15 @@ pub async fn cmd_redo(
         return Err(user_error("Nothing to redo"));
     }
 
-    let mut op_to_restore = match op_to_redo.parents().at_most_one().ok().flatten() {
-        Some(parent_of_op_to_redo) => parent_of_op_to_redo?,
+    let mut op_to_restore = match op_to_redo
+        .parents()
+        .await?
+        .into_iter()
+        .at_most_one()
+        .ok()
+        .flatten()
+    {
+        Some(parent_of_op_to_redo) => parent_of_op_to_redo,
         None => {
             return Err(internal_error("Undo operation should have a single parent"));
         }
diff --git a/cli/src/commands/undo.rs b/cli/src/commands/undo.rs
@@ -118,8 +118,8 @@ pub async fn cmd_undo(
         writeln!(ui.hint_default(), "To avoid this, run `jj redo` now.")?;
     }
 
-    let mut op_to_restore = match op_to_undo.parents().at_most_one() {
-        Ok(Some(parent_of_op_to_undo)) => parent_of_op_to_undo?,
+    let mut op_to_restore = match op_to_undo.parents().await?.into_iter().at_most_one() {
+        Ok(Some(parent_of_op_to_undo)) => parent_of_op_to_undo,
         Ok(None) => return Err(user_error("Cannot undo root operation")),
         Err(_) => {
             return Err(user_error("Cannot undo a merge operation")
diff --git a/cli/src/operation_templater.rs b/cli/src/operation_templater.rs
@@ -27,6 +27,7 @@ use jj_lib::op_store::OperationId;
 use jj_lib::operation::Operation;
 use jj_lib::repo::RepoLoader;
 use jj_lib::settings::UserSettings;
+use pollster::FutureExt;
 
 use crate::template_builder;
 use crate::template_builder::BuildContext;
@@ -577,7 +578,7 @@ where
         |_language, _diagnostics, _build_ctx, self_property, function| {
             function.expect_no_arguments()?;
             let out_property = self_property.and_then(|op| {
-                let ops: Vec<_> = op.parents().try_collect()?;
+                let ops: Vec<_> = op.parents().block_on()?;
                 Ok(ops)
             });
             Ok(out_property.into_dyn_wrapped())
diff --git a/lib/src/op_heads_store.rs b/lib/src/op_heads_store.rs
@@ -22,6 +22,7 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use futures::future::try_join_all;
 use itertools::Itertools as _;
+use pollster::FutureExt as _;
 use thiserror::Error;
 
 use crate::dag_walk;
@@ -138,7 +139,10 @@ where
     let filtered_op_heads = dag_walk::heads_ok(
         op_heads.into_iter().map(Ok),
         |op: &Operation| op.id().clone(),
-        |op: &Operation| op.parents().collect_vec(),
+        |op: &Operation| match op.parents().block_on() {
+            Ok(parents) => parents.into_iter().map(Ok).collect_vec(),
+            Err(err) => vec![Err(err)],
+        },
     )?;
     let op_head_ids_after: HashSet<_> =
         filtered_op_heads.iter().map(|op| op.id().clone()).collect();
diff --git a/lib/src/op_walk.rs b/lib/src/op_walk.rs
@@ -27,6 +27,7 @@ use futures::future::ready;
 use futures::future::try_join_all;
 use futures::stream;
 use itertools::Itertools as _;
+use pollster::FutureExt as _;
 use thiserror::Error;
 
 use crate::dag_walk;
@@ -161,7 +162,7 @@ async fn resolve_single_op(
     }?;
     for (i, c) in op_postfix.chars().enumerate() {
         let mut neighbor_ops = match c {
-            '-' => operation.parents().try_collect()?,
+            '-' => operation.parents().await?,
             '+' => find_child_ops(head_ops.as_ref().unwrap(), operation.id()).await?,
             _ => unreachable!(),
         };
@@ -276,7 +277,13 @@ pub fn walk_ancestors(
     stream::iter(dag_walk::topo_order_reverse_lazy_ok(
         head_ops.into_iter().map(Ok),
         |OperationByEndTime(op)| op.id().clone(),
-        |OperationByEndTime(op)| op.parents().map_ok(OperationByEndTime).collect_vec(),
+        |OperationByEndTime(op)| match op.parents().block_on() {
+            Ok(parents) => parents
+                .into_iter()
+                .map(|parent| Ok(OperationByEndTime(parent)))
+                .collect_vec(),
+            Err(err) => vec![Err(err)],
+        },
         |_| panic!("graph has cycle"),
     ))
     .map_ok(|OperationByEndTime(op)| op)
@@ -306,7 +313,13 @@ pub fn walk_ancestors_range(
     let trailing_iter = dag_walk::topo_order_reverse_lazy_ok(
         start_ops.into_iter().map(Ok),
         |OperationByEndTime(op)| op.id().clone(),
-        |OperationByEndTime(op)| op.parents().map_ok(OperationByEndTime).collect_vec(),
+        |OperationByEndTime(op)| match op.parents().block_on() {
+            Ok(parents) => parents
+                .into_iter()
+                .map(|op| Ok(OperationByEndTime(op)))
+                .collect_vec(),
+            Err(err) => vec![Err(err)],
+        },
         |_| panic!("graph has cycle"),
     )
     .map_ok(|OperationByEndTime(op)| op);
@@ -320,7 +333,13 @@ fn collect_ancestors_until_roots(
     let sorted_ops = match dag_walk::topo_order_reverse_chunked(
         start_ops,
         |OperationByEndTime(op)| op.id().clone(),
-        |OperationByEndTime(op)| op.parents().map_ok(OperationByEndTime).collect_vec(),
+        |OperationByEndTime(op)| match op.parents().block_on() {
+            Ok(parents) => parents
+                .into_iter()
+                .map(|op| Ok(OperationByEndTime(op)))
+                .collect_vec(),
+            Err(err) => vec![Err(err)],
+        },
         |_| panic!("graph has cycle"),
     ) {
         Ok(sorted_ops) => sorted_ops,
diff --git a/lib/src/operation.rs b/lib/src/operation.rs
@@ -23,7 +23,7 @@ use std::hash::Hasher;
 use std::iter;
 use std::sync::Arc;
 
-use pollster::FutureExt as _;
+use futures::future::try_join_all;
 
 use crate::backend::CommitId;
 use crate::op_store;
@@ -106,12 +106,12 @@ impl Operation {
         &self.data.parents
     }
 
-    pub fn parents(&self) -> impl ExactSizeIterator<Item = OpStoreResult<Self>> {
-        let op_store = &self.op_store;
-        self.data.parents.iter().map(|parent_id| {
-            let data = op_store.read_operation(parent_id).block_on()?;
-            Ok(Self::new(op_store.clone(), parent_id.clone(), data))
-        })
+    pub async fn parents(&self) -> OpStoreResult<Vec<Self>> {
+        try_join_all(self.data.parents.iter().map(async |parent_id| {
+            let data = self.op_store.read_operation(parent_id).await?;
+            Ok(Self::new(self.op_store.clone(), parent_id.clone(), data))
+        }))
+        .await
     }
 
     pub async fn view(&self) -> OpStoreResult<View> {
diff --git a/lib/src/transaction.rs b/lib/src/transaction.rs
@@ -17,6 +17,7 @@
 use std::sync::Arc;
 
 use itertools::Itertools as _;
+use pollster::FutureExt as _;
 use thiserror::Error;
 
 use crate::backend::Timestamp;
@@ -99,7 +100,10 @@ impl Transaction {
             self.parent_ops.iter().cloned().map(Ok),
             [Ok(other_op.clone())],
             |op: &Operation| op.id().clone(),
-            |op: &Operation| op.parents().collect_vec(),
+            |op: &Operation| match op.parents().block_on() {
+                Ok(parents) => parents.into_iter().map(Ok).collect_vec(),
+                Err(err) => vec![Err(err)],
+            },
         )?
         .unwrap();
         let repo_loader = self.base_repo().loader();
diff --git a/lib/src/working_copy.rs b/lib/src/working_copy.rs
@@ -23,6 +23,7 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use itertools::Itertools as _;
+use pollster::FutureExt;
 use thiserror::Error;
 use tracing::instrument;
 
@@ -378,7 +379,10 @@ impl WorkingCopyFreshness {
                 [Ok(wc_operation.clone())],
                 [Ok(repo_operation.clone())],
                 |op: &Operation| op.id().clone(),
-                |op: &Operation| op.parents().collect_vec(),
+                |op: &Operation| match op.parents().block_on() {
+                    Ok(parents) => parents.into_iter().map(Ok).collect_vec(),
+                    Err(err) => vec![Err(err)],
+                },
             )?
             .expect("unrelated operations");
             if ancestor_op.id() == repo_operation.id() {
diff --git a/lib/tests/test_evolution_predecessors.rs b/lib/tests/test_evolution_predecessors.rs
@@ -151,7 +151,9 @@ fn test_walk_predecessors_concurrent_ops() {
     let [op2, op3] = repo4
         .operation()
         .parents()
-        .map(Result::unwrap)
+        .block_on()
+        .unwrap()
+        .into_iter()
         .collect_array()
         .unwrap();
 
diff --git a/lib/tests/test_operations.rs b/lib/tests/test_operations.rs
@@ -272,7 +272,7 @@ fn test_reparent_range_linear() {
     let read_op = |id| loader.load_operation(id).block_on().unwrap();
 
     fn op_parents<const N: usize>(op: &Operation) -> [Operation; N] {
-        let parents: Vec<_> = op.parents().try_collect().unwrap();
+        let parents: Vec<_> = op.parents().block_on().unwrap();
         parents.try_into().unwrap()
     }
 
@@ -340,7 +340,7 @@ fn test_reparent_range_branchy() {
     let read_op = |id| loader.load_operation(id).block_on().unwrap();
 
     fn op_parents<const N: usize>(op: &Operation) -> [Operation; N] {
-        let parents: Vec<_> = op.parents().try_collect().unwrap();
+        let parents: Vec<_> = op.parents().block_on().unwrap();
         parents.try_into().unwrap()
     }
 
@@ -886,7 +886,7 @@ fn test_walk_ancestors() {
     let loader = repo_0.loader();
 
     fn op_parents<const N: usize>(op: &Operation) -> [Operation; N] {
-        let parents: Vec<_> = op.parents().try_collect().unwrap();
+        let parents: Vec<_> = op.parents().block_on().unwrap();
         parents.try_into().unwrap()
     }
 

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ pub async fn cmd_op_diff(`
`101`	`101`	`to_op = workspace_command.resolve_single_op(args.to.as_deref().unwrap_or("@"))?;`
`102`	`102`	`} else {`
`103`	`103`	`to_op = workspace_command.resolve_single_op(args.operation.as_deref().unwrap_or("@"))?;`
`104`		`- from_ops = to_op.parents().try_collect()?;`
	`104`	`+ from_ops = to_op.parents().await?;`
`105`	`105`	`}`
`106`	`106`	`let graph_style = GraphStyle::from_settings(settings)?;`
`107`	`107`	`let with_content_format = LogContentFormat::new(ui, settings)?;`