fix(59011): TypeScript generates invalid types if @import tags are spread over multiple lines (#59026)

Author: a-tarasyuk

src/compiler/parser.ts

@@ -2637,7 +2637,7 @@ namespace Parser {
     function createIdentifier(isIdentifier: boolean, diagnosticMessage?: DiagnosticMessage, privateIdentifierDiagnosticMessage?: DiagnosticMessage): Identifier {
         if (isIdentifier) {
             identifierCount++;
-            const pos = getNodePos();
+            const pos = scanner.hasPrecedingJSDocLeadingAsterisks() ? scanner.getTokenStart() : getNodePos();
             // Store original token kind if it is not just an Identifier so we can report appropriate error later in type checker
             const originalKeywordKind = token();
             const text = internIdentifier(scanner.getTokenValue());

src/compiler/scanner.ts

@@ -65,6 +65,8 @@ export interface Scanner {
     hasPrecedingLineBreak(): boolean;
     /** @internal */
     hasPrecedingJSDocComment(): boolean;
+    /** @internal */
+    hasPrecedingJSDocLeadingAsterisks(): boolean;
     isIdentifier(): boolean;
     isReservedWord(): boolean;
     isUnterminated(): boolean;
@@ -1059,6 +1061,7 @@ export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean
         hasExtendedUnicodeEscape: () => (tokenFlags & TokenFlags.ExtendedUnicodeEscape) !== 0,
         hasPrecedingLineBreak: () => (tokenFlags & TokenFlags.PrecedingLineBreak) !== 0,
         hasPrecedingJSDocComment: () => (tokenFlags & TokenFlags.PrecedingJSDocComment) !== 0,
+        hasPrecedingJSDocLeadingAsterisks: () => (tokenFlags & TokenFlags.PrecedingJSDocLeadingAsterisks) !== 0,
         isIdentifier: () => token === SyntaxKind.Identifier || token > SyntaxKind.LastReservedWord,
         isReservedWord: () => token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord,
         isUnterminated: () => (tokenFlags & TokenFlags.Unterminated) !== 0,
@@ -1874,7 +1877,6 @@ export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean
     function scan(): SyntaxKind {
         fullStartPos = pos;
         tokenFlags = TokenFlags.None;
-        let asteriskSeen = false;
         while (true) {
             tokenStart = pos;
             if (pos >= end) {
@@ -1995,9 +1997,13 @@ export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean
                         return pos += 2, token = SyntaxKind.AsteriskAsteriskToken;
                     }
                     pos++;
-                    if (skipJsDocLeadingAsterisks && !asteriskSeen && (tokenFlags & TokenFlags.PrecedingLineBreak)) {
+                    if (
+                        skipJsDocLeadingAsterisks &&
+                        (tokenFlags & TokenFlags.PrecedingJSDocLeadingAsterisks) === 0 &&
+                        (tokenFlags & TokenFlags.PrecedingLineBreak)
+                    ) {
                         // decoration at the start of a JSDoc comment line
-                        asteriskSeen = true;
+                        tokenFlags |= TokenFlags.PrecedingJSDocLeadingAsterisks;
                         continue;
                     }
                     return token = SyntaxKind.AsteriskToken;

src/compiler/types.ts

@@ -2812,6 +2812,8 @@ export const enum TokenFlags {
     /** @internal */
     ContainsInvalidSeparator = 1 << 14, // e.g. `0_1`
     /** @internal */
+    PrecedingJSDocLeadingAsterisks = 1 << 15,
+    /** @internal */
     BinaryOrOctalSpecifier = BinarySpecifier | OctalSpecifier,
     /** @internal */
     WithSpecifier = HexSpecifier | BinaryOrOctalSpecifier,

tests/baselines/reference/importTag18.js

@@ -0,0 +1,34 @@
+//// [tests/cases/conformance/jsdoc/importTag18.ts] ////
+
+//// [a.ts]
+export interface Foo {}
+
+//// [b.js]
+/**
+ * @import {
+ *    Foo
+ * } from "./a"
+ */
+
+/**
+ * @param {Foo} a
+ */
+export function foo(a) {}
+
+
+
+
+//// [a.d.ts]
+export interface Foo {
+}
+//// [b.d.ts]
+/**
+ * @import {
+ *    Foo
+ * } from "./a"
+ */
+/**
+ * @param {Foo} a
+ */
+export function foo(a: Foo): void;
+import type { Foo } from "./a";

tests/baselines/reference/importTag18.symbols

@@ -0,0 +1,20 @@
+//// [tests/cases/conformance/jsdoc/importTag18.ts] ////
+
+=== a.ts ===
+export interface Foo {}
+>Foo : Symbol(Foo, Decl(a.ts, 0, 0))
+
+=== b.js ===
+/**
+ * @import {
+ *    Foo
+ * } from "./a"
+ */
+
+/**
+ * @param {Foo} a
+ */
+export function foo(a) {}
+>foo : Symbol(foo, Decl(b.js, 0, 0))
+>a : Symbol(a, Decl(b.js, 9, 20))
+

tests/baselines/reference/importTag18.types

@@ -0,0 +1,22 @@
+//// [tests/cases/conformance/jsdoc/importTag18.ts] ////
+
+=== a.ts ===
+
+export interface Foo {}
+
+=== b.js ===
+/**
+ * @import {
+ *    Foo
+ * } from "./a"
+ */
+
+/**
+ * @param {Foo} a
+ */
+export function foo(a) {}
+>foo : (a: Foo) => void
+>    : ^ ^^^^^^^^^^^^^^
+>a : Foo
+>  : ^^^
+

tests/baselines/reference/importTag19.js

@@ -0,0 +1,32 @@
+//// [tests/cases/conformance/jsdoc/importTag19.ts] ////
+
+//// [a.ts]
+export interface Foo {}
+
+//// [b.js]
+/**
+ * @import { Foo }
+ * from "./a"
+ */
+
+/**
+ * @param {Foo} a
+ */
+export function foo(a) {}
+
+
+
+
+//// [a.d.ts]
+export interface Foo {
+}
+//// [b.d.ts]
+/**
+ * @import { Foo }
+ * from "./a"
+ */
+/**
+ * @param {Foo} a
+ */
+export function foo(a: Foo): void;
+import type { Foo } from "./a";

tests/baselines/reference/importTag19.symbols

@@ -0,0 +1,19 @@
+//// [tests/cases/conformance/jsdoc/importTag19.ts] ////
+
+=== a.ts ===
+export interface Foo {}
+>Foo : Symbol(Foo, Decl(a.ts, 0, 0))
+
+=== b.js ===
+/**
+ * @import { Foo }
+ * from "./a"
+ */
+
+/**
+ * @param {Foo} a
+ */
+export function foo(a) {}
+>foo : Symbol(foo, Decl(b.js, 0, 0))
+>a : Symbol(a, Decl(b.js, 8, 20))
+

tests/baselines/reference/importTag19.types

@@ -0,0 +1,21 @@
+//// [tests/cases/conformance/jsdoc/importTag19.ts] ////
+
+=== a.ts ===
+
+export interface Foo {}
+
+=== b.js ===
+/**
+ * @import { Foo }
+ * from "./a"
+ */
+
+/**
+ * @param {Foo} a
+ */
+export function foo(a) {}
+>foo : (a: Foo) => void
+>    : ^ ^^^^^^^^^^^^^^
+>a : Foo
+>  : ^^^
+

tests/baselines/reference/importTag20.js

@@ -0,0 +1,34 @@
+//// [tests/cases/conformance/jsdoc/importTag20.ts] ////
+
+//// [a.ts]
+export interface Foo {}
+
+//// [b.js]
+/**
+ * @import
+ * { Foo
+ * } from './a'
+ */
+
+/**
+ * @param {Foo} a
+ */
+export function foo(a) {}
+
+
+
+
+//// [a.d.ts]
+export interface Foo {
+}
+//// [b.d.ts]
+/**
+ * @import
+ * { Foo
+ * } from './a'
+ */
+/**
+ * @param {Foo} a
+ */
+export function foo(a: Foo): void;
+import type { Foo } from './a';