Analysis

Understanding the Issue

This issue asks to improve the private identifier checker, referencing two closed PRs:

feat(parser): improve errors for private ident outside class #19080 (feat(parser): improve errors for private ident outside class) — Added a dedicated diagnostic when #ident appears as a property key in invalid positions (object literals, destructuring, TS type/interface members). Changed "Unexpected token" → "Private identifier '#x' is not allowed outside class bodies". This was a parser-level change.
refactor(parser,semantic): move private ident check to parser #19081 (refactor(parser,semantic): move private ident check to parser) — Moved the semantic-layer obj.#name / #name in obj outside-class check into the parser by tracking class_body_depth in parser state. This was explicitly rejected by @Boshen: "Let's keep this in the checker."

Both PRs were stacked and neither merged.

Current State

Semantic checker (crates/oxc_semantic/src/checker/javascript.rs:346-353):

pub fn check_private_identifier_outside_class(ident: &PrivateIdentifier, ctx: &SemanticBuilder<'_>) {
    if ctx.class_table_builder.current_class_id.is_none() {
        ctx.error(diagnostics::private_not_in_class(&ident.name, ident.span));
    }
}

Fires on every PrivateIdentifier AST node when outside a class. This correctly handles obj.#name and #name in obj outside class bodies.

Parser (crates/oxc_parser/src/js/object.rs:168-184):

pub(crate) fn parse_property_name(&mut self) -> (PropertyKey<'a>, bool) {
    let key = match self.cur_kind() {
        Kind::Str => ...
        kind if kind.is_number() => ...
        Kind::LBrack => ...
        _ => {
            let ident = self.parse_identifier_name();  // Falls here for #x → "Unexpected token"
            PropertyKey::StaticIdentifier(self.alloc(ident))
        }
    };
    ...
}

When #x appears as a property key in an object literal ({#x: 1}), destructuring (const {#x} = y), or TS type members (interface I { #x: string }), the parser falls into parse_identifier_name() which produces an unhelpful "Unexpected token" error. No PrivateIdentifier AST node is produced, so the semantic checker never fires for these cases.

Root Cause

There are two distinct problem contexts:

Context	Current Error	Desired Error	Handled by
`obj.#name` / `#name in obj` outside class	✅ semantic: "Private identifier '#x' is not allowed outside class bodies"	same	semantic checker
`{#x: 1}`, `const {#x} = y`, `interface I { #x }`	❌ parser: "Unexpected token"	"Private identifier '#x' is not allowed outside class bodies"	currently nothing useful

Fix Plan

Option A (consistent with @Boshen's guidance): Make the parser produce PropertyKey::PrivateIdentifier nodes for error recovery (without emitting a parser error), letting the existing semantic check_private_identifier_outside_class catch all cases:

Add Kind::PrivateIdentifier branch to parse_property_name() in crates/oxc_parser/src/js/object.rs that creates PropertyKey::PrivateIdentifier for error recovery (no parser error emitted here)
The existing semantic check_private_identifier_outside_class already handles any PrivateIdentifier node outside a class body — no semantic changes needed
Update call sites: crates/oxc_parser/src/js/binding.rs, crates/oxc_parser/src/ts/types.rs
Update conformance snapshots (cargo insta review)

Option B (closer to PR #19080's approach): Emit the error in the parser during parse_property_name for non-class contexts.

Option A is likely preferable as it keeps all private-ident-outside-class errors in the semantic checker (consistent with @Boshen's feedback) while still improving the error message quality.

Affected Files

crates/oxc_parser/src/js/object.rs — Add PrivateIdentifier branch to parse_property_name
crates/oxc_parser/src/js/class.rs — Refactor parse_class_element_name to reuse parse_property_name (as PR feat(parser): improve errors for private ident outside class #19080 proposed)
Conformance snapshots in tasks/coverage/snapshots/

Verdict

Fixable: Yes, low-medium complexity. The core change is small: add a Kind::PrivateIdentifier arm to parse_property_name that creates a PropertyKey::PrivateIdentifier for error recovery. The semantic checker already provides the right error for any PrivateIdentifier seen outside a class body. The bulk of the work is updating conformance snapshots.

One open question for @Boshen: Should Option A (error stays in semantic only) or Option B (parser emits error immediately during parse_property_name) be preferred? Option A preserves the "keep it in the checker" philosophy uniformly.

Uh oh!

semantic: improve private ident checker #19669

Description

Metadata

Metadata

Assignees

Labels

Type

Fields

Projects

Milestone

Relationships

Development

Issue actions