Struct JsExpr 

pub struct JsExpr<'a> {
    pub ast: &'a Expression<'a>,
    pub source: &'a str,
    pub span: Span,
    pub coordinates: Option<&'a JsCoordinates<'a>>,
}

The retained JS payload behind super::ExprRef::Js.

The architecture names the variant Js(&'a Expression<'a>); the landed payload carries that AST reference beside its exact text and authored span, because the folio contract in the same task requires slice + span at print time and an AST pointer alone cannot recover either (a standalone-parsed expression’s oxc spans are text-relative, not file-relative). The deviation is recorded in docs/davinci/plan/phase-2-records/p2-5b.md.

Fields

ast: &'a Expression<'a>

The retained AST. Native wrapper offsets pass through JsExpr::ast_span_to_source; identity load-path offsets stay relative to this expression’s source, never to the compiled file.

source: &'a str

The decoded expression text, without any internal parser wrapper.

span: Span

The authored range of source in the compiled file.

coordinates: Option<&'a JsCoordinates<'a>>

Native once-parsed syntax has checked wrapper/decode coordinates. Identity load-path expressions retain their original layout semantics.

Implementations

impl<'a> JsExpr<'a>

pub fn from_retained_in( allocator: &'a Allocator, ast: &'a Expression<'a>, source: &'a str, span: Span, coordinates: JsCoordinates<'a>, ) -> Result<&'a Self, JsCoordinateError>

Transfer an existing AST, retaining its children without parsing or walking.

pub fn ast_span_to_source(&self, span: Span) -> Option<Span>

Correct parser offsets to decoded expression bytes before reading text.

pub fn authored_span(&self, span: Span) -> Option<Span>

Exact authored projection. Partial entity expansions cannot select edits.

pub fn matches_authored_source(&self, file: &str) -> bool

Verify that the emitter received the same authoritative authored bytes.

pub fn parse_in( allocator: &'a Allocator, source: &'a str, span: Span, ) -> Result<&'a Self, OpaqueReason>

Parse source as one complete TS-dialect expression into the arena, or classify why that is impossible.

The refusals are the two text-classifiable escape classes (see OpaqueReason for the position-classified ones):

• OpaqueReason::NestingRefused - the shared nesting guard (vize_l0::expression_guard) refused the text before oxc ever saw it, exactly as every other oxc entry point does.
• OpaqueReason::ParseRejected - oxc rejected the text, or the first complete expression does not cover it (a++; b++ parses as a++ and stops; retaining that would lie).

pub fn parse_ast_in( allocator: &'a Allocator, source: &'a str, ) -> Result<Expression<'a>, OpaqueReason>

Parse with the same complete-expression admission as Self::parse_in, returning the owned AST so another arena payload can contain it directly. The AST’s children borrow allocator; no outer AST or JsExpr payload is allocated here.

Trait Implementations

impl<'a> Clone for JsExpr<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for JsExpr<'a>

impl<'a> Debug for JsExpr<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.