Suboptimal code generation for transpiled class expressions

[mischnic]

Describe the bug

There is a unnecessary IIFE wrapper (which is also missing a pure comment, but ideally it would be removed entirely) around class expressions (not declarations)

Input code

console.log(class {run(){}});

Output code

console.log(function() {
    var _class = /*#__PURE__*/ function() {
        "use strict";
        function _class() {
            _classCallCheck(this, _class);
        }
        _createClass(_class, [
            {
                key: "run",
                value: function run() {
                }
            }
        ]);
        return _class;
    }();
    return _class;
}());

Expected behavior

Something like

console.log(/*#__PURE__*/ function() {
        "use strict";
        function _class() {
            _classCallCheck(this, _class);
        }
        _createClass(...);
        return _class;
    }()
);

so without that function(){var _class = ...; return _class;}() wrapper

Config

Full example

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

fn main() {
    let cm = Lrc::<SourceMap>::default();
    // let src = "console.log(<h1>s</h1>);";
    let src = "console.log(class {run(){}});";
    let (module, comments) = parse(src, "test.js", &cm).unwrap();

    swc_common::GLOBALS.set(&Globals::new(), || {
        helpers::HELPERS.set(&helpers::Helpers::default(), || {
            let global_mark = Mark::fresh(Mark::root());
            let module = module.fold_with(&mut resolver_with_mark(global_mark));

            // let transform =
            //     &mut react::react(cm.clone(), Some(&comments),
            // react::Options::default());
            let transform = &mut preset_env(
                global_mark,
                Some(&comments),
                swc_ecma_preset_env::Config::default(),
            );
            let module = module.fold_with(transform);

            println!("{:?}", comments);

            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()
}

Version
c3bf517

[mischnic]

With your PR, I'm still seeing the additional wrapper

console.log(function() {
    var _class = /*#__PURE__*/ function() {
        "use strict";
        function _class() {
            _classCallCheck(this, _class);
        }
        _createClass(_class, [
            {
                key: "run",
                value: function run() {
                }
            }
        ]);
        return _class;
    }();
    return _class;
}());

[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.