Does swc::Compiler handle comments with full fidelity?

[Vannevelj]

I'm using swc to parse text, adjust the AST and print it back out. When I print it out I notice that the resulting code is stripped from all its comments and equally the whitespace is messed up in a lot of places. To demonstrate the comments issue, I've created the following repro sample:

main.rs:

use swc_ecma_ast::EsVersion;
use swc_ecma_parser::{EsConfig, Syntax};
use swc::{SwcComments, Compiler};
use swc_common::collections::AHashMap;
use swc_common::errors::ColorConfig;
use swc_common::sync::Lrc;
use swc_common::{SourceMap, FileName, errors::Handler};

fn main() {
    let cm: Lrc<SourceMap> = Default::default();
    let compiler = Compiler::new(cm.clone());
    let handler = Handler::with_tty_emitter(ColorConfig::Auto, true, false, Some(cm.clone()));
    let config = EsConfig {
        jsx: true,
        fn_bind: true,
        import_assertions: true,
        ..Default::default()
    };

    let comments: SwcComments = Default::default();

    let file = cm.new_source_file(FileName::Custom("test.js".into()), String::from("// hello"));

    let program = compiler
        .parse_js(
            file,
            &handler,
            EsVersion::Es2022,
            Syntax::Es(config),
            swc::config::IsModule::Unknown,
            Some(&comments),
        )
        .expect("Failed to parse JS");

    let printed_code = compiler.print(
            &program,
            None,
            None,
            false,
            EsVersion::Es2022,
            swc::config::SourceMapsConfig::Bool(false),
            &AHashMap::default(),
            None,
            false,
            Some(&comments),
        )
        .expect("Failed to print");

    assert_eq!("// hello", printed_code.code);
}

cargo.toml:

[package]
name = "tmp-swc-roundtrip"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
swc = { git = "https://github.com/swc-project/swc" }
swc_ecma_ast= { git = "https://github.com/swc-project/swc" }
swc_ecma_parser= { git = "https://github.com/swc-project/swc" }

[dependencies.swc_common]
git = "https://github.com/swc-project/swc"
features = ["tty-emitter"]

I see from issues such as #2964 that up until very recently swc was aware of issues related to this so I'm not sure what I should expect to be possible. Am I not using the API correctly perhaps?

[kdy1]

Yes, swc preserve all comments correctly.

#2964 is about preserving comments when they should be stripped

[Vannevelj]

In that case, do you have any suggestion what I am doing wrong in my code sample?

[Vannevelj]

I tried a different approach by using VisitMut instead but I ended up with the same result: the comments appear discarded. e.g.

use swc::config::Options;
use swc_common::errors::{ColorConfig, Handler};
use swc_common::{FileName, SourceMap, Span};
use swc_common::sync::Lrc;
use swc_ecma_ast::{Pat, Param, TsTypeAnn, TsKeywordType, TsKeywordTypeKind, TsType};
use swc_ecma_visit::{as_folder, VisitMut, Fold, VisitMutWith};
use swc_ecma_transforms::pass::noop;

fn main() {
    let source_code = "function foo(a) { /* comments */ }";

    let cm: Lrc<SourceMap> = Default::default();
    let file = cm.new_source_file(FileName::Custom("test.js".into()), String::from(source_code));
    let compiler = swc::Compiler::new(cm.clone());
    let handler = Handler::with_tty_emitter(ColorConfig::Auto, true, false, Some(cm.clone()));

    let result = compiler.process_js_with_custom_pass(
        file,
        None,
        &handler,
        &Options::default(),
        |_,_| noop(),
        |_,_| my_visitor(),
    );

    let code = result.unwrap().code;
    println!("end: {code}");
}

fn my_visitor() -> impl Fold {
    as_folder(MyVisitor)
}

struct MyVisitor;
impl VisitMut for MyVisitor {
    fn visit_mut_param(&mut self, param: &mut Param) {
        param.visit_mut_children_with(self);

        let mut new_param = param.clone();
        match new_param.pat {
            Pat::Ident(ref mut ident) => {
                ident.type_ann = Some(create_any_type());
            }
            _ => return
        };

        *param = new_param
    }
}

fn create_any_type() -> TsTypeAnn {
    let any_keyword = TsKeywordType {
        span: Span::default(),
        kind: TsKeywordTypeKind::TsAnyKeyword,
    };

    TsTypeAnn {
        span: Span::default(),
        type_ann: Box::new(TsType::TsKeywordType(any_keyword)),
    }
}

Output:

end: function foo(a: any) {}

[Vannevelj]

For reference to others: swc does maintain comments when you use the process_js_with_custom_pass API using a VisitMut. The key here is to use a JscConfig so that you can set preserve_all_comments: true, e.g.

let result = compiler.process_js_with_custom_pass(
        file,
        None,
        &handler,
        &Options {
            config: Config {
                jsc: JscConfig {
                    preserve_all_comments: true,
                    ..Default::default()
                },
                ..Default::default()
            },
            ..Default::default()
        },
        |_,_| noop(),
        |_,_| my_visitor(),
    );

This correctly maintains the comments (in most cases -- some edge cases seem to ignore it). However swc does not maintain whitespace so I've opted for rslint instead which does.

[kdy1]

You can implement a custom code generator if you need it

[Vannevelj]

Do you have any documentation or examples that show how this would be done?