chore: 🤖 update pure annotation

crates/rolldown/src/ast_scanner/impl_visit.rs

@@ -14,7 +14,8 @@ impl<'me, 'ast> Visit<'ast> for AstScanner<'me> {
     for (idx, stmt) in program.body.iter().enumerate() {
       self.current_stmt_info.stmt_idx = Some(idx);
       self.current_stmt_info.side_effect =
-        SideEffectDetector::new(self.scope).detect_side_effect_of_stmt(stmt);
+        SideEffectDetector::new(self.scope, &self.travias, self.source)
+          .detect_side_effect_of_stmt(stmt);
 
       if cfg!(debug_assertions) {
         let mut codegen = Codegen::<false>::new(

crates/rolldown/src/ast_scanner/mod.rs

@@ -7,7 +7,7 @@ use oxc::{
       ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, IdentifierReference,
       ImportDeclaration, ModuleDeclaration, Program,
     },
-    Visit,
+    Trivias, Visit,
   },
   semantic::SymbolId,
   span::{Atom, Span},
@@ -46,6 +46,7 @@ pub struct AstScanner<'me> {
   module_type: ModuleType,
   file_path: &'me ResourceId,
   scope: &'me AstScope,
+  travias: &'me Trivias,
   symbol_table: &'me mut AstSymbols,
   current_stmt_info: StmtInfo,
   result: ScanResult,
@@ -65,6 +66,7 @@ impl<'me> AstScanner<'me> {
     module_type: ModuleType,
     source: &'me Arc<str>,
     file_path: &'me ResourceId,
+    travias: &'me Trivias,
   ) -> Self {
     // This is used for converting "export default foo;" => "var default_symbol = foo;"
     let symbol_id_for_default_export_ref =
@@ -106,6 +108,7 @@ impl<'me> AstScanner<'me> {
       used_module_ref: false,
       source,
       file_path,
+      travias,
     }
   }
 

crates/rolldown/src/ast_scanner/side_effect_detector.rs

@@ -1,7 +1,11 @@
+use std::sync::Arc;
+
 use once_cell::sync::Lazy;
 use oxc::ast::ast::{
   BindingPatternKind, Expression, IdentifierReference, MemberExpression, PropertyKey,
 };
+use oxc::ast::{CommentKind, Trivias};
+use oxc::span::Span;
 use rolldown_common::AstScope;
 use rustc_hash::FxHashSet;
 
@@ -19,6 +23,9 @@ static SIDE_EFFECT_FREE_MEMBER_EXPR_2: Lazy<FxHashSet<(&'static str, &'static st
     .collect()
   });
 
+static PURE_COMMENTS: Lazy<regex::Regex> =
+  Lazy::new(|| regex::Regex::new("^\\s*(#|@)__PURE__\\s*$").expect("Should create the regex"));
+
 static SIDE_EFFECT_FREE_MEMBER_EXPR_3: Lazy<FxHashSet<(&'static str, &'static str, &'static str)>> =
   Lazy::new(|| {
     [("Object", "prototype", "hasOwnProperty"), ("Object", "prototype", "constructor")]
@@ -29,11 +36,13 @@ static SIDE_EFFECT_FREE_MEMBER_EXPR_3: Lazy<FxHashSet<(&'static str, &'static st
 /// Detect if a statement "may" have side effect.
 pub struct SideEffectDetector<'a> {
   pub scope: &'a AstScope,
+  pub travias: &'a Trivias,
+  pub source: &'a Arc<str>,
 }
 
 impl<'a> SideEffectDetector<'a> {
-  pub fn new(scope: &'a AstScope) -> Self {
-    Self { scope }
+  pub fn new(scope: &'a AstScope, travias: &'a Trivias, source: &'a Arc<str>) -> Self {
+    Self { scope, travias, source }
   }
 
   fn is_unresolved_reference(&self, ident_ref: &IdentifierReference) -> bool {
@@ -185,7 +194,6 @@ impl<'a> SideEffectDetector<'a> {
       | Expression::ArrayExpression(_)
       | Expression::AssignmentExpression(_)
       | Expression::AwaitExpression(_)
-      | Expression::CallExpression(_)
       | Expression::ChainExpression(_)
       | Expression::ImportExpression(_)
       | Expression::NewExpression(_)
@@ -194,6 +202,37 @@ impl<'a> SideEffectDetector<'a> {
       | Expression::YieldExpression(_)
       | Expression::JSXElement(_)
       | Expression::JSXFragment(_) => true,
+      Expression::CallExpression(expr) => {
+        let mut leading_comment: Option<(CommentKind, Span)> = None;
+        self.travias.comments().for_each(|(kind, span)| {
+          if span.end < expr.span.start && matches!(kind, CommentKind::MultiLine) {
+            leading_comment = Some((kind, span));
+          }
+        });
+        let is_pure_comment = if let Some(leading_comment) = leading_comment {
+          // dbg!(&leading_comment);
+          let res = &self.source[leading_comment.1.end as usize + 2..expr.span.start as usize];
+          let is_between_str_all_whitespace = res.chars().all(|ch| ch == ' ');
+          if is_between_str_all_whitespace {
+            let comment_content =
+              &self.source[leading_comment.1.start as usize..leading_comment.1.end as usize];
+            PURE_COMMENTS.is_match(comment_content)
+          } else {
+            false
+          }
+        } else {
+          false
+        };
+        if is_pure_comment {
+          expr.arguments.iter().any(|arg| match arg {
+            oxc::ast::ast::Argument::SpreadElement(_) => true,
+            // TODO: implementa this
+            _ => false,
+          })
+        } else {
+          true
+        }
+      }
     }
   }
 
@@ -356,11 +395,10 @@ mod test {
       )
     };
 
-    let has_side_effect = ast
-      .program()
-      .body
-      .iter()
-      .any(|stmt| SideEffectDetector::new(&ast_scope).detect_side_effect_of_stmt(stmt));
+    let has_side_effect = ast.program().body.iter().any(|stmt| {
+      SideEffectDetector::new(&ast_scope, ast.trivias(), ast.source())
+        .detect_side_effect_of_stmt(stmt)
+    });
 
     has_side_effect
   }

crates/rolldown/src/module_loader/normal_module_task.rs

@@ -193,6 +193,7 @@ impl NormalModuleTask {
     let mut symbol_for_module = AstSymbols::from_symbol_table(symbol_table);
     let file_path = Arc::<str>::clone(&self.resolved_path.path).into();
     let repr_name = ResourceId::representative_name(&file_path);
+    let trivias = program.with_mut(|fields| std::mem::take(fields.trivias));
     let scanner = AstScanner::new(
       self.module_id,
       &ast_scope,
@@ -201,6 +202,7 @@ impl NormalModuleTask {
       self.module_type,
       source,
       &file_path,
+      &trivias,
     );
     let namespace_symbol = scanner.namespace_ref;
     program.hoist_import_export_from_stmts();

crates/rolldown/src/module_loader/runtime_normal_module_task.rs

@@ -112,6 +112,7 @@ impl RuntimeNormalModuleTask {
     );
     let mut symbol_for_module = AstSymbols::from_symbol_table(symbol_table);
     let facade_path = ResourceId::new("runtime");
+    let trivias = ast.with_mut(|fields| std::mem::take(fields.trivias));
     let scanner = AstScanner::new(
       self.module_id,
       &ast_scope,
@@ -120,6 +121,7 @@ impl RuntimeNormalModuleTask {
       ModuleType::EsmMjs,
       source,
       &facade_path,
+      &trivias,
     );
     let namespace_symbol = scanner.namespace_ref;
     ast.hoist_import_export_from_stmts();

crates/rolldown/tests/fixtures/tree_shaking/pure_annotation/_config.json

@@ -0,0 +1,5 @@
+{
+  "config": {
+    "treeshake": true
+  }
+}

crates/rolldown/tests/fixtures/tree_shaking/pure_annotation/a.js

@@ -0,0 +1 @@
+export const a = 100;

crates/rolldown/tests/fixtures/tree_shaking/pure_annotation/artifacts.snap

@@ -0,0 +1,16 @@
+---
+source: crates/rolldown/tests/common/case.rs
+expression: content
+input_file: crates/rolldown/tests/fixtures/tree_shaking/pure_annotation
+---
+# Assets
+
+## main.mjs
+
+```js
+// a.js
+const a = 100;
+
+// main.js
+console.log(`a: `, a);
+```

crates/rolldown/tests/fixtures/tree_shaking/pure_annotation/b.js

@@ -0,0 +1,5 @@
+export const b = 100;
+
+function test() {}
+
+export const c = /* #__PURE__ */                 test();

crates/rolldown/tests/fixtures/tree_shaking/pure_annotation/main.js

@@ -0,0 +1,4 @@
+import { a } from "./a";
+import { b } from "./b";
+
+console.log(`a: `, a);

crates/rolldown/tests/snapshots/fixtures__filename_with_hash.snap

@@ -1540,6 +1540,10 @@ expression: "snapshot_outputs.join(\"\\n\")"
 
 - main-!~{000}~.mjs => main-Ep15x52X.mjs
 
+# tests/fixtures/tree_shaking/pure_annotation
+
+- main-!~{000}~.mjs => main-Km8M_iGP.mjs
+
 # tests/fixtures/tree_shaking/unused_import_external
 
 - main-!~{000}~.mjs => main-Ix9nDVBV.mjs

crates/rolldown_oxc_utils/src/compiler.rs

@@ -14,7 +14,7 @@ impl OxcCompiler {
     let allocator = oxc::allocator::Allocator::default();
     let inner = Inner::new((source.into(), allocator), |(source, allocator)| {
       let parser = Parser::new(allocator, source, ty);
-      parser.parse().program
+      parser.parse()
     });
     OxcAst { inner, source_type: ty }
   }

crates/rolldown_oxc_utils/src/oxc_ast/helpers.rs

@@ -10,7 +10,7 @@ use super::WithFieldsMut;
 
 impl OxcAst {
   pub fn is_body_empty(&self) -> bool {
-    self.inner.with_dependent(|_, program| program.body.is_empty())
+    self.inner.with_dependent(|_, praser_return| praser_return.program.body.is_empty())
   }
 
   pub fn make_semantic<'ast>(
@@ -24,7 +24,7 @@ impl OxcAst {
 
   pub fn make_symbol_table_and_scope_tree(&self) -> (SymbolTable, ScopeTree) {
     self.inner.with_dependent(|dep, program| {
-      let semantic = Self::make_semantic(&dep.0, program, self.source_type);
+      let semantic = Self::make_semantic(&dep.0, &program.program, self.source_type);
       semantic.into_symbol_table_and_scope_tree()
     })
   }

crates/rolldown_oxc_utils/src/oxc_ast/mod.rs

@@ -1,6 +1,8 @@
 use std::{fmt::Debug, sync::Arc};
 
 use crate::OxcCompiler;
+use oxc::ast::Trivias;
+use oxc::parser::ParserReturn;
 use oxc::{allocator::Allocator, ast::ast::Program, span::SourceType};
 
 use self_cell::self_cell;
@@ -12,7 +14,7 @@ self_cell!(
     owner: (Arc<str>, Allocator),
 
     #[covariant]
-    dependent: Program,
+    dependent: ParserReturn,
   }
 );
 
@@ -32,7 +34,11 @@ impl OxcAst {
   }
 
   pub fn program(&self) -> &Program {
-    self.inner.borrow_dependent()
+    &self.inner.borrow_dependent().program
+  }
+
+  pub fn trivias(&self) -> &Trivias {
+    &self.inner.borrow_dependent().trivias
   }
 
   /// Visit all fields including `&mut Program` within a closure.
@@ -51,8 +57,13 @@ impl OxcAst {
     &'outer mut self,
     func: impl for<'inner> ::core::ops::FnOnce(WithFieldsMut<'outer, 'inner>) -> Ret,
   ) -> Ret {
-    self.inner.with_dependent_mut::<'outer, Ret>(|owner, program| {
-      func(WithFieldsMut { source: &owner.0, allocator: &owner.1, program })
+    self.inner.with_dependent_mut::<'outer, Ret>(|owner, parse_return| {
+      func(WithFieldsMut {
+        source: &owner.0,
+        allocator: &owner.1,
+        program: &mut parse_return.program,
+        trivias: &mut parse_return.trivias,
+      })
     })
   }
 }
@@ -61,6 +72,7 @@ pub struct WithFieldsMut<'outer, 'inner> {
   pub source: &'inner Arc<str>,
   pub allocator: &'inner Allocator,
   pub program: &'outer mut Program<'inner>,
+  pub trivias: &'outer mut Trivias,
 }
 
 impl Debug for OxcAst {