fix(parser): parse @x() @y() export default abstract class {} (#11630)

Also took the opportunity to reduce a rewind on `export default interface`.

Author: Boshen

crates/oxc_codegen/tests/integration/ts.rs

@@ -16,7 +16,12 @@ fn cases() {
     );
     test_same("class B {\n\tconstructor(override readonly a: number) {}\n}\n");
     test_same("export { type as as };\n");
-    test_same("@Decorator() abstract class C {}\n");
+}
+
+#[test]
+fn decorators() {
+    test_same("@a abstract class C {}\n");
+    test_tsx("@a @b export default abstract class {}", "export default @a @b abstract class {}\n");
 }
 
 #[test]

crates/oxc_parser/src/js/module.rs

@@ -4,7 +4,11 @@ use oxc_span::GetSpan;
 use rustc_hash::FxHashMap;
 
 use super::FunctionKind;
-use crate::{Context, ParserImpl, diagnostics, lexer::Kind, modifiers::Modifiers};
+use crate::{
+    Context, ParserImpl, diagnostics,
+    lexer::Kind,
+    modifiers::{Modifier, ModifierFlags, ModifierKind, Modifiers},
+};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum ImportOrExport {
@@ -548,78 +552,127 @@ impl<'a> ParserImpl<'a> {
         decorators: Vec<'a, Decorator<'a>>,
     ) -> Box<'a, ExportDefaultDeclaration<'a>> {
         let exported = self.parse_keyword_identifier(Kind::Default);
+        let declaration = self.parse_export_default_declaration_kind(decorators);
+        let exported = ModuleExportName::IdentifierName(exported);
+        let span = self.end_span(span);
+        self.ast.alloc_export_default_declaration(span, exported, declaration)
+    }
+
+    fn parse_export_default_declaration_kind(
+        &mut self,
+        mut decorators: Vec<'a, Decorator<'a>>,
+    ) -> ExportDefaultDeclarationKind<'a> {
         let decl_span = self.start_span();
+
+        // export default /* @__NO_SIDE_EFFECTS__ */ ...
         let has_no_side_effects_comment =
             self.lexer.trivia_builder.previous_token_has_no_side_effects_comment();
-        let kind = self.cur_kind();
-        if kind != Kind::Class {
-            for decorator in &decorators {
-                self.error(diagnostics::decorators_are_not_valid_here(decorator.span));
+
+        // export default @decorator ...
+        if self.at(Kind::At) {
+            let after_export_decorators = self.parse_decorators();
+            // @decorator export default @decorator ...
+            if !decorators.is_empty() {
+                for decorator in &after_export_decorators {
+                    self.error(diagnostics::decorators_in_export_and_class(decorator.span));
+                }
             }
+            decorators.extend(after_export_decorators);
         }
-        let declaration = match kind {
-            Kind::Class => ExportDefaultDeclarationKind::ClassDeclaration(
-                self.parse_class_declaration(decl_span, &Modifiers::empty(), decorators),
-            ),
-            Kind::At => {
-                let decorators = self.parse_decorators();
-                let modifiers = self.parse_modifiers(false, false);
-                ExportDefaultDeclarationKind::ClassDeclaration(
-                    self.parse_class_declaration(decl_span, &modifiers, decorators),
-                )
-            }
-            _ if self.is_ts
-                && self.at(Kind::Abstract)
-                && self.lookahead(|p| {
-                    p.bump_any();
-                    p.at(Kind::Class)
-                }) =>
-            {
-                // `export default abstract class ...`
-                // eat the abstract modifier
-                let modifiers = self.eat_modifiers_before_declaration();
-                ExportDefaultDeclarationKind::ClassDeclaration(self.parse_class_declaration(
-                    decl_span,
-                    &modifiers,
-                    self.ast.vec(),
-                ))
-            }
-            _ if self.is_ts
-                && self.at(Kind::Interface)
-                && self.lookahead(|p| {
-                    p.bump_any();
-                    !p.cur_token().is_on_new_line()
-                }) =>
-            {
-                // `export default interface [no line break here] ...`
-                let decl = self.parse_ts_interface_declaration(decl_span, &Modifiers::empty());
-                match decl {
-                    Declaration::TSInterfaceDeclaration(decl) => {
-                        ExportDefaultDeclarationKind::TSInterfaceDeclaration(decl)
+
+        let function_span = self.start_span();
+
+        let checkpoint = self.checkpoint();
+        let mut is_abstract = false;
+        let mut is_async = false;
+        let mut is_interface = false;
+
+        match self.cur_kind() {
+            Kind::Abstract => is_abstract = true,
+            Kind::Async => is_async = true,
+            Kind::Interface => is_interface = true,
+            _ => {}
+        }
+
+        if is_abstract || is_async || is_interface {
+            let modifier_span = self.start_span();
+            self.bump_any();
+            let cur_token = self.cur_token();
+            let kind = cur_token.kind();
+            if !cur_token.is_on_new_line() {
+                // export default abstract class ...
+                if is_abstract && kind == Kind::Class {
+                    let modifiers = self
+                        .ast
+                        .vec1(Modifier::new(self.end_span(modifier_span), ModifierKind::Abstract));
+                    let modifiers = Modifiers::new(Some(modifiers), ModifierFlags::ABSTRACT);
+                    return ExportDefaultDeclarationKind::ClassDeclaration(
+                        self.parse_class_declaration(decl_span, &modifiers, decorators),
+                    );
+                }
+
+                // export default async function ...
+                if is_async && kind == Kind::Function {
+                    for decorator in &decorators {
+                        self.error(diagnostics::decorators_are_not_valid_here(decorator.span));
                     }
-                    _ => unreachable!(),
+                    let mut func = self.parse_function_impl(
+                        function_span,
+                        /* r#async */ true,
+                        FunctionKind::DefaultExport,
+                    );
+                    if has_no_side_effects_comment {
+                        func.pure = true;
+                    }
+                    return ExportDefaultDeclarationKind::FunctionDeclaration(func);
                 }
-            }
-            _ if self.at_function_with_async() => {
-                let span = self.start_span();
-                let r#async = self.eat(Kind::Async);
-                let mut func = self.parse_function_impl(span, r#async, FunctionKind::DefaultExport);
-                if has_no_side_effects_comment {
-                    func.pure = true;
+
+                // export default interface ...
+                if is_interface {
+                    for decorator in &decorators {
+                        self.error(diagnostics::decorators_are_not_valid_here(decorator.span));
+                    }
+                    if let Declaration::TSInterfaceDeclaration(decl) =
+                        self.parse_ts_interface_declaration(modifier_span, &Modifiers::empty())
+                    {
+                        return ExportDefaultDeclarationKind::TSInterfaceDeclaration(decl);
+                    }
                 }
-                ExportDefaultDeclarationKind::FunctionDeclaration(func)
             }
-            _ => {
-                let decl = ExportDefaultDeclarationKind::from(
-                    self.parse_assignment_expression_or_higher(),
-                );
-                self.asi();
-                decl
+            self.rewind(checkpoint);
+        }
+
+        let kind = self.cur_kind();
+        // export default class ...
+        if kind == Kind::Class {
+            return ExportDefaultDeclarationKind::ClassDeclaration(self.parse_class_declaration(
+                decl_span,
+                &Modifiers::empty(),
+                decorators,
+            ));
+        }
+
+        for decorator in &decorators {
+            self.error(diagnostics::decorators_are_not_valid_here(decorator.span));
+        }
+
+        // export default function ...
+        if kind == Kind::Function {
+            let mut func = self.parse_function_impl(
+                function_span,
+                /* r#async */ false,
+                FunctionKind::DefaultExport,
+            );
+            if has_no_side_effects_comment {
+                func.pure = true;
             }
-        };
-        let exported = ModuleExportName::IdentifierName(exported);
-        let span = self.end_span(span);
-        self.ast.alloc_export_default_declaration(span, exported, declaration)
+            return ExportDefaultDeclarationKind::FunctionDeclaration(func);
+        }
+
+        // export default expr
+        let decl = ExportDefaultDeclarationKind::from(self.parse_assignment_expression_or_higher());
+        self.asi();
+        decl
     }
 
     // export ExportFromClause FromClause ;

crates/oxc_parser/src/ts/statement.rs

@@ -181,7 +181,6 @@ impl<'a> ParserImpl<'a> {
         span: u32,
         modifiers: &Modifiers<'a>,
     ) -> Declaration<'a> {
-        self.expect(Kind::Interface); // bump interface
         let id = self.parse_binding_identifier();
         let type_parameters = self.parse_ts_type_parameters();
         let (extends, implements) = self.parse_heritage_clause();
@@ -430,7 +429,10 @@ impl<'a> ParserImpl<'a> {
             }
             Kind::Type => self.parse_ts_type_alias_declaration(start_span, modifiers),
             Kind::Enum => self.parse_ts_enum_declaration(start_span, modifiers),
-            Kind::Interface => self.parse_ts_interface_declaration(start_span, modifiers),
+            Kind::Interface => {
+                self.bump_any();
+                self.parse_ts_interface_declaration(start_span, modifiers)
+            }
             Kind::Class => {
                 let decl = self.parse_class_declaration(start_span, modifiers, decorators);
                 Declaration::ClassDeclaration(decl)

tasks/coverage/snapshots/parser_misc.snap

@@ -42,11 +42,11 @@ Negative Passed: 45/45 (100.00%)
  2 │ 
    ╰────
 
-  × Decorators are not valid here.
-   ╭─[misc/fail/oxc-11472.js:3:1]
+  × Decorators may not appear after 'export' or 'export default' if they also appear before 'export'.
+   ╭─[misc/fail/oxc-11472.js:3:22]
  2 │ 
  3 │ @dec1 export default @dec2 class {}
-   · ─────
+   ·                      ─────
    ╰────
 
   × Expected `from` but found `EOF`