Unverified Commit 87d865f6 authored by Niklas Mischkulnig's avatar Niklas Mischkulnig Committed by GitHub

Turbopack: refactor `evaluate` to take module_graph (#85971)

For some operations, we need the module graph (e.g. determining unused exports, and for the future inner graph tree shaking).

Previously, it was constructed inside of the evaluation machinery.
parent 41c1f870
...@@ -21,6 +21,7 @@ use turbopack_core::{ ...@@ -21,6 +21,7 @@ use turbopack_core::{
context::AssetContext, context::AssetContext,
ident::Layer, ident::Layer,
issue::{IssueExt, IssueSeverity, StyledString}, issue::{IssueExt, IssueSeverity, StyledString},
module_graph::ModuleGraph,
reference_type::{InnerAssets, ReferenceType}, reference_type::{InnerAssets, ReferenceType},
resolve::{ resolve::{
ResolveResult, ResolveResult,
...@@ -31,7 +32,9 @@ use turbopack_core::{ ...@@ -31,7 +32,9 @@ use turbopack_core::{
virtual_source::VirtualSource, virtual_source::VirtualSource,
}; };
use turbopack_node::{ use turbopack_node::{
debug::should_debug, evaluate::evaluate, execution_context::ExecutionContext, debug::should_debug,
evaluate::{evaluate, get_evaluate_entries},
execution_context::ExecutionContext,
}; };
use self::{ use self::{
...@@ -752,15 +755,17 @@ async fn get_mock_stylesheet( ...@@ -752,15 +755,17 @@ async fn get_mock_stylesheet(
) )
.module(); .module();
let entries = get_evaluate_entries(mocked_response_asset, asset_context, None);
let module_graph = ModuleGraph::from_modules(entries.graph_entries(), false);
let root = mock_fs.root().owned().await?; let root = mock_fs.root().owned().await?;
let val = evaluate( let val = evaluate(
mocked_response_asset, entries,
root, root,
*env, *env,
loader_source, loader_source,
asset_context,
*chunking_context, *chunking_context,
None, module_graph,
vec![], vec![],
Completion::immutable(), Completion::immutable(),
should_debug("next_font::google"), should_debug("next_font::google"),
......
...@@ -18,12 +18,13 @@ use turbopack_core::{ ...@@ -18,12 +18,13 @@ use turbopack_core::{
context::AssetContext, context::AssetContext,
error::PrettyPrintError, error::PrettyPrintError,
file_source::FileSource, file_source::FileSource,
ident::AssetIdent,
issue::{ issue::{
Issue, IssueExt, IssueSource, IssueStage, OptionIssueSource, OptionStyledString, Issue, IssueExt, IssueSource, IssueStage, OptionIssueSource, OptionStyledString,
StyledString, StyledString,
}, },
module::Module, module::Module,
module_graph::{ModuleGraph, chunk_group_info::ChunkGroupEntry}, module_graph::{GraphEntries, ModuleGraph, chunk_group_info::ChunkGroupEntry},
output::{OutputAsset, OutputAssets}, output::{OutputAsset, OutputAssets},
reference_type::{InnerAssets, ReferenceType}, reference_type::{InnerAssets, ReferenceType},
source::Source, source::Source,
...@@ -68,23 +69,16 @@ struct EmittedEvaluatePoolAssets { ...@@ -68,23 +69,16 @@ struct EmittedEvaluatePoolAssets {
#[turbo_tasks::function(operation)] #[turbo_tasks::function(operation)]
async fn emit_evaluate_pool_assets_operation( async fn emit_evaluate_pool_assets_operation(
module_asset: ResolvedVc<Box<dyn Module>>, entries: ResolvedVc<EvaluateEntries>,
asset_context: ResolvedVc<Box<dyn AssetContext>>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>, chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
runtime_entries: Option<ResolvedVc<EvaluatableAssets>>, module_graph: ResolvedVc<ModuleGraph>,
) -> Result<Vc<EmittedEvaluatePoolAssets>> { ) -> Result<Vc<EmittedEvaluatePoolAssets>> {
let runtime_asset = asset_context let EvaluateEntries {
.process( entries,
Vc::upcast(FileSource::new( main_entry_ident,
embed_file_path(rcstr!("ipc/evaluate.ts")).owned().await?, } = &*entries.await?;
)),
ReferenceType::Internal(InnerAssets::empty().to_resolved().await?),
)
.module()
.to_resolved()
.await?;
let module_path = module_asset.ident().path().await?; let module_path = main_entry_ident.path().await?;
let file_name = module_path.file_name(); let file_name = module_path.file_name();
let file_name = if file_name.ends_with(".js") { let file_name = if file_name.ends_with(".js") {
Cow::Borrowed(file_name) Cow::Borrowed(file_name)
...@@ -94,62 +88,11 @@ async fn emit_evaluate_pool_assets_operation( ...@@ -94,62 +88,11 @@ async fn emit_evaluate_pool_assets_operation(
Cow::Owned(format!("{file_name}.js")) Cow::Owned(format!("{file_name}.js"))
}; };
let entrypoint = chunking_context.output_root().await?.join(&file_name)?; let entrypoint = chunking_context.output_root().await?.join(&file_name)?;
let entry_module = asset_context
.process(
Vc::upcast(VirtualSource::new(
runtime_asset.ident().path().await?.join("evaluate.js")?,
AssetContent::file(
File::from("import { run } from 'RUNTIME'; run(() => import('INNER'))").into(),
),
)),
ReferenceType::Internal(ResolvedVc::cell(fxindexmap! {
rcstr!("INNER") => module_asset,
rcstr!("RUNTIME") => runtime_asset
})),
)
.module()
.to_resolved()
.await?;
let runtime_entries = {
let globals_module = asset_context
.process(
Vc::upcast(FileSource::new(
embed_file_path(rcstr!("globals.ts")).owned().await?,
)),
ReferenceType::Internal(InnerAssets::empty().to_resolved().await?),
)
.module();
let Some(globals_module) =
Vc::try_resolve_sidecast::<Box<dyn EvaluatableAsset>>(globals_module).await?
else {
bail!("Internal module is not evaluatable");
};
let mut entries = vec![globals_module.to_resolved().await?];
if let Some(runtime_entries) = runtime_entries {
for &entry in &*runtime_entries.await? {
entries.push(entry)
}
}
entries
};
let module_graph = ModuleGraph::from_modules(
Vc::cell(vec![ChunkGroupEntry::Entry(
iter::once(entry_module)
.chain(runtime_entries.iter().copied().map(ResolvedVc::upcast))
.collect(),
)]),
false,
);
let bootstrap = chunking_context.root_entry_chunk_group_asset( let bootstrap = chunking_context.root_entry_chunk_group_asset(
entrypoint.clone(), entrypoint.clone(),
Vc::<EvaluatableAssets>::cell(runtime_entries) Vc::cell(entries.clone()),
.with_entry(*ResolvedVc::try_downcast(entry_module).unwrap()), *module_graph,
module_graph,
OutputAssets::empty(), OutputAssets::empty(),
OutputAssets::empty(), OutputAssets::empty(),
); );
...@@ -178,17 +121,11 @@ struct EmittedEvaluatePoolAssetsWithEffects { ...@@ -178,17 +121,11 @@ struct EmittedEvaluatePoolAssetsWithEffects {
#[turbo_tasks::function(operation)] #[turbo_tasks::function(operation)]
async fn emit_evaluate_pool_assets_with_effects_operation( async fn emit_evaluate_pool_assets_with_effects_operation(
module_asset: ResolvedVc<Box<dyn Module>>, entries: ResolvedVc<EvaluateEntries>,
asset_context: ResolvedVc<Box<dyn AssetContext>>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>, chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
runtime_entries: Option<ResolvedVc<EvaluatableAssets>>, module_graph: ResolvedVc<ModuleGraph>,
) -> Result<Vc<EmittedEvaluatePoolAssetsWithEffects>> { ) -> Result<Vc<EmittedEvaluatePoolAssetsWithEffects>> {
let operation = emit_evaluate_pool_assets_operation( let operation = emit_evaluate_pool_assets_operation(entries, chunking_context, module_graph);
module_asset,
asset_context,
chunking_context,
runtime_entries,
);
let assets = operation.read_strongly_consistent().await?; let assets = operation.read_strongly_consistent().await?;
let effects = Arc::new(get_effects(operation).await?); let effects = Arc::new(get_effects(operation).await?);
Ok(EmittedEvaluatePoolAssetsWithEffects { assets, effects }.cell()) Ok(EmittedEvaluatePoolAssetsWithEffects { assets, effects }.cell())
...@@ -216,22 +153,17 @@ pub enum EnvVarTracking { ...@@ -216,22 +153,17 @@ pub enum EnvVarTracking {
/// Pass the file you cared as `runtime_entries` to invalidate and reload the /// Pass the file you cared as `runtime_entries` to invalidate and reload the
/// evaluated result automatically. /// evaluated result automatically.
pub async fn get_evaluate_pool( pub async fn get_evaluate_pool(
module_asset: ResolvedVc<Box<dyn Module>>, entries: ResolvedVc<EvaluateEntries>,
cwd: FileSystemPath, cwd: FileSystemPath,
env: ResolvedVc<Box<dyn ProcessEnv>>, env: ResolvedVc<Box<dyn ProcessEnv>>,
asset_context: ResolvedVc<Box<dyn AssetContext>>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>, chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
runtime_entries: Option<ResolvedVc<EvaluatableAssets>>, module_graph: ResolvedVc<ModuleGraph>,
additional_invalidation: ResolvedVc<Completion>, additional_invalidation: ResolvedVc<Completion>,
debug: bool, debug: bool,
env_var_tracking: EnvVarTracking, env_var_tracking: EnvVarTracking,
) -> Result<Vc<NodeJsPool>> { ) -> Result<Vc<NodeJsPool>> {
let operation = emit_evaluate_pool_assets_with_effects_operation( let operation =
module_asset, emit_evaluate_pool_assets_with_effects_operation(entries, chunking_context, module_graph);
asset_context,
chunking_context,
runtime_entries,
);
let EmittedEvaluatePoolAssetsWithEffects { assets, effects } = let EmittedEvaluatePoolAssetsWithEffects { assets, effects } =
&*operation.read_strongly_consistent().await?; &*operation.read_strongly_consistent().await?;
effects.apply().await?; effects.apply().await?;
...@@ -401,29 +333,118 @@ pub async fn custom_evaluate(evaluate_context: impl EvaluateContext) -> Result<V ...@@ -401,29 +333,118 @@ pub async fn custom_evaluate(evaluate_context: impl EvaluateContext) -> Result<V
Ok(Vc::cell(result.map(RcStr::from))) Ok(Vc::cell(result.map(RcStr::from)))
} }
#[turbo_tasks::value]
pub struct EvaluateEntries {
entries: Vec<ResolvedVc<Box<dyn EvaluatableAsset + 'static>>>,
main_entry_ident: ResolvedVc<AssetIdent>,
}
#[turbo_tasks::value_impl]
impl EvaluateEntries {
#[turbo_tasks::function]
pub async fn graph_entries(self: Vc<Self>) -> Result<Vc<GraphEntries>> {
Ok(Vc::cell(vec![ChunkGroupEntry::Entry(
self.await?
.entries
.iter()
.cloned()
.map(ResolvedVc::upcast)
.collect(),
)]))
}
}
#[turbo_tasks::function]
pub async fn get_evaluate_entries(
module_asset: ResolvedVc<Box<dyn Module>>,
asset_context: ResolvedVc<Box<dyn AssetContext>>,
runtime_entries: Option<ResolvedVc<EvaluatableAssets>>,
) -> Result<Vc<EvaluateEntries>> {
let runtime_asset = asset_context
.process(
Vc::upcast(FileSource::new(
embed_file_path(rcstr!("ipc/evaluate.ts")).owned().await?,
)),
ReferenceType::Internal(InnerAssets::empty().to_resolved().await?),
)
.module()
.to_resolved()
.await?;
let entry_module = asset_context
.process(
Vc::upcast(VirtualSource::new(
runtime_asset.ident().path().await?.join("evaluate.js")?,
AssetContent::file(
File::from("import { run } from 'RUNTIME'; run(() => import('INNER'))").into(),
),
)),
ReferenceType::Internal(ResolvedVc::cell(fxindexmap! {
rcstr!("INNER") => module_asset,
rcstr!("RUNTIME") => runtime_asset
})),
)
.module()
.to_resolved()
.await?;
let runtime_entries = {
let globals_module = asset_context
.process(
Vc::upcast(FileSource::new(
embed_file_path(rcstr!("globals.ts")).owned().await?,
)),
ReferenceType::Internal(InnerAssets::empty().to_resolved().await?),
)
.module();
let Some(globals_module) =
Vc::try_resolve_sidecast::<Box<dyn EvaluatableAsset>>(globals_module).await?
else {
bail!("Internal module is not evaluatable");
};
let mut entries = vec![globals_module.to_resolved().await?];
if let Some(runtime_entries) = runtime_entries {
for &entry in &*runtime_entries.await? {
entries.push(entry)
}
}
entries
};
Ok(EvaluateEntries {
entries: runtime_entries
.iter()
.copied()
.chain(iter::once(ResolvedVc::try_downcast(entry_module).unwrap()))
.collect(),
main_entry_ident: module_asset.ident().to_resolved().await?,
}
.cell())
}
/// Pass the file you cared as `runtime_entries` to invalidate and reload the /// Pass the file you cared as `runtime_entries` to invalidate and reload the
/// evaluated result automatically. /// evaluated result automatically.
#[turbo_tasks::function] #[turbo_tasks::function]
pub async fn evaluate( pub async fn evaluate(
module_asset: ResolvedVc<Box<dyn Module>>, entries: ResolvedVc<EvaluateEntries>,
cwd: FileSystemPath, cwd: FileSystemPath,
env: ResolvedVc<Box<dyn ProcessEnv>>, env: ResolvedVc<Box<dyn ProcessEnv>>,
context_source_for_issue: ResolvedVc<Box<dyn Source>>, context_source_for_issue: ResolvedVc<Box<dyn Source>>,
asset_context: ResolvedVc<Box<dyn AssetContext>>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>, chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
runtime_entries: Option<ResolvedVc<EvaluatableAssets>>, module_graph: ResolvedVc<ModuleGraph>,
args: Vec<ResolvedVc<JsonValue>>, args: Vec<ResolvedVc<JsonValue>>,
additional_invalidation: ResolvedVc<Completion>, additional_invalidation: ResolvedVc<Completion>,
debug: bool, debug: bool,
) -> Result<Vc<Option<RcStr>>> { ) -> Result<Vc<Option<RcStr>>> {
custom_evaluate(BasicEvaluateContext { custom_evaluate(BasicEvaluateContext {
module_asset, entries,
cwd, cwd,
env, env,
context_source_for_issue, context_source_for_issue,
asset_context,
chunking_context, chunking_context,
runtime_entries, module_graph,
args, args,
additional_invalidation, additional_invalidation,
debug, debug,
...@@ -487,13 +508,12 @@ async fn pull_operation<T: EvaluateContext>( ...@@ -487,13 +508,12 @@ async fn pull_operation<T: EvaluateContext>(
#[derive(Clone, PartialEq, Eq, Hash, TaskInput, Debug, Serialize, Deserialize, TraceRawVcs)] #[derive(Clone, PartialEq, Eq, Hash, TaskInput, Debug, Serialize, Deserialize, TraceRawVcs)]
struct BasicEvaluateContext { struct BasicEvaluateContext {
module_asset: ResolvedVc<Box<dyn Module>>, entries: ResolvedVc<EvaluateEntries>,
cwd: FileSystemPath, cwd: FileSystemPath,
env: ResolvedVc<Box<dyn ProcessEnv>>, env: ResolvedVc<Box<dyn ProcessEnv>>,
context_source_for_issue: ResolvedVc<Box<dyn Source>>, context_source_for_issue: ResolvedVc<Box<dyn Source>>,
asset_context: ResolvedVc<Box<dyn AssetContext>>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>, chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
runtime_entries: Option<ResolvedVc<EvaluatableAssets>>, module_graph: ResolvedVc<ModuleGraph>,
args: Vec<ResolvedVc<JsonValue>>, args: Vec<ResolvedVc<JsonValue>>,
additional_invalidation: ResolvedVc<Completion>, additional_invalidation: ResolvedVc<Completion>,
debug: bool, debug: bool,
...@@ -507,12 +527,11 @@ impl EvaluateContext for BasicEvaluateContext { ...@@ -507,12 +527,11 @@ impl EvaluateContext for BasicEvaluateContext {
fn pool(&self) -> OperationVc<crate::pool::NodeJsPool> { fn pool(&self) -> OperationVc<crate::pool::NodeJsPool> {
get_evaluate_pool( get_evaluate_pool(
self.module_asset, self.entries,
self.cwd.clone(), self.cwd.clone(),
self.env, self.env,
self.asset_context,
self.chunking_context, self.chunking_context,
self.runtime_entries, self.module_graph,
self.additional_invalidation, self.additional_invalidation,
self.debug, self.debug,
EnvVarTracking::WholeEnvTracked, EnvVarTracking::WholeEnvTracked,
......
...@@ -15,6 +15,7 @@ use turbopack_core::{ ...@@ -15,6 +15,7 @@ use turbopack_core::{
context::{AssetContext, ProcessResult}, context::{AssetContext, ProcessResult},
file_source::FileSource, file_source::FileSource,
ident::AssetIdent, ident::AssetIdent,
module_graph::ModuleGraph,
reference_type::{EntryReferenceSubType, InnerAssets, ReferenceType}, reference_type::{EntryReferenceSubType, InnerAssets, ReferenceType},
resolve::{FindContextFileResult, find_context_file_or_package_key, options::ImportMapping}, resolve::{FindContextFileResult, find_context_file_or_package_key, options::ImportMapping},
source::Source, source::Source,
...@@ -29,7 +30,7 @@ use super::{ ...@@ -29,7 +30,7 @@ use super::{
webpack::WebpackLoaderContext, webpack::WebpackLoaderContext,
}; };
use crate::{ use crate::{
embed_js::embed_file_path, execution_context::ExecutionContext, embed_js::embed_file_path, evaluate::get_evaluate_entries, execution_context::ExecutionContext,
transforms::webpack::evaluate_webpack_loader, transforms::webpack::evaluate_webpack_loader,
}; };
...@@ -485,10 +486,16 @@ impl PostCssTransformedAsset { ...@@ -485,10 +486,16 @@ impl PostCssTransformedAsset {
.await?; .await?;
let postcss_executor = let postcss_executor =
postcss_executor(*evaluate_context, project_path.clone(), config_path) postcss_executor(*evaluate_context, project_path.clone(), config_path).module();
.module()
.to_resolved() let entries = get_evaluate_entries(postcss_executor, *evaluate_context, None)
.await?; .to_resolved()
.await?;
let module_graph = ModuleGraph::from_modules(entries.graph_entries(), false)
.to_resolved()
.await?;
let css_fs_path = self.source.ident().path(); let css_fs_path = self.source.ident().path();
// We need to get a path relative to the project because the postcss loader // We need to get a path relative to the project because the postcss loader
...@@ -502,12 +509,12 @@ impl PostCssTransformedAsset { ...@@ -502,12 +509,12 @@ impl PostCssTransformedAsset {
}; };
let config_value = evaluate_webpack_loader(WebpackLoaderContext { let config_value = evaluate_webpack_loader(WebpackLoaderContext {
module_asset: postcss_executor, entries,
cwd: project_path.clone(), cwd: project_path.clone(),
env: *env, env: *env,
context_source_for_issue: self.source, context_source_for_issue: self.source,
asset_context: evaluate_context,
chunking_context: *chunking_context, chunking_context: *chunking_context,
module_graph,
resolve_options_context: None, resolve_options_context: None,
args: vec![ args: vec![
ResolvedVc::cell(content.into()), ResolvedVc::cell(content.into()),
......
...@@ -29,7 +29,7 @@ use turbopack_core::{ ...@@ -29,7 +29,7 @@ use turbopack_core::{
Issue, IssueExt, IssueSeverity, IssueSource, IssueStage, OptionIssueSource, Issue, IssueExt, IssueSeverity, IssueSource, IssueStage, OptionIssueSource,
OptionStyledString, StyledString, OptionStyledString, StyledString,
}, },
module::Module, module_graph::ModuleGraph,
reference_type::{InnerAssets, ReferenceType}, reference_type::{InnerAssets, ReferenceType},
resolve::{ resolve::{
options::{ConditionValue, ResolveInPackage, ResolveIntoPackage, ResolveOptions}, options::{ConditionValue, ResolveInPackage, ResolveIntoPackage, ResolveOptions},
...@@ -55,7 +55,8 @@ use crate::{ ...@@ -55,7 +55,8 @@ use crate::{
debug::should_debug, debug::should_debug,
embed_js::embed_file_path, embed_js::embed_file_path,
evaluate::{ evaluate::{
EnvVarTracking, EvaluateContext, EvaluationIssue, custom_evaluate, get_evaluate_pool, EnvVarTracking, EvaluateContext, EvaluateEntries, EvaluationIssue, custom_evaluate,
get_evaluate_entries, get_evaluate_pool,
}, },
execution_context::ExecutionContext, execution_context::ExecutionContext,
pool::{FormattingMode, NodeJsPool}, pool::{FormattingMode, NodeJsPool},
...@@ -240,8 +241,13 @@ impl WebpackLoadersProcessedAsset { ...@@ -240,8 +241,13 @@ impl WebpackLoadersProcessedAsset {
}; };
let evaluate_context = transform.evaluate_context; let evaluate_context = transform.evaluate_context;
let webpack_loaders_executor = webpack_loaders_executor(*evaluate_context) let webpack_loaders_executor = webpack_loaders_executor(*evaluate_context).module();
.module()
let entries = get_evaluate_entries(webpack_loaders_executor, *evaluate_context, None)
.to_resolved()
.await?;
let module_graph = ModuleGraph::from_modules(entries.graph_entries(), false)
.to_resolved() .to_resolved()
.await?; .await?;
...@@ -254,12 +260,12 @@ impl WebpackLoadersProcessedAsset { ...@@ -254,12 +260,12 @@ impl WebpackLoadersProcessedAsset {
}; };
let loaders = transform.loaders.await?; let loaders = transform.loaders.await?;
let config_value = evaluate_webpack_loader(WebpackLoaderContext { let config_value = evaluate_webpack_loader(WebpackLoaderContext {
module_asset: webpack_loaders_executor, entries,
cwd: project_path.clone(), cwd: project_path.clone(),
env: *env, env: *env,
context_source_for_issue: this.source, context_source_for_issue: this.source,
asset_context: evaluate_context,
chunking_context: *chunking_context, chunking_context: *chunking_context,
module_graph,
resolve_options_context: Some(transform.resolve_options_context), resolve_options_context: Some(transform.resolve_options_context),
args: vec![ args: vec![
ResolvedVc::cell(content), ResolvedVc::cell(content),
...@@ -410,11 +416,11 @@ pub enum ResponseMessage { ...@@ -410,11 +416,11 @@ pub enum ResponseMessage {
#[derive(Clone, PartialEq, Eq, Hash, TaskInput, Serialize, Deserialize, Debug, TraceRawVcs)] #[derive(Clone, PartialEq, Eq, Hash, TaskInput, Serialize, Deserialize, Debug, TraceRawVcs)]
pub struct WebpackLoaderContext { pub struct WebpackLoaderContext {
pub module_asset: ResolvedVc<Box<dyn Module>>, pub entries: ResolvedVc<EvaluateEntries>,
pub cwd: FileSystemPath, pub cwd: FileSystemPath,
pub env: ResolvedVc<Box<dyn ProcessEnv>>, pub env: ResolvedVc<Box<dyn ProcessEnv>>,
pub context_source_for_issue: ResolvedVc<Box<dyn Source>>, pub context_source_for_issue: ResolvedVc<Box<dyn Source>>,
pub asset_context: ResolvedVc<Box<dyn AssetContext>>, pub module_graph: ResolvedVc<ModuleGraph>,
pub chunking_context: ResolvedVc<Box<dyn ChunkingContext>>, pub chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
pub resolve_options_context: Option<ResolvedVc<ResolveOptionsContext>>, pub resolve_options_context: Option<ResolvedVc<ResolveOptionsContext>>,
pub args: Vec<ResolvedVc<JsonValue>>, pub args: Vec<ResolvedVc<JsonValue>>,
...@@ -429,12 +435,11 @@ impl EvaluateContext for WebpackLoaderContext { ...@@ -429,12 +435,11 @@ impl EvaluateContext for WebpackLoaderContext {
fn pool(&self) -> OperationVc<crate::pool::NodeJsPool> { fn pool(&self) -> OperationVc<crate::pool::NodeJsPool> {
get_evaluate_pool( get_evaluate_pool(
self.module_asset, self.entries,
self.cwd.clone(), self.cwd.clone(),
self.env, self.env,
self.asset_context,
self.chunking_context, self.chunking_context,
None, self.module_graph,
self.additional_invalidation, self.additional_invalidation,
should_debug("webpack_loader"), should_debug("webpack_loader"),
// Env vars are read untracked, since we want a more granular dependency on certain env // Env vars are read untracked, since we want a more granular dependency on certain env
......
...@@ -39,9 +39,7 @@ use turbopack_core::{ ...@@ -39,9 +39,7 @@ use turbopack_core::{
file_source::FileSource, file_source::FileSource,
ident::Layer, ident::Layer,
issue::CollectibleIssuesExt, issue::CollectibleIssuesExt,
module_graph::{ module_graph::{ModuleGraph, export_usage::compute_export_usage_info},
ModuleGraph, chunk_group_info::ChunkGroupEntry, export_usage::compute_export_usage_info,
},
reference_type::{InnerAssets, ReferenceType}, reference_type::{InnerAssets, ReferenceType},
resolve::{ resolve::{
ExternalTraced, ExternalType, ExternalTraced, ExternalType,
...@@ -49,7 +47,10 @@ use turbopack_core::{ ...@@ -49,7 +47,10 @@ use turbopack_core::{
}, },
}; };
use turbopack_ecmascript_runtime::RuntimeType; use turbopack_ecmascript_runtime::RuntimeType;
use turbopack_node::{debug::should_debug, evaluate::evaluate}; use turbopack_node::{
debug::should_debug,
evaluate::{evaluate, get_evaluate_entries},
};
use turbopack_nodejs::NodeJsChunkingContext; use turbopack_nodejs::NodeJsChunkingContext;
use turbopack_resolve::resolve_options_context::ResolveOptionsContext; use turbopack_resolve::resolve_options_context::ResolveOptionsContext;
use turbopack_test_utils::{jest::JestRunResult, snapshot::UPDATE}; use turbopack_test_utils::{jest::JestRunResult, snapshot::UPDATE};
...@@ -462,13 +463,9 @@ async fn run_test_operation(prepared_test: ResolvedVc<PreparedTest>) -> Result<V ...@@ -462,13 +463,9 @@ async fn run_test_operation(prepared_test: ResolvedVc<PreparedTest>) -> Result<V
) )
.module(); .module();
// Keep this in sync with what `evaluate` does internally let entries = get_evaluate_entries(jest_entry_asset, asset_context, None);
let module_graph = ModuleGraph::from_modules(
Vc::cell(vec![ChunkGroupEntry::Entry(vec![ let module_graph = ModuleGraph::from_modules(entries.graph_entries(), false);
jest_entry_asset.to_resolved().await?,
])]),
false,
);
let chunking_context = NodeJsChunkingContext::builder( let chunking_context = NodeJsChunkingContext::builder(
project_root.clone(), project_root.clone(),
...@@ -514,13 +511,12 @@ async fn run_test_operation(prepared_test: ResolvedVc<PreparedTest>) -> Result<V ...@@ -514,13 +511,12 @@ async fn run_test_operation(prepared_test: ResolvedVc<PreparedTest>) -> Result<V
.build(); .build();
let res = evaluate( let res = evaluate(
jest_entry_asset, entries,
path.clone(), path.clone(),
Vc::upcast(CommandLineProcessEnv::new()), Vc::upcast(CommandLineProcessEnv::new()),
Vc::upcast(test_source), Vc::upcast(test_source),
asset_context,
Vc::upcast(chunking_context), Vc::upcast(chunking_context),
None, module_graph,
vec![], vec![],
Completion::immutable(), Completion::immutable(),
should_debug("execution_test"), should_debug("execution_test"),
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment