Node to String

[regexPattern]

Hi, I'm pretty new to parsing in general and to swc. I'm wondering if there's a function that allows me to get the string representation of an ast node, without having to rely on a SourceMap. For example, in my case I want to store the function definitions as a string:

use swc_common::BytePos;
use swc_ecma_ast::{EsVersion, FnDecl, Stmt};
use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax, TsConfig};

fn main() {
    let src = r#"


const value = "";

function myFunction(param1: number, param2: string, param3: any): number {}


"#;

    let mut parser = Parser::new_from(Lexer::new(
        Syntax::Typescript(TsConfig {
            tsx: false,
            decorators: true,
            dts: false,
            no_early_errors: true,
            disallow_ambiguous_jsx_like: false,
        }),
        EsVersion::Es2021,
        StringInput::new(src, BytePos(0), BytePos(0)),
        None,
    ));

    let stmts: Vec<Stmt> = parser.parse_script().unwrap().body;
    let func_decl: FnDecl = stmts
        .into_iter()
        .find_map(|stmt| stmt.decl()?.fn_decl())
        .unwrap();

    assert_eq!(
        // >>> Does this functionality exist.
        node_to_string(func_decl),
        "function myFunction(param1: number, param2: string, param3: any): number {}"
    );
}

[kwonoj]

The quickest way I can think of is compiler.print.

[regexPattern]

Seems to be a little cumbersome to do it this way, specially compared to how parsers like rome and rslint allow you to do it just by implementing Display on ast node types. I'll give it a try and see if I get it working.

[kwonoj]

I can't tell about other tooling's design, so far SWC's design is focused to provide integrated workflow across its features and I would say it's adequately working especially since there aren't a lot of users like your specific usecase. We'd consider revising interfaces over time.

[stahlbauer]

I would be interested in a good solution for this problem, too. I did use compiler.print. However, this required me to import the swc crate in my plugin, which in the end rendered the plugin unusable due to too many unbound function imports/exports in the WASM.

The swc_coverage_instrument plugin does some print_node magic along with tracing macros #[tracing::instrument(skip_all, fields(node = %self.print_node()))]. But I have no idea yet how to make such an approach working for my plugin.

[regexPattern]

In my case I ended up sticking with a SourceMap because of the friction that working with a Compiler introduced. I thought about maybe implementing some kind of printing functionality for each of the node types I cared about (maybe implementing std::fmt::Display on a newtype or something like that), but that meant mean that I had to assume a specific output format that might diverge from how to input code was formatted.

[kdy1]

Use swc_ecma_codegen