Improve error messages

ecmascript/parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "swc_ecma_parser"
-version = "0.34.0"
+version = "0.34.1"
 authors = ["강동윤 <[email protected]>"]
 license = "Apache-2.0/MIT"
 repository = "https://github.com/swc-project/swc.git"

ecmascript/parser/src/parser/class_and_fn.rs

@@ -198,7 +198,7 @@ impl<'a, I: Tokens> Parser<I> {
 
         if is!("export") {
             if !allow_export {
-                unexpected!();
+                syntax_error!(self.input.cur_span(), SyntaxError::ExportNotAllowed);
             }
 
             if !self.syntax().decorators_before_export() {
@@ -454,11 +454,12 @@ impl<'a, I: Tokens> Parser<I> {
             // generator method
             let key = self.parse_class_prop_name()?;
             if readonly {
-                syntax_error!(span!(start), SyntaxError::ReadOnlyMethod);
+                self.emit_err(span!(start), SyntaxError::ReadOnlyMethod);
             }
             if is_constructor(&key) {
-                unexpected!();
+                self.emit_err(span!(start), SyntaxError::GeneratorConstructor);
             }
+
             return self.make_method(
                 |p| p.parse_unique_formal_params(),
                 MakeMethodArgs {
@@ -656,7 +657,7 @@ impl<'a, I: Tokens> Parser<I> {
                 let key = self.parse_class_prop_name()?;
 
                 if readonly {
-                    unexpected!()
+                    self.emit_err(key_span, SyntaxError::GetterSetterCannotBeReadonly);
                 }
 
                 return match i.sym {
@@ -718,7 +719,7 @@ impl<'a, I: Tokens> Parser<I> {
             _ => {}
         }
 
-        unexpected!()
+        unexpected!("* for generator, private key, identifier or async")
     }
 
     fn make_property(

ecmascript/parser/src/parser/expr.rs

@@ -81,7 +81,7 @@ impl<'a, I: Tokens> Parser<I> {
                     }) => {
                         *type_params = Some(type_parameters);
                     }
-                    _ => unexpected!(),
+                    _ => unexpected!("("),
                 }
                 Ok(Some(arrow))
             });
@@ -374,7 +374,11 @@ impl<'a, I: Tokens> Parser<I> {
             }
         }
 
-        unexpected!()
+        unexpected!(
+            "this, import, async, function, [ for array literal, { for object literal, @ for \
+             decorator, function, class, null, true, false, number, bigint, string, regexp, ` for \
+             template literal, (, or an identifier"
+        )
     }
 
     fn parse_array_lit(&mut self) -> PResult<Box<Expr>> {
@@ -422,7 +426,7 @@ impl<'a, I: Tokens> Parser<I> {
         let prop = if is!("meta") {
             self.parse_ident_name()?
         } else {
-            unexpected!();
+            unexpected!("meta");
         };
 
         Ok(MetaPropExpr { meta, prop })
@@ -446,7 +450,7 @@ impl<'a, I: Tokens> Parser<I> {
                     return self.parse_subscripts(ExprOrSuper::Expr(expr), true);
                 }
 
-                unexpected!()
+                unexpected!("target")
             }
 
             // 'NewExpression' allows new call without paren.
@@ -457,7 +461,8 @@ impl<'a, I: Tokens> Parser<I> {
                 self.try_parse_ts(|p| {
                     let args = p.parse_ts_type_args()?;
                     if !is!('(') {
-                        unexpected!()
+                        // This will fail
+                        expect!('(');
                     }
                     Ok(Some(args))
                 })
@@ -626,7 +631,7 @@ impl<'a, I: Tokens> Parser<I> {
                 syntax_error!(span!(expr_start), SyntaxError::LineBreakBeforeArrow);
             }
             if !can_be_arrow {
-                unexpected!()
+                syntax_error!(span!(expr_start), SyntaxError::ArrowNotAllowed);
             }
             expect!("=>");
 
@@ -834,7 +839,7 @@ impl<'a, I: Tokens> Parser<I> {
                 ),
                 _ => unreachable!(),
             },
-            _ => unexpected!(),
+            _ => unexpected!("template token"),
         };
         let tail = is!('`');
         Ok(TplElement {
@@ -934,7 +939,11 @@ impl<'a, I: Tokens> Parser<I> {
                         .map(|expr| (Box::new(Expr::TaggedTpl(expr)), true))
                         .map(Some)
                     } else {
-                        unexpected!()
+                        if no_call {
+                            unexpected!("`")
+                        } else {
+                            unexpected!("( or `")
+                        }
                     }
                 });
                 if let Some(result) = result {
@@ -1037,9 +1046,9 @@ impl<'a, I: Tokens> Parser<I> {
             }
             ExprOrSuper::Super(..) => {
                 if no_call {
-                    unexpected!()
+                    syntax_error!(self.input.cur_span(), SyntaxError::InvalidSuperCall);
                 }
-                unexpected!()
+                syntax_error!(self.input.cur_span(), SyntaxError::InvalidSuper);
             }
         }
     }

ecmascript/parser/src/parser/jsx.rs

@@ -21,7 +21,7 @@ impl<'a, I: Tokens> Parser<I> {
                 _ => unreachable!(),
             },
             _ if ctx.in_forced_jsx_context => self.parse_ident_ref(),
-            _ => unexpected!(),
+            _ => unexpected!("jsx identifier"),
         }
     }
 
@@ -216,7 +216,7 @@ impl<'a, I: Tokens> Parser<I> {
         }
         let self_closing = eat!('/');
         if !eat!(JSXTagEnd) & !(self.ctx().in_forced_jsx_context && eat!('>')) {
-            unexpected!()
+            unexpected!("> (jsx closing tag)");
         }
         Ok(JSXOpeningElement {
             span: span!(start),
@@ -314,7 +314,7 @@ impl<'a, I: Tokens> Parser<I> {
                                 );
                             }
                         }
-                        _ => unexpected!(),
+                        _ => unexpected!("< (jsx tag start), jsx text or {"),
                     }
                 }
             }

ecmascript/parser/src/parser/macros.rs

@@ -1,7 +1,17 @@
 macro_rules! unexpected {
-    ($p:expr) => {{
-        let got = format!("{:?}", cur!($p, false).ok());
-        syntax_error!($p, $p.input.cur_span(), SyntaxError::Unexpected { got })
+    ($p:expr, $expected:literal) => {{
+        let got = match cur!($p, false).ok() {
+            Some(v) => format!("{:?}", v),
+            None => format!("<eof>"),
+        };
+        syntax_error!(
+            $p,
+            $p.input.cur_span(),
+            SyntaxError::Unexpected {
+                got,
+                expected: $expected
+            }
+        )
     }};
 }
 

ecmascript/parser/src/parser/mod.rs

@@ -153,6 +153,8 @@ impl<I: Tokens> Parser<I> {
         self.input.get_ctx()
     }
 
+    #[cold]
+    #[inline(never)]
     fn emit_err(&self, span: Span, error: SyntaxError) {
         if !self.emit_err || !self.syntax().early_errors() {
             return;
@@ -163,6 +165,8 @@ impl<I: Tokens> Parser<I> {
         })
     }
 
+    #[cold]
+    #[inline(never)]
     fn emit_error(&self, error: Error) {
         if !self.emit_err || !self.syntax().early_errors() {
             return;

ecmascript/parser/src/parser/object.rs

@@ -97,7 +97,9 @@ impl<'a, I: Tokens> Parser<I> {
                         expr,
                     })
                 }
-                _ => unexpected!(),
+                _ => unexpected!(
+                    "identifier, string literal, numeric literal or [ for the computed key"
+                ),
             };
 
             Ok(v)
@@ -198,7 +200,8 @@ impl<I: Tokens> ParseObject<Box<Expr>> for Parser<I> {
 
         let ident = match key {
             PropName::Ident(ident) => ident,
-            _ => unexpected!(),
+            // TODO
+            _ => unexpected!("identifier"),
         };
 
         if eat!('?') {
@@ -347,7 +350,16 @@ impl<I: Tokens> ParseObject<Box<Expr>> for Parser<I> {
                     _ => unreachable!(),
                 }
             }
-            _ => unexpected!(),
+            _ => {
+                if self.input.syntax().typescript() {
+                    unexpected!(
+                        "... , *,  (, [, :, , ?, =, an identifier, public, protected, private, \
+                         readonly, <."
+                    )
+                } else {
+                    unexpected!("... , *,  (, [, :, , ?, = or an identifier")
+                }
+            }
         }
     }
 }
@@ -412,7 +424,7 @@ impl<I: Tokens> ParseObject<Pat> for Parser<I> {
         }
         let key = match key {
             PropName::Ident(ident) => ident,
-            _ => unexpected!(),
+            _ => unexpected!("an identifier"),
         };
 
         let value = if eat!('=') {

ecmascript/parser/src/parser/pat.rs

@@ -51,7 +51,7 @@ impl<'a, I: Tokens> Parser<I> {
             //     expect!(')');
             //     Ok(pat)
             // }
-            _ => unexpected!(),
+            _ => unexpected!("yield, an identifier, [ or {"),
         }
     }
 

ecmascript/parser/src/parser/stmt.rs

@@ -172,15 +172,15 @@ impl<'a, I: Tokens> Parser<I> {
 
         if is!("function") {
             if !include_decl {
-                unexpected!()
+                self.emit_err(self.input.cur_span(), SyntaxError::DeclNotAllowed);
             }
 
             return self.parse_fn_decl(decorators).map(Stmt::from);
         }
 
         if is!("class") {
             if !include_decl {
-                unexpected!()
+                self.emit_err(self.input.cur_span(), SyntaxError::DeclNotAllowed);
             }
             return self
                 .parse_class_decl(start, start, decorators)

ecmascript/parser/src/parser/stmt/module_item.rs

@@ -148,7 +148,7 @@ impl<'a, I: Tokens> Parser<I> {
                     imported: None,
                 }))
             }
-            _ => unexpected!(),
+            _ => unexpected!("an identifier"),
         }
     }
 
@@ -503,7 +503,7 @@ impl<'a, I: Tokens> Parser<I> {
                 },
                 _ => unreachable!(),
             },
-            _ => unexpected!(),
+            _ => unexpected!("a string literal"),
         };
         expect!(';');
         Ok(src)