perf(parser): add #[cold] to error handling code

crates/oxc_parser/src/cursor.rs

@@ -44,6 +44,7 @@ impl<'a> ParserImpl<'a> {
     }
 
     /// Get current source text
+    #[inline]
     pub(crate) fn cur_src(&self) -> &'a str {
         let range = self.cur_token().span();
         // SAFETY:
@@ -53,11 +54,13 @@ impl<'a> ParserImpl<'a> {
     }
 
     /// Get current string
+    #[inline]
     pub(crate) fn cur_string(&self) -> &'a str {
         self.lexer.get_string(self.token)
     }
 
     /// Get current template string
+    #[inline]
     pub(crate) fn cur_template_string(&self) -> Option<&'a str> {
         self.lexer.get_template_string(self.token)
     }
@@ -187,6 +190,7 @@ impl<'a> ParserImpl<'a> {
     }
 
     /// # Errors
+    #[inline]
     pub(crate) fn expect_without_advance(&mut self, kind: Kind) {
         if !self.at(kind) {
             let range = self.cur_token().span();

crates/oxc_parser/src/error_handler.rs

@@ -15,6 +15,7 @@ pub struct FatalError {
 }
 
 impl<'a> ParserImpl<'a> {
+    #[cold]
     pub(crate) fn set_unexpected(&mut self) {
         // The lexer should have reported a more meaningful diagnostic
         // when it is a undetermined kind.
@@ -33,13 +34,15 @@ impl<'a> ParserImpl<'a> {
     /// # Panics
     ///
     ///   * The lexer did not push a diagnostic when `Kind::Undetermined` is returned
+    #[cold]
     #[must_use]
     pub(crate) fn unexpected<T: Dummy<'a>>(&mut self) -> T {
         self.set_unexpected();
         Dummy::dummy(self.ast.allocator)
     }
 
     /// Push a Syntax Error
+    #[cold]
     pub(crate) fn error(&mut self, error: OxcDiagnostic) {
         self.errors.push(error);
     }
@@ -50,13 +53,15 @@ impl<'a> ParserImpl<'a> {
     }
 
     /// Advance lexer's cursor to end of file.
+    #[cold]
     pub(crate) fn set_fatal_error(&mut self, error: OxcDiagnostic) {
         if self.fatal_error.is_none() {
             self.lexer.advance_to_end();
             self.fatal_error = Some(FatalError { error, errors_len: self.errors.len() });
         }
     }
 
+    #[cold]
     pub(crate) fn fatal_error<T: Dummy<'a>>(&mut self, error: OxcDiagnostic) -> T {
         self.set_fatal_error(error);
         Dummy::dummy(self.ast.allocator)