expr_simplifier replaces ternary expression with sequence (..., 0)

[mischnic]

Describe the bug

expr_simplifier replaces a ternary expression ... ? 0 : 1 with (..., 0)

Input code

var bit = 0;
var sum = 0;
sum += (bit ^= 1) ? 0 : 1;
sum += (bit ^= 1) ? 0 : 1;
console.log(sum);

Config

Details

use swc_common::{
    chain, comments::SingleThreadedComments, sync::Lrc, FileName, Globals, Mark, SourceMap,
};
use swc_ecma_ast::Module;
use swc_ecma_codegen::{text_writer::JsWriter, Config, Emitter};
use swc_ecma_parser::{lexer::Lexer, EsConfig, PResult, Parser, StringInput, Syntax};
use swc_ecma_preset_env::preset_env;
use swc_ecma_transforms::{
    compat::reserved_words::reserved_words,
    fixer, helpers, hygiene,
    optimization::simplify::{dead_branch_remover, expr_simplifier},
    react,
    resolver::resolver_with_mark,
};
use swc_ecma_visit::FoldWith;

fn main() {
    let cm = Lrc::<SourceMap>::default();
    let src = r#"
var bit = 0;
var sum = 0;
sum += (bit ^= 1) ? 0 : 1;
sum += (bit ^= 1) ? 0 : 1;
console.log(sum);
"#;
    let (module, comments) = parse(src, "test.js", &cm).unwrap();

    let transform = &mut expr_simplifier();
    let module = module.fold_with(transform);
    let module = module.fold_with(&mut chain!(
        reserved_words(),
        hygiene(),
        fixer(Some(&comments))
    ));

    let code = emit(&module, &comments, cm);
    println!("{}", code);
}

fn parse(
    code: &str,
    filename: &str,
    cm: &Lrc<SourceMap>,
) -> PResult<(Module, SingleThreadedComments)> {
    let source_file = cm.new_source_file(FileName::Real(filename.into()), code.into());
    let comments = SingleThreadedComments::default();

    let lexer = Lexer::new(
        Syntax::Es(EsConfig {
            jsx: true,
            ..Default::default()
        }),
        Default::default(),
        StringInput::from(&*source_file),
        Some(&comments),
    );
    let mut parser = Parser::new_from(lexer);
    match parser.parse_module() {
        Err(err) => Err(err),
        Ok(module) => Ok((module, comments)),
    }
}

fn emit(module: &Module, comments: &SingleThreadedComments, cm: Lrc<SourceMap>) -> String {
    let mut buf = vec![];
    {
        let writer = Box::new(JsWriter::new(cm.clone(), "\n", &mut buf, None));
        let config = Config { minify: false };
        let mut emitter = Emitter {
            cfg: config,
            comments: Some(&comments),
            cm,
            wr: writer,
        };
        emitter.emit_module(&module).unwrap();
    }

    String::from_utf8(buf).unwrap()
}

Current behaviour

var bit = 0;
var sum = 0;
sum += (bit ^= 1, 0);
sum += (bit ^= 1, 0);
console.log(sum);

Expected behavior
The behaviour of the code shouldn't change.

Version

d975a19

Context
parcel-bundler/parcel#6766

[swc-bot]

This closed issue has been automatically locked because it had no new activity for a month. If you are running into a similar issue, please create a new issue with the steps to reproduce. Thank you.