Address soundness hole in cycle prevention

tests/dependencies/single.rs

@@ -1,7 +1,7 @@
 //! Tests for single dependencies and basic dependency data flow
 
 use crate::common::task_fn;
-use dagx::{DagResult, DagRunner};
+use dagx::{DagResult, DagRunner, TaskHandle};
 use futures::FutureExt;
 
 #[tokio::test]
@@ -11,7 +11,7 @@ async fn test_single_dependency() -> DagResult<()> {
     let source = dag.add_task(task_fn(|_: ()| async { 42 }));
     let dependent = dag
         .add_task(task_fn(|x: i32| async move { x + 1 }))
-        .depends_on(&source);
+        .depends_on(source);
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
@@ -24,17 +24,19 @@ async fn test_dependency_data_flow() -> DagResult<()> {
     // Test that data flows correctly through dependencies
     let dag = DagRunner::new();
 
-    let source = dag.add_task(task_fn(|_: ()| async { vec![1, 2, 3, 4, 5] }));
+    let source: TaskHandle<_> = dag
+        .add_task(task_fn(|_: ()| async { vec![1, 2, 3, 4, 5] }))
+        .into();
 
     let sum = dag
         .add_task(task_fn(|v: Vec<i32>| async move { v.iter().sum::<i32>() }))
-        .depends_on(&source);
+        .depends_on(source);
 
     let product = dag
         .add_task(task_fn(
             |v: Vec<i32>| async move { v.iter().product::<i32>() },
         ))
-        .depends_on(&source);
+        .depends_on(source);
 
     let final_result = dag
         .add_task(task_fn(|(s, p): (i32, i32)| async move { s + p }))
@@ -62,7 +64,7 @@ async fn test_dependencies_with_different_types() -> DagResult<()> {
         .add_task(task_fn(|(i, s, b): (i32, String, bool)| async move {
             format!("{}: {} ({})", s, i, b)
         }))
-        .depends_on((&int_source, &string_source, &bool_source));
+        .depends_on((int_source, string_source, bool_source));
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
@@ -75,13 +77,13 @@ async fn test_shared_dependencies() -> DagResult<()> {
     // Test that a single node can be a dependency for multiple downstream nodes
     let dag = DagRunner::new();
 
-    let shared = dag.add_task(task_fn(|_: ()| async { 42 }));
+    let shared: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42 })).into();
 
     // Create 10 tasks that all depend on the shared node
     let dependents: Vec<_> = (0..10)
         .map(|i| {
             dag.add_task(task_fn(move |x: i32| async move { x * (i + 1) }))
-                .depends_on(&shared)
+                .depends_on(shared)
         })
         .collect();
 
@@ -106,7 +108,7 @@ async fn test_multiple_source_nodes() -> DagResult<()> {
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
-    for (i, source) in sources.iter().enumerate() {
+    for (i, source) in sources.into_iter().enumerate() {
         assert_eq!(dag.get(source)?, i as i32 * 10);
     }