feat(ast)!: Make source field of TSImportType a StringLiteral (#16114)

- [x] Change `source` field type in `TSImportType` from `TSType<'a>` to `StringLiteral<'a>` in `crates/oxc_ast/src/ast/ts.rs`
- [x] Remove `#[estree(via = TSImportTypeSource)]` attribute from the field
- [x] Run `just ast` to regenerate all derived code
- [x] Update the parser in `crates/oxc_parser/src/ts/types.rs` to parse a `StringLiteral` directly and emit errors for non-string literals
- [x] Delete the dead code `TSImportTypeSource` serializer from `crates/oxc_ast/src/serialize/ts.rs`
- [x] Add `ts_string_literal_expected` diagnostic (TS1141)
- [x] Update semantic snapshot for `import-type-with-type-params.snap`
- [x] Add test case for invalid import type source
- [x] Verify all tests pass
- [x] Simplify error recovery - just report error and create dummy string literal (per review feedback)
- [x] Fix spurious "Expected ')'" error by skipping invalid tokens in error recovery

<!-- START COPILOT CODING AGENT SUFFIX -->

<details>

<summary>Original prompt</summary>

>
> ----
>
> *This section details on the original issue you should resolve*
>
> <issue_title>AST: Make `source` field of `TSImportType` a `StringLiteral`</issue_title>
> <issue_description>Continuation of #16074.
>
> The expression inside `import(...)` in TS context (`TSImportType`) cannot legally be anything other than a string literal.
>
> Our parser is too liberal. We currently accept all kind of crazy stuff like:
>
> ```ts
> type A = typeof import(`react`);
> type B = typeof import(A);
> type C = typeof import(`${A} ${B}`);
> type D = typeof import(typeof import('react'));
> ```
>
> [Playground](https://playground.oxc.rs/#eNptU9tOGzEQ/ZXIQqJIqUSRKqFUfQjQSJVooaUqL31g1jsbDF7bHc/molX+nfEmdkDhyfaZ+5njXmk1UbwOOJqOvo7SxTcj0wZP/OGBEDQ/nHz55waPiwOPabFdHkYf9dPN6Ki/2OwzXB14vX0dDxWPT1KAGiuvJr2izqXDGsdq0oCNOFaNpxaYkQrCBC4muCAmeguM9RVqCwRsvIvFuHw0jDGAxgK14OZ2/9S+DYRxHxK1D2Jm6tJj3Vbe5pdu5ju3zVgFoJga6xWuGF2UuoniKPOAtX75G7kjd9NxNDXOOqdTZzlTKom0wFsgCc3oEPf3/LtjMpJQF0NE6ZqN/kbkaYdKC4mroQW5v6KqV13EP1DtZ2Ko7k3Nj2pyNlbo6pvm2jgZUtlG2g1SjXf281OpZhJDvzrPe5qe4uruHfh/et2SD1JLQfzoEGusJafsyUh780vftpBs1goqc5gyrMyyzPOLfQnrxF1FoJ+R72RnEp6dMwotbjvf1ffVE2q+JwiSI5OaCg29TlmIrDrpEOlNGK4CkmnRMdgbuQJ7uvXRbFeUGFJCadHallQGmqNoU2E8O/30WaoIzVfYSOKZp0sLMc4M2rps7XUVUacfyuytreGC/kCGGliY2q32fVX3KspEQQSC5EB0mcWofY1zHD6QS0Iokn2KtZevv6PcOc9DroxYnGffIUv+C0lR+aPI5D5c4wJL0mfE8FNWkQU2hIpovZ2JgFPEAqnyMROe5nFpUclUbhuB64G+BJfbJuGJZoisNi/WFa5W)
>
> TypeScript says these are all errors: [TS Playground](https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8VSQPYDMoEsC2YUCdgAKAA3wgEMBjYEgSgG4AoZaAIQSXAnS1wOIxGLblADCnVrxx5CpACQBvGAF8oStivrNWUACKTu0-nKkYZAogHJy1YFbrCgA)
>
> ### AST change
>
> We should alter the type of the `source` field from `TSType<'a>` to `StringLiteral<'a>`:
>
> https://github.com/oxc-project/oxc/blob/35d0ee491cbcd271ebceaac7e25cff0490ded5c4/crates/oxc_ast/src/ast/ts.rs#L1382-L1389
>
> ```diff
> pub struct TSImportType<'a> {
>     pub span: Span,
> -   #[estree(via = TSImportTypeSource)]
> -   pub source: TSType<'a>,
> +   pub source: StringLiteral<'a>,
>     pub options: Option<Box<'a, ObjectExpression<'a>>>,
>     pub qualifier: Option<TSImportTypeQualifier<'a>>,
>     pub type_arguments: Option<Box<'a, TSTypeParameterInstantiation<'a>>>,
> }
> ```
>
> ### Parser changes
>
> If we change the AST first and run `just ast` to regenerate traits code, then all the places which rely on the type of `source` field will become apparent. We'll then need to alter the parser to throw an error if it encounters something that isn't a string literal.
>
> ### `ESTree` serialization
>
> Currently there's a custom deserializer to alter the AST on JS side from `TSType` to `StringLiteral`:
>
> https://github.com/oxc-project/oxc/blob/91eb3f2be509cef11cffeff51fac61a3a4fbd12c/crates/oxc_ast/src/serialize/ts.rs#L506-L538
>
> Once we've changed the field type in AST, this code can be deleted - it's dead code once `#[estree(via = TSImportTypeSource)]` attribute is removed from the `source` field in AST struct.</issue_description>
>
> ## Comments on the Issue (you are @copilot in this section)
>
> <comments>
> </comments>
>

</details>

- Fixes #16111

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our [2 minute survey](https://gh.io/copilot-coding-agent-survey).

Author: Copilot

apps/oxlint/src-js/generated/deserialize.js

@@ -5221,16 +5221,11 @@ function deserializeTSImportType(pos) {
       end,
       range: [start, end],
       parent,
-    }),
-    source = deserializeTSType(pos + 8);
-  if (source.type === "TSLiteralType") {
-    source = source.literal;
-    source.parent = parent;
-  }
-  node.source = source;
-  node.options = deserializeOptionBoxObjectExpression(pos + 24);
-  node.qualifier = deserializeOptionTSImportTypeQualifier(pos + 32);
-  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 48);
+    });
+  node.source = deserializeStringLiteral(pos + 8);
+  node.options = deserializeOptionBoxObjectExpression(pos + 56);
+  node.qualifier = deserializeOptionTSImportTypeQualifier(pos + 64);
+  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 80);
   parent = previousParent;
   return node;
 }

crates/oxc_ast/src/ast/ts.rs

@@ -1381,8 +1381,7 @@ pub enum TSTypeQueryExprName<'a> {
 #[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree, UnstableAddress)]
 pub struct TSImportType<'a> {
     pub span: Span,
-    #[estree(via = TSImportTypeSource)]
-    pub source: TSType<'a>,
+    pub source: StringLiteral<'a>,
     pub options: Option<Box<'a, ObjectExpression<'a>>>,
     pub qualifier: Option<TSImportTypeQualifier<'a>>,
     pub type_arguments: Option<Box<'a, TSTypeParameterInstantiation<'a>>>,

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -1449,13 +1449,13 @@ const _: () = {
     assert!(align_of::<TSTypeQueryExprName>() == 8);
 
     // Padding: 0 bytes
-    assert!(size_of::<TSImportType>() == 56);
+    assert!(size_of::<TSImportType>() == 88);
     assert!(align_of::<TSImportType>() == 8);
     assert!(offset_of!(TSImportType, span) == 0);
     assert!(offset_of!(TSImportType, source) == 8);
-    assert!(offset_of!(TSImportType, options) == 24);
-    assert!(offset_of!(TSImportType, qualifier) == 32);
-    assert!(offset_of!(TSImportType, type_arguments) == 48);
+    assert!(offset_of!(TSImportType, options) == 56);
+    assert!(offset_of!(TSImportType, qualifier) == 64);
+    assert!(offset_of!(TSImportType, type_arguments) == 80);
 
     assert!(size_of::<TSImportTypeQualifier>() == 16);
     assert!(align_of::<TSImportTypeQualifier>() == 8);
@@ -3065,13 +3065,13 @@ const _: () = if cfg!(target_family = "wasm") || align_of::<u64>() == 8 {
     assert!(align_of::<TSTypeQueryExprName>() == 4);
 
     // Padding: 0 bytes
-    assert!(size_of::<TSImportType>() == 32);
+    assert!(size_of::<TSImportType>() == 52);
     assert!(align_of::<TSImportType>() == 4);
     assert!(offset_of!(TSImportType, span) == 0);
     assert!(offset_of!(TSImportType, source) == 8);
-    assert!(offset_of!(TSImportType, options) == 16);
-    assert!(offset_of!(TSImportType, qualifier) == 20);
-    assert!(offset_of!(TSImportType, type_arguments) == 28);
+    assert!(offset_of!(TSImportType, options) == 36);
+    assert!(offset_of!(TSImportType, qualifier) == 40);
+    assert!(offset_of!(TSImportType, type_arguments) == 48);
 
     assert!(size_of::<TSImportTypeQualifier>() == 8);
     assert!(align_of::<TSImportTypeQualifier>() == 4);

crates/oxc_ast/src/generated/ast_builder.rs

@@ -10629,7 +10629,7 @@ impl<'a> AstBuilder<'a> {
     pub fn ts_type_import_type<T1, T2>(
         self,
         span: Span,
-        source: TSType<'a>,
+        source: StringLiteral<'a>,
         options: T1,
         qualifier: Option<TSImportTypeQualifier<'a>>,
         type_arguments: T2,
@@ -14024,7 +14024,7 @@ impl<'a> AstBuilder<'a> {
     pub fn ts_type_query_expr_name_import_type<T1, T2>(
         self,
         span: Span,
-        source: TSType<'a>,
+        source: StringLiteral<'a>,
         options: T1,
         qualifier: Option<TSImportTypeQualifier<'a>>,
         type_arguments: T2,
@@ -14057,7 +14057,7 @@ impl<'a> AstBuilder<'a> {
     pub fn ts_import_type<T1, T2>(
         self,
         span: Span,
-        source: TSType<'a>,
+        source: StringLiteral<'a>,
         options: T1,
         qualifier: Option<TSImportTypeQualifier<'a>>,
         type_arguments: T2,
@@ -14090,7 +14090,7 @@ impl<'a> AstBuilder<'a> {
     pub fn alloc_ts_import_type<T1, T2>(
         self,
         span: Span,
-        source: TSType<'a>,
+        source: StringLiteral<'a>,
         options: T1,
         qualifier: Option<TSImportTypeQualifier<'a>>,
         type_arguments: T2,

crates/oxc_ast/src/generated/derive_dummy.rs

@@ -2638,7 +2638,7 @@ impl<'a> Dummy<'a> for TSTypeQueryExprName<'a> {
 impl<'a> Dummy<'a> for TSImportType<'a> {
     /// Create a dummy [`TSImportType`].
     ///
-    /// Has cost of making 1 allocation (8 bytes).
+    /// Does not allocate any data into arena.
     fn dummy(allocator: &'a Allocator) -> Self {
         Self {
             span: Dummy::dummy(allocator),

crates/oxc_ast/src/generated/derive_estree.rs

@@ -2982,7 +2982,7 @@ impl ESTree for TSImportType<'_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
         let mut state = serializer.serialize_struct();
         state.serialize_field("type", &JsonSafeString("TSImportType"));
-        state.serialize_field("source", &crate::serialize::ts::TSImportTypeSource(self));
+        state.serialize_field("source", &self.source);
         state.serialize_field("options", &self.options);
         state.serialize_field("qualifier", &self.qualifier);
         state.serialize_field("typeArguments", &self.type_arguments);

crates/oxc_ast/src/serialize/ts.rs

@@ -503,39 +503,6 @@ impl ESTree for TSFunctionTypeParams<'_, '_> {
     }
 }
 
-/// Serializer for `source` field of `TSImportType`.
-///
-/// Serialized as a `StringLiteral` - all other values are illegal syntax.
-#[ast_meta]
-#[estree(
-    ts_type = "StringLiteral",
-    raw_deser = "
-        let source = DESER[TSType](POS_OFFSET.source);
-        if (source.type === 'TSLiteralType') {
-            source = source.literal;
-            if (PARENT) source.parent = parent;
-        } else {
-            // Should be unreachable - illegal syntax
-        }
-        source
-    "
-)]
-pub struct TSImportTypeSource<'a, 'b>(pub &'b TSImportType<'a>);
-
-impl ESTree for TSImportTypeSource<'_, '_> {
-    fn serialize<S: Serializer>(&self, serializer: S) {
-        let source = &self.0.source;
-        if let TSType::TSLiteralType(ts_lit_type) = source
-            && let TSLiteral::StringLiteral(str_lit) = &ts_lit_type.literal
-        {
-            str_lit.serialize(serializer);
-            return;
-        }
-        // Should be unreachable - illegal syntax
-        source.serialize(serializer);
-    }
-}
-
 /// Converter for [`TSParenthesizedType`].
 ///
 /// In raw transfer, do not produce a `TSParenthesizedType` node in AST if `PRESERVE_PARENS` is false.

crates/oxc_ast_visit/src/generated/visit.rs

@@ -3955,7 +3955,7 @@ pub mod walk {
         let kind = AstKind::TSImportType(visitor.alloc(it));
         visitor.enter_node(kind);
         visitor.visit_span(&it.span);
-        visitor.visit_ts_type(&it.source);
+        visitor.visit_string_literal(&it.source);
         if let Some(options) = &it.options {
             visitor.visit_object_expression(options);
         }

crates/oxc_ast_visit/src/generated/visit_mut.rs

@@ -4164,7 +4164,7 @@ pub mod walk_mut {
         let kind = AstType::TSImportType;
         visitor.enter_node(kind);
         visitor.visit_span(&mut it.span);
-        visitor.visit_ts_type(&mut it.source);
+        visitor.visit_string_literal(&mut it.source);
         if let Some(options) = &mut it.options {
             visitor.visit_object_expression(options);
         }

crates/oxc_codegen/src/gen.rs

@@ -3515,7 +3515,7 @@ impl Gen for TSTypeQueryExprName<'_> {
 impl Gen for TSImportType<'_> {
     fn r#gen(&self, p: &mut Codegen, ctx: Context) {
         p.print_str("import(");
-        self.source.print(p, ctx);
+        p.print_string_literal(&self.source, false);
         if let Some(options) = &self.options {
             p.print_str(", ");
             options.print_expr(p, Precedence::Lowest, ctx);