feat: support custom source map implementations

Cargo.toml

@@ -36,8 +36,8 @@ crate-type = ["rlib"]
 [features]
 default = ["bundler", "nodejs", "sourcemap"]
 browserslist = ["browserslist-rs"]
-bundler = ["dashmap", "sourcemap", "rayon"]
-cli = ["clap", "serde_json", "browserslist", "jemallocator"]
+bundler = ["dashmap", "custom_sourcemap", "rayon"]
+cli = ["clap", "serde_json", "browserslist", "jemallocator", "sourcemap"]
 jsonschema = ["schemars", "serde", "parcel_selectors/jsonschema"]
 nodejs = ["dep:serde", "dep:serde-content"]
 serde = [
@@ -49,7 +49,8 @@ serde = [
   "parcel_selectors/serde",
   "into_owned",
 ]
-sourcemap = ["parcel_sourcemap"]
+sourcemap = ["custom_sourcemap", "dep:parcel_sourcemap"]
+custom_sourcemap = ["dep:rustc-hash"]
 visitor = []
 into_owned = [
   "static-self",
@@ -74,6 +75,7 @@ lazy_static = "1.4.0"
 const-str = "1.1.0"
 pathdiff = "0.2.1"
 ahash = "0.8.7"
+rustc-hash = { version = "2", optional = true }
 pastey = "0.1.0"
 indexmap = { version = "2.2.6", features = ["serde"] }
 # CLI deps

benches/common/mod.rs

@@ -1,4 +1,5 @@
 use criterion::black_box;
+use parcel_sourcemap::SourceMap;
 use rspack_lightningcss::stylesheet::{MinifyOptions, ParserOptions, PrinterOptions, StyleSheet};
 use std::fmt::Write;
 
@@ -37,14 +38,43 @@ pub fn transform_stylesheet(css: &str) {
   let mut stylesheet = StyleSheet::parse(css, ParserOptions::default()).unwrap();
   stylesheet.minify(MinifyOptions::default()).unwrap();
   let result = stylesheet
-    .to_css(PrinterOptions {
-      minify: true,
-      ..PrinterOptions::default()
-    })
+    .to_css(
+      PrinterOptions {
+        minify: true,
+        ..PrinterOptions::default()
+      },
+      None::<&mut ()>,
+    )
     .unwrap();
   black_box(result);
 }
 
+pub fn transform_stylesheet_with_source_map(css: &str) {
+  let mut source_map = SourceMap::new("/");
+  let source_index = source_map.add_source("bench.css");
+  source_map.set_source_content(source_index as usize, css).unwrap();
+
+  let mut stylesheet = StyleSheet::parse(
+    css,
+    ParserOptions {
+      source_index,
+      ..ParserOptions::default()
+    },
+  )
+  .unwrap();
+  stylesheet.minify(MinifyOptions::default()).unwrap();
+  let result = stylesheet
+    .to_css(
+      PrinterOptions {
+        minify: true,
+        ..PrinterOptions::default()
+      },
+      Some(&mut source_map),
+    )
+    .unwrap();
+  black_box((result, source_map));
+}
+
 fn small_fixture() -> String {
   r#"
 :root {

benches/transform.rs

@@ -27,12 +27,19 @@ fn bench_stylesheet_transform(c: &mut Criterion) {
   for fixture in &fixtures {
     group.throughput(Throughput::Bytes(fixture.css.len() as u64));
     group.bench_with_input(
-      BenchmarkId::from_parameter(fixture.name),
+      BenchmarkId::new("no-source-map", fixture.name),
       fixture.css.as_str(),
       |b, css| {
         b.iter(|| common::transform_stylesheet(black_box(css)));
       },
     );
+    group.bench_with_input(
+      BenchmarkId::new("source-map", fixture.name),
+      fixture.css.as_str(),
+      |b, css| {
+        b.iter(|| common::transform_stylesheet_with_source_map(black_box(css)));
+      },
+    );
   }
 
   group.finish();

c/src/lib.rs

@@ -338,7 +338,6 @@ pub extern "C" fn lightningcss_stylesheet_to_css(
     } else {
       Some(unsafe { std::str::from_utf8_unchecked(CStr::from_ptr(options.project_root).to_bytes()) })
     },
-    source_map: source_map.as_mut(),
     targets: if options.targets != Targets::default() {
       Some(options.targets.into()).into()
     } else {
@@ -356,7 +355,11 @@ pub extern "C" fn lightningcss_stylesheet_to_css(
     },
   };
 
-  let res = unwrap!(wrapper.stylesheet.to_css(opts), error, ToCssResult::default());
+  let res = unwrap!(
+    wrapper.stylesheet.to_css(opts, source_map.as_mut()),
+    error,
+    ToCssResult::default()
+  );
 
   let map = if let Some(mut source_map) = source_map {
     if !options.input_source_map.is_null() {

derive/src/to_css.rs

@@ -25,10 +25,7 @@ pub fn derive_to_css(input: TokenStream) -> TokenStream {
 
   let output = quote! {
     impl #impl_generics ToCss for #ident #ty_generics #where_clause {
-      fn to_css<W>(&self, dest: &mut Printer<W>) -> Result<(), PrinterError>
-      where
-        W: std::fmt::Write,
-      {
+      fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
         #imp
       }
     }
@@ -121,7 +118,10 @@ fn derive_enum(data: &DataEnum, opts: &CssOptions) -> TokenStream2 {
         Fields::Unit => {
           let s = Literal::string(&variant.ident.to_string().to_case(opts.case));
           quote! {
-            Self::#name => dest.write_str(#s)
+            Self::#name => {
+              dest.write_str(#s)?;
+              Ok(())
+            }
           }
         }
         Fields::Named(_) => {

examples/custom_at_rule.rs

@@ -4,7 +4,7 @@ use cssparser::*;
 use rspack_lightningcss::{
   declaration::DeclarationBlock,
   error::PrinterError,
-  printer::Printer,
+  printer::PrinterTrait,
   properties::custom::{Token, TokenOrValue},
   rules::{style::StyleRule, CssRule, CssRuleList, Location},
   selector::{Component, Selector},
@@ -42,14 +42,17 @@ fn main() {
   stylesheet.visit(&mut ApplyVisitor { rules: &style_rules }).unwrap();
 
   let result = stylesheet
-    .to_css(PrinterOptions {
-      targets: Browsers {
-        chrome: Some(100 << 16),
-        ..Browsers::default()
-      }
-      .into(),
-      ..PrinterOptions::default()
-    })
+    .to_css(
+      PrinterOptions {
+        targets: Browsers {
+          chrome: Some(100 << 16),
+          ..Browsers::default()
+        }
+        .into(),
+        ..PrinterOptions::default()
+      },
+      None::<&mut ()>,
+    )
     .unwrap();
   println!("{}", result.code);
 }
@@ -294,7 +297,7 @@ impl<'i, V: Visitor<'i, AtRule>> Visit<'i, AtRule, V> for AtRule {
 }
 
 impl ToCss for AtRule {
-  fn to_css<W: std::fmt::Write>(&self, dest: &mut Printer<W>) -> Result<(), PrinterError> {
+  fn to_css<PrinterT: PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
     match self {
       AtRule::Tailwind(rule) => {
         let _ = rule.loc; // TODO: source maps
@@ -304,7 +307,8 @@ impl ToCss for AtRule {
           TailwindDirective::Utilities => "TAILWIND UTILITIES HERE",
           TailwindDirective::Variants => "TAILWIND VARIANTS HERE",
         };
-        dest.write_str(directive)
+        dest.write_str(directive)?;
+        Ok(())
       }
       AtRule::Apply(_) => Ok(()),
     }

napi/src/at_rule_parser.rs

@@ -4,6 +4,7 @@ use cssparser::*;
 use lightningcss::{
   declaration::DeclarationBlock,
   error::ParserError,
+  printer::PrinterTrait,
   rules::{CssRuleList, Location},
   stylesheet::ParserOptions,
   traits::{AtRuleParser, ToCss},
@@ -161,13 +162,7 @@ impl<'i> AtRuleParser<'i> for CustomAtRuleParser {
 }
 
 impl<'i> ToCss for AtRule<'i> {
-  fn to_css<W>(
-    &self,
-    dest: &mut lightningcss::printer::Printer<W>,
-  ) -> Result<(), lightningcss::error::PrinterError>
-  where
-    W: std::fmt::Write,
-  {
+  fn to_css<PrinterT: PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), lightningcss::error::PrinterError> {
     dest.write_char('@')?;
     serialize_identifier(&self.name, dest)?;
     if let Some(prelude) = &self.prelude {

napi/src/lib.rs

@@ -763,24 +763,26 @@ fn compile<'i>(
       unused_symbols: config.unused_symbols.clone().unwrap_or_default(),
     })?;
 
-    stylesheet.to_css(PrinterOptions {
-      minify: config.minify.unwrap_or_default(),
-      source_map: source_map.as_mut(),
-      project_root,
-      targets,
-      analyze_dependencies: if let Some(d) = &config.analyze_dependencies {
-        match d {
-          AnalyzeDependenciesOption::Bool(b) if *b => Some(DependencyOptions { remove_imports: true }),
-          AnalyzeDependenciesOption::Config(c) => Some(DependencyOptions {
-            remove_imports: !c.preserve_imports,
-          }),
-          _ => None,
-        }
-      } else {
-        None
+    stylesheet.to_css(
+      PrinterOptions {
+        minify: config.minify.unwrap_or_default(),
+        project_root,
+        targets,
+        analyze_dependencies: if let Some(d) = &config.analyze_dependencies {
+          match d {
+            AnalyzeDependenciesOption::Bool(b) if *b => Some(DependencyOptions { remove_imports: true }),
+            AnalyzeDependenciesOption::Config(c) => Some(DependencyOptions {
+              remove_imports: !c.preserve_imports,
+            }),
+            _ => None,
+          }
+        } else {
+          None
+        },
+        pseudo_classes: config.pseudo_classes.as_ref().map(|p| p.into()),
       },
-      pseudo_classes: config.pseudo_classes.as_ref().map(|p| p.into()),
-    })?
+      source_map.as_mut(),
+    )?
   };
 
   let map = if let Some(mut source_map) = source_map {
@@ -898,24 +900,26 @@ fn compile_bundle<'i, 'o, P: SourceProvider, F: FnOnce(&mut StyleSheet<'i, AtRul
       unused_symbols: config.unused_symbols.clone().unwrap_or_default(),
     })?;
 
-    stylesheet.to_css(PrinterOptions {
-      minify: config.minify.unwrap_or_default(),
-      source_map: source_map.as_mut(),
-      project_root,
-      targets,
-      analyze_dependencies: if let Some(d) = &config.analyze_dependencies {
-        match d {
-          AnalyzeDependenciesOption::Bool(b) if *b => Some(DependencyOptions { remove_imports: true }),
-          AnalyzeDependenciesOption::Config(c) => Some(DependencyOptions {
-            remove_imports: !c.preserve_imports,
-          }),
-          _ => None,
-        }
-      } else {
-        None
+    stylesheet.to_css(
+      PrinterOptions {
+        minify: config.minify.unwrap_or_default(),
+        project_root,
+        targets,
+        analyze_dependencies: if let Some(d) = &config.analyze_dependencies {
+          match d {
+            AnalyzeDependenciesOption::Bool(b) if *b => Some(DependencyOptions { remove_imports: true }),
+            AnalyzeDependenciesOption::Config(c) => Some(DependencyOptions {
+              remove_imports: !c.preserve_imports,
+            }),
+            _ => None,
+          }
+        } else {
+          None
+        },
+        pseudo_classes: config.pseudo_classes.as_ref().map(|p| p.into()),
       },
-      pseudo_classes: config.pseudo_classes.as_ref().map(|p| p.into()),
-    })?
+      source_map.as_mut(),
+    )?
   };
 
   let map = if let Some(source_map) = &mut source_map {
@@ -1022,7 +1026,6 @@ fn compile_attr<'i>(
     });
     attr.to_css(PrinterOptions {
       minify: config.minify,
-      source_map: None,
       project_root: None,
       targets,
       analyze_dependencies: if config.analyze_dependencies {