rspack_plugin_javascript/parser_plugin/

side_effects_parser_plugin.rs

use std::sync::LazyLock;

use rspack_core::{
  DeferredPureCheck, Dependency, DependencyRange, ModuleDependency, SideEffectsBailoutItemWithSpan,
};
use rspack_util::SpanExt;
use rustc_hash::FxHashSet;
use swc_atoms::Atom;
use swc_experimental_allocator::{CloneIn, atom::Atom as AstAtom};
use swc_experimental_ecma_ast::{
  ArrayLit, ArrowExpr, BlockStmt, BlockStmtOrExpr, CallExpr, Class, ClassMember, CommentKind,
  Comments, Decl, DefaultDecl, ExportSpecifier, Expr, ExprOrSpread, Function, GetSpan,
  ImportSpecifier, ModuleDecl, ModuleExportName, ModuleItem, ObjectPatProp, Pat, Program, PropName,
  Span, Span as AstSpan, Stmt, VarDecl, VarDeclKind, VarDeclOrExpr, Visit, VisitWith,
};
use swc_experimental_ecma_utils::{ExprCtx, ExprExt};

use crate::{
  ClassExt, JavascriptParserPlugin,
  dependency::ESMImportSideEffectDependency,
  parser_plugin::esm_import_dependency_parser_plugin::{ESM_SPECIFIER_TAG, ESMSpecifierData},
  visitors::{JavascriptParser, Statement, TagInfoData, VariableDeclaration},
};

static PURE_COMMENTS: LazyLock<regex::Regex> = LazyLock::new(|| {
  regex::Regex::new("(?s)^\\s*(#|@)__PURE__(?:\\s|$)").expect("Should create the regex")
});
pub struct SideEffectsParserPlugin {
  analyze_side_effects_free: bool,
}

impl SideEffectsParserPlugin {
  pub fn new(analyze_side_effects_free: bool) -> Self {
    Self {
      analyze_side_effects_free,
    }
  }
}

struct PureAnnotation<'a> {
  side_effects_free: FxHashSet<Atom>,
  parser: &'a JavascriptParser<'a>,
}

fn compat_atom(atom: &AstAtom<'_>) -> Atom {
  Atom::from(atom.as_str())
}

fn has_no_side_effects_notation(comments: &Comments<'_>, span: AstSpan) -> bool {
  comments.has_flag(span.start, "NO_SIDE_EFFECTS")
}

fn expr_ctx<'a>(parser: &'a JavascriptParser<'_>, is_unresolved_ref_safe: bool) -> ExprCtx<'a> {
  ExprCtx {
    semantic: parser.ast.semantic,
    is_unresolved_ref_safe,
    in_strict: false,
    remaining_depth: 4,
  }
}

impl<'a> Visit<'a> for PureAnnotation<'a> {
  fn visit_module_decl(&mut self, node: &ModuleDecl<'a>) {
    match &node {
      ModuleDecl::ExportDefaultExpr(default_expr) => {
        if let Some(fn_expr) = default_expr.expr.as_fn()
          && (has_no_side_effects_notation(self.parser.ast.comments, default_expr.span())
            || has_no_side_effects_notation(self.parser.ast.comments, fn_expr.span()))
        {
          if let Some(ident) = &fn_expr.ident {
            self.side_effects_free.insert(compat_atom(&ident.sym));
          }
          self.side_effects_free.insert(Atom::from("default"));
        } else if let Some(arrow_expr) = default_expr.expr.as_arrow()
          && (has_no_side_effects_notation(self.parser.ast.comments, default_expr.span())
            || has_no_side_effects_notation(self.parser.ast.comments, arrow_expr.span()))
        {
          self.side_effects_free.insert(Atom::from("default"));
        }
      }
      ModuleDecl::ExportDefaultDecl(default_decl) => {
        if let Some(fn_expr) = default_decl.decl.as_fn()
          && (has_no_side_effects_notation(self.parser.ast.comments, default_decl.span())
            || has_no_side_effects_notation(self.parser.ast.comments, fn_expr.span()))
        {
          if let Some(ident) = &fn_expr.ident {
            self.side_effects_free.insert(compat_atom(&ident.sym));
          }
          self.side_effects_free.insert(Atom::from("default"));
        }
      }
      ModuleDecl::ExportDecl(export_decl) => {
        if let Some(fn_decl) = export_decl.decl.as_fn()
          && (has_no_side_effects_notation(self.parser.ast.comments, export_decl.span())
            || has_no_side_effects_notation(self.parser.ast.comments, fn_decl.span()))
        {
          self
            .side_effects_free
            .insert(compat_atom(&fn_decl.ident.sym));
        } else if let Some(var_decl) = export_decl.decl.as_var()
          && matches!(var_decl.kind, VarDeclKind::Const)
          && var_decl.decls.len() == 1
        {
          let const_decl = &var_decl.decls[0];
          if let Some(ident) = const_decl.name.as_ident()
            && let Some(Expr::Fn(fn_expr)) = const_decl.init.as_ref()
            && (has_no_side_effects_notation(self.parser.ast.comments, var_decl.span())
              || has_no_side_effects_notation(self.parser.ast.comments, fn_expr.span())
              || has_no_side_effects_notation(self.parser.ast.comments, export_decl.span()))
          {
            self.side_effects_free.insert(compat_atom(&ident.id.sym));
          } else if let Some(ident) = const_decl.name.as_ident()
            && let Some(Expr::Arrow(fn_expr)) = const_decl.init.as_ref()
            && (has_no_side_effects_notation(self.parser.ast.comments, var_decl.span())
              || has_no_side_effects_notation(self.parser.ast.comments, fn_expr.span())
              || has_no_side_effects_notation(self.parser.ast.comments, export_decl.span()))
          {
            self.side_effects_free.insert(compat_atom(&ident.id.sym));
          }
        }
      }
      _ => {}
    }
  }

  fn visit_stmt(&mut self, node: &Stmt<'a>) {
    if let Stmt::Decl(decl) = node {
      #[allow(clippy::collapsible_match)]
      match &**decl {
        Decl::Fn(fn_decl) => {
          if has_no_side_effects_notation(self.parser.ast.comments, fn_decl.span()) {
            self
              .side_effects_free
              .insert(compat_atom(&fn_decl.ident.sym));
          }
        }
        Decl::Var(var_decl) => {
          /*
          example:
          ```
          /*#__NO_SIDE_EFFECTS__*/ const sideEffectFreeVariable = () => {}
          const sideEffectFreeVariable = /*#__NO_SIDE_EFFECTS__*/ () => {}
          ```
           */
          if matches!(var_decl.kind, VarDeclKind::Const) && var_decl.decls.len() == 1 {
            let const_decl = &var_decl.decls[0];

            if let Some(ident) = const_decl.name.as_ident()
              && let Some(Expr::Fn(fn_expr)) = const_decl.init.as_ref()
              && (has_no_side_effects_notation(self.parser.ast.comments, var_decl.span())
                || has_no_side_effects_notation(self.parser.ast.comments, fn_expr.span()))
            {
              self.side_effects_free.insert(compat_atom(&ident.id.sym));
            } else if let Some(ident) = const_decl.name.as_ident()
              && let Some(Expr::Arrow(fn_expr)) = const_decl.init.as_ref()
              && (has_no_side_effects_notation(self.parser.ast.comments, var_decl.span())
                || has_no_side_effects_notation(self.parser.ast.comments, fn_expr.span()))
            {
              self.side_effects_free.insert(compat_atom(&ident.id.sym));
            }
          }
        }
        _ => {}
      }
    }
  }
}

fn collect_pure_function_acceptable_names(program: &Program) -> FxHashSet<Atom> {
  // Names a user can list in `pureFunctions` and have actually take effect:
  //   - any top-level binding (function/class/var decl or import) — so calls
  //     to local helpers and imported identifiers can be marked pure;
  //   - export aliases of local bindings (`export { foo as bar }`) and the
  //     `default` keyword for default-exported functions/arrows — preserves
  //     the original "configure on the source module" workflow.
  let mut names = FxHashSet::default();
  let mut insert = |name: Atom| {
    names.insert(name);
  };

  match program {
    Program::Module(module) => {
      // First pass: collect every actual top-level binding name.
      for item in &module.body {
        match item {
          ModuleItem::Stmt(stmt) => {
            if let Stmt::Decl(decl) = &**stmt {
              visit_decl_binding_names(decl, &mut insert)
            }
          }
          ModuleItem::ModuleDecl(decl) => {
            visit_module_decl_defined_binding_names(decl, &mut insert)
          }
        }
      }

      // Second pass: re-export aliases and `default` for default-exported fns.
      let local_bindings = names.clone();
      for item in &module.body {
        let ModuleItem::ModuleDecl(decl) = item else {
          continue;
        };
        match &**decl {
          ModuleDecl::ExportNamed(named_export) if named_export.src.is_none() => {
            for specifier in &named_export.specifiers {
              let ExportSpecifier::Named(named) = specifier else {
                continue;
              };
              let orig_atom = match &named.orig {
                ModuleExportName::Ident(ident) => compat_atom(&ident.sym),
                ModuleExportName::Str(_) => continue,
              };
              if !local_bindings.contains(&orig_atom) {
                continue;
              }
              match named.exported.as_ref().unwrap_or(&named.orig) {
                ModuleExportName::Ident(ident) => {
                  names.insert(compat_atom(&ident.sym));
                }
                ModuleExportName::Str(s) => {
                  names.insert(Atom::from(s.value.to_string_lossy().as_ref()));
                }
              }
            }
          }
          ModuleDecl::ExportDefaultDecl(default_decl)
            if matches!(default_decl.decl, DefaultDecl::Fn(_)) =>
          {
            names.insert(Atom::from("default"));
          }
          ModuleDecl::ExportDefaultExpr(default_expr)
            if default_expr.expr.is_fn() || default_expr.expr.is_arrow() =>
          {
            names.insert(Atom::from("default"));
          }
          _ => {}
        }
      }
    }
    Program::Script(script) => {
      for stmt in &script.body {
        if let Stmt::Decl(decl) = stmt {
          visit_decl_binding_names(decl, &mut insert);
        }
      }
    }
  }

  names
}

fn collect_defined_configured_side_effects_free(
  program: &Program,
  configured_side_effects_free: &[String],
) -> FxHashSet<Atom> {
  let acceptable = collect_pure_function_acceptable_names(program);

  configured_side_effects_free
    .iter()
    .filter_map(|name| {
      let atom = Atom::from(name.clone());
      acceptable.contains(&atom).then_some(atom)
    })
    .collect()
}

fn visit_pat_binding_names(pat: &Pat, f: &mut impl FnMut(Atom)) {
  match pat {
    Pat::Ident(ident) => f(compat_atom(&ident.id.sym)),
    Pat::Array(array) => {
      for elem in array.elems.iter().flatten() {
        visit_pat_binding_names(elem, f);
      }
    }
    Pat::Object(object) => {
      for prop in &object.props {
        match prop {
          ObjectPatProp::KeyValue(prop) => {
            visit_pat_binding_names(&prop.value, f);
          }
          ObjectPatProp::Assign(prop) => f(compat_atom(&prop.key.id.sym)),
          ObjectPatProp::Rest(prop) => visit_pat_binding_names(&prop.arg, f),
        }
      }
    }
    Pat::Assign(assign) => visit_pat_binding_names(&assign.left, f),
    Pat::Rest(rest) => visit_pat_binding_names(&rest.arg, f),
    Pat::Expr(_) | Pat::Invalid(_) => {}
  }
}

fn visit_decl_binding_names(decl: &Decl, f: &mut impl FnMut(Atom)) {
  match decl {
    Decl::Fn(fn_decl) => f(compat_atom(&fn_decl.ident.sym)),
    Decl::Class(class_decl) => f(compat_atom(&class_decl.ident.sym)),
    Decl::Var(var_decl) => {
      for declarator in &var_decl.decls {
        visit_pat_binding_names(&declarator.name, f);
      }
    }
    _ => {}
  }
}

fn visit_module_decl_defined_binding_names(decl: &ModuleDecl, f: &mut impl FnMut(Atom)) {
  match decl {
    ModuleDecl::Import(import_decl) => {
      for specifier in &import_decl.specifiers {
        match specifier {
          ImportSpecifier::Named(named) => f(compat_atom(&named.local.sym)),
          ImportSpecifier::Default(default) => f(compat_atom(&default.local.sym)),
          ImportSpecifier::Namespace(namespace) => f(compat_atom(&namespace.local.sym)),
        }
      }
    }
    ModuleDecl::ExportDecl(export_decl) => visit_decl_binding_names(&export_decl.decl, f),
    ModuleDecl::ExportDefaultDecl(default_decl) => match &default_decl.decl {
      DefaultDecl::Fn(fn_expr) => {
        if let Some(ident) = &fn_expr.ident {
          f(compat_atom(&ident.sym));
        }
      }
      DefaultDecl::Class(class_expr) => {
        if let Some(ident) = &class_expr.ident {
          f(compat_atom(&ident.sym));
        }
      }
    },
    _ => {}
  }
}

fn collect_duplicate_top_level_names(program: &Program) -> FxHashSet<Atom> {
  let mut counts = rustc_hash::FxHashMap::<Atom, usize>::default();
  let mut count_name = |name: Atom| {
    *counts.entry(name).or_default() += 1;
  };

  match program {
    Program::Module(module) => {
      for item in &module.body {
        match item {
          ModuleItem::Stmt(stmt) => {
            if let Stmt::Decl(decl) = &**stmt {
              visit_decl_binding_names(decl, &mut count_name)
            }
          }
          ModuleItem::ModuleDecl(decl) => {
            visit_module_decl_defined_binding_names(decl, &mut count_name)
          }
        }
      }
    }
    Program::Script(script) => {
      for stmt in &script.body {
        if let Stmt::Decl(decl) = stmt {
          visit_decl_binding_names(decl, &mut count_name);
        }
      }
    }
  }

  counts
    .into_iter()
    .filter_map(|(name, count)| (count > 1).then_some(name))
    .collect()
}

fn mark_side_effects_free(parser: &mut JavascriptParser, name: &Atom, export_name: Option<&Atom>) {
  let side_effects_free = parser.build_info.side_effects_free.get_or_insert_default();
  side_effects_free.insert(name.clone());
  if let Some(export_name) = export_name {
    side_effects_free.insert(export_name.clone());
  }
}

fn try_mark_auto_side_effects_free_var_decl(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  var_decl: &VarDecl,
  export_name: Option<&Atom>,
  comments: &Comments<'_>,
  duplicate_names: &FxHashSet<Atom>,
) {
  if !matches!(var_decl.kind, VarDeclKind::Const) {
    return;
  }

  for declarator in &var_decl.decls {
    let Some(ident) = declarator.name.as_ident() else {
      continue;
    };
    let ident = compat_atom(&ident.id.sym);

    if parser
      .build_info
      .side_effects_free
      .as_ref()
      .is_some_and(|side_effects_free| side_effects_free.contains(&ident))
    {
      continue;
    }

    if duplicate_names.contains(&ident) {
      continue;
    }

    let is_side_effects_free = match declarator.init.as_ref() {
      Some(Expr::Fn(fn_expr)) => is_side_effects_free_function_body(
        parser,
        analyze_side_effects_free,
        &fn_expr.function,
        comments,
      ),
      Some(Expr::Arrow(arrow_expr)) => {
        is_side_effects_free_arrow_body(parser, analyze_side_effects_free, arrow_expr, comments)
      }
      _ => false,
    };

    if is_side_effects_free {
      mark_side_effects_free(parser, &ident, export_name);
    }
  }
}

fn try_mark_auto_side_effects_free_stmt(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  stmt: &Stmt,
  comments: &Comments<'_>,
  duplicate_names: &FxHashSet<Atom>,
) {
  if let Stmt::Decl(decl) = stmt {
    match &**decl {
      Decl::Fn(fn_decl) => {
        let ident = compat_atom(&fn_decl.ident.sym);
        if parser
          .build_info
          .side_effects_free
          .as_ref()
          .is_some_and(|side_effects_free| side_effects_free.contains(&ident))
          || duplicate_names.contains(&ident)
        {
          return;
        }

        if is_side_effects_free_function_body(
          parser,
          analyze_side_effects_free,
          &fn_decl.function,
          comments,
        ) {
          mark_side_effects_free(parser, &ident, None);
        }
      }
      Decl::Var(var_decl) => try_mark_auto_side_effects_free_var_decl(
        parser,
        analyze_side_effects_free,
        var_decl,
        None,
        comments,
        duplicate_names,
      ),
      _ => {}
    }
  }
}

fn try_mark_auto_side_effects_free_module_decl(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  decl: &ModuleDecl,
  comments: &Comments<'_>,
  duplicate_names: &FxHashSet<Atom>,
) {
  match decl {
    ModuleDecl::ExportDefaultExpr(default_expr) => {
      let Some(fn_expr) = default_expr.expr.as_fn() else {
        return;
      };
      let Some(ident) = &fn_expr.ident else {
        return;
      };
      let ident = compat_atom(&ident.sym);
      let export_name = Atom::from("default");
      if parser
        .build_info
        .side_effects_free
        .as_ref()
        .is_some_and(|side_effects_free| side_effects_free.contains(&ident))
        || duplicate_names.contains(&ident)
      {
        return;
      }
      if is_side_effects_free_function_body(
        parser,
        analyze_side_effects_free,
        &fn_expr.function,
        comments,
      ) {
        mark_side_effects_free(parser, &ident, Some(&export_name));
      }
    }
    ModuleDecl::ExportDefaultDecl(default_decl) => {
      let Some(fn_expr) = default_decl.decl.as_fn() else {
        return;
      };
      let Some(ident) = &fn_expr.ident else {
        return;
      };
      let ident = compat_atom(&ident.sym);
      let export_name = Atom::from("default");
      if parser
        .build_info
        .side_effects_free
        .as_ref()
        .is_some_and(|side_effects_free| side_effects_free.contains(&ident))
        || duplicate_names.contains(&ident)
      {
        return;
      }
      if is_side_effects_free_function_body(
        parser,
        analyze_side_effects_free,
        &fn_expr.function,
        comments,
      ) {
        mark_side_effects_free(parser, &ident, Some(&export_name));
      }
    }
    ModuleDecl::ExportDecl(export_decl) => match &export_decl.decl {
      Decl::Fn(fn_decl) => {
        if parser
          .build_info
          .side_effects_free
          .as_ref()
          .is_some_and(|side_effects_free| {
            side_effects_free.contains(&compat_atom(&fn_decl.ident.sym))
          })
          || duplicate_names.contains(&compat_atom(&fn_decl.ident.sym))
        {
          return;
        }

        if is_side_effects_free_function_body(
          parser,
          analyze_side_effects_free,
          &fn_decl.function,
          comments,
        ) {
          mark_side_effects_free(parser, &compat_atom(&fn_decl.ident.sym), None);
        }
      }
      Decl::Var(var_decl) => try_mark_auto_side_effects_free_var_decl(
        parser,
        analyze_side_effects_free,
        var_decl,
        None,
        comments,
        duplicate_names,
      ),
      _ => {}
    },
    _ => {}
  }
}

fn mark_auto_side_effects_free_program(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  program: &Program,
  comments: &Comments<'_>,
  duplicate_names: &FxHashSet<Atom>,
) {
  match program {
    Program::Module(module) => {
      for item in &module.body {
        match item {
          ModuleItem::Stmt(stmt) => try_mark_auto_side_effects_free_stmt(
            parser,
            analyze_side_effects_free,
            stmt,
            comments,
            duplicate_names,
          ),
          ModuleItem::ModuleDecl(decl) => try_mark_auto_side_effects_free_module_decl(
            parser,
            analyze_side_effects_free,
            decl,
            comments,
            duplicate_names,
          ),
        }
      }
    }
    Program::Script(script) => {
      for stmt in &script.body {
        try_mark_auto_side_effects_free_stmt(
          parser,
          analyze_side_effects_free,
          stmt,
          comments,
          duplicate_names,
        );
      }
    }
  }
}

#[rspack_macros::implemented_javascript_parser_hooks]
impl<'p, 'a> JavascriptParserPlugin<'p, 'a> for SideEffectsParserPlugin {
  fn program(&self, parser: &mut JavascriptParser<'p>, ast: &Program) -> Option<bool> {
    parser.build_info.side_effects_free = None;
    parser.build_info.deferred_pure_checks.clear();

    // analyze if any function contains #__NO_SIDE_EFFECTS__ annotation
    // so that pure functions in current module can be marked as pure
    if self.analyze_side_effects_free {
      // Build the explicit/implicit pureFunctions set in three steps:
      // 1. collect NO_SIDE_EFFECTS annotations already present in the module,
      // 2. keep only configured names that actually exist at top level,
      // 3. run a fixed-point top-level auto analysis so local pure helpers can
      //    unlock later candidates regardless of declaration order.
      // use a raw swc visitor so that we can find all pure functions before the parser visit the ast
      let mut pure_annotation = PureAnnotation {
        side_effects_free: FxHashSet::default(),
        parser,
      };
      ast.visit_with(&mut pure_annotation);
      let detected_side_effects_free = pure_annotation.side_effects_free;
      if !detected_side_effects_free.is_empty() {
        let side_effects_free = parser.build_info.side_effects_free.get_or_insert_default();
        side_effects_free.extend(detected_side_effects_free);
      }

      if let Some(flagged_side_effects_free) = &parser.javascript_options.side_effects_free {
        let defined_side_effects_free =
          collect_defined_configured_side_effects_free(ast, flagged_side_effects_free);
        if !defined_side_effects_free.is_empty() {
          let side_effects_free = parser.build_info.side_effects_free.get_or_insert_default();
          side_effects_free.extend(defined_side_effects_free);
        }
      }

      let duplicate_names = collect_duplicate_top_level_names(ast);
      loop {
        let prev_len = parser
          .build_info
          .side_effects_free
          .as_ref()
          .map_or(0, FxHashSet::len);
        mark_auto_side_effects_free_program(
          parser,
          self.analyze_side_effects_free,
          ast,
          parser.ast.comments,
          &duplicate_names,
        );
        let next_len = parser
          .build_info
          .side_effects_free
          .as_ref()
          .map_or(0, FxHashSet::len);
        if next_len == prev_len {
          break;
        }
      }
    }

    None
  }

  fn module_declaration(
    &self,
    parser: &mut JavascriptParser<'p>,
    decl: &ModuleDecl,
  ) -> Option<bool> {
    match decl {
      ModuleDecl::ExportDefaultExpr(expr) => {
        let mut callees = vec![];
        if !is_pure_expression(
          parser,
          self.analyze_side_effects_free,
          &expr.expr,
          parser.ast.comments,
          Some(&mut callees),
        ) {
          let range = DependencyRange::from(expr.span);
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("ExportDefaultExpr"),
          ));
        } else {
          // record all potential pure callee
          for (callee, span) in callees {
            if let Some(deferred_check) = try_extract_deferred_check(parser, callee, span) {
              parser
                .build_info
                .deferred_pure_checks
                .insert(deferred_check);
            } else {
              let range = DependencyRange::from(span);
              let loc = parser.to_dependency_location(range);
              parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
                range,
                loc,
                String::from("ExportDefaultExpr"),
              ));
              break;
            }
          }
        }
      }
      ModuleDecl::ExportDecl(decl) => {
        let mut callees = vec![];
        if !is_pure_decl(
          parser,
          self.analyze_side_effects_free,
          &decl.decl,
          parser.ast.comments,
          Some(&mut callees),
        ) {
          let range = DependencyRange::from(decl.decl.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Decl"),
          ));
        }
        for (callee, span) in callees {
          if let Some(deferred_check) = try_extract_deferred_check(parser, callee, span) {
            parser
              .build_info
              .deferred_pure_checks
              .insert(deferred_check);
          } else {
            let range = DependencyRange::from(span);
            let loc = parser.to_dependency_location(range);
            parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
              range,
              loc,
              String::from("Decl"),
            ));
            break;
          }
        }
      }
      _ => {}
    };
    None
  }
  fn statement(&self, parser: &mut JavascriptParser<'p>, stmt: Statement) -> Option<bool> {
    if !parser.is_top_level_scope() {
      return None;
    }
    self.analyze_stmt_side_effects(&stmt, parser);
    None
  }

  fn finish(&self, parser: &mut JavascriptParser<'p>) -> Option<bool> {
    if self.analyze_side_effects_free {
      let mut not_defined = Vec::new();
      // check if all user flagged side_effects_free are defined
      if let Some(side_effects_free) = &parser.javascript_options.side_effects_free {
        let mut side_effects_free = side_effects_free.iter().collect::<Vec<_>>();
        side_effects_free.sort();
        let defined_side_effects_free = parser.build_info.side_effects_free.as_ref();
        for atom in side_effects_free {
          if !defined_side_effects_free.is_some_and(|configured_side_effects_free| {
            configured_side_effects_free.contains(&Atom::from(atom.clone()))
          }) {
            not_defined.push(Atom::from(atom.clone()));
          }
        }
      }

      if !not_defined.is_empty() {
        if let Some(side_effects_free) = parser.build_info.side_effects_free.as_mut() {
          for atom in &not_defined {
            side_effects_free.remove(atom);
          }
        }

        let resource = parser.resource_data.resource();
        parser.add_warning(
          rspack_error::Diagnostic::warn("PURE_FUNCTION_NOT_FOUND".into(), format!("Following pure functions are not found in {resource}:\n[{}]\nRemove it from `module.rules[*].parser.pureFunctions`", not_defined.iter().map(|atom| format!("`{atom}`")).collect::<Vec<_>>().join(", ")))
        );
      }
    }

    None
  }
}

#[inline(never)]
fn is_pure_call_expr(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  expr: &Expr,
  comments: &Comments<'_>,
  callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  let Expr::Call(call_expr) = expr else {
    unreachable!();
  };
  let pure_flag = has_pure_comment(comments, expr.span().start)
    || has_pure_comment(comments, call_expr.callee.span().start);
  let callee = &call_expr.callee;

  if pure_flag {
    return is_pure_call_args(
      parser,
      analyze_side_effects_free,
      call_expr,
      comments,
      callees,
    );
  } else if analyze_side_effects_free && let Some(Expr::Ident(ident)) = callee.as_expr() {
    match resolve_explicit_side_effects_free_callee(
      parser,
      &compat_atom(&ident.sym),
      callee.span(),
      callees.is_none(),
    ) {
      ExplicitSideEffectsFreeCallee::Direct => {
        return is_pure_call_args(
          parser,
          analyze_side_effects_free,
          call_expr,
          comments,
          callees,
        );
      }
      ExplicitSideEffectsFreeCallee::Deferred => {
        let Some(callees) = callees else {
          return false;
        };
        callees.push((compat_atom(&ident.sym), callee.span()));
        return is_pure_call_args(
          parser,
          analyze_side_effects_free,
          call_expr,
          comments,
          Some(callees),
        );
      }
      ExplicitSideEffectsFreeCallee::Invalid => return false,
      ExplicitSideEffectsFreeCallee::NotMarked => {}
    }

    if let Some(callees) = callees {
      callees.push((compat_atom(&ident.sym), callee.span()));
      return is_pure_call_args(
        parser,
        analyze_side_effects_free,
        call_expr,
        comments,
        Some(callees),
      );
    }
  }

  !expr.may_have_side_effects(expr_ctx(parser, false))
}

#[inline(never)]
fn is_pure_call_args(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  call_expr: &CallExpr,
  comments: &Comments<'_>,
  mut callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  for arg in &call_expr.args {
    if arg.spread.is_some() {
      return false;
    }
    if !is_pure_expression(
      parser,
      analyze_side_effects_free,
      &arg.expr,
      comments,
      callees.as_deref_mut(),
    ) {
      return false;
    }
  }
  true
}

fn is_pure_array_lit<'a>(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  array_lit: &'a ArrayLit,
  comments: &'a Comments<'a>,
  mut callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  for elem in array_lit.elems.iter().flatten() {
    if elem.spread.is_some()
      || !is_pure_expression(
        parser,
        analyze_side_effects_free,
        &elem.expr,
        comments,
        callees.as_deref_mut(),
      )
    {
      return false;
    }
  }
  true
}

enum ExplicitSideEffectsFreeCallee {
  Direct,
  Deferred,
  Invalid,
  NotMarked,
}

fn resolve_explicit_side_effects_free_callee(
  parser: &mut JavascriptParser,
  ident: &Atom,
  span: Span,
  allow_unresolved_marked: bool,
) -> ExplicitSideEffectsFreeCallee {
  let is_marked = parser
    .build_info
    .side_effects_free
    .as_ref()
    .is_some_and(|side_effects_free| side_effects_free.contains(ident));

  if !is_marked {
    return ExplicitSideEffectsFreeCallee::NotMarked;
  }

  // For non-imports the deferred path doesn't apply at all, so we skip the
  // user-config lookup and fall straight through to Direct/Invalid.
  if try_extract_deferred_check(parser, ident.clone(), span).is_some() {
    // When the user explicitly listed this name in `pureFunctions`, trust the
    // assertion at the call site instead of deferring to the import target.
    // This lets users mark imported helpers (e.g. `import { cva } from 'cva'`)
    // as pure on the consumer side without also configuring the source module.
    let is_user_configured = parser
      .javascript_options
      .side_effects_free
      .as_ref()
      .is_some_and(|names| names.iter().any(|name| name.as_str() == ident.as_str()));
    if !is_user_configured {
      return ExplicitSideEffectsFreeCallee::Deferred;
    }
  }

  if let Some((declared_scope, is_free)) = parser
    .get_variable_info(ident)
    .map(|info| (info.declared_scope, info.is_free()))
  {
    if !is_free && declared_scope == parser.definitions {
      return ExplicitSideEffectsFreeCallee::Direct;
    }
    return ExplicitSideEffectsFreeCallee::Invalid;
  }

  if allow_unresolved_marked {
    return ExplicitSideEffectsFreeCallee::Direct;
  }

  ExplicitSideEffectsFreeCallee::Invalid
}

fn try_extract_deferred_check(
  parser: &mut JavascriptParser,
  ident: Atom,
  span: Span,
) -> Option<DeferredPureCheck> {
  let info = parser.get_variable_info(&ident)?;

  let tag_info_id = info.tag_info?;
  let tag_info = parser.definitions_db.expect_get_tag_info(tag_info_id);

  if tag_info.tag != ESM_SPECIFIER_TAG {
    return None;
  }

  let data = ESMSpecifierData::downcast(tag_info.data.clone()?);

  parser
    .get_dependencies()
    .iter()
    .find(|dep| {
      let Some(dep) = dep.downcast_ref::<ESMImportSideEffectDependency>() else {
        return false;
      };

      let request_eq = dep.request() == &data.source;
      let attributes: Option<&rspack_core::ImportAttributes> = data.attributes.as_ref();
      let attributes_eq = attributes == dep.get_attributes();
      request_eq && attributes_eq
    })
    .map(|dep| DeferredPureCheck {
      atom: data
        .ids
        .first()
        .cloned()
        .unwrap_or_else(|| data.name.clone()),
      dep_id: *dep.id(),
      start: span.real_lo(),
      end: span.real_hi(),
    })
}

fn is_pure_new_expr(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  expr: &Expr,
  comments: &Comments<'_>,
) -> bool {
  let Expr::New(new_expr) = expr else {
    unreachable!();
  };
  let pure_flag = has_pure_comment(comments, expr.span().start);
  if !pure_flag {
    !expr.may_have_side_effects(expr_ctx(parser, false))
  } else {
    are_pure_args(
      parser,
      analyze_side_effects_free,
      new_expr.args.as_deref().unwrap_or(&[]),
      comments,
    )
  }
}

fn has_pure_comment(comments: &Comments<'_>, pos: u32) -> bool {
  comments.leading.get(&pos).is_some_and(|comment_list| {
    comment_list
      .iter()
      .any(|comment| comment.kind == CommentKind::Block && PURE_COMMENTS.is_match(&comment.text))
  })
}

fn are_pure_args<'a>(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  args: &'a [ExprOrSpread],
  comments: &'a Comments<'a>,
) -> bool {
  args.iter().all(|arg| {
    if arg.spread.is_some() {
      false
    } else {
      is_pure_expression(parser, analyze_side_effects_free, &arg.expr, comments, None)
    }
  })
}

impl SideEffectsParserPlugin {
  fn analyze_stmt_side_effects(&self, stmt: &Statement, parser: &mut JavascriptParser) {
    if parser.side_effects_item.is_some() {
      return;
    }
    let mut callees = vec![];
    match stmt {
      Statement::If(if_stmt) => {
        if !is_pure_expression(
          parser,
          self.analyze_side_effects_free,
          &if_stmt.test,
          parser.ast.comments,
          Some(&mut callees),
        ) {
          let range = DependencyRange::from(if_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
        }
      }
      Statement::While(while_stmt) => {
        if !is_pure_expression(
          parser,
          self.analyze_side_effects_free,
          &while_stmt.test,
          parser.ast.comments,
          Some(&mut callees),
        ) {
          let range = DependencyRange::from(while_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
        }
      }
      Statement::DoWhile(do_while_stmt) => {
        if !is_pure_expression(
          parser,
          self.analyze_side_effects_free,
          &do_while_stmt.test,
          parser.ast.comments,
          Some(&mut callees),
        ) {
          let range = DependencyRange::from(do_while_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
        }
      }
      Statement::For(for_stmt) => {
        let pure_init = match for_stmt.init {
          Some(ref init) => match init {
            VarDeclOrExpr::VarDecl(decl) => is_pure_var_decl(
              parser,
              self.analyze_side_effects_free,
              decl,
              parser.ast.comments,
              Some(&mut callees),
            ),
            VarDeclOrExpr::Expr(expr) => is_pure_expression(
              parser,
              self.analyze_side_effects_free,
              expr,
              parser.ast.comments,
              Some(&mut callees),
            ),
          },
          None => true,
        };

        if !pure_init {
          let range = DependencyRange::from(for_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
          return;
        }

        let pure_test = match &for_stmt.test {
          Some(test) => is_pure_expression(
            parser,
            self.analyze_side_effects_free,
            test,
            parser.ast.comments,
            Some(&mut callees),
          ),
          None => true,
        };

        if !pure_test {
          let range = DependencyRange::from(for_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
          return;
        }

        let pure_update = match for_stmt.update {
          Some(ref expr) => is_pure_expression(
            parser,
            self.analyze_side_effects_free,
            expr,
            parser.ast.comments,
            Some(&mut callees),
          ),
          None => true,
        };

        if !pure_update {
          let range = DependencyRange::from(for_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
        }
      }
      Statement::Expr(expr_stmt) => {
        if !is_pure_expression(
          parser,
          self.analyze_side_effects_free,
          &expr_stmt.expr,
          parser.ast.comments,
          Some(&mut callees),
        ) {
          let range = DependencyRange::from(expr_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
        }
      }
      Statement::Switch(switch_stmt) => {
        if !is_pure_expression(
          parser,
          self.analyze_side_effects_free,
          &switch_stmt.discriminant,
          parser.ast.comments,
          Some(&mut callees),
        ) {
          let range = DependencyRange::from(switch_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
        }
      }
      Statement::Class(class_stmt) => {
        if !is_pure_class(
          parser,
          self.analyze_side_effects_free,
          class_stmt.class(),
          parser.ast.comments,
          Some(&mut callees),
        ) {
          let range = DependencyRange::from(stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
        }
      }
      Statement::Var(var_stmt) => match var_stmt {
        VariableDeclaration::VarDecl(var_decl) => {
          if !is_pure_var_decl(
            parser,
            self.analyze_side_effects_free,
            var_decl,
            parser.ast.comments,
            Some(&mut callees),
          ) {
            let range = DependencyRange::from(var_stmt.span());
            let loc = parser.to_dependency_location(range);
            parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
              range,
              loc,
              String::from("Statement"),
            ));
          }
        }
        VariableDeclaration::UsingDecl(_) => {
          let range = DependencyRange::from(var_stmt.span());
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
        }
      },
      Statement::Empty(_) => {}
      Statement::Labeled(_) => {}
      Statement::Block(_) => {}
      Statement::Fn(_) => {}
      _ => {
        let range = DependencyRange::from(stmt.span());
        let loc = parser.to_dependency_location(range);
        parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
          range,
          loc,
          String::from("Statement"),
        ))
      }
    };

    if parser.side_effects_item.is_none() {
      for (callee, span) in callees {
        if let Some(deferred_check) = try_extract_deferred_check(parser, callee, span) {
          parser
            .build_info
            .deferred_pure_checks
            .insert(deferred_check);
        } else {
          let range = DependencyRange::from(span);
          let loc = parser.to_dependency_location(range);
          parser.side_effects_item = Some(SideEffectsBailoutItemWithSpan::new(
            range,
            loc,
            String::from("Statement"),
          ));
          break;
        }
      }
    }
  }
}

pub fn is_pure_pat<'a>(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  pat: &'a Pat,
  comments: &'a Comments<'a>,
  mut callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  match pat {
    Pat::Ident(_) => true,
    Pat::Array(array_pat) => {
      for pat in array_pat.elems.iter().flatten() {
        if !is_pure_pat(
          parser,
          analyze_side_effects_free,
          pat,
          comments,
          callees.as_deref_mut(),
        ) {
          return false;
        }
      }
      true
    }
    Pat::Rest(_) => true,
    Pat::Invalid(_) | Pat::Assign(_) | Pat::Object(_) => false,
    Pat::Expr(expr) => {
      is_pure_expression(parser, analyze_side_effects_free, expr, comments, callees)
    }
  }
}

fn is_side_effects_free_param(pat: &Pat) -> bool {
  matches!(pat, Pat::Ident(_))
}

#[inline(never)]
fn is_side_effects_free_var_decl(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  var_decl: &VarDecl,
  comments: &Comments<'_>,
) -> bool {
  for declarator in &var_decl.decls {
    if declarator.name.as_ident().is_none() {
      return false;
    }

    if let Some(init) = declarator.init.as_ref()
      && !is_pure_expression(parser, analyze_side_effects_free, init, comments, None)
    {
      return false;
    }
  }

  true
}

fn stmt_may_have_side_effects(parser: &JavascriptParser, stmt: &Stmt) -> bool {
  let expr_ctx = expr_ctx(parser, true);

  match stmt {
    Stmt::Empty(_) => false,
    Stmt::Expr(expr_stmt) => expr_stmt.expr.may_have_side_effects(expr_ctx),
    Stmt::Return(return_stmt) => return_stmt
      .arg
      .as_ref()
      .is_some_and(|arg| arg.may_have_side_effects(expr_ctx)),
    Stmt::Decl(decl) => match &**decl {
      Decl::Var(var_decl) => var_decl.decls.iter().any(|declarator| {
        declarator.name.as_ident().is_none()
          || declarator
            .init
            .as_ref()
            .is_some_and(|init| init.may_have_side_effects(expr_ctx))
      }),
      _ => true,
    },
    _ => true,
  }
}

fn is_side_effects_free_stmt(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  stmt: &Stmt,
  comments: &Comments<'_>,
) -> bool {
  if !stmt_may_have_side_effects(parser, stmt) {
    return true;
  }

  match stmt {
    Stmt::Expr(expr_stmt) => is_pure_expression(
      parser,
      analyze_side_effects_free,
      &expr_stmt.expr,
      comments,
      None,
    ),
    Stmt::Return(return_stmt) => return_stmt
      .arg
      .as_ref()
      .is_none_or(|arg| is_pure_expression(parser, analyze_side_effects_free, arg, comments, None)),
    Stmt::Decl(decl) => match &**decl {
      Decl::Var(var_decl) => {
        is_side_effects_free_var_decl(parser, analyze_side_effects_free, var_decl, comments)
      }
      _ => false,
    },
    _ => false,
  }
}

#[inline(never)]
fn is_side_effects_free_block_stmt(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  block_stmt: &BlockStmt,
  comments: &Comments<'_>,
) -> bool {
  for stmt in &block_stmt.stmts {
    if !is_side_effects_free_stmt(parser, analyze_side_effects_free, stmt, comments) {
      return false;
    }
  }

  true
}

#[inline(never)]
fn is_side_effects_free_function_body(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  function: &Function,
  comments: &Comments<'_>,
) -> bool {
  if !function
    .params
    .iter()
    .all(|param| is_side_effects_free_param(&param.pat))
  {
    return false;
  }

  function.body.as_ref().is_none_or(|body| {
    is_side_effects_free_block_stmt(parser, analyze_side_effects_free, body, comments)
  })
}

#[inline(never)]
fn is_side_effects_free_arrow_body(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  arrow_expr: &ArrowExpr,
  comments: &Comments<'_>,
) -> bool {
  if !arrow_expr.params.iter().all(is_side_effects_free_param) {
    return false;
  }

  match &arrow_expr.body {
    BlockStmtOrExpr::BlockStmt(block_stmt) => {
      is_side_effects_free_block_stmt(parser, analyze_side_effects_free, block_stmt, comments)
    }
    BlockStmtOrExpr::Expr(expr) => {
      is_pure_expression(parser, analyze_side_effects_free, expr, comments, None)
    }
  }
}

pub fn is_pure_function<'a>(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  function: &'a Function,
  comments: &'a Comments<'a>,
  mut callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  for param in &function.params {
    if !is_pure_pat(
      parser,
      analyze_side_effects_free,
      &param.pat,
      comments,
      callees.as_deref_mut(),
    ) {
      return false;
    }
  }
  true
}

#[inline(never)]
pub fn is_pure_expression<'a>(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  expr: &'a Expr,
  comments: &'a Comments<'a>,
  callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  pub fn _is_pure_expression<'a>(
    parser: &mut JavascriptParser,
    analyze_side_effects_free: bool,
    expr: &'a Expr,
    comments: &'a Comments<'a>,
    mut callees: Option<&mut Vec<(Atom, Span)>>,
  ) -> bool {
    if let Some(res) = parser.plugin_drive.clone().is_pure(parser, expr) {
      return res;
    }

    match expr {
      Expr::Array(array_lit) => is_pure_array_lit(
        parser,
        analyze_side_effects_free,
        array_lit,
        comments,
        callees.as_deref_mut(),
      ),
      Expr::Call(_) => {
        is_pure_call_expr(parser, analyze_side_effects_free, expr, comments, callees)
      }
      Expr::New(_) => is_pure_new_expr(parser, analyze_side_effects_free, expr, comments),
      Expr::Paren(_) => unreachable!(),
      Expr::Seq(seq_expr) => {
        for expr in &seq_expr.exprs {
          if !is_pure_expression(
            parser,
            analyze_side_effects_free,
            expr,
            comments,
            callees.as_deref_mut(),
          ) {
            return false;
          }
        }
        true
      }
      _ => {
        if !expr.may_have_side_effects(expr_ctx(parser, true)) {
          return true;
        }
        // could_have_side_effects is true by default, so here we test if it's modified by other plugins to return false.
        let evaluated = parser.evaluate_expression(expr);
        !evaluated.could_have_side_effects()
      }
    }
  }
  _is_pure_expression(parser, analyze_side_effects_free, expr, comments, callees)
}

#[inline(never)]
pub fn is_pure_class_member<'a>(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  member: &'a ClassMember,
  comments: &'a Comments<'a>,
  mut callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  let is_key_pure = match member.class_key() {
    Some(PropName::Ident(_ident)) => true,
    Some(PropName::Str(_)) => true,
    Some(PropName::Num(_)) => true,
    Some(PropName::Computed(computed)) => is_pure_expression(
      parser,
      analyze_side_effects_free,
      &computed.expr,
      comments,
      callees.as_deref_mut(),
    ),
    Some(PropName::BigInt(_)) => true,
    None => true,
  };
  if !is_key_pure {
    return false;
  }
  let is_static = member.is_static();
  let is_value_pure = match member {
    ClassMember::Constructor(_) => true,
    ClassMember::Method(_) => true,
    ClassMember::PrivateMethod(_) => true,
    ClassMember::ClassProp(prop) => {
      if let Some(ref value) = prop.value {
        is_pure_expression(
          parser,
          analyze_side_effects_free,
          value,
          comments,
          callees.as_deref_mut(),
        )
      } else {
        true
      }
    }
    ClassMember::PrivateProp(prop) => {
      if let Some(ref value) = prop.value {
        is_pure_expression(parser, analyze_side_effects_free, value, comments, callees)
      } else {
        true
      }
    }
    ClassMember::Empty(_) => true,
    ClassMember::StaticBlock(_) => false,
    ClassMember::AutoAccessor(_) => false,
  };
  if is_static && !is_value_pure {
    return false;
  }
  true
}

#[inline(never)]
pub fn is_pure_decl(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  stmt: &Decl,
  comments: &Comments<'_>,
  callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  match stmt {
    Decl::Class(class) => is_pure_class(
      parser,
      analyze_side_effects_free,
      &class.class,
      comments,
      callees,
    ),
    Decl::Fn(_) => true,
    Decl::Var(var) => is_pure_var_decl(parser, analyze_side_effects_free, var, comments, callees),
    Decl::Using(_) => false,
  }
}

#[inline(never)]
pub fn is_pure_class(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  class: &Class,
  comments: &Comments<'_>,
  mut callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  if let Some(ref super_class) = class.super_class
    && !is_pure_expression(
      parser,
      analyze_side_effects_free,
      super_class,
      comments,
      callees.as_deref_mut(),
    )
  {
    return false;
  }
  let is_pure_key = |parser: &mut JavascriptParser,
                     key: &PropName,
                     callees: Option<&mut Vec<(Atom, Span)>>|
   -> bool {
    match key {
      PropName::BigInt(_) | PropName::Ident(_) | PropName::Str(_) | PropName::Num(_) => true,
      PropName::Computed(computed) => is_pure_expression(
        parser,
        analyze_side_effects_free,
        &computed.expr,
        comments,
        callees,
      ),
    }
  };

  for item in &class.body {
    let pure = match item {
      ClassMember::Constructor(_) => class.super_class.is_none(),
      ClassMember::Method(method) => is_pure_key(parser, &method.key, callees.as_deref_mut()),
      ClassMember::PrivateMethod(method) => is_pure_expression(
        parser,
        analyze_side_effects_free,
        &Expr::PrivateName(method.key.clone_in(parser.ast.allocator)),
        comments,
        callees.as_deref_mut(),
      ),
      ClassMember::ClassProp(prop) => {
        is_pure_key(parser, &prop.key, callees.as_deref_mut())
          && (!prop.is_static
            || if let Some(ref value) = prop.value {
              is_pure_expression(
                parser,
                analyze_side_effects_free,
                value,
                comments,
                callees.as_deref_mut(),
              )
            } else {
              true
            })
      }
      ClassMember::PrivateProp(prop) => {
        is_pure_expression(
          parser,
          analyze_side_effects_free,
          &Expr::PrivateName(prop.key.clone_in(parser.ast.allocator)),
          comments,
          callees.as_deref_mut(),
        ) && (!prop.is_static
          || if let Some(ref value) = prop.value {
            is_pure_expression(
              parser,
              analyze_side_effects_free,
              value,
              comments,
              callees.as_deref_mut(),
            )
          } else {
            true
          })
      }
      ClassMember::Empty(_) => true,
      ClassMember::StaticBlock(_) => false, // TODO: support is pure analyze for statements
      ClassMember::AutoAccessor(_) => false,
    };
    if !pure {
      return false;
    }
  }
  true
}

#[inline(never)]
fn is_pure_var_decl<'a>(
  parser: &mut JavascriptParser,
  analyze_side_effects_free: bool,
  var: &'a VarDecl,
  comments: &'a Comments<'a>,
  mut callees: Option<&mut Vec<(Atom, Span)>>,
) -> bool {
  for decl in &var.decls {
    if let Some(ref init) = decl.init
      && !is_pure_expression(
        parser,
        analyze_side_effects_free,
        init,
        comments,
        callees.as_deref_mut(),
      )
    {
      return false;
    }
  }
  true
}