Unverified Commit f50164ed authored by Niklas Mischkulnig's avatar Niklas Mischkulnig Committed by GitHub

Turbopack: remove unused code (#75897)

parent 10e4a0a8
......@@ -11,6 +11,6 @@ pub use ecmascript_client_reference::{
ecmascript_client_reference_transition::NextEcmascriptClientReferenceTransition,
};
pub use visit_client_reference::{
client_reference_graph, find_server_entries, ClientReference, ClientReferenceGraphResult,
ClientReferenceType, ClientReferenceTypes, ServerEntries, VisitedClientReferenceGraphNodes,
find_server_entries, ClientReference, ClientReferenceGraphResult, ClientReferenceType,
ClientReferenceTypes, ServerEntries, VisitedClientReferenceGraphNodes,
};
......@@ -7,7 +7,7 @@ use tracing::Instrument;
use turbo_rcstr::RcStr;
use turbo_tasks::{
debug::ValueDebugFormat,
graph::{AdjacencyMap, GraphTraversal, Visit, VisitControlFlow, VisitedNodes},
graph::{AdjacencyMap, GraphTraversal, Visit, VisitControlFlow},
trace::TraceRawVcs,
FxIndexMap, FxIndexSet, NonLocalValue, ReadRef, ResolvedVc, TryJoinIterExt, ValueToString, Vc,
};
......@@ -143,98 +143,6 @@ impl ClientReferenceGraphResult {
}
}
#[turbo_tasks::function]
pub async fn client_reference_graph(
entries: Vec<ResolvedVc<Box<dyn Module>>>,
visited_nodes: Vc<VisitedClientReferenceGraphNodes>,
) -> Result<Vc<ClientReferenceGraphResult>> {
async move {
let mut client_references = vec![];
let mut server_component_entries = vec![];
let mut server_utils = vec![];
let mut client_references_by_server_component = FxIndexMap::default();
// Make sure None (for the various internal next/dist/esm/client/components/*) is listed
// first
client_references_by_server_component.insert(None, Vec::new());
let (graph, visited_nodes) = AdjacencyMap::new()
.skip_duplicates_with_visited_nodes(VisitedNodes(visited_nodes.await?.0.clone()))
.visit(
entries
.iter()
.copied()
.map(|module| async move {
Ok(VisitClientReferenceNode {
state: if let Some(server_component) =
ResolvedVc::try_downcast_type::<NextServerComponentModule>(module)
{
VisitClientReferenceNodeState::InServerComponent {
server_component,
}
} else {
VisitClientReferenceNodeState::Entry {
entry_path: module.ident().path().to_resolved().await?,
}
},
ty: VisitClientReferenceNodeType::Internal(
module,
module.ident().to_string().await?,
),
})
})
.try_join()
.await?,
VisitClientReference {
stop_at_server_entries: false,
},
)
.await
.completed()?
.into_inner_with_visited();
for node in graph.into_reverse_topological() {
match &node.ty {
VisitClientReferenceNodeType::Internal(_asset, _) => {
// No-op. These nodes are only useful during graph
// traversal.
}
VisitClientReferenceNodeType::ClientReference(client_reference, _) => {
client_references.push(*client_reference);
if let ClientReferenceType::EcmascriptClientReference(entry) =
client_reference.ty()
{
client_references_by_server_component
.entry(client_reference.server_component)
.or_insert_with(Vec::new)
.push(ResolvedVc::upcast::<Box<dyn Module>>(
entry.await?.ssr_module,
));
}
}
VisitClientReferenceNodeType::ServerUtilEntry(server_util, _) => {
server_utils.push(*server_util);
}
VisitClientReferenceNodeType::ServerComponentEntry(server_component, _) => {
server_component_entries.push(*server_component);
}
}
}
Ok(ClientReferenceGraphResult {
client_references,
client_references_by_server_component,
server_component_entries,
server_utils,
visited_nodes: VisitedClientReferenceGraphNodes(visited_nodes.0).resolved_cell(),
}
.cell())
}
.instrument(tracing::info_span!("find client references"))
.await
}
#[turbo_tasks::value(shared)]
#[derive(Clone, Debug)]
pub struct ServerEntries {
......
pub(crate) mod dynamic_module;
pub(crate) mod dynamic_transition;
pub(crate) mod visit_dynamic;
pub use dynamic_module::NextDynamicEntryModule;
pub use dynamic_transition::NextDynamicTransition;
pub use visit_dynamic::NextDynamicEntries;
use std::future::Future;
use anyhow::Result;
use tracing::Instrument;
use turbo_rcstr::RcStr;
use turbo_tasks::{
graph::{AdjacencyMap, GraphTraversal, Visit, VisitControlFlow},
ReadRef, ResolvedVc, TryJoinIterExt, ValueToString, Vc,
};
use turbopack_core::{
module::{Module, Modules},
reference::primary_referenced_modules,
};
use super::NextDynamicEntryModule;
#[turbo_tasks::value(transparent)]
pub struct NextDynamicEntries(Vec<ResolvedVc<NextDynamicEntryModule>>);
#[turbo_tasks::value_impl]
impl NextDynamicEntries {
#[turbo_tasks::function]
pub async fn from_entries(entries: Vc<Modules>) -> Result<Vc<NextDynamicEntries>> {
async move {
let nodes: Vec<_> = AdjacencyMap::new()
.skip_duplicates()
.visit(
entries
.await?
.iter()
.copied()
.map(|m| async move {
Ok(VisitDynamicNode::Internal(m, m.ident().to_string().await?))
})
.try_join()
.await?,
VisitDynamic,
)
.await
.completed()?
.into_inner()
.into_reverse_topological()
.collect();
let mut next_dynamics = vec![];
for node in nodes {
match node {
VisitDynamicNode::Internal(_asset, _) => {
// No-op. These nodes are only useful during graph
// traversal.
}
VisitDynamicNode::Dynamic(dynamic_asset, _) => {
next_dynamics.push(dynamic_asset);
}
}
}
Ok(Vc::cell(next_dynamics))
}
.instrument(tracing::info_span!("find next/dynamic references"))
.await
}
}
struct VisitDynamic;
#[derive(Clone, Eq, PartialEq, Hash)]
enum VisitDynamicNode {
Dynamic(ResolvedVc<NextDynamicEntryModule>, ReadRef<RcStr>),
Internal(ResolvedVc<Box<dyn Module>>, ReadRef<RcStr>),
}
impl Visit<VisitDynamicNode> for VisitDynamic {
type Edge = VisitDynamicNode;
type EdgesIntoIter = Vec<Self::Edge>;
type EdgesFuture = impl Future<Output = Result<Self::EdgesIntoIter>>;
fn visit(&mut self, edge: Self::Edge) -> VisitControlFlow<VisitDynamicNode> {
// We always visit all nodes, as a dynamic asset can transitively reference
// another.
VisitControlFlow::Continue(edge)
}
fn edges(&mut self, node: &VisitDynamicNode) -> Self::EdgesFuture {
let node = node.clone();
async move {
let module = match node {
VisitDynamicNode::Dynamic(dynamic_module, _) => ResolvedVc::upcast(dynamic_module),
VisitDynamicNode::Internal(module, _) => module,
};
let referenced_modules = primary_referenced_modules(*module).await?;
let referenced_modules = referenced_modules.iter().map(|module| async move {
if let Some(next_dynamic_module) =
ResolvedVc::try_downcast_type::<NextDynamicEntryModule>(*module)
{
return Ok(VisitDynamicNode::Dynamic(
next_dynamic_module,
next_dynamic_module.ident().to_string().await?,
));
}
Ok(VisitDynamicNode::Internal(
*module,
module.ident().to_string().await?,
))
});
let nodes = referenced_modules.try_join().await?;
Ok(nodes)
}
}
fn span(&mut self, node: &VisitDynamicNode) -> tracing::Span {
match node {
VisitDynamicNode::Dynamic(_, name) => {
tracing::info_span!("dynamic module", name = name.to_string())
}
VisitDynamicNode::Internal(_, name) => {
tracing::info_span!("module", name = name.to_string())
}
}
}
}
use std::io::Write as _;
use anyhow::Result;
use tracing::{info_span, Instrument};
use turbo_tasks::{FxIndexMap, ReadRef, ResolvedVc, TryJoinIterExt, ValueToString, Vc};
use turbopack_core::{
chunk::{AsyncModuleInfo, ChunkItem, ChunkItemExt, ChunkItemTy, ModuleId},
code_builder::{Code, CodeBuilder},
error::PrettyPrintError,
issue::{code_gen::CodeGenerationIssue, IssueExt, IssueSeverity, StyledString},
code_builder::Code,
};
use turbopack_ecmascript::chunk::{
EcmascriptChunkContent, EcmascriptChunkItem, EcmascriptChunkItemExt,
......@@ -100,44 +96,3 @@ impl EcmascriptDevChunkContentEntries {
Ok(Vc::cell(entries))
}
}
#[turbo_tasks::function]
async fn item_code(
item: Vc<Box<dyn EcmascriptChunkItem>>,
async_module_info: Option<Vc<AsyncModuleInfo>>,
) -> Result<Vc<Code>> {
Ok(
match item
.content_with_async_module_info(async_module_info)
.module_factory()
.resolve()
.await
{
Ok(factory) => factory,
Err(error) => {
let id = item.id().to_string().await;
let id = id.as_ref().map_or_else(|_| "unknown", |id| &**id);
let error = error.context(format!(
"An error occurred while generating the chunk item {}",
id
));
let error_message = format!("{}", PrettyPrintError(&error));
let js_error_message = serde_json::to_string(&error_message)?;
CodeGenerationIssue {
severity: IssueSeverity::Error.resolved_cell(),
path: item.asset_ident().path().to_resolved().await?,
title: StyledString::Text("Code generation for chunk item errored".into())
.resolved_cell(),
message: StyledString::Text(error_message.into()).resolved_cell(),
}
.resolved_cell()
.emit();
let mut code = CodeBuilder::default();
code += "(() => {{\n\n";
writeln!(code, "throw new Error({error});", error = &js_error_message)?;
code += "\n}})";
code.build().cell()
}
},
)
}
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