Turbopack: correctly track await import("path") in static analysis (#77811)

1. There was a problem where the module name was `"path"` in the static analyzer (and not `path`), so the lookup to the Node builtin modules list silently failed as `"\"path\"" != "path"`
2. Then, to make this actually correct, introduce `JsValue::Promise` and `JsValue::Awaited` so that `import("path")` and `await import("path")` actually are different JsValues

This is correctly tracked now and includes the Wasm asset in the NFT list:
```js
    const { readFileSync } = await import('fs')
    const { join } = await import('path')
    const wasm = readFileSync(
      join(process.cwd(), '../web/lib/results/parser/biome_wasm_bg_opt.wasm')
    )
```

Closes PACK-4269

Author: mischnic

turbopack/crates/turbopack-ecmascript/src/analyzer/builtin.rs

@@ -662,6 +662,16 @@ pub fn replace_builtin(value: &mut JsValue) -> bool {
             }
         }
 
+        JsValue::Awaited(_, operand) => {
+            if let JsValue::Promise(_, inner) = &mut **operand {
+                *value = take(inner);
+                true
+            } else {
+                *value = take(operand);
+                true
+            }
+        }
+
         _ => false,
     }
 }

turbopack/crates/turbopack-ecmascript/src/analyzer/graph.rs

@@ -543,7 +543,7 @@ impl EvalContext {
                 SyntaxContext::empty(),
             )),
 
-            Expr::Await(AwaitExpr { arg, .. }) => self.eval(arg),
+            Expr::Await(AwaitExpr { arg, .. }) => JsValue::awaited(Box::new(self.eval(arg))),
 
             Expr::Seq(e) => {
                 let mut seq = e.exprs.iter().map(|e| self.eval(e)).peekable();

turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs

@@ -111,6 +111,13 @@ impl ConstantString {
         }
     }
 
+    pub fn as_atom(&self) -> Cow<Atom> {
+        match self {
+            Self::Atom(s) => Cow::Borrowed(s),
+            Self::RcStr(s) => Cow::Owned(s.as_str().into()),
+        }
+    }
+
     pub fn is_empty(&self) -> bool {
         self.as_str().is_empty()
     }
@@ -482,6 +489,12 @@ pub enum JsValue {
     /// A tenary operator `test ? cons : alt`
     /// `(total_node_count, test, cons, alt)`
     Tenary(u32, Box<JsValue>, Box<JsValue>, Box<JsValue>),
+    /// A promise resolving to some value
+    /// `(total_node_count, value)`
+    Promise(u32, Box<JsValue>),
+    /// An await call (potentially) unwrapping a promise.
+    /// `(total_node_count, value)`
+    Awaited(u32, Box<JsValue>),
 
     /// A for-of loop
     ///
@@ -734,6 +747,8 @@ impl Display for JsValue {
             }
             JsValue::Iterated(_, iterable) => write!(f, "Iterated({})", iterable),
             JsValue::TypeOf(_, operand) => write!(f, "typeof({})", operand),
+            JsValue::Promise(_, operand) => write!(f, "Promise<{}>", operand),
+            JsValue::Awaited(_, operand) => write!(f, "await({})", operand),
         }
     }
 }
@@ -795,6 +810,7 @@ impl JsValue {
             | JsValue::Object { .. }
             | JsValue::Alternatives { .. }
             | JsValue::Function(..)
+            | JsValue::Promise(..)
             | JsValue::Member(..) => JsValueMetaKind::Nested,
             JsValue::Concat(..)
             | JsValue::Add(..)
@@ -807,6 +823,7 @@ impl JsValue {
             | JsValue::Tenary(..)
             | JsValue::MemberCall(..)
             | JsValue::Iterated(..)
+            | JsValue::Awaited(..)
             | JsValue::TypeOf(..) => JsValueMetaKind::Operation,
             JsValue::Variable(..)
             | JsValue::Argument(..)
@@ -991,6 +1008,14 @@ impl JsValue {
         Self::Member(1 + o.total_nodes() + p.total_nodes(), o, p)
     }
 
+    pub fn promise(operand: Box<JsValue>) -> Self {
+        Self::Promise(1 + operand.total_nodes(), operand)
+    }
+
+    pub fn awaited(operand: Box<JsValue>) -> Self {
+        Self::Awaited(1 + operand.total_nodes(), operand)
+    }
+
     pub fn unknown(
         value: impl Into<Arc<JsValue>>,
         side_effects: bool,
@@ -1063,6 +1088,8 @@ impl JsValue {
             | JsValue::Member(c, _, _)
             | JsValue::Function(c, _, _)
             | JsValue::Iterated(c, ..)
+            | JsValue::Promise(c, ..)
+            | JsValue::Awaited(c, ..)
             | JsValue::TypeOf(c, ..) => *c,
         }
     }
@@ -1104,6 +1131,12 @@ impl JsValue {
             JsValue::Not(c, r) => {
                 *c = 1 + r.total_nodes();
             }
+            JsValue::Promise(c, r) => {
+                *c = 1 + r.total_nodes();
+            }
+            JsValue::Awaited(c, r) => {
+                *c = 1 + r.total_nodes();
+            }
 
             JsValue::Object {
                 total_nodes: c,
@@ -1252,6 +1285,12 @@ impl JsValue {
                 JsValue::TypeOf(_, operand) => {
                     operand.make_unknown_without_content(false, "node limit reached");
                 }
+                JsValue::Awaited(_, operand) => {
+                    operand.make_unknown_without_content(false, "node limit reached");
+                }
+                JsValue::Promise(_, operand) => {
+                    operand.make_unknown_without_content(false, "node limit reached");
+                }
                 JsValue::Member(_, o, p) => {
                     make_max_unknown([&mut **o, &mut **p].into_iter());
                     self.update_total_nodes();
@@ -1494,6 +1533,18 @@ impl JsValue {
                     operand.explain_internal_inner(hints, indent_depth, depth, unknown_depth)
                 )
             }
+            JsValue::Promise(_, operand) => {
+                format!(
+                    "Promise<{}>",
+                    operand.explain_internal_inner(hints, indent_depth, depth, unknown_depth)
+                )
+            }
+            JsValue::Awaited(_, operand) => {
+                format!(
+                    "await({})",
+                    operand.explain_internal_inner(hints, indent_depth, depth, unknown_depth)
+                )
+            }
             JsValue::New(_, callee, list) => {
                 format!(
                     "new {}({})",
@@ -2111,6 +2162,8 @@ impl JsValue {
             JsValue::Argument(_, _) => false,
             JsValue::Iterated(_, iterable) => iterable.has_side_effects(),
             JsValue::TypeOf(_, operand) => operand.has_side_effects(),
+            JsValue::Promise(_, operand) => operand.has_side_effects(),
+            JsValue::Awaited(_, operand) => operand.has_side_effects(),
         }
     }
 
@@ -2307,7 +2360,8 @@ impl JsValue {
             | JsValue::Module(..)
             | JsValue::Function(..)
             | JsValue::WellKnownObject(_)
-            | JsValue::WellKnownFunction(_) => Some(false),
+            | JsValue::WellKnownFunction(_)
+            | JsValue::Promise(_, _) => Some(false),
 
             // Booleans are not strings
             JsValue::Not(..) | JsValue::Binary(..) => Some(false),
@@ -2346,6 +2400,11 @@ impl JsValue {
                 _,
             ) => Some(true),
 
+            JsValue::Awaited(_, operand) => match &**operand {
+                JsValue::Promise(_, v) => v.is_string(),
+                v => v.is_string(),
+            },
+
             JsValue::FreeVar(..)
             | JsValue::Variable(_)
             | JsValue::Unknown { .. }
@@ -2650,14 +2709,10 @@ macro_rules! for_each_children_async {
                 $value.update_total_nodes();
                 ($value, m1 || m2)
             }
-            JsValue::Iterated(_, box iterable) => {
-                let (new_iterable, modified) = $visit_fn(take(iterable), $($args),+).await?;
-                *iterable = new_iterable;
-
-                $value.update_total_nodes();
-                ($value, modified)
-            }
-            JsValue::TypeOf(_, box operand) => {
+            JsValue::Iterated(_, box operand)
+            | JsValue::TypeOf(_, box operand)
+            | JsValue::Promise(_, box operand)
+            | JsValue::Awaited(_, box operand) => {
                 let (new_operand, modified) = $visit_fn(take(operand), $($args),+).await?;
                 *operand = new_operand;
 
@@ -2962,15 +3017,10 @@ impl JsValue {
                 modified
             }
 
-            JsValue::Iterated(_, iterable) => {
-                let modified = visitor(iterable);
-                if modified {
-                    self.update_total_nodes();
-                }
-                modified
-            }
-
-            JsValue::TypeOf(_, operand) => {
+            JsValue::Iterated(_, operand)
+            | JsValue::TypeOf(_, operand)
+            | JsValue::Promise(_, operand)
+            | JsValue::Awaited(_, operand) => {
                 let modified = visitor(operand);
                 if modified {
                     self.update_total_nodes();
@@ -3164,11 +3214,10 @@ impl JsValue {
                 visitor(alt);
             }
 
-            JsValue::Iterated(_, iterable) => {
-                visitor(iterable);
-            }
-
-            JsValue::TypeOf(_, operand) => {
+            JsValue::Iterated(_, operand)
+            | JsValue::TypeOf(_, operand)
+            | JsValue::Promise(_, operand)
+            | JsValue::Awaited(_, operand) => {
                 visitor(operand);
             }
 
@@ -3566,10 +3615,10 @@ impl JsValue {
                 cons.similar_hash(state, depth - 1);
                 alt.similar_hash(state, depth - 1);
             }
-            JsValue::Iterated(_, iterable) => {
-                iterable.similar_hash(state, depth - 1);
-            }
-            JsValue::TypeOf(_, operand) => {
+            JsValue::Iterated(_, operand)
+            | JsValue::TypeOf(_, operand)
+            | JsValue::Promise(_, operand)
+            | JsValue::Awaited(_, operand) => {
                 operand.similar_hash(state, depth - 1);
             }
             JsValue::Module(ModuleValue {
@@ -3879,10 +3928,12 @@ pub mod test_utils {
                 box JsValue::WellKnownFunction(WellKnownFunctionKind::Import),
                 ref args,
             ) => match &args[0] {
-                JsValue::Constant(v) => JsValue::Module(ModuleValue {
-                    module: v.to_string().into(),
-                    annotations: ImportAnnotations::default(),
-                }),
+                JsValue::Constant(ConstantValue::Str(v)) => {
+                    JsValue::promise(Box::new(JsValue::Module(ModuleValue {
+                        module: v.as_atom().into_owned(),
+                        annotations: ImportAnnotations::default(),
+                    })))
+                }
                 _ => v.into_unknown(true, "import() non constant"),
             },
             JsValue::Call(

turbopack/crates/turbopack-ecmascript/src/analyzer/well_known.rs

@@ -57,11 +57,7 @@ pub async fn well_known_function_call(
         WellKnownFunctionKind::PathJoin => path_join(args),
         WellKnownFunctionKind::PathDirname => path_dirname(args),
         WellKnownFunctionKind::PathResolve(cwd) => path_resolve(*cwd, args),
-        WellKnownFunctionKind::Import => JsValue::unknown(
-            JsValue::call(Box::new(JsValue::WellKnownFunction(kind)), args),
-            true,
-            "import() is not supported",
-        ),
+        WellKnownFunctionKind::Import => import(args),
         WellKnownFunctionKind::Require => require(args),
         WellKnownFunctionKind::RequireContextRequire(value) => {
             require_context_require(value, args).await?
@@ -322,6 +318,27 @@ pub fn path_dirname(mut args: Vec<JsValue>) -> JsValue {
     )
 }
 
+/// Resolve the contents of an import call, throwing errors
+/// if we come across any unsupported syntax.
+pub fn import(args: Vec<JsValue>) -> JsValue {
+    match &args[..] {
+        [JsValue::Constant(ConstantValue::Str(v))] => {
+            JsValue::promise(Box::new(JsValue::Module(ModuleValue {
+                module: v.as_atom().into_owned(),
+                annotations: ImportAnnotations::default(),
+            })))
+        }
+        _ => JsValue::unknown(
+            JsValue::call(
+                Box::new(JsValue::WellKnownFunction(WellKnownFunctionKind::Import)),
+                args,
+            ),
+            true,
+            "only a single constant argument is supported",
+        ),
+    }
+}
+
 /// Resolve the contents of a require call, throwing errors
 /// if we come across any unsupported syntax.
 pub fn require(args: Vec<JsValue>) -> JsValue {

turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-explained.snapshot

@@ -1,6 +1,6 @@
-a = module<"a", {}>
+a = Promise<module<a, {}>>
 
-b = (???*0* | module<"a", {}> | module<"b", {}>)
+b = (???*0* | Promise<module<a, {}>> | Promise<module<b, {}>>)
 - *0* b
   ⚠️  pattern without value