Problem when emit modified module AST

[lidessen]

Here is my code:

use swc_common::FilePathMapping;
use swc_common::{sync::Lrc, FileName, SourceMap};
use swc_ecmascript::ast::{EsVersion, ImportDecl, Module};
use swc_ecmascript::codegen::text_writer::JsWriter;
use swc_ecmascript::codegen::{Config, Emitter};
use swc_ecmascript::parser::{
    error::Error as SwcError, lexer::Lexer, Parser, StringInput, Syntax, TsConfig,
};
use swc_ecmascript::visit::{as_folder, FoldWith, VisitMut};

const ES_VERSION: EsVersion = EsVersion::Es2021;

struct ImportProcessor;

impl VisitMut for ImportProcessor {
    fn visit_mut_import_decl(&mut self, import: &mut ImportDecl) {
        import.src.value = "testaaa".into();
    }
}

pub fn parse(source: String, cm: &Lrc<SourceMap>) -> Result<Module, SwcError> {
    let source_file = cm.new_source_file(FileName::Real("index.js".into()), source.into());
    let syntax = Syntax::Typescript(TsConfig {
        decorators: true,
        dts: false,
        tsx: true,
        no_early_errors: false,
    });
    let lexer = Lexer::new(syntax, ES_VERSION, StringInput::from(&*source_file), None);
    let mut parser = Parser::new_from(lexer);

    Ok(parser.parse_module()?)
}

pub fn visit_imports(module: Module) -> Module {
    module.fold_with(&mut as_folder(ImportProcessor))
}

pub fn emit(module: &Module, 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: None,
            cm: cm.clone(),
            wr: writer,
        };
        emitter.emit_module(&module).unwrap();
    }

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

pub fn process(source: String) -> String {
    let cm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
    match parse(source, &cm) {
        Ok(module) => emit(&visit_imports(module), cm),
        Err(_) => "".into(),
    }
}

what the ImportProcessor did is just replace all import.src with testaaa

But when I call

process("import {abc,a} from 'deno'".into())

the output is import { abc, a } from 'denoaaa';, why?

[kdy1]

You can try debugging using dbg! on ast nodes are other types.

[lidessen]

visit_imports(module) = Module {
    span: Span {
        lo: BytePos(
            0,
        ),
        hi: BytePos(
            26,
        ),
        ctxt: #0,
    },
    body: [
        ModuleDecl(
            Import(
                ImportDecl {
                    span: Span {
                        lo: BytePos(
                            0,
                        ),
                        hi: BytePos(
                            26,
                        ),
                        ctxt: #0,
                    },
                    specifiers: [
                        Named(
                            ImportNamedSpecifier {
                                span: Span {
                                    lo: BytePos(
                                        8,
                                    ),
                                    hi: BytePos(
                                        11,
                                    ),
                                    ctxt: #0,
                                },
                                local: Ident {
                                    span: Span {
                                        lo: BytePos(
                                            8,
                                        ),
                                        hi: BytePos(
                                            11,
                                        ),
                                        ctxt: #0,
                                    },
                                    sym: Atom('abc' type=inline),
                                    optional: false,
                                },
                                imported: None,
                                is_type_only: false,
                            },
                        ),
                        Named(
                            ImportNamedSpecifier {
                                span: Span {
                                    lo: BytePos(
                                        12,
                                    ),
                                    hi: BytePos(
                                        13,
                                    ),
                                    ctxt: #0,
                                },
                                local: Ident {
                                    span: Span {
                                        lo: BytePos(
                                            12,
                                        ),
                                        hi: BytePos(
                                            13,
                                        ),
                                        ctxt: #0,
                                    },
                                    sym: Atom('a' type=inline),
                                    optional: false,
                                },
                                imported: None,
                                is_type_only: false,
                            },
                        ),
                    ],
                    src: Str {
                        span: Span {
                            lo: BytePos(
                                20,
                            ),
                            hi: BytePos(
                                26,
                            ),
                            ctxt: #0,
                        },
                        value: Atom('testaaa' type=inline),
                        has_escape: false,
                        kind: Normal {
                            contains_quote: true,
                        },
                    },
                    type_only: false,
                    asserts: None,
                },
            ),
        ),
    ],
    shebang: None,
}

The AST is as wished before I emit it, do I have some thing wrong with my emit function?

[kdy1]

Ah, as you modified content of Str, Str.kind must be StrKind::Synthesized. I'll document it.

[lidessen]

I changed the kind to StrKind::Synthesized and it works, thank you!!!

[lidessen]

Ah, as you modified content of Str, Str.kind must be StrKind::Synthesized. I'll document it.

I have another stupid question, why modifies here don't need to change the kind?

[kdy1]

Oh, it seems like a bug. Nice catch, thanks!

Edit: Updated the PR for doc to include patch for it.