fix(estree): Align TSMappedType fields (#10392)

Part of #9705 

In this PR, I've tried to align `TSMappedType` with TS-ESLint.

>
https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/ast-spec/src/type/TSMappedType/spec.ts

```js
// BEFORE
{
  type: "TSMappedType",
  typeParameter: {
    name: Identifier,
    constraint: TypeNode,
  },
  // ...
}

// AFTER
{
  type: "TSMappedType",  
  key: Identifier,
  constraint: TypeNode,
  // ...
}
```

And also fixed serializer for `optional` and `readonly` types.

They are defined as `boolean | '+' | '-' | undefined`, but we use `true
| '+' | '-' | null`.

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: overlookmotel <theoverlookmotel@gmail.com>

Author: 3 people

crates/oxc_ast/src/ast/ts.rs

@@ -1412,9 +1412,11 @@ pub struct TSConstructorType<'a> {
 #[scope]
 #[derive(Debug)]
 #[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree)]
+#[estree(add_fields(key = TSMappedTypeKey, constraint = TSMappedTypeConstraint))]
 pub struct TSMappedType<'a> {
     pub span: Span,
     /// Key type parameter, e.g. `P` in `[P in keyof T]`.
+    #[estree(skip)]
     pub type_parameter: Box<'a, TSTypeParameter<'a>>,
     pub name_type: Option<TSType<'a>>,
     pub type_annotation: Option<TSType<'a>>,
@@ -1448,14 +1450,13 @@ pub struct TSMappedType<'a> {
 #[ast]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[generate_derive(CloneIn, Dummy, ContentEq, ESTree)]
+#[estree(via = TSMappedTypeModifierOperatorConverter)]
 pub enum TSMappedTypeModifierOperator {
     /// e.g. `?` in `{ [P in K]?: T }`
     True = 0,
     /// e.g. `+?` in `{ [P in K]+?: T }`
-    #[estree(rename = "+")]
     Plus = 1,
     /// e.g. `-?` in `{ [P in K]-?: T }`
-    #[estree(rename = "-")]
     Minus = 2,
     /// No modifier present
     None = 3,

crates/oxc_ast/src/generated/derive_estree.rs

@@ -3159,23 +3159,19 @@ impl ESTree for TSMappedType<'_> {
         state.serialize_field("type", &JsonSafeString("TSMappedType"));
         state.serialize_field("start", &self.span.start);
         state.serialize_field("end", &self.span.end);
-        state.serialize_field("typeParameter", &self.type_parameter);
         state.serialize_field("nameType", &self.name_type);
         state.serialize_field("typeAnnotation", &self.type_annotation);
         state.serialize_field("optional", &self.optional);
         state.serialize_field("readonly", &self.readonly);
+        state.serialize_field("key", &crate::serialize::TSMappedTypeKey(self));
+        state.serialize_field("constraint", &crate::serialize::TSMappedTypeConstraint(self));
         state.end();
     }
 }
 
 impl ESTree for TSMappedTypeModifierOperator {
     fn serialize<S: Serializer>(&self, serializer: S) {
-        match self {
-            Self::True => JsonSafeString("true").serialize(serializer),
-            Self::Plus => JsonSafeString("+").serialize(serializer),
-            Self::Minus => JsonSafeString("-").serialize(serializer),
-            Self::None => JsonSafeString("none").serialize(serializer),
-        }
+        crate::serialize::TSMappedTypeModifierOperatorConverter(self).serialize(serializer)
     }
 }
 

crates/oxc_ast/src/serialize.rs

@@ -1021,6 +1021,58 @@ impl ESTree for TSModuleDeclarationGlobal<'_, '_> {
     }
 }
 
+/// Serializer for `key` and `constraint` field of `TSMappedType`.
+#[ast_meta]
+#[estree(
+    ts_type = "TSTypeParameter['name']",
+    raw_deser = "
+        const typeParameter = DESER[Box<TSTypeParameter>](POS_OFFSET.type_parameter);
+        typeParameter.name
+    "
+)]
+pub struct TSMappedTypeKey<'a, 'b>(pub &'b TSMappedType<'a>);
+
+impl ESTree for TSMappedTypeKey<'_, '_> {
+    fn serialize<S: Serializer>(&self, serializer: S) {
+        self.0.type_parameter.name.serialize(serializer);
+    }
+}
+
+// NOTE: Variable `typeParameter` in `raw_deser` is shared between `key` and `constraint` serializers.
+// They will be concatenated in the generated code.
+#[ast_meta]
+#[estree(ts_type = "TSTypeParameter['constraint']", raw_deser = "typeParameter.constraint")]
+pub struct TSMappedTypeConstraint<'a, 'b>(pub &'b TSMappedType<'a>);
+
+impl ESTree for TSMappedTypeConstraint<'_, '_> {
+    fn serialize<S: Serializer>(&self, serializer: S) {
+        self.0.type_parameter.constraint.serialize(serializer);
+    }
+}
+
+#[ast_meta]
+#[estree(
+    ts_type = "true | '+' | '-' | null",
+    raw_deser = "
+        const operator = DESER[u8](POS);
+        [true, '+', '-', null][operator]
+    "
+)]
+pub struct TSMappedTypeModifierOperatorConverter<'a>(pub &'a TSMappedTypeModifierOperator);
+
+impl ESTree for TSMappedTypeModifierOperatorConverter<'_> {
+    fn serialize<S: Serializer>(&self, serializer: S) {
+        match self.0 {
+            TSMappedTypeModifierOperator::True => true.serialize(serializer),
+            TSMappedTypeModifierOperator::Plus => JsonSafeString("+").serialize(serializer),
+            TSMappedTypeModifierOperator::Minus => JsonSafeString("-").serialize(serializer),
+            // This is typed as `undefined` (= key is not present) in TS-ESTree.
+            // But we serialize it as `null` to align result in snapshot tests.
+            TSMappedTypeModifierOperator::None => Null(()).serialize(serializer),
+        }
+    }
+}
+
 // --------------------
 // Comments
 // --------------------

napi/parser/deserialize-js.js

@@ -1844,15 +1844,17 @@ function deserializeTSConstructorType(pos) {
 }
 
 function deserializeTSMappedType(pos) {
+  const typeParameter = deserializeBoxTSTypeParameter(pos + 8);
   return {
     type: 'TSMappedType',
     start: deserializeU32(pos),
     end: deserializeU32(pos + 4),
-    typeParameter: deserializeBoxTSTypeParameter(pos + 8),
     nameType: deserializeOptionTSType(pos + 16),
     typeAnnotation: deserializeOptionTSType(pos + 32),
     optional: deserializeTSMappedTypeModifierOperator(pos + 48),
     readonly: deserializeTSMappedTypeModifierOperator(pos + 49),
+    key: typeParameter.name,
+    constraint: typeParameter.constraint,
   };
 }
 
@@ -3882,18 +3884,8 @@ function deserializeTSTypeQueryExprName(pos) {
 }
 
 function deserializeTSMappedTypeModifierOperator(pos) {
-  switch (uint8[pos]) {
-    case 0:
-      return 'true';
-    case 1:
-      return '+';
-    case 2:
-      return '-';
-    case 3:
-      return 'none';
-    default:
-      throw new Error(`Unexpected discriminant ${uint8[pos]} for TSMappedTypeModifierOperator`);
-  }
+  const operator = deserializeU8(pos);
+  return [true, '+', '-', null][operator];
 }
 
 function deserializeTSModuleReference(pos) {

napi/parser/deserialize-ts.js

@@ -1920,15 +1920,17 @@ function deserializeTSConstructorType(pos) {
 }
 
 function deserializeTSMappedType(pos) {
+  const typeParameter = deserializeBoxTSTypeParameter(pos + 8);
   return {
     type: 'TSMappedType',
     start: deserializeU32(pos),
     end: deserializeU32(pos + 4),
-    typeParameter: deserializeBoxTSTypeParameter(pos + 8),
     nameType: deserializeOptionTSType(pos + 16),
     typeAnnotation: deserializeOptionTSType(pos + 32),
     optional: deserializeTSMappedTypeModifierOperator(pos + 48),
     readonly: deserializeTSMappedTypeModifierOperator(pos + 49),
+    key: typeParameter.name,
+    constraint: typeParameter.constraint,
   };
 }
 
@@ -3958,18 +3960,8 @@ function deserializeTSTypeQueryExprName(pos) {
 }
 
 function deserializeTSMappedTypeModifierOperator(pos) {
-  switch (uint8[pos]) {
-    case 0:
-      return 'true';
-    case 1:
-      return '+';
-    case 2:
-      return '-';
-    case 3:
-      return 'none';
-    default:
-      throw new Error(`Unexpected discriminant ${uint8[pos]} for TSMappedTypeModifierOperator`);
-  }
+  const operator = deserializeU8(pos);
+  return [true, '+', '-', null][operator];
 }
 
 function deserializeTSModuleReference(pos) {

npm/oxc-types/types.d.ts

@@ -1344,15 +1344,14 @@ export interface TSConstructorType extends Span {
 
 export interface TSMappedType extends Span {
   type: 'TSMappedType';
-  typeParameter: TSTypeParameter;
   nameType: TSType | null;
   typeAnnotation: TSType | null;
-  optional: TSMappedTypeModifierOperator;
-  readonly: TSMappedTypeModifierOperator;
+  optional: true | '+' | '-' | null;
+  readonly: true | '+' | '-' | null;
+  key: TSTypeParameter['name'];
+  constraint: TSTypeParameter['constraint'];
 }
 
-export type TSMappedTypeModifierOperator = 'true' | '+' | '-' | 'none';
-
 export interface TSTemplateLiteralType extends Span {
   type: 'TSTemplateLiteralType';
   quasis: Array<TemplateElement>;