Quelle  pass.rs

//! Code to traverse the AST and drive the rest of scope analysis.
//!
//! This module is responsible for walking the AST. Other modules do the actual
//! analysis.
//!
//! Scope analysis is currently a second pass, after parsing, using the AST,
//! but the goal is to do this analysis as part of the parse phase, even when
//! no AST is built. So we try to keep AST use separate from the analysis code.

use crate::builder::{ScopeBuildError, ScopeDataMapAndScriptStencilList, ScopeDataMapBuilder};
use crate::data::FunctionDeclarationPropertyMap;
use ast::arena;
use ast::associated_data::AssociatedData;
use ast::source_atom_set::CommonSourceAtomSetIndices;
use ast::{types::*, visit::Pass};
use std::collections::HashMap;
use stencil::scope::ScopeDataMap;
use stencil::script::{ScriptStencilIndex, ScriptStencilList};

/// The result of scope analysis.
pub struct ScopePassResult<'alloc> {
    pub scope_data_map: ScopeDataMap,
    pub function_declarations: HashMap<ScriptStencilIndex, &'alloc Function<'alloc>>,
    pub function_stencil_indices: AssociatedData<ScriptStencilIndex>,
    pub function_declaration_properties: FunctionDeclarationPropertyMap,
    pub scripts: ScriptStencilList,
    pub error: Option<ScopeBuildError>,
}

/// The top-level struct responsible for extracting the necessary information
/// from the AST. The analysis itself is done mainly by the `ScopeDataMapBuilder`,
/// which has very limited interaction with the AST.
///
/// FIXME: This should be rewritten as a grammar extension.
#[derive(Debug)]
pub struct ScopePass<'alloc> {
    builder: ScopeDataMapBuilder,
    function_declarations: HashMap<ScriptStencilIndex, &'alloc Function<'alloc>>,
}

impl<'alloc> ScopePass<'alloc> {
    pub fn new() -> Self {
        Self {
            builder: ScopeDataMapBuilder::new(),
            function_declarations: HashMap::new(),
        }
    }
}

impl<'alloc> From<ScopePass<'alloc>> for ScopePassResult<'alloc> {
    fn from(pass: ScopePass<'alloc>) -> ScopePassResult<'alloc> {
        let ScopeDataMapAndScriptStencilList {
            scope_data_map,
            function_stencil_indices,
            function_declaration_properties,
            scripts,
            error,
        } = pass.builder.into();
        ScopePassResult {
            scope_data_map,
            function_declarations: pass.function_declarations,
            function_stencil_indices,
            function_declaration_properties,
            scripts,
            error,
        }
    }
}

impl<'alloc> Pass<'alloc> for ScopePass<'alloc> {
    fn enter_script(&mut self, _ast: &'alloc Script<'alloc>) {
        self.builder.before_script();
    }

    fn leave_script(&mut self, _ast: &'alloc Script<'alloc>) {
        self.builder.after_script();
    }

    fn enter_enum_statement_variant_block_statement(&mut self, block: &'alloc Block<'alloc>) {
        self.builder.before_block_statement(block);
    }

    fn leave_enum_statement_variant_block_statement(&mut self, _block: &'alloc Block<'alloc>) {
        self.builder.after_block_statement();
    }

    fn enter_variable_declaration(&mut self, ast: &'alloc VariableDeclaration<'alloc>) {
        match ast.kind {
            VariableDeclarationKind::Var { .. } => {
                self.builder.before_var_declaration();
            }
            VariableDeclarationKind::Let { .. } => {
                self.builder.before_let_declaration();
            }
            VariableDeclarationKind::Const { .. } => {
                self.builder.before_const_declaration();
            }
        }
    }

    fn leave_variable_declaration(&mut self, ast: &'alloc VariableDeclaration<'alloc>) {
        match ast.kind {
            VariableDeclarationKind::Var { .. } => {
                self.builder.after_var_declaration();
            }
            VariableDeclarationKind::Let { .. } => {
                self.builder.after_let_declaration();
            }
            VariableDeclarationKind::Const { .. } => {
                self.builder.after_const_declaration();
            }
        }
    }

    fn visit_binding_identifier(&mut self, ast: &'alloc BindingIdentifier) {
        self.builder.on_binding_identifier(ast.name.value);
    }

    // Given we override `visit_binding_identifier` above,
    // visit_identifier is not called for Identifier inside BindingIdentifier,
    // and this is called only for references, either
    // IdentifierExpression or AssignmentTargetIdentifier.
    fn visit_identifier(&mut self, ast: &'alloc Identifier) {
        self.builder.on_non_binding_identifier(ast.value);
    }

    fn visit_enum_expression_variant_this_expression(&mut self) {
        self.builder
            .on_non_binding_identifier(CommonSourceAtomSetIndices::this());
    }

    fn enter_enum_statement_variant_function_declaration(&mut self, ast: &'alloc Function<'alloc>) {
        if !self.builder.is_syntax_only_mode() {
            self.builder.enter_syntax_only_mode();
        }

        let name = if let Some(ref name) = ast.name {
            name.name.value
        } else {
            panic!("FunctionDeclaration should have name");
        };
        let fun_index =
            self.builder
                .before_function_declaration(name, ast, ast.is_generator, ast.is_async);
        self.function_declarations.insert(fun_index, ast);
    }

    fn leave_enum_statement_variant_function_declaration(&mut self, ast: &'alloc Function<'alloc>) {
        self.builder.after_function_declaration(ast);
    }

    fn enter_enum_expression_variant_function_expression(&mut self, ast: &'alloc Function<'alloc>) {
        if !self.builder.is_syntax_only_mode() {
            self.builder.enter_syntax_only_mode();
        }

        self.builder
            .before_function_expression(ast, ast.is_generator, ast.is_async);
    }

    fn leave_enum_expression_variant_function_expression(&mut self, ast: &'alloc Function<'alloc>) {
        self.builder.after_function_expression(ast);
    }

    fn visit_formal_parameters(&mut self, ast: &'alloc FormalParameters<'alloc>) {
        self.builder.before_function_parameters(ast);

        self.enter_formal_parameters(ast);
        for item in &ast.items {
            self.builder.before_parameter();
            self.visit_parameter(item);
        }
        if let Some(item) = &ast.rest {
            self.builder.before_rest_parameter();
            self.visit_binding(item);
        }
        self.leave_formal_parameters(ast);

        self.builder.after_function_parameters();
    }

    fn enter_enum_method_definition_variant_method(&mut self, ast: &'alloc Method<'alloc>) {
        self.builder
            .before_method(ast, ast.is_generator, ast.is_async);
        // FIXME: Call self.builder.on_function_name
    }

    fn leave_enum_method_definition_variant_method(&mut self, ast: &'alloc Method<'alloc>) {
        self.builder.after_method(ast);
    }

    /// Getter doesn't have FormalParameters.
    /// Call builder methods just before body.
    fn visit_getter(&mut self, ast: &'alloc Getter<'alloc>) {
        self.builder.before_getter(ast);
        // FIXME: Call self.builder.on_function_name

        self.enter_getter(ast);
        self.visit_class_element_name(&ast.property_name);

        // FIXME: Pass something that points `()` part of getter.
        self.builder.on_getter_parameter(ast);

        self.visit_function_body(&ast.body);
        self.leave_getter(ast);

        self.builder.after_getter(ast);
    }

    /// Setter doesn't have FormalParameters, but single Parameter.
    /// Call builder methods around it.
    fn visit_setter(&mut self, ast: &'alloc Setter<'alloc>) {
        self.builder.before_setter(ast);
        // FIXME: Call self.builder.on_function_name

        self.enter_setter(ast);
        self.visit_class_element_name(&ast.property_name);

        // FIXME: Pass something that points `(param)` part of setter,
        // including `(` and `)`.
        self.builder.before_setter_parameter(&ast.param);
        self.visit_parameter(&ast.param);
        self.builder.after_setter_parameter();

        self.visit_function_body(&ast.body);
        self.leave_setter(ast);

        self.builder.after_setter(ast);
    }

    fn leave_binding_with_default(&mut self, _ast: &'alloc BindingWithDefault<'alloc>) {
        self.builder.after_initializer();
    }

    fn enter_enum_property_name_variant_computed_property_name(
        &mut self,
        _ast: &'alloc ComputedPropertyName<'alloc>,
    ) {
        self.builder.before_computed_property_name();
    }

    fn enter_binding_pattern(&mut self, _ast: &'alloc BindingPattern<'alloc>) {
        self.builder.before_binding_pattern();
    }

    fn enter_function_body(&mut self, ast: &>'alloc FunctionBody<'alloc>) {
        self.builder.before_function_body(ast);
    }

    fn leave_function_body(&mut self, _ast: &'alloc FunctionBody<'alloc>) {
        self.builder.after_function_body();
    }

    fn enter_enum_expression_variant_arrow_expression(
        &mut self,
        is_async: &'alloc bool,
        params: &'alloc FormalParameters<'alloc>,
        _body: &'alloc ArrowExpressionBody<'alloc>,
    ) {
        self.builder.before_arrow_function(*is_async, params);
    }

    fn leave_enum_expression_variant_arrow_expression(
        &mut self,
        _is_async: &'alloc bool,
        _params: &'alloc FormalParameters<'alloc>,
        body: &'alloc ArrowExpressionBody<'alloc>,
    ) {
        self.builder.after_arrow_function(body);
    }

    /// Arrow function with expression body.
    /// Use the expression as the node for function body.
    fn enter_enum_arrow_expression_body_variant_expression(
        &mut self,
        ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        let expr: &Expression = ast;
        self.builder.before_function_body(expr);
    }

    fn leave_enum_arrow_expression_body_variant_expression(
        &mut self,
        _ast: &'alloc arena::Box<'alloc, Expression<'alloc>>,
    ) {
        self.builder.after_function_body();
    }

    fn enter_catch_clause(&mut self, _ast: &>'alloc CatchClause<'alloc>) {
        self.builder.before_catch_clause();
    }

    fn enter_call_expression(&mut self, ast: &'alloc CallExpression<'alloc>) {
        match &ast.callee {
            ExpressionOrSuper::Expression(expr) => match &**expr {
                Expression::IdentifierExpression(IdentifierExpression { name, .. }) => {
                    if name.value == CommonSourceAtomSetIndices::eval() {
                        self.builder.on_direct_eval();
                    }
                }
                _ => {}
            },
            _ => {}
        }
    }

    fn enter_class_declaration(&mut self, _ast: &'alloc ClassDeclaration<'alloc>) {
        self.builder.on_class();
    }

    fn enter_class_expression(&mut self, _ast: &'alloc ClassExpression<'alloc>) {
        self.builder.on_class();
    }

    fn enter_enum_statement_variant_with_statement(
        &mut self,
        _object: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        _body: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        self.builder.on_with();
    }

    fn visit_enum_unary_operator_variant_delete(&mut self) {
        self.builder.on_delete();
    }

    fn enter_enum_statement_variant_for_statement(
        &mut self,
        init: &'alloc Option<VariableDeclarationOrExpression<'alloc>>,
        _test: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
        _update: &'alloc Option<arena::Box<'alloc, Expression<'alloc>>>,
        _block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        match init {
            Some(VariableDeclarationOrExpression::VariableDeclaration(decl)) => match decl.kind {
                VariableDeclarationKind::Let { .. } | VariableDeclarationKind::Const { .. } => {
                    self.builder.on_lexical_for();
                }
                _ => {}
            },
            _ => {}
        }
    }

    fn enter_enum_statement_variant_for_in_statement(
        &mut self,
        left: &'alloc VariableDeclarationOrAssignmentTarget<'alloc>,
        _right: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        _block: &'alloc arena::Box<'alloc, Statement<'alloc>>,
    ) {
        match left {
            VariableDeclarationOrAssignmentTarget::VariableDeclaration(decl) => match decl.kind {
                VariableDeclarationKind::Let { .. } | VariableDeclarationKind::Const { .. } => {
                    self.builder.on_lexical_for();
                }
                _ => {}
            },
            _ => {}
        }
    }

    fn enter_enum_statement_variant_switch_statement(
        &mut self,
        _discriminant: &'alloc arena::Box<'alloc, Expression<'alloc>>,
        _cases: &'alloc arena::Vec<'alloc, SwitchCase<'alloc>>,
    ) {
        self.builder.on_switch();
    }

    fn visit_enum_expression_variant_new_target_expression(&mut self) {
        self.builder.on_new_target();
    }
}