refactor: Swap swc_css out

Cargo.toml

@@ -76,19 +76,19 @@ lto = "off"
 [workspace.dependencies]
 async-recursion = "1.0.2"
 # Keep consistent with preset_env_base through swc_core
-browserslist-rs = { version = "0.12.2" }
+browserslist-rs = { version = "0.13.0" }
 
 mdxjs = "0.1.19"
-modularize_imports = { version = "0.55.0" }
-styled_components = { version = "0.82.0" }
-styled_jsx = { version = "0.59.0" }
-swc_core = { version = "0.86.40", features = [
+modularize_imports = { version = "0.56.0" }
+styled_components = { version = "0.83.0" }
+styled_jsx = { version = "0.60.0" }
+swc_core = { version = "0.86.60", features = [
   "ecma_loader_lru",
   "ecma_loader_parking_lot",
 ] }
-swc_emotion = { version = "0.58.0" }
-swc_relay = { version = "0.30.0" }
-testing = { version = "0.35.7" }
+swc_emotion = { version = "0.59.0" }
+swc_relay = { version = "0.31.0" }
+testing = { version = "0.35.10" }
 
 auto-hash-map = { path = "crates/turbo-tasks-auto-hash-map" }
 node-file-trace = { path = "crates/node-file-trace", default-features = false }
@@ -246,3 +246,4 @@ url = "2.2.2"
 urlencoding = "2.1.2"
 webbrowser = "0.8.7"
 which = "4.4.0"
+

crates/turbopack-core/src/issue/mod.rs

@@ -457,6 +457,18 @@ impl IssueSource {
         })
     }
 
+    #[turbo_tasks::function]
+    pub fn from_line_col(
+        source: Vc<Box<dyn Source>>,
+        start: SourcePos,
+        end: SourcePos,
+    ) -> Vc<Self> {
+        Self::cell(IssueSource {
+            source,
+            range: Some(SourceRange::LineColumn(start, end).cell()),
+        })
+    }
+
     /// Create a [`IssueSource`] from byte offsets given by an swc ast node
     /// span.
     ///

crates/turbopack-core/src/source_pos.rs

@@ -1,5 +1,5 @@
 use serde::{Deserialize, Serialize};
-use turbo_tasks::trace::TraceRawVcs;
+use turbo_tasks::{trace::TraceRawVcs, TaskInput};
 use turbo_tasks_hash::DeterministicHash;
 
 /// LINE FEED (LF), one of the basic JS line terminators.
@@ -16,6 +16,7 @@ const U8_CR: u8 = 0x0D;
     Clone,
     PartialOrd,
     Ord,
+    TaskInput,
     TraceRawVcs,
     Serialize,
     Deserialize,

crates/turbopack-css/Cargo.toml

@@ -14,7 +14,13 @@ anyhow = { workspace = true }
 async-trait = { workspace = true }
 indexmap = { workspace = true }
 indoc = { workspace = true }
+lightningcss = { version = "1.0.0-alpha.50", features = [
+  "serde",
+  "visitor",
+  "into_owned",
+] }
 once_cell = { workspace = true }
+parcel_selectors = "0.26.0"
 regex = { workspace = true }
 serde = { workspace = true }
 turbo-tasks = { workspace = true }
@@ -24,17 +30,10 @@ turbopack-core = { workspace = true }
 turbopack-ecmascript = { workspace = true }
 turbopack-swc-utils = { workspace = true }
 
+parcel_sourcemap = "2.1.1"
+smallvec = "1.11.0"
 swc_core = { workspace = true, features = [
   "ecma_ast",
-  "css_ast",
-  "css_ast_serde",
-  "css_codegen",
-  "css_parser",
-  "css_utils",
-  "css_visit",
-  "css_visit_path",
-  "css_compat",
-  "css_modules",
   "common",
   "common_concurrent",
 ] }

crates/turbopack-css/src/asset.rs

@@ -1,12 +1,4 @@
 use anyhow::Result;
-use swc_core::{
-    common::{Globals, GLOBALS},
-    css::{
-        ast::{AtRule, AtRulePrelude, Rule},
-        codegen::{writer::basic::BasicCssWriter, CodeGenerator, Emit},
-        visit::{VisitMutWith, VisitMutWithPath},
-    },
-};
 use turbo_tasks::{TryJoinIterExt, ValueToString, Vc};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::{
@@ -23,12 +15,11 @@ use turbopack_core::{
 use crate::{
     chunk::{CssChunkItem, CssChunkItemContent, CssChunkPlaceable, CssChunkType, CssImport},
     code_gen::CodeGenerateable,
-    parse::{parse_css, ParseCss, ParseCssResult, ParseCssResultSourceMap},
-    path_visitor::ApplyVisitors,
-    references::{
-        analyze_css_stylesheet, compose::CssModuleComposeReference, import::ImportAssetReference,
+    process::{
+        finalize_css, parse_css, process_css_with_placeholder, CssWithPlaceholderResult,
+        FinalCssResult, ParseCss, ParseCssResult, ProcessCss,
     },
-    transform::CssInputTransforms,
+    references::{compose::CssModuleComposeReference, import::ImportAssetReference},
     CssModuleAssetType,
 };
 
@@ -42,7 +33,6 @@ fn modifier() -> Vc<String> {
 pub struct CssModuleAsset {
     source: Vc<Box<dyn Source>>,
     asset_context: Vc<Box<dyn AssetContext>>,
-    transforms: Vc<CssInputTransforms>,
     ty: CssModuleAssetType,
 }
 
@@ -53,13 +43,11 @@ impl CssModuleAsset {
     pub fn new(
         source: Vc<Box<dyn Source>>,
         asset_context: Vc<Box<dyn AssetContext>>,
-        transforms: Vc<CssInputTransforms>,
         ty: CssModuleAssetType,
     ) -> Vc<Self> {
         Self::cell(CssModuleAsset {
             source,
             asset_context,
-            transforms,
             ty,
         })
     }
@@ -74,8 +62,34 @@ impl CssModuleAsset {
 #[turbo_tasks::value_impl]
 impl ParseCss for CssModuleAsset {
     #[turbo_tasks::function]
-    fn parse_css(&self) -> Vc<ParseCssResult> {
-        parse_css(self.source, self.ty, self.transforms)
+    async fn parse_css(self: Vc<Self>) -> Result<Vc<ParseCssResult>> {
+        let this = self.await?;
+
+        Ok(parse_css(this.source, Vc::upcast(self), this.ty))
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl ProcessCss for CssModuleAsset {
+    #[turbo_tasks::function]
+    async fn get_css_with_placeholder(self: Vc<Self>) -> Result<Vc<CssWithPlaceholderResult>> {
+        let parse_result = self.parse_css();
+
+        dbg!("CssModuleAsset::get_css_with_placeholder");
+
+        Ok(process_css_with_placeholder(parse_result))
+    }
+
+    #[turbo_tasks::function]
+    async fn finalize_css(
+        self: Vc<Self>,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
+    ) -> Result<Vc<FinalCssResult>> {
+        let process_result = self.get_css_with_placeholder();
+
+        dbg!("CssModuleAsset::finalize_css");
+
+        Ok(finalize_css(process_result, chunking_context))
     }
 }
 
@@ -91,14 +105,14 @@ impl Module for CssModuleAsset {
 
     #[turbo_tasks::function]
     async fn references(self: Vc<Self>) -> Result<Vc<ModuleReferences>> {
-        let this = self.await?;
+        let result = self.parse_css().await?;
         // TODO: include CSS source map
-        Ok(analyze_css_stylesheet(
-            this.source,
-            Vc::upcast(self),
-            this.ty,
-            this.transforms,
-        ))
+
+        match &*result {
+            ParseCssResult::Ok { references, .. } => Ok(*references),
+            ParseCssResult::Unparseable => Ok(ModuleReferences::empty()),
+            ParseCssResult::NotFound => Ok(ModuleReferences::empty()),
+        }
     }
 }
 
@@ -238,72 +252,24 @@ impl CssChunkItem for CssModuleChunkItem {
         let code_gens = code_gens.into_iter().try_join().await?;
         let code_gens = code_gens.iter().map(|cg| &**cg).collect::<Vec<_>>();
         // TOOD use interval tree with references into "code_gens"
-        let mut visitors = Vec::new();
-        let mut root_visitors = Vec::new();
         for code_gen in code_gens {
             for import in &code_gen.imports {
                 imports.push(import.clone());
             }
-
-            for (path, visitor) in code_gen.visitors.iter() {
-                if path.is_empty() {
-                    root_visitors.push(&**visitor);
-                } else {
-                    visitors.push((path, &**visitor));
-                }
-            }
         }
 
-        let parsed = self.module.parse_css().await?;
+        let result = self.module.finalize_css(chunking_context).await?;
 
-        if let ParseCssResult::Ok {
-            stylesheet,
+        if let FinalCssResult::Ok {
+            output_code,
             source_map,
             ..
-        } = &*parsed
+        } = &*result
         {
-            let mut stylesheet = stylesheet.clone();
-
-            let globals = Globals::new();
-            GLOBALS.set(&globals, || {
-                if !visitors.is_empty() {
-                    stylesheet.visit_mut_with_path(
-                        &mut ApplyVisitors::new(visitors),
-                        &mut Default::default(),
-                    );
-                }
-                for visitor in root_visitors {
-                    stylesheet.visit_mut_with(&mut visitor.create());
-                }
-            });
-
-            // remove imports
-            stylesheet.rules.retain(|r| {
-                !matches!(
-                    r,
-                    &Rule::AtRule(box AtRule {
-                        prelude: Some(box AtRulePrelude::ImportPrelude(_)),
-                        ..
-                    })
-                )
-            });
-
-            let mut code_string = String::new();
-            let mut srcmap = vec![];
-
-            let mut code_gen = CodeGenerator::new(
-                BasicCssWriter::new(&mut code_string, Some(&mut srcmap), Default::default()),
-                Default::default(),
-            );
-
-            code_gen.emit(&stylesheet)?;
-
-            let srcmap = ParseCssResultSourceMap::new(source_map.clone(), srcmap).cell();
-
             Ok(CssChunkItemContent {
-                inner_code: code_string.into(),
+                inner_code: output_code.to_owned().into(),
                 imports,
-                source_map: Some(srcmap),
+                source_map: Some(*source_map),
             }
             .into())
         } else {

crates/turbopack-css/src/chunk/mod.rs

@@ -29,7 +29,7 @@ use turbopack_core::{
 use writer::expand_imports;
 
 use self::{single_item_chunk::chunk::SingleItemCssChunk, source_map::CssChunkSourceMapAsset};
-use crate::{parse::ParseCssResultSourceMap, util::stringify_js, ImportAssetReference};
+use crate::{process::ParseCssResultSourceMap, util::stringify_js, ImportAssetReference};
 
 #[turbo_tasks::value]
 pub struct CssChunk {