js_parser: parse export default @dec class as a class declaration

src/js_parser/lower/lower_decorators.rs

@@ -720,25 +720,31 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool, const SEMA: bool>
 
     // ── Public API ───────────────────────────────────────
 
+    /// `default_export` is the binding of an `export default class` statement,
+    /// the one class statement that can have no name. Such a class is named
+    /// "default", and takes the binding as its name only when class decorators
+    /// have to rebind it.
     pub(crate) fn lower_standard_decorators_stmt(
         &mut self,
         stmt: Stmt,
+        default_export: Option<js_ast::LocRef>,
         out: &mut BumpVec<'a, Stmt>,
     ) {
         let mut s_class = match stmt.data {
             js_ast::StmtData::SClass(c) => c,
             _ => unreachable!(),
         };
-        let lowered = self.lower_class_body(&mut s_class.class, stmt.loc, None);
+        let name_from_context = default_export.map(|_| js_ast::ClauseItem::DEFAULT_ALIAS);
+        let lowered = self.lower_class_body(&mut s_class.class, stmt.loc, name_from_context);
         out.extend(lowered.temps);
         let Some(decorators) = lowered.class_decorators else {
             out.push(stmt);
             return;
         };
-        let name = s_class
+        let name = *s_class
             .class
             .class_name
-            .expect("a class statement has a name");
+            .get_or_insert_with(|| default_export.expect("a class statement has a name"));
         let decorated = self.use_ref(decorators.decorated, name.loc);
         let rebind = self.assign_to(name.ref_, decorated, name.loc);
         out.push(self.expr_stmt(decorators.evaluate, stmt.loc));

src/js_parser/p.rs

@@ -7452,9 +7452,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool, const SEMA: bool>
                 // Standard decorator lowering path (for both JS and TS files)
                 if s_class.class.should_lower_standard_decorators {
                     // `lower_standard_decorators_stmt` takes an out-param Vec; wrap to
-                    // keep this function's slice contract.
+                    // keep this function's slice contract. `s_export_default` calls
+                    // it itself, so a class that arrives here has a name.
                     let mut out = BumpVec::<Stmt>::new_in(self.arena);
-                    self.lower_standard_decorators_stmt(stmt, &mut out);
+                    self.lower_standard_decorators_stmt(stmt, None, &mut out);
                     return out.into_bump_slice_mut();
                 }
 

src/js_parser/parse/parse_stmt.rs

@@ -1584,8 +1584,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool, const SEMA: bool>
                     ));
                 }
 
+                // "@" is in the lookahead set that rules out an expression after
+                // "export default": a decorator here starts a class declaration.
                 if p.lexer.token == T::TFunction
                     || p.lexer.token == T::TClass
+                    || p.lexer.token == T::TAt
                     || p.lexer.is_contextual_keyword(b"interface")
                 {
                     let mut _opts = ParseStatementOptions {
@@ -1594,6 +1597,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool, const SEMA: bool>
                         lexical_decl: LexicalDecl::AllowAll,
                         ..Default::default()
                     };
+                    let errors_before_decorators =
+                        (p.lexer.token == T::TAt).then(|| p.log().errors);
                     let stmt = p.parse_stmt(&mut _opts)?;
 
                     let default_name: LocRef = 'default_name_getter: {
@@ -1623,11 +1628,18 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool, const SEMA: bool>
                             // declaration: the nested statement came back as an
                             // expression statement ("export default interface = 2",
                             // "export default interface => 1") or a labeled statement
-                            // ("export default interface: 0"). None of these can be a
-                            // default export value, so report a syntax error instead of
-                            // building an S.ExportDefault that the visit and print
-                            // passes don't support.
+                            // ("export default interface: 0"). Decorators that no class
+                            // follows end here too ("export default @dec abstract = 1").
+                            // None of these can be a default export value, so report a
+                            // syntax error instead of building an S.ExportDefault that the
+                            // visit and print passes don't support.
                             _ => {
+                                // `t_at` has reported the token that is not a class.
+                                if errors_before_decorators
+                                    .is_some_and(|errors| p.log().errors > errors)
+                                {
+                                    return Err(crate::Error::SyntaxError);
+                                }
                                 let r =
                                     js_lexer::range_of_identifier(p.source, p.real_loc(stmt.loc));
                                 p.log().add_range_error_fmt(

src/js_parser/visit/visit_stmt.rs

@@ -798,30 +798,32 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool, const SEMA: bool>
                                 replace_expr,
                             ) = entry
                             {
+                                // The class is discarded. Lowering it would put it back
+                                // in `data.value`.
                                 data.value = js_ast::StmtOrExpr::Expr(replace_expr);
+                                stmts.push(*stmt);
                             } else {
                                 let _ = p.inject_replacement_export(
                                     stmts,
                                     Ref::NONE,
                                     bun_ast::Loc::EMPTY,
                                     &entry,
                                 );
-                                restore_dead!();
-                                record_on_exit!();
-                                return Ok(());
                             }
+                            restore_dead!();
+                            record_on_exit!();
+                            return Ok(());
                         }
 
                         if !data.default_name.ref_.is_symbol() {
                             data.default_name = p.create_default_name(stmt.loc);
                         }
 
-                        // We only inject a name into classes when decorator lowering
-                        // needs one: legacy TS decorators (`has_decorators`) or
-                        // standard decorator lowering, which also covers classes with
-                        // only auto-accessor fields and no decorators.
+                        // The legacy TS decorator lowering reads `class_name`, so an
+                        // anonymous class takes the default export's symbol as its name.
+                        // The standard lowering takes that symbol as an argument.
                         if class.class.has_decorators
-                            || class.class.should_lower_standard_decorators
+                            && !class.class.should_lower_standard_decorators
                         {
                             if class.class.class_name.is_none()
                                 || class.class.class_name.unwrap().ref_.is_empty()
@@ -833,7 +835,17 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool, const SEMA: bool>
                         // Lower the class (handles both TS legacy and standard decorators).
                         // Standard decorator lowering may produce prefix statements
                         // (variable declarations) before the class statement.
-                        let class_stmts = p.lower_class(js_ast::StmtOrExpr::Stmt(s2_copy));
+                        let class_stmts = if class.class.should_lower_standard_decorators {
+                            let mut lowered: StmtList<'a> = BumpVec::new_in(p.arena);
+                            p.lower_standard_decorators_stmt(
+                                s2_copy,
+                                Some(data.default_name),
+                                &mut lowered,
+                            );
+                            lowered.into_bump_slice_mut()
+                        } else {
+                            p.lower_class(js_ast::StmtOrExpr::Stmt(s2_copy))
+                        };
 
                         // Find the s_class statement in the returned list
                         let mut class_stmt_idx: usize = 0;
@@ -847,13 +859,36 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool, const SEMA: bool>
                         // Emit any prefix statements before the export default
                         stmts.extend_from_slice(&class_stmts[0..class_stmt_idx]);
 
+                        let after_class = &class_stmts[class_stmt_idx + 1..];
+                        if p.options.features.server_components.wraps_exports()
+                            && !after_class.is_empty()
+                        {
+                            // Decorator lowering assigns to the class by name after it, so
+                            // the class stays a declaration and the export wraps its binding.
+                            let name = class
+                                .class
+                                .class_name
+                                .expect("decorator lowering names the class");
+                            stmts.push(class_stmts[class_stmt_idx]);
+                            stmts.extend_from_slice(after_class);
+                            p.record_usage(name.ref_);
+                            data.value = js_ast::StmtOrExpr::Expr(
+                                p.wrap_value_for_server_component_reference(
+                                    Expr::init_identifier(name.ref_, name.loc),
+                                    b"default",
+                                ),
+                            );
+                            stmts.push(*stmt);
+                            restore_dead!();
+                            record_on_exit!();
+                            return Ok(());
+                        }
+
                         data.value = js_ast::StmtOrExpr::Stmt(class_stmts[class_stmt_idx]);
                         stmts.push(*stmt);
 
                         // Emit any suffix statements after the export default
-                        if class_stmt_idx + 1 < class_stmts.len() {
-                            stmts.extend_from_slice(&class_stmts[class_stmt_idx + 1..]);
-                        }
+                        stmts.extend_from_slice(after_class);
 
                         if p.options.features.server_components.wraps_exports() {
                             // `data.value` is mutated *after* pushing `stmt`; the pushed

src/jsc/RuntimeTranspilerCache.rs

@@ -64,7 +64,9 @@ bun_core::declare_scope!(cache, visible);
 /// `onResolve` rewrote (`namespace:path`). Older entries request the bare path, and
 /// the cache-HIT path reinstates #33904 for them.
 /// Version 34: An import that a plugin `onResolve` answers is printed as it is written.
-const EXPECTED_VERSION: u32 = 34;
+/// Version 35: `export default @dec class` is a class declaration, and standard decorator
+/// lowering names an anonymous `export default class` "default".
+const EXPECTED_VERSION: u32 = 35;
 
 /// Source files smaller than this are not written to / read from the on-disk
 /// transpiler cache. Originally 50 KiB, which excluded almost every file in a

test/bake/dev/bundle.test.ts

@@ -940,3 +940,35 @@ devTest("a render() that does not return a Response is reported as that", {
     }).toEqual({ status: 500, saysWhatIsWrong: true, referenceError: false });
   },
 });
+// A "use client" module without a separate SSR graph exports `registerClientReference(value, ...)`.
+// The statements that decorator lowering puts after a class assign to the class by name, so the
+// class has to stay a declaration: as the wrapped value it left `Df = ...` with no binding
+// ("ReferenceError: Df is not defined").
+for (const spelling of [
+  "@dec export default class Df {}",
+  "export default @dec class Df {}",
+  "export default @dec class {}",
+]) {
+  devTest(`a "use client" module keeps the binding of \`${spelling}\` (experimentalDecorators)`, {
+    framework: minimalFramework,
+    files: {
+      "tsconfig.json": JSON.stringify({ compilerOptions: { experimentalDecorators: true } }),
+      "client.ts": `
+        "use client";
+        function dec(cls: any) {
+          globalThis.decorated = (globalThis.decorated ?? 0) + 1;
+        }
+        ${spelling}
+      `,
+      "routes/index.ts": `
+        import Client from "../client";
+        export default function (req, meta) {
+          return new Response(JSON.stringify([typeof Client.value, Client.uid, globalThis.decorated]));
+        }
+      `,
+    },
+    async test(dev) {
+      await dev.fetch("/").equals('["function","default",1]');
+    },
+  });
+}

test/bundler/transpiler/decorators.test.ts

@@ -1,6 +1,13 @@
 // @ts-nocheck
 import { describe, expect, test } from "bun:test";
 import { bunEnv, bunExe } from "harness";
+import DecoratedAfterDefaultClass, {
+  decorated as decoratedAfterDefault,
+  binding as decoratedAfterDefaultBinding,
+} from "./decorator-after-export-default-class-fixture";
+import DecoratedAfterDefaultAnonClass, {
+  decorated as decoratedAfterDefaultAnon,
+} from "./decorator-after-export-default-class-fixture-anon";
 import DecoratedClass from "./decorator-export-default-class-fixture";
 import DecoratedAnonClass from "./decorator-export-default-class-fixture-anon";
 
@@ -1020,6 +1027,17 @@ test("export default class works (anonymous name)", () => {
   expect(new DecoratedAnonClass()["methoddecorated"]).toBe(true);
 });
 
+test("export default @decorator class Named runs the decorator and binds the name", () => {
+  expect(decoratedAfterDefault).toEqual(["DecoratedClass"]);
+  expect(decoratedAfterDefaultBinding).toBe(DecoratedAfterDefaultClass);
+  expect(new DecoratedAfterDefaultClass()["replaced"]).toBe(true);
+});
+
+test("export default @decorator class runs the decorator (anonymous name)", () => {
+  expect(decoratedAfterDefaultAnon).toEqual([DecoratedAfterDefaultAnonClass]);
+  expect(new DecoratedAfterDefaultAnonClass().method()).toBe(42);
+});
+
 test("field with supra-BMP string-literal key and initializer is assigned under the correct key", () => {
   function dec(_t: any, _k: any) {}
   class Foo {