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]>
292 lines
7.6 KiB
Rust
292 lines
7.6 KiB
Rust
#![feature(arbitrary_self_types)]
|
|
#![feature(arbitrary_self_types_pointers)]
|
|
#![allow(clippy::needless_return)] // tokio macro-generated code doesn't respect this
|
|
|
|
use std::sync::Mutex;
|
|
|
|
use turbo_rcstr::RcStr;
|
|
use turbo_tasks::{ResolvedVc, Vc, debug::ValueDebug};
|
|
use turbo_tasks_testing::{Registration, register, run_once};
|
|
|
|
static REGISTRATION: Registration = register!();
|
|
|
|
#[turbo_tasks::function(operation, root)]
|
|
async fn dbg_operation(value: ResolvedVc<Box<dyn ValueDebug>>) -> anyhow::Result<Vc<RcStr>> {
|
|
let trait_ref = value.into_trait_ref().await?;
|
|
let s = trait_ref.dbg().await?;
|
|
Ok(Vc::cell(s.into()))
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_primitive_debug() {
|
|
run_once(®ISTRATION, move || async move {
|
|
let a = ResolvedVc::<u32>::cell(42);
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"42",
|
|
);
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_transparent_debug() {
|
|
run_once(®ISTRATION, move || async move {
|
|
let a = Transparent(42).resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"42",
|
|
);
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_enum_none_debug() {
|
|
run_once(®ISTRATION, move || async move {
|
|
let a = Enum::None.resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"Enum :: None",
|
|
);
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_enum_transparent_debug() {
|
|
run_once(®ISTRATION, move || async move {
|
|
let a = Enum::Transparent(Transparent(42).resolved_cell()).resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"Enum :: Transparent(\n 42,\n)",
|
|
);
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_enum_inner_vc_debug() {
|
|
run_once(®ISTRATION, move || async move {
|
|
let a = Enum::Enum(Enum::None.resolved_cell()).resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"Enum :: Enum(\n Enum :: None,\n)",
|
|
);
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_struct_unit_debug() {
|
|
run_once(®ISTRATION, move || async move {
|
|
let a = StructUnit.resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"StructUnit",
|
|
);
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_struct_transparent_debug() {
|
|
run_once(®ISTRATION, move || async move {
|
|
let a = StructWithTransparent {
|
|
transparent: Transparent(42).resolved_cell(),
|
|
}
|
|
.resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"StructWithTransparent {\n transparent: 42,\n}",
|
|
);
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_struct_option_debug() {
|
|
run_once(®ISTRATION, || async {
|
|
let a = StructWithOption { option: None }.resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"StructWithOption {\n option: None,\n}",
|
|
);
|
|
|
|
let b = StructWithOption {
|
|
option: Some(Transparent(42).resolved_cell()),
|
|
}
|
|
.resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(b))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"StructWithOption {\n option: Some(\n 42,\n ),\n}",
|
|
);
|
|
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_struct_vec_debug() {
|
|
run_once(®ISTRATION, || async {
|
|
let a = StructWithVec { vec: Vec::new() }.resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"StructWithVec {\n vec: [],\n}"
|
|
);
|
|
|
|
let b = StructWithVec {
|
|
vec: vec![Transparent(42).resolved_cell()],
|
|
}
|
|
.resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(b))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"StructWithVec {\n vec: [\n 42,\n ],\n}",
|
|
);
|
|
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_struct_ignore_debug() {
|
|
run_once(®ISTRATION, || async {
|
|
let a = StructWithIgnore {
|
|
dont_ignore: 42,
|
|
ignore: Mutex::new(()),
|
|
}
|
|
.resolved_cell();
|
|
assert_eq!(
|
|
format!(
|
|
"{}",
|
|
dbg_operation(ResolvedVc::upcast(a))
|
|
.read_strongly_consistent()
|
|
.await?,
|
|
),
|
|
"StructWithIgnore {\n dont_ignore: 42,\n}",
|
|
);
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[turbo_tasks::value(transparent, shared)]
|
|
struct Transparent(u32);
|
|
|
|
// Allow Enum::Enum
|
|
#[allow(clippy::enum_variant_names)]
|
|
#[turbo_tasks::value(shared)]
|
|
enum Enum {
|
|
None,
|
|
Transparent(ResolvedVc<Transparent>),
|
|
Enum(ResolvedVc<Enum>),
|
|
}
|
|
|
|
#[turbo_tasks::value(shared)]
|
|
struct StructUnit;
|
|
|
|
#[turbo_tasks::value(shared)]
|
|
struct StructWithTransparent {
|
|
transparent: ResolvedVc<Transparent>,
|
|
}
|
|
|
|
#[turbo_tasks::value(shared)]
|
|
struct StructWithOption {
|
|
option: Option<ResolvedVc<Transparent>>,
|
|
}
|
|
|
|
#[turbo_tasks::value(shared)]
|
|
struct StructWithVec {
|
|
vec: Vec<ResolvedVc<Transparent>>,
|
|
}
|
|
|
|
#[turbo_tasks::value(shared, eq = "manual")]
|
|
struct StructWithIgnore {
|
|
dont_ignore: u32,
|
|
// We're using a `Mutex` instead of a `T: Debug` type to ensure we support `T: !Debug`.
|
|
#[turbo_tasks(debug_ignore, trace_ignore)]
|
|
ignore: Mutex<()>,
|
|
}
|
|
|
|
impl PartialEq for StructWithIgnore {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.dont_ignore == other.dont_ignore
|
|
}
|
|
}
|
|
|
|
impl Eq for StructWithIgnore {}
|