Address soundness hole in cycle prevention

tests/dependencies/resolution.rs

@@ -1,7 +1,7 @@
 //! Tests for dependency resolution order and transitive dependencies
 
 use crate::common::task_fn;
-use dagx::{DagResult, DagRunner};
+use dagx::{DagResult, DagRunner, TaskHandle};
 use futures::FutureExt;
 use std::sync::{Arc, Mutex};
 
@@ -37,7 +37,7 @@ async fn test_dependency_resolution_order() -> DagResult<()> {
                 x + 1
             }
         }))
-        .depends_on(&a)
+        .depends_on(a)
     };
 
     let c = {
@@ -108,17 +108,17 @@ async fn test_transitive_dependencies() -> DagResult<()> {
     // A -> B -> C (creates transitive A -> C relationship)
     let dag = DagRunner::new();
 
-    let a = dag.add_task(task_fn(|_: ()| async { 10 }));
+    let a: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 10 })).into();
     let b = dag
         .add_task(task_fn(|x: i32| async move { x * 2 }))
-        .depends_on(&a);
+        .depends_on(a);
     let c = dag
         .add_task(task_fn(|x: i32| async move { x + 5 }))
         .depends_on(b);
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
-    assert_eq!(dag.get(&a)?, 10);
+    assert_eq!(dag.get(a)?, 10);
     assert_eq!(dag.get(b)?, 20);
     assert_eq!(dag.get(c)?, 25); // 20 + 5
 
@@ -130,7 +130,7 @@ async fn test_deep_chain_50_levels() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let first = dag.add_task(task_fn(|_: ()| async { 0 }));
-    let mut handles = vec![(&first).into()];
+    let mut handles = vec![first.into()];
 
     for _i in 1..=50 {
         let next = dag
@@ -150,7 +150,7 @@ async fn test_deep_chain_200_levels() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let first = dag.add_task(task_fn(|_: ()| async { 1 }));
-    let mut current = (&first).into();
+    let mut current = first.into();
 
     for _ in 0..200 {
         current = dag

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);
     }
 

tests/dependencies/tuples.rs

@@ -12,7 +12,7 @@ async fn test_two_dependencies() -> DagResult<()> {
     let b = dag.add_task(task_fn(|_: ()| async { 20 }));
     let sum = dag
         .add_task(task_fn(|(x, y): (i32, i32)| async move { x + y }))
-        .depends_on((&a, &b));
+        .depends_on((a, b));
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
@@ -31,7 +31,7 @@ async fn test_three_dependencies() -> DagResult<()> {
         .add_task(task_fn(
             |(x, y, z): (i32, i32, i32)| async move { x + y + z },
         ))
-        .depends_on((&a, &b, &c));
+        .depends_on((a, b, c));
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
@@ -44,7 +44,7 @@ async fn test_four_dependencies() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=4)
-        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
         .collect();
 
     let sum = dag
@@ -64,7 +64,7 @@ async fn test_five_dependencies() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=5)
-        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
         .collect();
 
     let sum = dag
@@ -84,7 +84,7 @@ async fn test_six_dependencies() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=6)
-        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
         .collect();
 
     let sum = dag.add_task(task_fn(
@@ -106,7 +106,7 @@ async fn test_seven_dependencies() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=7)
-        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
         .collect();
 
     let sum = dag
@@ -130,7 +130,7 @@ async fn test_eight_dependencies() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let deps: Vec<_> = (1..=8)
-        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })))
+        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i })).into())
         .collect();
 
     let sum = dag