Struct ExpressionStatement 

#[repr(C)]
pub struct ExpressionStatement<'gc> {
    pub metadata: NodeMetadata<'gc>,
    pub expression: &'gc Node<'gc>,
    pub directive: Cell<NodeString>,
}

The ExpressionStatement AST node.

Fields

metadata: NodeMetadata<'gc>

Source range, debug location, paren count, and node id.

expression: &'gc Node<'gc>

ESTree expression property.

directive: Cell<NodeString>

ESTree directive property.

Implementations

impl<'gc> ExpressionStatement<'gc>

pub fn new( metadata: NodeMetadata<'gc>, expression: &'gc Node<'gc>, directive: NodeString, ) -> Self

Build ExpressionStatement from its metadata and ESTree.def fields.

pub fn try_directive_str<'a>(&self, gc: &'a GCLock<'_, '_>) -> Option<&'a str>

The directive string value as UTF-8, or None if it has no UTF-8 form.

A JS string value is a sequence of UTF-16 code units, so it may legally contain an unpaired surrogate ("\uD800" parses, and is not an error). That, and only that, is what None reports: the value is intact, it simply cannot be spelled in UTF-8. Read it losslessly with GCLock::bytes.

Only an unpaired surrogate is unrepresentable. A WTF-8 surrogate pair is not: the lexer interns an astral character in surrogate-pair form, and it is folded back into the character it encodes, so a "😀" literal yields Some("😀"), not None.

There is deliberately no plain directive_str: an unrepresentable identifier means something is broken, but an unrepresentable string literal is legal JS, and a codegen or refactoring tool that let U+FFFD be substituted here would silently rewrite the user’s program. Reach for Self::directive_str_lossy only when a best-effort rendering is what you want.

Valid UTF-8 is borrowed from the atom’s own bytes and allocates nothing; folding a surrogate pair allocates once per atom, cached in the context. The returned &str borrows from gc, not from self.

pub fn directive_str_lossy<'a>(&self, gc: &'a GCLock<'_, '_>) -> &'a str

The directive string value as UTF-8, substituting U+FFFD for anything unrepresentable.

This is lossy. A JS string value may legally contain an unpaired surrogate ("\uD800" parses), which has no UTF-8 form; each one becomes exactly one U+FFFD here. Do not use this to re-emit source: a codegen or refactoring tool would silently rewrite the user’s program.

Only an unpaired surrogate is unrepresentable. A WTF-8 surrogate pair is not: the lexer interns an astral character in surrogate-pair form, and it is folded back into the character it encodes, so a "😀" literal comes out intact.

Use Self::try_directive_str or GCLock::bytes when the exact value matters. The returned &str borrows from gc, not from self.

Trait Implementations

impl<'gc> Debug for ExpressionStatement<'gc>

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

Formats the value using the given formatter.