Struct sljs::ast::LexicalContext

pub struct LexicalContext { /* private fields */ }

LexicalContext collects lexical scope information for some static analysis.

It produces Programs, Functions and BlockStatements, ensuring that their bindings and free variables are statically known and correct.

Implementations

impl LexicalContext

pub fn new_program<F>(action: F) -> ParseResult<Program> where
    F: FnOnce(&mut LexicalContext) -> ParseResult<BlockStatement>, 

Start building a AST for a Program

E.g.

use sljs::ast::{self, build::*};

let program = ast::LexicalContext::new_program(|ctx|
    ctx.enter_block(|ctx| {
        Ok(vec![                                // : Vec<Statement>
            ctx.var_("x", lit(2))?,             // : Statement
            add(ctx.id("x"), lit(3)).into(),    // : Statement
        ])
    })                                          // : ParseResult<BlockStatement>
).expect("Program");

pub fn id(&mut self, name: &str) -> Expression

AST-builder wrapper for Self::new_id

pub fn new_id(&mut self, name: JSString) -> Identifier

Create and note the usage of an Identifier in an expression context.

pub fn var(&mut self, name: &str) -> ParseResult<Statement>

AST-builder wrapper for Self::declare_var for one variable without initialization

pub fn var_(&mut self, name: &str, initexpr: Expression) -> ParseResult<Statement>

AST-builder wrapper for Self::declare_var for one variable with initialization

pub fn declare_var(
    &mut self,
    kind: DeclarationKind,
    name: &Identifier
) -> ParseResult<()>

Note a let/const/var declaration.

pub fn function<F>(
    &mut self,
    argnames: &[&str],
    body: F
) -> ParseResult<Expression> where
    F: FnMut(&mut LexicalContext) -> ParseResult<Vec<Statement>>, 

AST-builder wrapper for Self::enter_function

It takes a closure that produces the list of statements in the body and return a FunctionExpression wrapped in an Expression:

use sljs::{
    ast::LexicalContext,
    ast::build::*,
};

let mut ctx = LexicalContext::default();
let sqr = ctx.function(&["x"], |ctx| Ok(vec![
    return_(mul(ctx.id("x"), ctx.id("x"))),
])).expect("FunctionExpression");

pub fn declare_func(&mut self, function: &FunctionDeclaration) -> ParseResult<()>

Note a function declaration.

pub fn block<F>(&mut self, action: F) -> ParseResult<BlockStatement> where
    F: FnOnce(&mut Self) -> ParseResult<Vec<Statement>>, 

An AST-builder wrapper for Self::enter_block

pub fn enter_block<F>(&mut self, action: F) -> ParseResult<BlockStatement> where
    F: FnOnce(&mut LexicalContext) -> ParseResult<Vec<Statement>>, 

pub fn enter_function<F>(&mut self, action: F) -> ParseResult<Function> where
    F: FnOnce(&mut LexicalContext) -> ParseResult<(Option<Identifier>, Vec<Pattern>, BlockStatement)>, 

Trait Implementations

impl Debug for LexicalContext

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

Formats the value using the given formatter.

impl Default for LexicalContext

fn default() -> Self

This is not what you usually want, build a Program with LexicalContext::new_program instead.