Enum JsValue

pub enum JsValue {
    Constant(ConstantValue),
    Url(ConstantString, JsValueUrlKind),
    WellKnownObject(WellKnownObjectKind),
    WellKnownFunction(WellKnownFunctionKind),
    Unknown {
        original_value: Option<Arc<JsValue>>,
        reason: Cow<'static, str>,
        has_side_effects: bool,
    },
    Array {
        total_nodes: u32,
        items: Vec<JsValue>,
        mutable: bool,
    },
    Object {
        total_nodes: u32,
        parts: Vec<ObjectPart>,
        mutable: bool,
    },
    Alternatives {
        total_nodes: u32,
        values: Vec<JsValue>,
        logical_property: Option<LogicalProperty>,
    },
    Function(u32, u32, Box<JsValue>),
    Concat(u32, Vec<JsValue>),
    Add(u32, Vec<JsValue>),
    Not(u32, Box<JsValue>),
    Logical(u32, LogicalOperator, Vec<JsValue>),
    Binary(u32, Box<JsValue>, BinaryOperator, Box<JsValue>),
    New(u32, Box<JsValue>, Vec<JsValue>),
    Call(u32, Box<JsValue>, Vec<JsValue>),
    SuperCall(u32, Vec<JsValue>),
    MemberCall(u32, Box<JsValue>, Box<JsValue>, Vec<JsValue>),
    Member(u32, Box<JsValue>, Box<JsValue>),
    Tenary(u32, Box<JsValue>, Box<JsValue>, Box<JsValue>),
    Promise(u32, Box<JsValue>),
    Awaited(u32, Box<JsValue>),
    Iterated(u32, Box<JsValue>),
    TypeOf(u32, Box<JsValue>),
    Variable(Id),
    Argument(u32, usize),
    FreeVar(Atom),
    Module(ModuleValue),
}

TODO: Use Arc There are 4 kinds of values: Leaves, Nested, Operations, and Placeholders (see [JsValueMetaKind] for details). Values are processed in two phases:

• Analyze phase: We convert AST into JsValues. We don’t have contextual information so we need to insert placeholders to represent that.
• Link phase: We try to reduce a value to a constant value. The link phase has 5 substeps that are executed on each node in the graph depth-first. When a value is modified, we need to visit the new children again.
• Replace variables with their values. This replaces JsValue::Variable. No variable should be remaining after that.
• Replace placeholders with contextual information. This usually replaces JsValue::FreeVar and JsValue::Module. Some JsValue::Call on well- known functions might also be replaced. No free vars or modules should be remaining after that.
• Replace operations on well-known objects and functions. This handles JsValue::Call and JsValue::Member on well-known objects and functions.
• Replace all built-in functions with their values when they are compile-time constant.
• For optimization, any nested operations are replaced with JsValue::Unknown. So only one layer of operation remains. Any remaining operation or placeholder can be treated as unknown.

Variants

Constant(ConstantValue)

A constant primitive value.

Url(ConstantString, JsValueUrlKind)

A constant URL object.

WellKnownObject(WellKnownObjectKind)

Some kind of well-known object (must not be an array, otherwise Array.concat needs to be changed)

WellKnownFunction(WellKnownFunctionKind)

Some kind of well-known function

Unknown

Not-analyzable value. Might contain the original value for additional info. Has a reason string for explanation.

Fields

original_value: Option<Arc<JsValue>>

reason: Cow<'static, str>

has_side_effects: bool

Array

An array of nested values

Fields

total_nodes: u32

items: Vec<JsValue>

mutable: bool

Object

An object of nested values

Fields

total_nodes: u32

parts: Vec<ObjectPart>

mutable: bool

Alternatives

A list of alternative values

Fields

total_nodes: u32

values: Vec<JsValue>

logical_property: Option<LogicalProperty>

Function(u32, u32, Box<JsValue>)

A function reference. The return value might contain JsValue::Argument placeholders that need to be replaced when calling this function. (total_node_count, func_ident, return_value)

Concat(u32, Vec<JsValue>)

A string concatenation of values. foo.${unknownVar}.js => ‘foo’ + Unknown + ‘.js’

Add(u32, Vec<JsValue>)

An addition of values. This can be converted to JsValue::Concat if the type of the variable is string.

Not(u32, Box<JsValue>)

Logical negation !expr

Logical(u32, LogicalOperator, Vec<JsValue>)

Logical operator chain e. g. expr && expr

Binary(u32, Box<JsValue>, BinaryOperator, Box<JsValue>)

Binary expression e. g. expr == expr

New(u32, Box<JsValue>, Vec<JsValue>)

A constructor call. (total_node_count, callee, args)

Call(u32, Box<JsValue>, Vec<JsValue>)

A function call without a this context. (total_node_count, callee, args)

SuperCall(u32, Vec<JsValue>)

A super call to the parent constructor. (total_node_count, args)

MemberCall(u32, Box<JsValue>, Box<JsValue>, Vec<JsValue>)

A function call with a this context. (total_node_count, obj, prop, args)

Member(u32, Box<JsValue>, Box<JsValue>)

A member access obj[prop] (total_node_count, obj, prop)

Tenary(u32, Box<JsValue>, Box<JsValue>, Box<JsValue>)

A tenary operator test ? cons : alt (total_node_count, test, cons, alt)

Promise(u32, Box<JsValue>)

A promise resolving to some value (total_node_count, value)

Awaited(u32, Box<JsValue>)

An await call (potentially) unwrapping a promise. (total_node_count, value)

Iterated(u32, Box<JsValue>)

A for-of loop

(total_node_count, iterable)

TypeOf(u32, Box<JsValue>)

A typeof expression.

(total_node_count, operand)

Variable(Id)

A reference to a variable.

Argument(u32, usize)

A reference to an function argument. (func_ident, arg_index)

FreeVar(Atom)

A reference to a free variable.

Module(ModuleValue)

This is a reference to a imported module.

Implementations

impl JsValue

pub fn alternatives(list: Vec<JsValue>) -> Self

pub fn alternatives_with_addtional_property( list: Vec<JsValue>, logical_property: LogicalProperty, ) -> Self

pub fn concat(list: Vec<JsValue>) -> Self

pub fn add(list: Vec<JsValue>) -> Self

pub fn logical_and(list: Vec<JsValue>) -> Self

pub fn logical_or(list: Vec<JsValue>) -> Self

pub fn nullish_coalescing(list: Vec<JsValue>) -> Self

pub fn tenary(test: Box<JsValue>, cons: Box<JsValue>, alt: Box<JsValue>) -> Self

pub fn iterated(iterable: Box<JsValue>) -> Self

pub fn equal(a: Box<JsValue>, b: Box<JsValue>) -> Self

pub fn not_equal(a: Box<JsValue>, b: Box<JsValue>) -> Self

pub fn strict_equal(a: Box<JsValue>, b: Box<JsValue>) -> Self

pub fn strict_not_equal(a: Box<JsValue>, b: Box<JsValue>) -> Self

pub fn logical_not(inner: Box<JsValue>) -> Self

pub fn type_of(operand: Box<JsValue>) -> Self

pub fn array(items: Vec<JsValue>) -> Self

pub fn frozen_array(items: Vec<JsValue>) -> Self

pub fn function(func_ident: u32, return_value: Box<JsValue>) -> Self

pub fn object(list: Vec<ObjectPart>) -> Self

pub fn frozen_object(list: Vec<ObjectPart>) -> Self

pub fn new(f: Box<JsValue>, args: Vec<JsValue>) -> Self

pub fn call(f: Box<JsValue>, args: Vec<JsValue>) -> Self

pub fn super_call(args: Vec<JsValue>) -> Self

pub fn member_call(o: Box<JsValue>, p: Box<JsValue>, args: Vec<JsValue>) -> Self

pub fn member(o: Box<JsValue>, p: Box<JsValue>) -> Self

pub fn promise(operand: Box<JsValue>) -> Self

pub fn awaited(operand: Box<JsValue>) -> Self

pub fn unknown( value: impl Into<Arc<JsValue>>, side_effects: bool, reason: impl Into<Cow<'static, str>>, ) -> Self

pub fn unknown_empty( side_effects: bool, reason: impl Into<Cow<'static, str>>, ) -> Self

pub fn unknown_if( is_unknown: bool, value: JsValue, side_effects: bool, reason: impl Into<Cow<'static, str>>, ) -> Self

impl JsValue

pub fn has_children(&self) -> bool

pub fn total_nodes(&self) -> u32

pub fn debug_assert_total_nodes_up_to_date(&mut self)

pub fn ensure_node_limit(&mut self, limit: u32)

impl JsValue

pub fn explain_args( args: &[JsValue], depth: usize, unknown_depth: usize, ) -> (String, String)

pub fn explain(&self, depth: usize, unknown_depth: usize) -> (String, String)

impl JsValue

pub fn make_unknown( &mut self, side_effects: bool, reason: impl Into<Cow<'static, str>>, )

Convert the value into unknown with a specific reason.

pub fn into_unknown( self, side_effects: bool, reason: impl Into<Cow<'static, str>>, ) -> Self

Convert the owned value into unknown with a specific reason.

pub fn make_unknown_without_content( &mut self, side_effects: bool, reason: impl Into<Cow<'static, str>>, )

Convert the value into unknown with a specific reason, but don’t retain the original value.

pub fn make_nested_operations_unknown(&mut self) -> bool

Make all nested operations unknown when the value is an operation.

pub fn add_unknown_mutations(&mut self, side_effects: bool)

impl JsValue

pub fn get_defineable_name_len(&self) -> Option<usize>

When the value has a user-defineable name, return the length of it (in segments). Otherwise returns None.

• any free var has itself as user-defineable name: [“foo”]
• any member access adds the identifier as segment after the object: [“foo”, “prop”]
• some well-known objects/functions have a user-defineable names: [“import”]
• member calls without arguments also have a user-defineable name which is the property with () appended: [“foo”, “prop()”]
• typeof expressions add typeof after the argument’s segments: [“foo”, “typeof”]

pub fn iter_defineable_name_rev(&self) -> DefineableNameIter<'_>

Returns a reverse iterator over the segments of the user-defineable name. e. g. foo.bar().baz would yield baz, bar(), foo. (1+2).foo.baz would also yield baz, foo even while the value is not a complete user-defineable name. Before calling this method you must use JsValue::get_defineable_name_len to determine if the value has a user-defineable name at all.

pub fn match_free_var_reference<'a, T>( &self, var_graph: Option<&VarGraph>, free_var_references: &'a FxIndexMap<DefineableNameSegment, FxIndexMap<Vec<DefineableNameSegment>, T>>, prop: &DefineableNameSegment, ) -> Option<&'a T>

Returns any matching defined replacement that matches this value (the replacement that matches $self.$prop).

Optionally when passed a VarGraph, verifies that the first segment is not a local variable/was not reassigned.

pub fn match_define<'a, T>( &self, defines: &'a FxIndexMap<Vec<DefineableNameSegment>, T>, ) -> Option<&'a T>

Returns any matching defined replacement that matches this value.

impl JsValue

pub fn as_str(&self) -> Option<&str>

Returns the constant string if the value represents a constant string.

pub fn as_bool(&self) -> Option<bool>

Returns the constant bool if the value represents a constant boolean.

pub fn has_side_effects(&self) -> bool

pub fn is_truthy(&self) -> Option<bool>

Checks if the value is truthy. Returns None if we don’t know. Returns Some if we know if or if not the value is truthy.

pub fn is_falsy(&self) -> Option<bool>

Checks if the value is falsy. Returns None if we don’t know. Returns Some if we know if or if not the value is falsy.

pub fn is_nullish(&self) -> Option<bool>

Checks if the value is nullish (null or undefined). Returns None if we don’t know. Returns Some if we know if or if not the value is nullish.

pub fn is_not_nullish(&self) -> Option<bool>

Checks if we know that the value is not nullish. Returns None if we don’t know. Returns Some if we know if or if not the value is not nullish.

pub fn is_empty_string(&self) -> Option<bool>

Checks if we know that the value is an empty string. Returns None if we don’t know. Returns Some if we know if or if not the value is an empty string.

pub fn is_unknown(&self) -> bool

Returns true, if the value is unknown and storing it as condition doesn’t make sense. This is for optimization purposes.

pub fn is_string(&self) -> Option<bool>

Checks if we know that the value is a string. Returns None if we don’t know. Returns Some if we know if or if not the value is a string.

pub fn starts_with(&self, str: &str) -> Option<bool>

Checks if we know that the value starts with a given string. Returns None if we don’t know. Returns Some if we know if or if not the value starts with the given string.

pub fn ends_with(&self, str: &str) -> Option<bool>

Checks if we know that the value ends with a given string. Returns None if we don’t know. Returns Some if we know if or if not the value ends with the given string.

impl JsValue

pub async fn visit_async_until_settled<'a, F, R, E>( self, visitor: &mut F, ) -> Result<(Self, bool), E>

where R: 'a + Future<Output = Result<(Self, bool), E>> + Send, F: 'a + FnMut(JsValue) -> R + Send,

Visit the node and all its children with a function in a loop until the visitor returns false for the node and all children

pub async fn visit_each_children_async_until_settled<'a, F, R, E>( self, visitor: &mut F, ) -> Result<Self, E>

where R: 'a + Future<Output = Result<(Self, bool), E>> + Send, F: 'a + FnMut(JsValue) -> R + Send,

Visit all children of the node with an async function in a loop until the visitor returns false

pub async fn visit_async<'a, F, R, E>( self, visitor: &mut F, ) -> Result<(Self, bool), E>

where R: 'a + Future<Output = Result<(Self, bool), E>>, F: 'a + FnMut(JsValue) -> R,

Visit the node and all its children with an async function.

pub async fn visit_each_children_async<'a, F, R, E>( self, visitor: &mut F, ) -> Result<(Self, bool), E>

where R: 'a + Future<Output = Result<(Self, bool), E>>, F: 'a + FnMut(JsValue) -> R,

Visit all children of the node with an async function.

pub async fn for_each_children_async<'a, F, R, E>( self, visitor: &mut F, ) -> Result<(Self, bool), E>

where R: 'a + Future<Output = Result<(Self, bool), E>>, F: 'a + FnMut(JsValue) -> R,

Call an async function for each child of the node.

pub fn visit_mut_until_settled( &mut self, visitor: &mut impl FnMut(&mut JsValue) -> bool, )

Visit the node and all its children with a function in a loop until the visitor returns false

pub fn visit_mut( &mut self, visitor: &mut impl FnMut(&mut JsValue) -> bool, ) -> bool

Visit the node and all its children with a function.

pub fn visit_mut_conditional( &mut self, condition: impl Fn(&JsValue) -> bool, visitor: &mut impl FnMut(&mut JsValue) -> bool, ) -> bool

Visit all children of the node with a function. Only visits nodes where the condition is true.

pub fn for_each_children_mut( &mut self, visitor: &mut impl FnMut(&mut JsValue) -> bool, ) -> bool

Calls a function for each child of the node. Allows mutating the node. Updates the total nodes count after mutation.

pub fn for_each_early_children_mut( &mut self, visitor: &mut impl FnMut(&mut JsValue) -> bool, ) -> bool

Calls a function for only early children. Allows mutating the node. Updates the total nodes count after mutation.

pub fn for_each_late_children_mut( &mut self, visitor: &mut impl FnMut(&mut JsValue) -> bool, ) -> bool

Calls a function for only late children. Allows mutating the node. Updates the total nodes count after mutation.

pub fn visit(&self, visitor: &mut impl FnMut(&JsValue))

Visit the node and all its children with a function.

pub fn for_each_children(&self, visitor: &mut impl FnMut(&JsValue))

Calls a function for all children of the node.

impl JsValue

pub fn normalize_shallow(&mut self)

Normalizes only the current node. Nested alternatives, concatenations, or operations are collapsed.

pub fn normalize(&mut self)

Normalizes the current node and all nested nodes.

Trait Implementations

impl Clone for JsValue

fn clone(&self) -> JsValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for JsValue

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

Formats the value using the given formatter.

impl Default for JsValue

fn default() -> Self

Returns the “default value” for a type.

impl Display for JsValue

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

Formats the value using the given formatter.

impl From<&CompileTimeDefineValue> for JsValue

fn from(v: &CompileTimeDefineValue) -> Self

Converts to this type from the input type.

impl From<&FreeVarReference> for JsValue

fn from(v: &FreeVarReference) -> Self

Converts to this type from the input type.

impl From<&str> for JsValue

fn from(v: &str) -> Self

Converts to this type from the input type.

impl From<Atom> for JsValue

fn from(v: Atom) -> Self

Converts to this type from the input type.

impl From<BigInt> for JsValue

fn from(v: BigInt) -> Self

Converts to this type from the input type.

impl From<Box<BigInt>> for JsValue

fn from(v: Box<BigInt>) -> Self

Converts to this type from the input type.

impl From<ConstantValue> for JsValue

fn from(v: ConstantValue) -> Self

Converts to this type from the input type.

impl From<RcStr> for JsValue

fn from(v: RcStr) -> Self

Converts to this type from the input type.

impl From<Str> for JsValue

fn from(v: Str) -> Self

Converts to this type from the input type.

impl From<String> for JsValue

fn from(v: String) -> Self

Converts to this type from the input type.

impl From<f64> for JsValue

fn from(v: f64) -> Self

Converts to this type from the input type.

impl Hash for JsValue

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for JsValue

fn eq(&self, other: &JsValue) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for JsValue

impl StructuralPartialEq for JsValue