feat(parser): show allowed modifiers in invalid modifier error messages

Author: sapphi-red

crates/oxc_parser/src/diagnostics.rs

@@ -4,7 +4,27 @@ use oxc_ast::ast::REGEXP_FLAGS_LIST;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_span::Span;
 
-use crate::modifiers::{Modifier, ModifierKind};
+use crate::modifiers::{Modifier, ModifierFlags, ModifierKind};
+
+trait DiagnosticExt {
+    fn with_allowed_modifier_help(self, allowed: Option<ModifierFlags>) -> Self;
+}
+
+impl DiagnosticExt for OxcDiagnostic {
+    fn with_allowed_modifier_help(self, allowed: Option<ModifierFlags>) -> Self {
+        if let Some(allowed) = allowed {
+            if allowed.is_empty() {
+                self.with_help("No modifiers are allowed here.")
+            } else if allowed.iter().count() == 1 {
+                self.with_help(format!("Only '{allowed}' modifier is allowed here."))
+            } else {
+                self.with_help(format!("Allowed modifiers are: {allowed}"))
+            }
+        } else {
+            self
+        }
+    }
+}
 
 #[inline]
 fn ts_error<C, M>(code: C, message: M) -> OxcDiagnostic
@@ -622,14 +642,19 @@ pub fn import_requires_a_specifier(span: Span) -> OxcDiagnostic {
 }
 
 #[cold]
-pub fn modifier_cannot_be_used_here(modifier: &Modifier) -> OxcDiagnostic {
+pub fn modifier_cannot_be_used_here(
+    modifier: &Modifier,
+    allowed: Option<ModifierFlags>,
+) -> OxcDiagnostic {
     OxcDiagnostic::error(format!("'{}' modifier cannot be used here.", modifier.kind))
         .with_label(modifier.span)
+        .with_allowed_modifier_help(allowed)
 }
 
 #[cold]
 pub fn modifier_only_on_property_declaration_or_index_signature(
     modifier: &Modifier,
+    allowed: Option<ModifierFlags>,
 ) -> OxcDiagnostic {
     ts_error(
         "1024",
@@ -639,6 +664,7 @@ pub fn modifier_only_on_property_declaration_or_index_signature(
         ),
     )
     .with_label(modifier.span)
+    .with_allowed_modifier_help(allowed)
 }
 
 #[cold]
@@ -667,23 +693,35 @@ pub fn modifier_already_seen(modifier: &Modifier) -> OxcDiagnostic {
         .with_help("Remove the duplicate modifier.")
 }
 
-pub fn cannot_appear_on_class_elements(modifier: &Modifier) -> OxcDiagnostic {
+pub fn cannot_appear_on_class_elements(
+    modifier: &Modifier,
+    allowed: Option<ModifierFlags>,
+) -> OxcDiagnostic {
     ts_error(
         "1031",
         format!("'{}' modifier cannot appear on class elements of this kind.", modifier.kind),
     )
     .with_label(modifier.span)
+    .with_allowed_modifier_help(allowed)
 }
 
-pub fn cannot_appear_on_a_type_member(modifier: &Modifier) -> OxcDiagnostic {
+pub fn cannot_appear_on_a_type_member(
+    modifier: &Modifier,
+    allowed: Option<ModifierFlags>,
+) -> OxcDiagnostic {
     ts_error("1070", format!("'{}' modifier cannot appear on a type member.", modifier.kind))
         .with_label(modifier.span)
+        .with_allowed_modifier_help(allowed)
 }
 
 #[cold]
-pub fn cannot_appear_on_a_type_parameter(modifier: &Modifier) -> OxcDiagnostic {
+pub fn cannot_appear_on_a_type_parameter(
+    modifier: &Modifier,
+    allowed: Option<ModifierFlags>,
+) -> OxcDiagnostic {
     ts_error("1273", format!("'{}' modifier cannot be used on a type parameter.", modifier.kind))
         .with_label(modifier.span)
+        .with_allowed_modifier_help(allowed)
 }
 
 #[cold]
@@ -695,22 +733,31 @@ pub fn can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias(
         .with_label(span)
 }
 
-pub fn cannot_appear_on_a_parameter(modifier: &Modifier) -> OxcDiagnostic {
+pub fn cannot_appear_on_a_parameter(
+    modifier: &Modifier,
+    allowed: Option<ModifierFlags>,
+) -> OxcDiagnostic {
     ts_error("1090", format!("'{}' modifier cannot appear on a parameter.", modifier.kind))
         .with_label(modifier.span)
+        .with_allowed_modifier_help(allowed)
 }
 
-pub fn cannot_appear_on_an_index_signature(modifier: &Modifier) -> OxcDiagnostic {
+pub fn cannot_appear_on_an_index_signature(
+    modifier: &Modifier,
+    allowed: Option<ModifierFlags>,
+) -> OxcDiagnostic {
     ts_error("1071", format!("'{}' modifier cannot appear on an index signature.", modifier.kind))
         .with_label(modifier.span)
+        .with_allowed_modifier_help(allowed)
 }
 
-pub fn accessor_modifier(modifier: &Modifier) -> OxcDiagnostic {
+pub fn accessor_modifier(modifier: &Modifier, allowed: Option<ModifierFlags>) -> OxcDiagnostic {
     ts_error(
         "1243",
         format!("'accessor' modifier cannot be used with '{}' modifier.", modifier.kind),
     )
     .with_label(modifier.span)
+    .with_allowed_modifier_help(allowed.map(|a| a - ModifierFlags::ACCESSOR))
 }
 
 #[cold]
@@ -720,7 +767,10 @@ pub fn readonly_in_array_or_tuple_type(span: Span) -> OxcDiagnostic {
 }
 
 #[cold]
-pub fn accessibility_modifier_on_private_property(modifier: &Modifier) -> OxcDiagnostic {
+pub fn accessibility_modifier_on_private_property(
+    modifier: &Modifier,
+    _allowed: Option<ModifierFlags>,
+) -> OxcDiagnostic {
     ts_error("18010", "An accessibility modifier cannot be used with a private identifier.")
         .with_label(modifier.span)
         .with_help("Private identifiers are enforced at runtime, while accessibility modifiers only affect type checking, so using both is redundant.")
@@ -863,9 +913,13 @@ pub fn rest_after_tuple_member_name(span: Span) -> OxcDiagnostic {
 }
 
 #[cold]
-pub fn parameter_modifiers_in_ts(modifier: &Modifier) -> OxcDiagnostic {
+pub fn parameter_modifiers_in_ts(
+    modifier: &Modifier,
+    allowed: Option<ModifierFlags>,
+) -> OxcDiagnostic {
     ts_error("8012", "Parameter modifiers can only be used in TypeScript files.")
         .with_label(modifier.span)
+        .with_allowed_modifier_help(allowed)
 }
 
 #[cold]

crates/oxc_parser/src/js/class.rs

@@ -96,6 +96,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             modifiers,
             ModifierFlags::DECLARE | ModifierFlags::ABSTRACT,
+            true,
             diagnostics::modifier_cannot_be_used_here,
         );
 
@@ -226,6 +227,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             &modifiers,
             ModifierFlags::all() - ModifierFlags::EXPORT,
+            false,
             diagnostics::cannot_appear_on_class_elements,
         );
 
@@ -292,7 +294,10 @@ impl<'a> ParserImpl<'a> {
                             ));
                         }
                     }
-                    _ => self.error(diagnostics::cannot_appear_on_an_index_signature(modifier)),
+                    _ => self.error(diagnostics::cannot_appear_on_an_index_signature(
+                        modifier,
+                        Some(ModifierFlags::READONLY | ModifierFlags::STATIC),
+                    )),
                 }
             }
 
@@ -336,6 +341,7 @@ impl<'a> ParserImpl<'a> {
                     self.verify_modifiers(
                         modifiers,
                         ModifierFlags::all() - ModifierFlags::ACCESSIBILITY,
+                        false,
                         diagnostics::accessibility_modifier_on_private_property,
                     );
                 }
@@ -382,6 +388,7 @@ impl<'a> ParserImpl<'a> {
                 | ModifierFlags::STATIC
                 | ModifierFlags::ABSTRACT
                 | ModifierFlags::OVERRIDE,
+            true,
             diagnostics::accessor_modifier,
         );
         self.ast.class_element_accessor_property(
@@ -430,6 +437,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             modifiers,
             ModifierFlags::all() - ModifierFlags::ASYNC - ModifierFlags::DECLARE,
+            false,
             diagnostics::modifier_cannot_be_used_here,
         );
         ClassElement::MethodDefinition(method_definition)
@@ -505,12 +513,28 @@ impl<'a> ParserImpl<'a> {
             for modifier in modifiers.iter() {
                 match modifier.kind {
                     ModifierKind::Declare => {
-                        self.error(diagnostics::cannot_appear_on_class_elements(modifier));
+                        self.error(diagnostics::cannot_appear_on_class_elements(
+                            modifier,
+                            Some(
+                                ModifierFlags::ACCESSIBILITY
+                                    | ModifierFlags::STATIC
+                                    | ModifierFlags::ABSTRACT
+                                    | ModifierFlags::OVERRIDE
+                                    | ModifierFlags::ASYNC,
+                            ),
+                        ));
                     }
                     ModifierKind::Readonly => {
                         self.error(
                             diagnostics::modifier_only_on_property_declaration_or_index_signature(
                                 modifier,
+                                Some(
+                                    ModifierFlags::ACCESSIBILITY
+                                        | ModifierFlags::STATIC
+                                        | ModifierFlags::ABSTRACT
+                                        | ModifierFlags::OVERRIDE
+                                        | ModifierFlags::ASYNC,
+                                ),
                             ),
                         );
                     }

crates/oxc_parser/src/js/function.rs

@@ -78,12 +78,14 @@ impl<'a> ParserImpl<'a> {
             self.verify_modifiers(
                 &modifiers,
                 allowed_modifiers,
+                true,
                 diagnostics::cannot_appear_on_a_parameter,
             );
         } else {
             self.verify_modifiers(
                 &modifiers,
                 ModifierFlags::empty(),
+                true,
                 diagnostics::parameter_modifiers_in_ts,
             );
         }
@@ -167,6 +169,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             modifiers,
             ModifierFlags::DECLARE | ModifierFlags::ASYNC,
+            true,
             diagnostics::modifier_cannot_be_used_here,
         );
 

crates/oxc_parser/src/js/object.rs

@@ -68,6 +68,7 @@ impl<'a> ParserImpl<'a> {
             self.verify_modifiers(
                 &modifiers,
                 ModifierFlags::ASYNC,
+                true,
                 diagnostics::modifier_cannot_be_used_here,
             );
             let method = self.parse_method(
@@ -89,6 +90,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             &modifiers,
             ModifierFlags::empty(),
+            true,
             diagnostics::modifier_cannot_be_used_here,
         );
 
@@ -210,6 +212,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             modifiers,
             ModifierFlags::empty(),
+            true,
             diagnostics::modifier_cannot_be_used_here,
         );
         self.ast.alloc_object_property(

crates/oxc_parser/src/modifiers.rs

@@ -1,4 +1,7 @@
+use std::fmt::Display;
+
 use bitflags::bitflags;
+use cow_utils::CowUtils;
 use oxc_allocator::Vec;
 use oxc_ast::ast::TSAccessibility;
 use oxc_diagnostics::OxcDiagnostic;
@@ -30,6 +33,7 @@ bitflags! {
       const ACCESSOR      = 1 << 14;
       const EXPORT        = 1 << 15;
       const ACCESSIBILITY = Self::PRIVATE.bits() | Self::PROTECTED.bits() | Self::PUBLIC.bits();
+      const TYPE_PARAM    = Self::CONST.bits() | Self::IN.bits() | Self::OUT.bits();
   }
 }
 
@@ -97,6 +101,18 @@ impl ModifierFlags {
     }
 }
 
+impl Display for ModifierFlags {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (i, (name, _)) in self.iter_names().enumerate() {
+            if i != 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{}", name.cow_to_lowercase())?;
+        }
+        Ok(())
+    }
+}
+
 #[derive(Debug, Hash)]
 pub struct Modifier {
     pub span: Span,
@@ -483,13 +499,16 @@ impl<'a> ParserImpl<'a> {
         &mut self,
         modifiers: &Modifiers<'a>,
         allowed: ModifierFlags,
+        // if true, allowed is exact match; if false, allowed is a superset
+        // used whether to use for the diagnostic message
+        strict: bool,
         diagnose: F,
     ) where
-        F: Fn(&Modifier) -> OxcDiagnostic,
+        F: Fn(&Modifier, Option<ModifierFlags>) -> OxcDiagnostic,
     {
         for modifier in modifiers.iter() {
             if !allowed.contains(modifier.kind.into()) {
-                self.error(diagnose(modifier));
+                self.error(diagnose(modifier, strict.then_some(allowed)));
             }
         }
     }

crates/oxc_parser/src/ts/statement.rs

@@ -39,6 +39,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             modifiers,
             ModifierFlags::DECLARE | ModifierFlags::CONST,
+            true,
             diagnostics::modifier_cannot_be_used_here,
         );
         self.ast.declaration_ts_enum(
@@ -172,6 +173,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             modifiers,
             ModifierFlags::DECLARE,
+            true,
             diagnostics::modifier_cannot_be_used_here,
         );
 
@@ -200,6 +202,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             modifiers,
             ModifierFlags::DECLARE,
+            true,
             diagnostics::modifier_cannot_be_used_here,
         );
         if let Some((implements_kw_span, _)) = implements {
@@ -253,6 +256,7 @@ impl<'a> ParserImpl<'a> {
             self.verify_modifiers(
                 &modifiers,
                 ModifierFlags::READONLY,
+                true,
                 diagnostics::cannot_appear_on_an_index_signature,
             );
             return TSSignature::TSIndexSignature(
@@ -263,6 +267,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             &modifiers,
             ModifierFlags::READONLY,
+            true,
             diagnostics::cannot_appear_on_a_type_member,
         );
 
@@ -396,6 +401,7 @@ impl<'a> ParserImpl<'a> {
         self.verify_modifiers(
             modifiers,
             ModifierFlags::DECLARE,
+            true,
             diagnostics::modifier_cannot_be_used_here,
         );
         self.ast.alloc_ts_module_declaration(
@@ -440,6 +446,7 @@ impl<'a> ParserImpl<'a> {
                 self.verify_modifiers(
                     modifiers,
                     ModifierFlags::DECLARE,
+                    true,
                     diagnostics::modifier_cannot_be_used_here,
                 );
                 let decl = self.parse_variable_declaration(