fix(parser): align private callable diagnostics

Author: doodlewind

src/compiler.rs

@@ -4890,10 +4890,6 @@ impl<'source> Parser<'source> {
         if self.array_assignment_pattern_ahead() {
             return self.parse_array_assignment_expression();
         }
-        let leading_assignment_pattern_literal = matches!(
-            self.current().kind,
-            TokenKind::Punctuator(Punctuator::LeftBracket | Punctuator::LeftBrace)
-        );
         // QuickJS's `name0` is captured only when the AssignmentExpression
         // starts with the identifier token itself. Parenthesized lvalues are
         // valid References but intentionally do not trigger NamedEvaluation.
@@ -4925,6 +4921,10 @@ impl<'source> Parser<'source> {
                 )
             )
         {
+            // QuickJS consumes every assignment operator before get_lvalue
+            // rejects an optional-chain Reference, so the diagnostic points
+            // at the first RHS token.
+            self.advance()?;
             return Err(self.syntax_here("invalid assignment left-hand side"));
         }
         let logical = match self.current().kind {
@@ -4940,8 +4940,7 @@ impl<'source> Parser<'source> {
                 let infer_name = direct_identifier_name.as_deref() == Some(target.name.as_str());
                 return self.parse_logical_identifier_assignment(target, logical, infer_name);
             }
-            return self
-                .parse_logical_member_assignment(logical, leading_assignment_pattern_literal);
+            return self.parse_logical_member_assignment(logical);
         }
 
         let assignment_span = self.current().span;
@@ -5145,18 +5144,11 @@ impl<'source> Parser<'source> {
     /// as QuickJS `js_parse_assign_expr2`. The kept member Reference is used
     /// only by the assignment branch; the short-circuit branch removes its
     /// base/key operands with `Nip` and returns the original property value.
-    fn parse_logical_member_assignment(
-        &mut self,
-        logical: LogicalAssignment,
-        leading_assignment_pattern_literal: bool,
-    ) -> Result<(), Error> {
+    fn parse_logical_member_assignment(&mut self, logical: LogicalAssignment) -> Result<(), Error> {
         let Some(target) = self.promote_tail_member_get_for_compound()? else {
-            // QuickJS consumes a logical-assignment operator after an
-            // Array/Object literal before get_lvalue rejects that literal,
-            // matching the arithmetic compound-assignment diagnostic path.
-            if leading_assignment_pattern_literal {
-                self.advance()?;
-            }
+            // As with every other assignment operator, QuickJS advances to
+            // the RHS before get_lvalue rejects a non-Reference left side.
+            self.advance()?;
             return Err(self.syntax_here("invalid assignment left-hand side"));
         };
         let lvalue_depth = match &target {
@@ -6822,7 +6814,7 @@ impl<'source> Parser<'source> {
                     BytecodeFunctionKind::Generator | BytecodeFunctionKind::AsyncGenerator
                 ) =>
             {
-                return Err(self.syntax_here("unexpected 'yield' keyword"));
+                return Err(self.syntax_here("unexpected token in expression: 'yield'"));
             }
             TokenKind::Keyword(keyword)
                 if self.current_ir().strict && strict_reserved_identifier(keyword) =>

src/compiler/class.rs

@@ -488,12 +488,23 @@ impl<'source> Parser<'source> {
         let has_line_terminator = quickjs_simple_lookahead_has_line_terminator(
             &self.lexer.source()[self.current().span.end.byte_offset..],
         );
+        // QuickJS first treats `async` as an ordinary property name only for
+        // the five tokens which can immediately finish or continue that
+        // property. Every other same-line token enters the async-method path;
+        // a malformed key is then diagnosed at that token by the shared class
+        // property-name parser. This includes `;`, invalid punctuation, and a
+        // raw backslash from an attempted escaped `#` token.
         Ok(!has_line_terminator
-            && (Self::class_property_name_starts(&next.kind)
-                || matches!(
-                    next.kind,
-                    TokenKind::Punctuator(Punctuator::Multiply | Punctuator::Semicolon)
-                )))
+            && !matches!(
+                next.kind,
+                TokenKind::Punctuator(
+                    Punctuator::Colon
+                        | Punctuator::Comma
+                        | Punctuator::RightBrace
+                        | Punctuator::LeftParen
+                        | Punctuator::Equal
+                )
+            ))
     }
 
     fn class_property_name_starts(kind: &TokenKind<'_>) -> bool {

src/compiler/object_literal.rs

@@ -141,10 +141,7 @@ impl<'source> Parser<'source> {
                             .to_js_string()?
                     }
                     TokenKind::PrivateIdentifier(_) => {
-                        return Err(Error::syntax(
-                            "private identifiers are not valid in object literals",
-                            source_span(token.span),
-                        ));
+                        return Err(self.syntax_here("invalid property name"));
                     }
                     _ => return Err(self.syntax_here("invalid property name")),
                 };
@@ -155,6 +152,7 @@ impl<'source> Parser<'source> {
                         | TokenKind::Keyword(_)
                         | TokenKind::String(_)
                         | TokenKind::Number(_)
+                        | TokenKind::PrivateIdentifier(_)
                         | TokenKind::Punctuator(Punctuator::LeftBracket)
                 );
                 let async_prefix_has_line_terminator = method_prefix.as_deref() == Some("async")
@@ -332,10 +330,7 @@ impl<'source> Parser<'source> {
                 return Ok(ObjectMethodPropertyKey::Computed);
             }
             TokenKind::PrivateIdentifier(_) => {
-                return Err(Error::syntax(
-                    "private identifiers are not valid in object literals",
-                    source_span(token.span),
-                ));
+                return Err(self.syntax_here("invalid property name"));
             }
             _ => return Err(self.syntax_here("invalid property name")),
         };

src/compiler/tests.rs

@@ -821,6 +821,12 @@ fn class_field_early_error_diagnostics_match_quickjs() {
             "invalid first character of private name",
             24,
         ),
+        (
+            r"class C { async \u0023m() {} }",
+            "invalid property name",
+            17,
+        ),
+        ("class C { async @() {} }", "invalid property name", 17),
     ] {
         let error = compile_unlinked_script(source).unwrap_err();
         assert_eq!(error.kind(), ErrorKind::Syntax, "{source}");
@@ -897,7 +903,17 @@ fn private_field_early_error_diagnostics_match_quickjs() {
 
 #[test]
 fn invalid_assignment_diagnostics_advance_to_rhs_like_quickjs() {
-    for (source, column) in [("1 = 0", 5), ("f() += 0", 8), ("1 = @", 5)] {
+    for (source, column) in [
+        ("1 = 0", 5),
+        ("f() += 0", 8),
+        ("1 = @", 5),
+        ("1 &&= 0", 7),
+        ("f() ||= 0", 9),
+        ("a?.b = 0", 8),
+        ("a?.b += 0", 9),
+        ("a?.b ??= 0", 10),
+        ("class C { #x; m(){ #x in {} &&= 0; } }", 33),
+    ] {
         let error = compile_unlinked_script(source).unwrap_err();
         assert_eq!(error.kind(), ErrorKind::Syntax, "{source}");
         assert_eq!(
@@ -1848,6 +1864,14 @@ fn generator_method_frontiers_keep_async_delegation_explicit() {
             .message(),
         "invalid property name"
     );
+    let yield_reference = compile_unlinked_script("class C { *#gen() { void yield; } }")
+        .expect_err("yield must not parse as an IdentifierReference in a generator method");
+    assert_eq!(yield_reference.kind(), ErrorKind::Syntax);
+    assert_eq!(
+        yield_reference.message(),
+        "unexpected token in expression: 'yield'"
+    );
+    assert_eq!(yield_reference.span().unwrap().start.column, 26);
 
     compile_unlinked_script("class C { async *method(){ yield 1; } }")
         .expect("public class async-generator method should use the independent async driver");
@@ -13344,8 +13368,27 @@ fn object_literal_grammar_is_fail_closed_at_remaining_method_frontiers() {
         compile_unlinked_script("({#private:1})")
             .unwrap_err()
             .message(),
-        "private identifiers are not valid in object literals"
+        "invalid property name"
     );
+
+    for (source, column) in [
+        ("({#private: 1})", 3),
+        ("({#private() {}})", 3),
+        ("({*#private() {}})", 4),
+        ("({get #private() {}})", 7),
+        ("({set #private(value) {}})", 7),
+        ("({async #private() {}})", 9),
+        ("({async *#private() {}})", 10),
+    ] {
+        let error = compile_unlinked_script(source).unwrap_err();
+        assert_eq!(error.kind(), ErrorKind::Syntax, "{source:?}");
+        assert_eq!(error.message(), "invalid property name", "{source:?}");
+        let start = error
+            .span()
+            .expect("object-literal error lost its span")
+            .start;
+        assert_eq!((start.line, start.column), (1, column), "{source:?}");
+    }
 }
 
 #[test]