fix(es/minifier): Abort function inliner if keep_fnames is true (#…

…8145)

**Related issue:**

 - vercel/next.js#56408

crates/dbg-swc/src/es/minifier/compare_opts.rs

@@ -0,0 +1,62 @@
+use std::{path::PathBuf, sync::Arc};
+
+use anyhow::{Context, Result};
+use clap::Args;
+use swc_common::SourceMap;
+use swc_ecma_minifier::option::{CompressOptions, MangleOptions};
+
+use crate::util::{
+    all_js_files,
+    minifier::{get_minified, get_minified_with_opts},
+    print_js,
+};
+
+/// [Experimental] Internal command to check the size difference caused by
+/// options.
+#[derive(Debug, Args)]
+pub struct CompareOptsCommand {
+    pub path: PathBuf,
+}
+
+impl CompareOptsCommand {
+    pub fn run(self, cm: Arc<SourceMap>) -> Result<()> {
+        let files = all_js_files(&self.path)?;
+
+        let mut default_sum = 0;
+        let mut new_sum = 0;
+
+        for file in files {
+            let default_record = get_minified(cm.clone(), &file, true, true)?;
+            let default_code = print_js(cm.clone(), &default_record.module, true)
+                .context("failed to convert ast to code")?;
+
+            eprintln!("default: {} bytes", default_code.as_bytes().len());
+            default_sum += default_code.as_bytes().len();
+
+            let new_record = get_minified_with_opts(
+                cm.clone(),
+                &file,
+                Some(CompressOptions {
+                    keep_classnames: true,
+                    keep_fnames: true,
+                    ..Default::default()
+                }),
+                Some(MangleOptions {
+                    keep_class_names: true,
+                    keep_fn_names: true,
+                    ..Default::default()
+                }),
+            )?;
+            let new_code = print_js(cm.clone(), &new_record.module, true)
+                .context("failed to convert ast to code")?;
+
+            eprintln!("new: {} bytes", new_code.as_bytes().len());
+            new_sum += new_code.as_bytes().len();
+        }
+
+        eprintln!("default (total): {} bytes", default_sum);
+        eprintln!("new (total): {} bytes", new_sum);
+
+        Ok(())
+    }
+}

crates/dbg-swc/src/es/minifier/mod.rs

@@ -5,10 +5,12 @@ use clap::Subcommand;
 use swc_common::SourceMap;
 
 use self::{
-    compare::CompareCommand, ensure_size::EnsureSize, next::NextCommand, reduce::ReduceCommand,
+    compare::CompareCommand, compare_opts::CompareOptsCommand, ensure_size::EnsureSize,
+    next::NextCommand, reduce::ReduceCommand,
 };
 
 mod compare;
+mod compare_opts;
 mod ensure_size;
 mod next;
 mod reduce;
@@ -20,6 +22,7 @@ pub enum MinifierCommand {
     Next(NextCommand),
     Reduce(ReduceCommand),
     Compare(CompareCommand),
+    CompareOpts(CompareOptsCommand),
     EnsureSize(EnsureSize),
 }
 
@@ -30,6 +33,7 @@ impl MinifierCommand {
             MinifierCommand::Reduce(cmd) => cmd.run(cm),
             MinifierCommand::EnsureSize(cmd) => cmd.run(cm),
             MinifierCommand::Compare(cmd) => cmd.run(cm),
+            MinifierCommand::CompareOpts(cmd) => cmd.run(cm),
         }
     }
 }

crates/dbg-swc/src/util/minifier.rs

@@ -7,7 +7,7 @@ use std::{
 use anyhow::{bail, Context, Result};
 use swc_common::{FileName, SourceMap};
 use swc_ecma_ast::*;
-use swc_ecma_minifier::option::MinifyOptions;
+use swc_ecma_minifier::option::{CompressOptions, MangleOptions, MinifyOptions};
 use swc_ecma_transforms_base::fixer::fixer;
 use swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};
 
@@ -18,6 +18,28 @@ pub fn get_minified(
     file: &Path,
     compress: bool,
     mangle: bool,
+) -> Result<ModuleRecord> {
+    get_minified_with_opts(
+        cm,
+        file,
+        if compress {
+            Some(Default::default())
+        } else {
+            None
+        },
+        if mangle {
+            Some(Default::default())
+        } else {
+            None
+        },
+    )
+}
+
+pub fn get_minified_with_opts(
+    cm: Arc<SourceMap>,
+    file: &Path,
+    compress: Option<CompressOptions>,
+    mangle: Option<MangleOptions>,
 ) -> Result<ModuleRecord> {
     let fm = cm.load_file(file)?;
 
@@ -30,16 +52,8 @@ pub fn get_minified(
             Some(&m.comments),
             None,
             &MinifyOptions {
-                compress: if compress {
-                    Some(Default::default())
-                } else {
-                    None
-                },
-                mangle: if mangle {
-                    Some(Default::default())
-                } else {
-                    None
-                },
+                compress,
+                mangle,
                 ..Default::default()
             },
             &swc_ecma_minifier::option::ExtraOptions {

crates/swc_ecma_minifier/src/compress/optimize/inline.rs

@@ -706,17 +706,32 @@ impl Optimizer<'_> {
                     }
                 }
 
-                self.changed = true;
-                #[cfg(feature = "debug")]
+                #[allow(unused)]
                 match &decl {
                     Decl::Class(c) => {
+                        if self.options.keep_classnames
+                            || self.mangle_options.map_or(false, |v| v.keep_class_names)
+                        {
+                            log_abort!("inline: [x] Keep fn names");
+                            return;
+                        }
+
+                        self.changed = true;
                         report_change!(
                             "inline: Decided to inline class `{}{:?}` as it's used only once",
                             c.ident.sym,
                             c.ident.span.ctxt
                         );
                     }
                     Decl::Fn(f) => {
+                        if self.options.keep_fnames
+                            || self.mangle_options.map_or(false, |v| v.keep_fn_names)
+                        {
+                            log_abort!("inline: [x] Keep fn names");
+                            return;
+                        }
+
+                        self.changed = true;
                         report_change!(
                             "inline: Decided to inline function `{}{:?}` as it's used only once",
                             f.ident.sym,