mirror of
https://github.com/hanzoai/next.js.git
synced 2026-10-30 14:46:38 +00:00
5d0dab5fc6
### What? Replaces the silent "make root node" promotion in the turbo-tasks backend with a panic that enforces tasks to already have the `root` attribute before performing strongly consistent reads, reading task collectibles, or removing collectibles. ### Why? Previously, the backend would silently promote any non-root task to a root node (aggregation number `u32::MAX`) when these operations were requested. This masked incorrect task configuration — tasks that needed root-level aggregation weren't explicitly declared as such, making it harder to reason about the aggregation graph and hiding potential performance issues from implicit promotions. ### How? **Backend enforcement (3 locations):** - **Strongly consistent read** (`backend/mod.rs`): Checks `NativeFunction.is_root` on the target task. If it's a persistent task without `root`, panics with both the target and reader task descriptions. - **Read task collectibles** (`backend/mod.rs`): Same check when reading collectibles from a task. - **Remove collectibles** (`operation/update_collectible.rs`): Same check when removing collectibles (count < 0). All three locations drop the task guard before panicking to avoid deadlocking with `debug_get_task_description`. **Macro support for `root` on methods:** - `value_impl_macro.rs`: Now reads the `root` attribute from `#[turbo_tasks::function(root)]` on inherent impl and trait impl methods (previously hardcoded to `false`). - `value_trait_macro.rs`: Same for trait default methods. **`root` attribute additions:** - All `#[turbo_tasks::function(operation)]` in test files, benchmarks, and fuzz code - Production operations in `crates/next-api/` that are read with strong consistency - Regular functions and methods in tests that use `.strongly_consistent()` - Trait methods in `value_impl` and `value_trait` blocks used with strong consistency **New test:** - `non_root_task_panic.rs`: Verifies the panic fires when attempting a strongly consistent read on a non-root operation task. Captures the panic from the worker thread via a panic hook since the panic propagates as a channel error to the test thread. <!-- NEXT_JS_LLM_PR --> --------- Co-authored-by: Claude Opus 4.7 (1M context) <[email protected]>
84 lines
2.6 KiB
Rust
84 lines
2.6 KiB
Rust
#![feature(arbitrary_self_types)]
|
|
#![feature(arbitrary_self_types_pointers)]
|
|
|
|
use anyhow::Result;
|
|
use bincode::{Decode, Encode};
|
|
use turbo_tasks::{NonLocalValue, ResolvedVc, TaskInput, Vc, trace::TraceRawVcs};
|
|
use turbo_tasks_testing::{Registration, register, run_once_without_cache_check};
|
|
|
|
static REGISTRATION: Registration = register!();
|
|
|
|
const EXPECTED_TRACE: &str = "\
|
|
Adder::add_method (read cell of type u64)
|
|
self:
|
|
Adder::new (read cell of type trace_transient::Adder)
|
|
args:
|
|
unknown transient task (read cell of type ())
|
|
args:
|
|
unknown transient task (read cell of type u16)
|
|
unknown transient task (read cell of type u32)";
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_trace_transient() {
|
|
let result = run_once_without_cache_check(®ISTRATION, async {
|
|
test_trace_transient_operation(
|
|
ResolvedVc::cell(()),
|
|
ResolvedVc::<u16>::cell(2),
|
|
ResolvedVc::<u32>::cell(3),
|
|
)
|
|
.read_strongly_consistent()
|
|
.await
|
|
})
|
|
.await;
|
|
|
|
let message = format!("{:#}", result.unwrap_err());
|
|
assert!(message.contains(&EXPECTED_TRACE.to_string()));
|
|
}
|
|
|
|
#[turbo_tasks::function(operation, root)]
|
|
async fn test_trace_transient_operation(
|
|
arg1: ResolvedVc<()>,
|
|
arg2: ResolvedVc<u16>,
|
|
arg3: ResolvedVc<u32>,
|
|
) -> Result<Vc<u64>> {
|
|
let resolved = Adder::new(*arg1)
|
|
.add_method(*arg2, *arg3)
|
|
.to_resolved()
|
|
.await?;
|
|
Ok(read_incorrect_task_input(IncorrectTaskInput(resolved)))
|
|
}
|
|
|
|
#[turbo_tasks::value]
|
|
struct Adder;
|
|
|
|
#[turbo_tasks::value_impl]
|
|
impl Adder {
|
|
#[turbo_tasks::function]
|
|
fn new(arg: ResolvedVc<()>) -> Vc<Adder> {
|
|
let _ = arg; // Make sure unused argument filtering doesn't remove the arg
|
|
Adder.cell()
|
|
}
|
|
|
|
#[turbo_tasks::function]
|
|
async fn add_method(&self, arg1: ResolvedVc<u16>, arg2: ResolvedVc<u32>) -> Result<Vc<u64>> {
|
|
let _ = self; // Make sure unused argument filtering doesn't remove the arg
|
|
Ok(Vc::cell(u64::from(*arg1.await?) + u64::from(*arg2.await?)))
|
|
}
|
|
}
|
|
|
|
#[turbo_tasks::function]
|
|
async fn read_incorrect_task_input(value: IncorrectTaskInput) -> Result<Vc<u64>> {
|
|
Ok(Vc::cell(*value.0.await?))
|
|
}
|
|
|
|
/// Has an intentionally incorrect `TaskInput` implementation, representing some code that the debug
|
|
/// tracing might be particularly useful with.
|
|
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TraceRawVcs, Encode, Decode, NonLocalValue)]
|
|
struct IncorrectTaskInput(ResolvedVc<u64>);
|
|
|
|
impl TaskInput for IncorrectTaskInput {
|
|
fn is_transient(&self) -> bool {
|
|
false
|
|
}
|
|
}
|