Commit f68fc84e authored by Matt Mastracci's avatar Matt Mastracci

Inert/sync

parent 9ff61b82
......@@ -2,13 +2,13 @@ use std::{collections::hash_map::Entry, fmt::Display, future::Future, sync::Arc}
use anyhow::Result;
use parking_lot::Mutex;
use rustc_hash::{FxHashMap, FxHashSet};
use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
use swc_core::ecma::ast::Id;
use super::{JsValue, graph::VarGraph};
use crate::analyzer::graph::VarMeta;
pub async fn link<'a, B, RB, F, RF>(
pub async fn link<'a, B, F, RF>(
graph: &VarGraph,
mut val: JsValue,
early_visitor: &B,
......@@ -17,11 +17,17 @@ pub async fn link<'a, B, RB, F, RF>(
var_cache: &Mutex<FxHashMap<Id, JsValue>>,
) -> Result<(JsValue, u32)>
where
RB: 'a + Future<Output = Result<(JsValue, bool)>> + Send,
B: 'a + Fn(JsValue) -> RB + Sync,
B: Fn(&mut JsValue) -> bool + Sync,
RF: 'a + Future<Output = Result<(JsValue, bool)>> + Send,
F: 'a + Fn(JsValue) -> RF + Sync,
{
// Fast path: values that are already fully resolved and will pass through
// both visitors unchanged. These have no children, no placeholders, and
// the visitor catch-all is a no-op for them.
if val.is_inert() {
return Ok((val, 0));
}
val.normalize();
let (val, steps) = link_internal_iterative(
graph,
......@@ -75,7 +81,7 @@ impl Display for Step {
}
// If a variable was already visited in this linking call, don't visit it again.
pub(crate) async fn link_internal_iterative<'a, B, RB, F, RF>(
pub(crate) async fn link_internal_iterative<'a, B, F, RF>(
graph: &'a VarGraph,
val: JsValue,
early_visitor: &'a B,
......@@ -84,22 +90,21 @@ pub(crate) async fn link_internal_iterative<'a, B, RB, F, RF>(
var_cache: &Mutex<FxHashMap<Id, JsValue>>,
) -> Result<(JsValue, u32)>
where
RB: 'a + Future<Output = Result<(JsValue, bool)>> + Send,
B: 'a + Fn(JsValue) -> RB + Sync,
B: Fn(&mut JsValue) -> bool + Sync,
RF: 'a + Future<Output = Result<(JsValue, bool)>> + Send,
F: 'a + Fn(JsValue) -> RF + Sync,
{
let initial_capacity = (val.total_nodes() as usize).min(64);
// Tracks the number of nodes in the queue and done combined
let mut total_nodes = val.total_nodes();
let initial_capacity = (total_nodes as usize).min(64);
let mut work_queue_stack: Vec<Step> = Vec::with_capacity(initial_capacity * 2);
let mut done: Vec<JsValue> = Vec::with_capacity(initial_capacity);
// Tracks the number of nodes in the queue and done combined
let mut total_nodes = 0;
let mut cycle_stack: FxHashSet<Id> = FxHashSet::default();
let mut cycle_stack: FxHashSet<Id> = FxHashSet::with_capacity_and_hasher(initial_capacity, FxBuildHasher::default());
let mut fun_args_depth: u32 = 0;
// Tracks the number linking steps so far
let mut steps = 0;
total_nodes += val.total_nodes();
work_queue_stack.push(Step::Enter(val));
while let Some(step) = work_queue_stack.pop() {
......@@ -269,7 +274,7 @@ where
continue;
}
let (mut val, visit_modified) = early_visitor(val).await?;
let visit_modified = early_visitor(&mut val);
val.debug_assert_total_nodes_up_to_date();
if visit_modified && val.total_nodes() > LIMIT_NODE_SIZE {
total_nodes += 1;
......
......@@ -1145,6 +1145,16 @@ impl JsValue {
// Methods regarding node count
impl JsValue {
/// Returns true if this value is fully resolved and will not be transformed
/// by the linker's visitors. These are leaf values with no placeholders and
/// no operations — the visitors' catch-all paths are no-ops for them.
pub fn is_inert(&self) -> bool {
matches!(
self,
JsValue::Constant(_) | JsValue::Url(_, _) | JsValue::Unknown { .. }
)
}
pub fn has_children(&self) -> bool {
self.total_nodes() > 1
}
......@@ -3804,9 +3814,8 @@ pub mod test_utils {
utils::module_value_to_well_known_object,
};
pub async fn early_visitor(mut v: JsValue) -> Result<(JsValue, bool)> {
let m = early_replace_builtin(&mut v);
Ok((v, m))
pub fn early_visitor(v: &mut JsValue) -> bool {
early_replace_builtin(v)
}
/// Visitor that replaces well known functions and objects with their
......
......@@ -490,7 +490,7 @@ impl AnalysisState<'_> {
Ok(link(
self.var_graph,
value,
&early_value_visitor,
&|v: &mut JsValue| early_replace_builtin(v),
&|value| {
value_visitor(
*self.origin,
......@@ -3367,11 +3367,6 @@ fn require_resolve(path: FileSystemPath) -> String {
format!("/ROOT/{}", path.path.as_str())
}
async fn early_value_visitor(mut v: JsValue) -> Result<(JsValue, bool)> {
let modified = early_replace_builtin(&mut v);
Ok((v, modified))
}
async fn value_visitor(
origin: Vc<Box<dyn ResolveOrigin>>,
v: JsValue,
......
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