[rust-compiler] Carry uninspected AST subtrees as raw JSON text (react#36730)

Stacked on react#36729 (upstream rejects cross-fork base branches, so this
targets main as a draft; the first commit belongs to the parent PR.
Review the last three commits. Will rebase and mark ready when react#36729
lands.)

Unmodeled AST subtrees (type annotations, class bodies, unknown
statements) were stored as `serde_json::Value` trees: every node
allocated through a `Map<String, Value>`, and pass-through subtrees were
repeatedly traversed by code that never looks inside them. They are now
`RawNode`, a newtype over `Box<RawValue>` holding the original JSON text
verbatim.

Design notes, since two obvious alternatives fail:
- Bare `RawValue` fields break under `#[serde(tag = "type")]` enums:
internally-tagged deserialization buffers content into serde's private
`Content` tree, which `RawValue` cannot read from.
`RawNode::deserialize` instead streams whatever deserializer it is
handed through `serde_transcode` into a fresh JSON string, which works
behind tagged enums, `flatten`, and `from_value` alike.
- Default-limit reparses break deep ASTs: internal `RawNode` reparse
sites use `from_json_str_unbounded` (disables serde_json's 128-level
recursion limit, matching how the top-level parse is configured);
regression-tested with a 400-deep statement chain.

`parse_value` fails loudly on malformed text rather than masking
corruption with `Value::Null`; RawNode holds valid JSON by construction.

Size-neutral in the shipped binary; the win is structural (no
speculative `Value` trees on the hot path, pass-through subtrees stay
untouched text).

Verified on this exact tree: cargo workspace tests, both snap channels
1804/1804.

---------

Co-authored-by: Boshen <1430279+Boshen@users.noreply.github.com>

Author: poteto

compiler/Cargo.lock

@@ -790,7 +790,7 @@ fn calls_hooks_or_creates_jsx_in_class_body(
 ) -> bool {
     body.body
         .iter()
-        .any(|member| calls_hooks_or_creates_jsx_in_json(member))
+        .any(|member| calls_hooks_or_creates_jsx_in_json(&member.parse_value()))
 }
 
 fn calls_hooks_or_creates_jsx_in_json(value: &serde_json::Value) -> bool {
@@ -930,11 +930,11 @@ fn calls_hooks_or_creates_jsx_in_pattern(pattern: &PatternLike) -> bool {
 /// Returns false for primitive type annotations that indicate this is NOT a component.
 fn is_valid_props_annotation(param: &PatternLike) -> bool {
     let type_annotation = match param {
-        PatternLike::Identifier(id) => id.type_annotation.as_deref(),
-        PatternLike::ObjectPattern(op) => op.type_annotation.as_deref(),
-        PatternLike::ArrayPattern(ap) => ap.type_annotation.as_deref(),
-        PatternLike::AssignmentPattern(ap) => ap.type_annotation.as_deref(),
-        PatternLike::RestElement(re) => re.type_annotation.as_deref(),
+        PatternLike::Identifier(id) => id.type_annotation.as_ref(),
+        PatternLike::ObjectPattern(op) => op.type_annotation.as_ref(),
+        PatternLike::ArrayPattern(ap) => ap.type_annotation.as_ref(),
+        PatternLike::AssignmentPattern(ap) => ap.type_annotation.as_ref(),
+        PatternLike::RestElement(re) => re.type_annotation.as_ref(),
         PatternLike::MemberExpression(_)
         | PatternLike::TSAsExpression(_)
         | PatternLike::TSSatisfiesExpression(_)
@@ -943,7 +943,7 @@ fn is_valid_props_annotation(param: &PatternLike) -> bool {
         | PatternLike::TypeCastExpression(_) => None,
     };
     let annot = match type_annotation {
-        Some(val) => val,
+        Some(raw) => raw.parse_value(),
         None => return true, // No annotation = valid
     };
     let annot_type = match annot.get("type").and_then(|v| v.as_str()) {
@@ -2181,7 +2181,9 @@ fn stmt_references_identifier_at_top_level(stmt: &Statement, name: &str) -> bool
         // Unmodeled statements (e.g. `export = X`) can reference top-level
         // bindings; scan the raw node for a matching Identifier so the
         // gating reference-before-declaration analysis does not miss them.
-        Statement::Unknown(unknown) => raw_node_references_identifier(unknown.raw(), name),
+        Statement::Unknown(unknown) => {
+            raw_node_references_identifier(&unknown.raw().parse_value(), name)
+        }
         _ => false,
     }
 }

compiler/crates/react_compiler/src/entrypoint/program.rs

@@ -5,7 +5,8 @@ edition = "2024"
 
 [dependencies]
 serde = { version = "1", features = ["derive"] }
-serde_json = "1"
+serde_json = { version = "1", features = ["raw_value", "unbounded_depth"] }
+serde-transcode = "1"
 indexmap = { version = "2", features = ["serde"] }
 
 [dev-dependencies]

compiler/crates/react_compiler_ast/Cargo.toml

@@ -1,18 +1,101 @@
 use serde::Deserialize;
 use serde::Serialize;
 
+/// An AST subtree the compiler does not model with typed nodes (type
+/// annotations, class bodies, parser extras). Wraps JSON text: serialization
+/// is verbatim pass-through and deserialization streams the subtree into text
+/// without retaining a `serde_json::Value` tree. Consumers that inspect these
+/// subtrees parse on demand via [`RawNode::parse_value`]; paths that do so
+/// repeatedly per traversal pay a parse each time, so cache the parsed Value
+/// at the call site if it shows up in profiles.
+///
+/// Deserialize is hand-implemented with a transcode rather than capturing a
+/// `RawValue` directly: most nodes sit under `#[serde(tag = "type")]` enums,
+/// whose content buffering breaks `RawValue`'s text-borrowing capture.
+#[derive(Debug, Clone, Serialize)]
+#[serde(transparent)]
+pub struct RawNode(pub Box<serde_json::value::RawValue>);
+
+impl<'de> serde::Deserialize<'de> for RawNode {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let mut buf = Vec::new();
+        let mut ser = serde_json::Serializer::new(&mut buf);
+        serde_transcode::transcode(deserializer, &mut ser).map_err(serde::de::Error::custom)?;
+        let text = String::from_utf8(buf).map_err(serde::de::Error::custom)?;
+        serde_json::value::RawValue::from_string(text)
+            .map(RawNode)
+            .map_err(serde::de::Error::custom)
+    }
+}
+
+impl RawNode {
+    pub fn from_value(value: &serde_json::Value) -> Self {
+        RawNode(
+            serde_json::value::RawValue::from_string(value.to_string())
+                .expect("serde_json::Value always serializes to valid JSON"),
+        )
+    }
+
+    pub fn null() -> Self {
+        RawNode(
+            serde_json::value::RawValue::from_string("null".to_string())
+                .expect("null is valid JSON"),
+        )
+    }
+
+    /// The raw JSON text of this subtree.
+    pub fn get(&self) -> &str {
+        self.0.get()
+    }
+
+    /// Parse the subtree into a `serde_json::Value` for structural inspection.
+    /// RawNode text is valid JSON by construction, so failure here means a
+    /// broken invariant, not bad input; fail loudly rather than degrade.
+    pub fn parse_value(&self) -> serde_json::Value {
+        from_json_str_unbounded(self.0.get())
+            .expect("RawNode holds valid JSON by construction")
+    }
+
+    /// The node's `"type"` field, without parsing the whole subtree into a Value.
+    pub fn type_name(&self) -> Option<String> {
+        #[derive(Deserialize)]
+        struct TypeProbe {
+            #[serde(rename = "type")]
+            type_name: Option<String>,
+        }
+        from_json_str_unbounded::<TypeProbe>(self.0.get())
+            .ok()
+            .and_then(|p| p.type_name)
+    }
+}
+
+/// Parse JSON text with serde_json's recursion limit disabled. Every internal
+/// reparse of [`RawNode`] text must go through this: the napi entrypoint
+/// deserializes arbitrarily deep ASTs with the limit disabled (on a 64MB
+/// stack), and the tolerant statement path's reparses must not quietly
+/// reintroduce the default limit.
+pub fn from_json_str_unbounded<'de, T: serde::Deserialize<'de>>(
+    s: &'de str,
+) -> serde_json::Result<T> {
+    let mut deserializer = serde_json::Deserializer::from_str(s);
+    deserializer.disable_recursion_limit();
+    T::deserialize(&mut deserializer)
+}
+
 /// Custom deserializer that distinguishes "field absent" from "field: null".
 /// - JSON field absent → `None` (via `#[serde(default)]`)
-/// - JSON field `null` → `Some(Value::Null)`
-/// - JSON field with value → `Some(value)`
+/// - JSON field `null` → `Some(RawNode("null"))`
+/// - JSON field with value → `Some(raw value)`
 ///
 /// Use with `#[serde(default, skip_serializing_if = "Option::is_none", deserialize_with = "nullable_value")]`
-pub fn nullable_value<'de, D>(deserializer: D) -> Result<Option<Box<serde_json::Value>>, D::Error>
+pub fn nullable_value<'de, D>(deserializer: D) -> Result<Option<RawNode>, D::Error>
 where
     D: serde::Deserializer<'de>,
 {
-    let value = serde_json::Value::deserialize(deserializer)?;
-    Ok(Some(Box::new(value)))
+    RawNode::deserialize(deserializer).map(Some)
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -75,7 +158,7 @@ pub struct BaseNode {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub range: Option<(u32, u32)>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub extra: Option<serde_json::Value>,
+    pub extra: Option<RawNode>,
     #[serde(
         default,
         skip_serializing_if = "Option::is_none",