Performance on large projects / exclude files from plugin

[FelixMalfait]

Hello, thanks for Lingui!

We have a large NestJS project (~5,000 source files) but only ~100 files use Lingui macros on the server side (msg, t from @lingui/core/macro). The @lingui/swc-plugin is configured globally in our .swcrc, so it processes all 5,000 files on every build — even though ~4,900 of them have no Lingui imports at all.

The per-file overhead seem to add up significantly and impact performance
Would it be possible for the plugin to short-circuit early when a file contains no Lingui imports if that's not the case? Maybe an early exit before doing a full AST traversal (if that's what you do), it would make the no-op case near-instant and dramatically improve build times for large codebases where only a small fraction of files use Lingui.
Alternatively, is there a way to configure SWC to apply the plugin only to specific files/directories?

Thanks a lot

Félix

[timofei-iatsenko]

Could you share more stats what is the overhead in seconds/milliseconds? Just to have a baseline understanding.

The plugin already doing a short-circuit but on the level of the each node of the visitor.

    fn fold_function(&mut self, n: Function) -> Function {
        // If no package that we care about is imported, skip the following
        // transformation logic.
        if !self.has_lingui_macro_imports {
            return n;
        }

    // ....

    }

It's possible to to skip the AST traversal entirely in the plugin, by reading the sourcecode as string and just grepping it for macro import. However i suspect that this will not give any noticable performance benefits because if there is no imports the visitor is already doing nothing and should finish very quick (no memory allocation, no copies, etc)

I believe the performance penality may come from the way how the swc plugins system works. It need to serialize the whole AST and transfer it to the WebAssembly memory where plugin is executed, and then plugin should transfer it back.

So i think instantiation of the WASM and this serialization/de-serialization adds this performance penality. So even if i skip the AST traversal entirely, SWC host still would need to instantiate the plugin.

Any way, we can try, i can prepare a version skipping the traversal and you will check it on your side.

What version of swc_core your pipeline is using?

If that would not help we can rise the issue to upstream, and ask to change plugin api to for example copy the AST only if it's accessed. Or add an additional hook determining should we run this plugin or not.

[FelixMalfait]

Thank you! I'll re-run the number today and come back to you.

[timofei-iatsenko]

@FelixMalfait what version of swc-core you use so i can preapre a version with this swc-core for you

[FelixMalfait]

Setup:

• @swc/core: 1.13.3
• @lingui/swc-plugin: 5.6.0 (swc_core 27.0.6)
• 4,589 TypeScript files, only ~100 have @lingui imports
• Apple M3 Pro, 18 GB RAM, macOS, Node v24.5.0

OK so to be honest it's really not as bad as I thought when I look at the overall impact on the project, I misintepreted something the first time I ran this hypothesis. Over a few runs, here's what I get:

	Median	Mean	Range
Without plugin	4.98s	5.00s	4.30–5.50s
With plugin	6.36s	7.12s	5.85–8.90s
Delta	+1.86s	+2.06s	1.55–3.40s

+40% is a significant impact for 100 files sur but it's not dramatic at all for us given it's just 2seconds overall, I think there is something else in the project that is adding 10 seconds. If you had a quick fix that would have been nice but if it requires upstream changes, I don't think it's worth it (at least for us)

[timofei-iatsenko]

I could make a changes only on top of the latest version we have on main, and it uses swc_core@50.2.3

Could you update your @swc/core to latest?

[timofei-iatsenko]

I created a version which skips entire AST traversal. This is quick solution which doesn't cover configuration parameters, etc, just to check the idea lingui_macro_plugin.wasm.zip

It's build with this code snippet:

    // Early exit optimization: skip AST traversal if there are no Lingui macro imports
    // Use span_to_snippet to get the source code from the program's span
    if let Ok(src) = metadata.source_map.span_to_snippet(program.span()) {
        // Check for Lingui macro imports using simple string search
        let has_lingui_imports = src.contains("@lingui/core/macro")
            || src.contains("@lingui/react/macro")
            || src.contains("@lingui/macro");

        if !has_lingui_imports {
            let filename = metadata.source_map.span_to_filename(program.span());

            println!("File is skipped from transform since it doesnt have any lingui macro imports! {filename}");
            // No Lingui imports found, skip transformation
            return program;
        }
    }

However, i think it would not give any performance benefits, because metadata.source_map field is lazy, and when it's accessed that invokes an expensive cross boundary calls (transfering the object from host to plugin)

To use this, unpack zip file, put the file somewhere in the project directory and specify the path in swc config to this file directly.

Let me know the result of the experiment!