Enum boa::syntax::ast::node::declaration::DeclarationList

pub enum DeclarationList {
    Const(Box<[Declaration]>),
    Let(Box<[Declaration]>),
    Var(Box<[Declaration]>),
}

Variants

Const(Box<[Declaration]>)

The const statements are block-scoped, much like variables defined using the let keyword.

This declaration creates a constant whose scope can be either global or local to the block in which it is declared. Global constants do not become properties of the window object, unlike var variables.

An initializer for a constant is required. You must specify its value in the same statement in which it’s declared. (This makes sense, given that it can’t be changed later.)

More information:

• ECMAScript reference
• MDN documentation

Let(Box<[Declaration]>)

The let statement declares a block scope local variable, optionally initializing it to a value.

let allows you to declare variables that are limited to a scope of a block statement, or expression on which it is used, unlike the var keyword, which defines a variable globally, or locally to an entire function regardless of block scope.

Just like const the let does not create properties of the window object when declared globally (in the top-most scope).

More information:

• ECMAScript reference
• MDN documentation

Var(Box<[Declaration]>)

The var statement declares a variable, optionally initializing it to a value.

var declarations, wherever they occur, are processed before any code is executed. This is called hoisting, and is discussed further below.

The scope of a variable declared with var is its current execution context, which is either the enclosing function or, for variables declared outside any function, global. If you re-declare a JavaScript variable, it will not lose its value.

Assigning a value to an undeclared variable implicitly creates it as a global variable (it becomes a property of the global object) when the assignment is executed.

More information:

• ECMAScript reference
• MDN documentation

Trait Implementations

impl AsRef<[Declaration]> for DeclarationList

fn as_ref(&self) -> &[Declaration]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for DeclarationList

fn clone(&self) -> DeclarationList

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DeclarationList

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

Formats the value using the given formatter.

impl Display for DeclarationList

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

Formats the value using the given formatter.

impl Drop for DeclarationList

fn drop(&mut self)

Executes the destructor for this type.

impl Executable for DeclarationList

fn run(&self, context: &mut Context) -> JsResult<JsValue>

Runs this executable in the given context.

impl Finalize for DeclarationList

fn finalize(&self)

impl From<DeclarationList> for Node

fn from(list: DeclarationList) -> Self

Converts to this type from the input type.

impl PartialEq<DeclarationList> for DeclarationList

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Trace for DeclarationList

unsafe fn trace(&self)

Marks all contained Gcs.

unsafe fn root(&self)

Increments the root-count of all contained Gcs.

unsafe fn unroot(&self)

Decrements the root-count of all contained Gcs.

fn finalize_glue(&self)

Runs Finalize::finalize() on this object and all contained subobjects

impl StructuralPartialEq for DeclarationList