refactor(ast): Replace TSMappedType::type_parameter with key and constraint fields

[Copilot]

Replace TSMappedType::type_parameter with dedicated fields to match TSESTree

Summary

Successfully replaced TSMappedType::type_parameter (Box) with two dedicated fields that accurately represent the allowed syntax and match the TSESTree specification:

• key: BindingIdentifier<'a> - The type parameter name (e.g., P in [P in keyof T])
• constraint: TSType<'a> - The constraint (e.g., keyof T in [P in keyof T])

Changes Made

• Updated TSMappedType struct definition in crates/oxc_ast/src/ast/ts.rs
  • Replaced type_parameter: Box<'a, TSTypeParameter<'a>> with key and constraint fields
  • Removed the #[estree(add_fields(...))] attribute as fields are now real
• Updated parser in crates/oxc_parser/src/ts/types.rs
  • Modified parse_mapped_type() to extract and pass key and constraint separately
• Updated serialization in crates/oxc_ast/src/serialize/ts.rs
  • Removed TSMappedTypeKey and TSMappedTypeConstraint serializers (no longer needed)
• Updated codegen in crates/oxc_codegen/src/gen.rs
  • Updated to access key and constraint directly
• Updated formatter in crates/oxc_formatter/src/write/mapped_type.rs
  • Updated to access key and constraint directly
• Added semantic binding for TSMappedType in crates/oxc_semantic/src/binder.rs
  • Bind the key field with SymbolFlags::TypeParameter
  • Added TSMappedType case in builder.rs
• Fixed no-unused-vars linter to handle TSMappedType keys correctly
  • Mapped type keys are always considered used
  • Added exception for type references within TSMappedType
• Regenerated all generated files with just ast and traverse build script
• Formatted code with cargo fmt

Testing

✅ All tests pass:

• Parser unit tests: 54/54 passed
• Codegen unit tests: 87/87 passed
• Formatter unit tests: 82/82 passed
• Semantic unit tests: 5/5 passed
• Semantic integration tests: 39/39 passed (including test_ts_mapped_type)
• Linter tests: 815/815 passed (including no-unused-vars tests)
• Conformance tests: 100% pass rate with no regressions
• Clippy: No warnings

✅ Manual testing verified:

• Basic mapped types: { [P in keyof T]: T[P] }
• Optional modifiers: { [P in keyof T]?: T[P] }
• Readonly modifiers: { readonly [P in keyof T]: T[P] }
• Name type (as clause): { [K in keyof T as NewType]: T[K] }
• Combined modifiers: { -readonly [P in keyof T]-?: T[P] }
• Nested mapped types work correctly
• Mapped type keys used in value type: { [K in keyof T]: T[K] }
• Mapped type keys not explicitly used: { [name in Foo]: Bar }

Benefits

1. Type Safety: The AST structure now only allows syntactically valid constructs (no const, default, in, out modifiers that aren't applicable to mapped types)
2. TSESTree Compatibility: Matches the structure expected by TypeScript tooling and TypeScript-ESLint
3. Clarity: The intent and constraints are explicit in the type definition
4. Maintainability: Reduces confusion about which fields are applicable
5. Correctness: Prevents the possibility of creating invalid AST nodes
6. Semantic Binding: Mapped type keys are now properly bound as symbols in the semantic analysis
7. Linter Support: no-unused-vars rule correctly handles mapped type keys

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Replace TSMappedType::type_parameter with dedicated fields to match TSESTree</issue_title>
<issue_description>## Summary

Currently, TSMappedType uses TSTypeParameter to represent its type parameter, which includes several fields that are syntactically invalid in mapped types (r#const, default). We should replace type_parameter with dedicated fields that accurately represent the allowed syntax and match the TSESTree specification.

Current Implementation

pub struct TSMappedType<'a> {
    pub span: Span,
    pub type_parameter: Box<'a, TSTypeParameter<'a>>,
    pub name_type: Option<TSType<'a>>,
    pub type_annotation: Option<TSType<'a>>,
    pub optional: Option<TSMappedTypeModifierOperator>,
    pub readonly: Option<TSMappedTypeModifierOperator>,
    pub scope_id: Cell<Option<ScopeId>>,
}

Problem

1. Semantic Mismatch: TSTypeParameter includes fields that are not valid in mapped type syntax:

   • r#const - mapped types cannot use const modifier
   • default - mapped types cannot have default types
   • in - variance annotation not applicable to mapped types
   • out - variance annotation not applicable to mapped types

2. TSESTree Incompatibility: The current structure doesn't match the TSESTree specification, which defines mapped types with separate key and constraint fields rather than a full type parameter.

This creates both a semantic mismatch where the AST structure allows syntactically invalid constructs and a compatibility issue with TypeScript tooling.

Proposed Solution

Replace type_parameter: Box<'a, TSTypeParameter<'a>> with two explicit fields to match TSESTree:

#[ast(visit)]
#[scope]
#[derive(Debug)]
#[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree)]
pub struct TSMappedType<'a> {
    pub span: Span,
    /// The type parameter name (e.g., `P` in `[P in keyof T]`)
    pub key: BindingIdentifier<'a>,
    /// The constraint (e.g., `keyof T` in `[P in keyof T]`)
    pub constraint: TSType<'a>,
    pub name_type: Option<TSType<'a>>,
    pub type_annotation: Option<TSType<'a>>,
    pub optional: Option<TSMappedTypeModifierOperator>,
    pub readonly: Option<TSMappedTypeModifierOperator>,
    pub scope_id: Cell<Option<ScopeId>>,
}

Note: The existing #[estree(add_fields(key = TSMappedTypeKey, constraint = TSMappedTypeConstraint))] can be removed as these will now be real fields.

Benefits

1. Type Safety: The AST structure will only allow syntactically valid constructs
2. TSESTree Compatibility: Matches the structure expected by TypeScript tooling and TypeScript-ESLint
3. Clarity: The intent and constraints are explicit in the type definition
4. Maintainability: Reduces confusion about which TSTypeParameter fields are applicable
5. Correctness: Prevents the possibility of creating invalid AST nodes

Example

For the mapped type:

type Readonly<T> = { readonly [P in keyof T]: T[P] }

• key would be the identifier P (as BindingIdentifier)
• constraint would be the type keyof T (as TSType)

TSESTree Compatibility

This change aligns Oxc's AST with typescript-eslint's TSESTree specification, which defines TSMappedType with key and constraint fields. This could help us to remove specific converting logic from OXC AST to ESTree</issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes Replace TSMappedType::type_parameter with dedicated fields to match TSESTree #15101

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

[graphite-app]

How to use the Graphite Merge Queue

Add either label to this PR to merge it via the merge queue:

• 0-merge - adds this PR to the back of the merge queue
• hotfix - for urgent hot fixes, skip the queue and merge this PR next

You must have a Graphite account in order to use the merge queue. Sign up using this link.

An organization admin has enabled the Graphite Merge Queue in this repository.

Please do not merge from GitHub as this will restart CI on PRs being processed by the merge queue.

[codspeed-hq]

CodSpeed Performance Report

Merging #15121 will not alter performance

_{Comparing copilot/replace-type-parameter-fields (35cd6e6) with main (27b4f36)}

Summary

✅ 37 untouched

[Dunqing]

@copilot, oh, I just realized that after the change, we should handle the BindingIdentifier for TSMappedType in crates/oxc_semantic/src/binder.rs. Note that we can reuse the SymbolFlags::TypeParameter for it.

[Copilot]

@copilot, oh, I just realized that after the change, we should handle the BindingIdentifier for TSMappedType in crates/oxc_semantic/src/binder.rs. Note that we can reuse the `SymbolFlags::TypeParame...

Done! Added semantic binding for the key field in TSMappedType using SymbolFlags::TypeParameter as suggested. The implementation is in commit 35cd6e6.

Changes:

• Added Binder implementation for TSMappedType in binder.rs
• Added TSMappedType case in builder.rs to call the bind method
• The test_ts_mapped_type test now passes, properly recognizing K as a declared symbol

[Dunqing]

@copilot CI fails, please investigate the issue and fix it

[Dunqing]

@copilot CI fails, please investigate the issue and fix it

[Copilot]

@copilot CI fails, please investigate the issue and fix it

Fixed! The CI was failing due to the no-unused-vars linter not handling TSMappedType keys correctly.

Changes in commit 5df64d7:

• Added TSMappedType to the AST kind handling in is_ignored() - mapped type keys are always considered used
• Added exception in type reference checks to allow references within TSMappedType nodes
• All 815 linter tests now pass