crates/core/tests/un_enum_rule.rs

GitHub
mod common;

use common::{assert_eq_normalized, render_pipeline, render_pipeline_until};
use swc_core::common::{sync::Lrc, FileName, Mark, SourceMap, SyntaxContext, GLOBALS};
use swc_core::ecma::ast::{BindingIdent, Decl, EsVersion, ModuleItem, Pat, Stmt};
use swc_core::ecma::parser::{lexer::Lexer, EsSyntax, Parser, StringInput, Syntax};
use swc_core::ecma::transforms::base::resolver;
use swc_core::ecma::visit::VisitMutWith;
use wakaru_core::rules::UnEnum;

fn apply(input: &str) -> String {
    apply_rule(input, false)
}

fn apply_resolved(input: &str) -> String {
    apply_rule(input, true)
}

fn apply_rule(input: &str, resolve_bindings: bool) -> String {
    GLOBALS.set(&Default::default(), || {
        use swc_core::common::{sync::Lrc, FileName, SourceMap};
        use swc_core::ecma::codegen::{text_writer::JsWriter, Config, Emitter};
        use swc_core::ecma::parser::{lexer::Lexer, EsSyntax, Parser, StringInput, Syntax};

        let cm: Lrc<SourceMap> = Default::default();
        let fm = cm.new_source_file(
            FileName::Custom("test.js".to_string()).into(),
            input.to_string(),
        );
        let lexer = Lexer::new(
            Syntax::Es(EsSyntax {
                jsx: true,
                ..Default::default()
            }),
            Default::default(),
            StringInput::from(&*fm),
            None,
        );
        let mut parser = Parser::new_from(lexer);
        let mut module = parser.parse_module().expect("parse failed");

        if resolve_bindings {
            let unresolved_mark = Mark::new();
            let top_level_mark = Mark::new();
            module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
            module.visit_mut_with(&mut UnEnum::new_with_mark(unresolved_mark));
        } else {
            module.visit_mut_with(&mut UnEnum::new());
        }

        let mut output = Vec::new();
        {
            let mut emitter = Emitter {
                cfg: Config::default().with_minify(false),
                cm: cm.clone(),
                comments: None,
                wr: JsWriter::new(cm, "\n", &mut output, None),
            };
            emitter.emit_module(&module).expect("emit failed");
        }
        String::from_utf8(output).expect("utf-8")
    })
}

#[test]
fn recovers_exported_commonjs_enum() {
    let input = r#"
var LocalMode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
  e["Prod"] = "prod";
})(LocalMode = exports.Mode || (exports.Mode = {}));
"#;
    let expected = r#"
var LocalMode = {
  Dev: 0,
  0: "Dev",
  Prod: "prod"
};
export { LocalMode as Mode };
"#;
    assert_eq_normalized(&apply_resolved(input), expected);
}

#[test]
fn pipeline_promotes_adjacent_exported_enum_to_const() {
    let input = r#"
export let Mode;
(function (e) {
  e["Dev"] = "dev";
})(Mode || (Mode = {}));
use(Mode);
"#;
    let expected = r#"
export const Mode = {
  Dev: "dev"
};
use(Mode);
"#;
    assert_eq_normalized(&render_pipeline(input), expected);
}

#[test]
fn recovers_alternate_exported_commonjs_enum_form() {
    let input = r#"
var Mode;
(function (e) {
  e[e["Dev"] = -1] = "Dev";
})(Mode || (exports.Mode = Mode = {}));
"#;
    let expected = r#"
var Mode = {
  Dev: -1,
  [-1]: "Dev"
};
export { Mode };
"#;
    assert_eq_normalized(&apply_resolved(input), expected);
}

#[test]
fn exported_commonjs_enum_preserves_position_after_split_declarations() {
    let input = r#"
var Mode;
var before = "initialized first";
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Mode || (exports.Mode = {}));
"#;
    let expected = r#"
var Mode;
var before = "initialized first";
Mode = {
  Dev: 0,
  0: "Dev"
};
export { Mode };
"#;
    assert_eq_normalized(&apply_resolved(input), expected);
}

#[test]
fn exported_commonjs_enum_rejects_intervening_binding_use() {
    let input = r#"
var Mode;
var before = observe(Mode);
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Mode || (exports.Mode = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_intervening_public_export_use() {
    let input = r#"
var Mode;
observe(exports.Mode);
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Mode || (exports.Mode = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_later_public_export_read() {
    let input = r#"
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Mode || (exports.Mode = {}));
observe(exports.Mode);
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn split_exported_commonjs_enum_rejects_later_deferred_public_read() {
    let input = r#"
var Mode;
prepare();
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode || (exports.Mode = Mode = {}));
function later() {
  return exports.Mode;
}
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_allows_later_other_public_export_read() {
    let input = r#"
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Mode || (exports.Mode = {}));
observe(exports.Other);
"#;
    let expected = r#"
var Mode = {
  Dev: 0,
  0: "Dev"
};
export { Mode };
observe(exports.Other);
"#;
    assert_eq_normalized(&apply_resolved(input), expected);
}

#[test]
fn exported_commonjs_enum_rejects_effectful_values() {
    let input = r#"
var Mode;
(function (e) {
  e[e["Dev"] = observe()] = "Dev";
})(Mode = exports.Mode || (exports.Mode = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_local_exports_binding() {
    let input = r#"
const exports = {};
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Mode || (exports.Mode = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_mismatched_public_names() {
    let input = r#"
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Mode || (exports.Other = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_duplicate_esm_export() {
    let input = r#"
var Existing;
export { Existing as Mode };
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Mode || (exports.Mode = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_duplicate_exported_function_name() {
    let input = r#"
export function Existing() {}
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Existing || (exports.Existing = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_duplicate_exported_class_name() {
    let input = r#"
export class Existing {}
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Existing || (exports.Existing = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_duplicate_destructured_export_name() {
    let input = r#"
export var { Existing } = source;
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Existing || (exports.Existing = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_duplicate_namespace_export_name() {
    let input = r#"
export * as Existing from "./dep.js";
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Existing || (exports.Existing = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_rejects_duplicate_string_export_name() {
    let input = r#"
const value = 1;
export { value as "Existing" };
var Mode;
(function (e) {
  e[e["Dev"] = 0] = "Dev";
})(Mode = exports.Existing || (exports.Existing = {}));
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn exported_commonjs_enum_is_top_level_only() {
    let input = r#"
function make() {
  var Mode;
  (function (e) {
    e[e["Dev"] = 0] = "Dev";
  })(Mode = exports.Mode || (exports.Mode = {}));
}
"#;
    assert_eq_normalized(&apply_resolved(input), input);
}

#[test]
fn test_numeric_enum() {
    let input = r#"
var Direction;
(function (Direction) {
  Direction[Direction["Up"] = 1] = "Up";
  Direction[Direction["Down"] = 2] = "Down";
  Direction[Direction["Left"] = 3] = "Left";
  Direction[Direction["Right"] = -4] = "Right";
})(Direction || (Direction = {}));
"#;
    let expected = r#"
var Direction = {
  Up: 1,
  1: "Up",
  Down: 2,
  2: "Down",
  Left: 3,
  3: "Left",
  Right: -4,
  [-4]: "Right"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn numeric_enum_preserves_forward_reverse_overwrite_order() {
    let input = r#"
var Direction;
(function (Direction) {
  Direction[Direction["A"] = 1] = "A";
  Direction[Direction["1"] = 2] = "1";
})(Direction || (Direction = {}));
"#;
    let expected = r#"
var Direction = {
  A: 1,
  1: "A",
  "1": 2,
  2: "1"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn preserves_enum_with_non_literal_member_value() {
    let input = r#"
var Direction;
(function (Direction) {
  Direction[Direction["Up"] = nextValue()] = "Up";
})(Direction || (Direction = {}));
"#;
    assert_eq_normalized(&apply(input), input);
}

#[test]
fn test_string_enum() {
    let input = r#"
var Direction;
(function (Direction) {
  Direction["Up"] = "UP";
  Direction["Down"] = "DOWN";
  Direction.Left = "LEFT";
  Direction.Right = "RIGHT";
})(Direction || (Direction = {}));
"#;
    let expected = r#"
var Direction = {
  Up: "UP",
  Down: "DOWN",
  Left: "LEFT",
  Right: "RIGHT"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn test_mangled_enum() {
    let input = r#"
var Direction;
(function (i) {
  i[i["Up"] = 1] = "Up";
  i[i["Down"] = 2] = "Down";
})(Direction || (Direction = {}));
"#;
    let expected = r#"
var Direction = {
  Up: 1,
  1: "Up",
  Down: 2,
  2: "Down"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn test_function_initializer_enum() {
    let input = r#"
var Direction = function (Direction) {
  Direction[Direction["Up"] = 1] = "Up";
  Direction[Direction["Down"] = 2] = "Down";
  return Direction;
}(Direction || {});
"#;
    let expected = r#"
var Direction = {
  Up: 1,
  1: "Up",
  Down: 2,
  2: "Down"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn test_arrow_initializer_enum() {
    let input = r#"
var Direction = ((Direction2) => {
  Direction2[Direction2["Up"] = 1] = "Up";
  Direction2[Direction2["Down"] = 2] = "Down";
  return Direction2;
})(Direction || {});
"#;
    let expected = r#"
var Direction = {
  Up: 1,
  1: "Up",
  Down: 2,
  2: "Down"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn test_concise_arrow_sequence_initializer_enum() {
    let input = r#"
var Direction = (Direction2 => (
  Direction2[Direction2.Up = 1] = "Up",
  Direction2[Direction2.Down = 2] = "Down",
  Direction2[Direction2.Right = -4] = "Right",
  Direction2
))(Direction || {});
"#;
    let expected = r#"
var Direction = {
  Up: 1,
  1: "Up",
  Down: 2,
  2: "Down",
  Right: -4,
  [-4]: "Right"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn pipeline_recovers_sequence_return_enum_after_conditionals() {
    let input = r#"
var Direction=(Direction2=>(Direction2[Direction2.Up=1]="Up",Direction2[Direction2.Down=2]="Down",Direction2[Direction2.Left=4]="Left",Direction2[Direction2.Right=-4]="Right",Direction2))(Direction||{});use(1,Direction[2],-4);
"#;
    let expected = r#"
var Direction = {
  Up: 1,
  1: "Up",
  Down: 2,
  2: "Down",
  Left: 4,
  4: "Left",
  Right: -4,
  [-4]: "Right"
};
use(1, Direction[2], -4);
"#;
    assert_eq_normalized(&render_pipeline_until(input, "UnEnum"), expected);
}

#[test]
fn test_concise_arrow_sequence_string_enum() {
    let input = r#"
var Status = (Status2 => (
  Status2.Ready = "ready",
  Status2.Done = "done",
  Status2
))(Status || {});
"#;
    let expected = r#"
var Status = {
  Ready: "ready",
  Done: "done"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn test_exported_function_initializer_enum() {
    let input = r#"
export let Mode = function (Mode) {
  Mode["Dev"] = "dev";
  Mode["Prod"] = "prod";
  return Mode;
}({});
"#;
    let expected = r#"
export let Mode = {
  Dev: "dev",
  Prod: "prod"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn test_enum_invalid_identifier_keys() {
    let input = r#"
var RenderMode;
(function (RenderMode) {
  RenderMode[RenderMode["2D"] = 1] = "2D";
  RenderMode[RenderMode["WebGL"] = 2] = "WebGL";
})(RenderMode || (RenderMode = {}));
"#;
    let expected = r#"
var RenderMode = {
  "2D": 1,
  1: "2D",
  WebGL: 2,
  2: "WebGL"
};
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn test_noop_not_an_enum() {
    let input = r#"
var x = 1;
console.log(x);
"#;
    let expected = r#"
var x = 1;
console.log(x);
"#;
    assert_eq_normalized(&apply(input), expected);
}

#[test]
fn bare_var_enum_preserves_binding_context() {
    let input = r#"
var Direction;
(function(Direction) {
    Direction[Direction["Up"] = 0] = "Up";
    Direction[Direction["Down"] = 1] = "Down";
})(Direction || (Direction = {}));
console.log(Direction.Up);
"#;

    let (original_ctxt, output_ctxt) = enum_var_binding_context(input);

    assert_eq!(
        output_ctxt, original_ctxt,
        "enum var declaration should preserve the original binding context"
    );
    assert_ne!(
        output_ctxt,
        SyntaxContext::empty(),
        "regression input should use a scoped binding"
    );
}

#[test]
fn standalone_enum_preserves_binding_context() {
    let input = r#"
(function(Status) {
    Status[Status["Active"] = 0] = "Active";
    Status[Status["Inactive"] = 1] = "Inactive";
})(Status || (Status = {}));
console.log(Status.Active);
"#;

    let (original_ctxt, output_ctxt) = standalone_enum_binding_context(input);

    assert_eq!(
        output_ctxt, original_ctxt,
        "standalone enum assignment should preserve the original binding context"
    );
    assert_ne!(
        output_ctxt,
        SyntaxContext::empty(),
        "regression input should use a scoped binding"
    );
}

fn enum_var_binding_context(input: &str) -> (SyntaxContext, SyntaxContext) {
    GLOBALS.set(&Default::default(), || {
        let cm: Lrc<SourceMap> = Default::default();
        let fm = cm.new_source_file(
            FileName::Custom("fixture.js".to_string()).into(),
            input.to_string(),
        );
        let lexer = Lexer::new(
            Syntax::Es(EsSyntax::default()),
            EsVersion::latest(),
            StringInput::from(&*fm),
            None,
        );
        let mut parser = Parser::new_from(lexer);
        let mut module = parser.parse_module().expect("input should parse");

        let unresolved_mark = Mark::new();
        let top_level_mark = Mark::new();
        module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));

        let original_ctxt = first_var_decl_context(&module);

        module.visit_mut_with(&mut UnEnum::new_with_mark(unresolved_mark));

        let output_ctxt = first_var_decl_context(&module);

        (original_ctxt, output_ctxt)
    })
}

fn standalone_enum_binding_context(input: &str) -> (SyntaxContext, SyntaxContext) {
    GLOBALS.set(&Default::default(), || {
        let cm: Lrc<SourceMap> = Default::default();
        let fm = cm.new_source_file(
            FileName::Custom("fixture.js".to_string()).into(),
            input.to_string(),
        );
        let lexer = Lexer::new(
            Syntax::Es(EsSyntax::default()),
            EsVersion::latest(),
            StringInput::from(&*fm),
            None,
        );
        let mut parser = Parser::new_from(lexer);
        let mut module = parser.parse_module().expect("input should parse");

        let unresolved_mark = Mark::new();
        let top_level_mark = Mark::new();
        module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));

        let original_ctxt = iife_arg_ident_context(&module);

        module.visit_mut_with(&mut UnEnum::new_with_mark(unresolved_mark));

        let output_ctxt = first_assign_target_context(&module);

        (original_ctxt, output_ctxt)
    })
}

fn first_var_decl_context(module: &swc_core::ecma::ast::Module) -> SyntaxContext {
    let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = &module.body[0] else {
        panic!("expected var declaration as first statement");
    };
    let Pat::Ident(BindingIdent { id, .. }) = &var.decls[0].name else {
        panic!("expected identifier in var declaration");
    };
    id.ctxt
}

fn iife_arg_ident_context(module: &swc_core::ecma::ast::Module) -> SyntaxContext {
    use swc_core::ecma::ast::{CallExpr, Expr, ExprStmt};
    let ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) = &module.body[0] else {
        panic!("expected expression statement");
    };
    let Expr::Call(CallExpr { args, .. }) = expr.as_ref() else {
        panic!("expected call expression");
    };
    let arg = strip_parens_ref(&args[0].expr);
    let Expr::Bin(bin) = arg else {
        panic!("expected binary expression in arg");
    };
    let Expr::Ident(id) = bin.left.as_ref() else {
        panic!("expected ident in left of LogicalOr");
    };
    id.ctxt
}

fn strip_parens_ref(expr: &swc_core::ecma::ast::Expr) -> &swc_core::ecma::ast::Expr {
    use swc_core::ecma::ast::Expr;
    let mut current = expr;
    while let Expr::Paren(p) = current {
        current = p.expr.as_ref();
    }
    current
}

fn first_assign_target_context(module: &swc_core::ecma::ast::Module) -> SyntaxContext {
    use swc_core::ecma::ast::{AssignExpr, AssignTarget, Expr, ExprStmt, SimpleAssignTarget};
    let ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) = &module.body[0] else {
        panic!("expected expression statement after transformation");
    };
    let Expr::Assign(AssignExpr { left, .. }) = expr.as_ref() else {
        panic!("expected assignment expression");
    };
    let AssignTarget::Simple(SimpleAssignTarget::Ident(BindingIdent { id, .. })) = left else {
        panic!("expected identifier assign target");
    };
    id.ctxt
}