Attempt to reuse type parameter constraint nodes (#58539)

microsoft · May 16, 2024 · 79a8514 · 79a8514
1 parent e8274f7
commit 79a8514
Show file tree

Hide file tree

Showing 705 changed files with 4,654 additions and 4,609 deletions.
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -7459,8 +7459,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
  return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
  }
 
+ function typeToTypeNodeHelperWithPossibleReusableTypeNode(type: Type, typeNode: TypeNode | undefined, context: NodeBuilderContext) {
+ return typeNode && tryReuseExistingNonParameterTypeNode(context, typeNode, type) || typeToTypeNodeHelper(type, context);
+ }
+
  function typeParameterToDeclaration(type: TypeParameter, context: NodeBuilderContext, constraint = getConstraintOfTypeParameter(type)): TypeParameterDeclaration {
- const constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
+ const constraintNode = constraint && typeToTypeNodeHelperWithPossibleReusableTypeNode(constraint, getConstraintDeclaration(type), context);
  return typeParameterToDeclarationWithConstraint(type, context, constraintNode);
  }
 
@@ -8274,7 +8278,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
  sym = resolveEntityName(leftmost, meaning, /*ignoreErrors*/ true, /*dontResolveAlias*/ true);
  if (
  context.enclosingDeclaration &&
- (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration || !findAncestor(node, n => n === context.enclosingDeclaration)) &&
  !(sym && sym.flags & SymbolFlags.TypeParameter)
  ) {
  sym = getExportSymbolOfValueSymbolIfExported(sym);
@@ -8431,6 +8434,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
  }
 
  function visitExistingNodeTreeSymbolsWorker(node: Node): Node | undefined {
+ if (isJSDocTypeExpression(node)) {
+ // Unwrap JSDocTypeExpressions
+ return visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode);
+ }
  // We don't _actually_ support jsdoc namepath types, emit `any` instead
  if (isJSDocAllType(node) || node.kind === SyntaxKind.JSDocNamepathType) {
  return factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);

diff --git a/tests/baselines/reference/1.0lib-noErrors.types b/tests/baselines/reference/1.0lib-noErrors.types
@@ -2081,7 +2081,7 @@ interface Array<T> {
  */
  concat<U extends T[]>(...items: U[]): T[];
 >concat : { <U extends T[]>(...items: U[]): T[]; (...items: T[]): T[]; }
-> : ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^ ^^ ^^^^^^^^^
+> : ^^^ ^^^^^^^^^ ^^^^^ ^^ ^^^ ^^^^^^ ^^ ^^^^^^^^^
 >items : U[]
 > : ^^^
 
@@ -2091,7 +2091,7 @@ interface Array<T> {
  */
  concat(...items: T[]): T[];
 >concat : { <U extends T[]>(...items: U[]): T[]; (...items: T[]): T[]; }
-> : ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
+> : ^^^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
 >items : T[]
 > : ^^^
 

diff --git a/...nce/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types b/...nce/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types
@@ -21,7 +21,7 @@ module A {
 
  export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
-> : ^ ^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : T
 > : ^
 

diff --git a/...selines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types b/...selines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types
@@ -21,7 +21,7 @@ export module A {
 
  export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
-> : ^ ^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : T
 > : ^
 

diff --git a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types
@@ -25,7 +25,7 @@ module Root {
 
  export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
-> : ^ ^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : T
 > : ^
 

diff --git a/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types b/tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types
@@ -21,7 +21,7 @@ module A {
 
  export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
-> : ^ ^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : T
 > : ^
 

diff --git a/tests/baselines/reference/accessorsOverrideProperty8.types b/tests/baselines/reference/accessorsOverrideProperty8.types
@@ -22,7 +22,7 @@ type AnyCtor<P extends object> = new (...a: any[]) => P
 
 declare function classWithProperties<T extends { [key: string]: Types }, P extends object>(properties: T, klass: AnyCtor<P>): {
 >classWithProperties : <T extends { [key: string]: Types; }, P extends object>(properties: T, klass: AnyCtor<P>) => { new (): P & Properties<T>; prototype: P & Properties<T>; }
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ 
+> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ 
 >key : string
 > : ^^^^^^
 >properties : T
@@ -43,7 +43,7 @@ const Base = classWithProperties({
 >classWithProperties({ get x() { return 'boolean' as const }, y: 'string',}, class Base {}) : { new (): Base & Properties<{ readonly x: "boolean"; y: "string"; }>; prototype: Base & Properties<{ readonly x: "boolean"; y: "string"; }>; }
 > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >classWithProperties : <T extends { [key: string]: Types; }, P extends object>(properties: T, klass: AnyCtor<P>) => { new (): P & Properties<T>; prototype: P & Properties<T>; }
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >{ get x() { return 'boolean' as const }, y: 'string',} : { readonly x: "boolean"; y: "string"; }
 > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

diff --git a/tests/baselines/reference/accessorsOverrideProperty9.types b/tests/baselines/reference/accessorsOverrideProperty9.types
@@ -50,7 +50,7 @@ interface ApiItemContainerMixin extends ApiItem {
 
 function ApiItemContainerMixin<TBaseClass extends IApiItemConstructor>(
 >ApiItemContainerMixin : <TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass) => TBaseClass & (new (...args: any[]) => ApiItemContainerMixin)
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ 
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ 
 
  baseClass: TBaseClass
 >baseClass : TBaseClass
@@ -102,7 +102,7 @@ export class ApiEnum extends ApiItemContainerMixin(ApiItem) {
 >ApiItemContainerMixin(ApiItem) : ApiItem & ApiItemContainerMixin
 > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >ApiItemContainerMixin : <TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass) => TBaseClass & (new (...args: any[]) => ApiItemContainerMixin)
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >ApiItem : typeof ApiItem
 > : ^^^^^^^^^^^^^^
 

diff --git a/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.types b/tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.types
@@ -4,7 +4,7 @@
 // test for #17069
 function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k: K) {
 >sum : <T extends Record<K, number>, K extends string>(n: number, v: T, k: K) => void
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
 >n : number
 > : ^^^^^^
 >v : T
@@ -42,7 +42,7 @@ function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k:
 }
 function realSum<T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) {
 >realSum : <T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) => void
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
 >n : number
 > : ^^^^^^
 >vs : T[]

diff --git a/tests/baselines/reference/aliasUsageInGenericFunction.types b/tests/baselines/reference/aliasUsageInGenericFunction.types
@@ -22,7 +22,7 @@ interface IHasVisualizationModel {
 }
 function foo<T extends { a: IHasVisualizationModel }>(x: T) {
 >foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
-> : ^ ^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^  ^^ ^^ ^^^^^^
 >a : IHasVisualizationModel
 > : ^^^^^^^^^^^^^^^^^^^^^^
 >x : T
@@ -38,7 +38,7 @@ var r = foo({ a: moduleA });
 >foo({ a: moduleA }) : { a: typeof moduleA; }
 > : ^^^^^^^^^^^^^^^^^^^^^^
 >foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^
 >{ a: moduleA } : { a: typeof moduleA; }
 > : ^^^^^^^^^^^^^^^^^^^^^^
 >a : typeof moduleA
@@ -52,7 +52,7 @@ var r2 = foo({ a: <IHasVisualizationModel>null });
 >foo({ a: <IHasVisualizationModel>null }) : { a: IHasVisualizationModel; }
 > : ^^^^^ ^^^
 >foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^
 >{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
 > : ^^^^^ ^^^
 >a : IHasVisualizationModel

diff --git a/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.types b/tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.types
@@ -3,7 +3,7 @@
 === Class.ts ===
 import { Configurable } from "./Configurable"
 >Configurable : <T extends import("Configurable").Constructor<{}>>(base: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^
 
 export class HiddenClass {}
 >HiddenClass : HiddenClass
@@ -15,7 +15,7 @@ export class ActualClass extends Configurable(HiddenClass) {}
 >Configurable(HiddenClass) : HiddenClass
 > : ^^^^^^^^^^^
 >Configurable : <T extends import("Configurable").Constructor<{}>>(base: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^ ^^ ^^^^^^
 >HiddenClass : typeof HiddenClass
 > : ^^^^^^^^^^^^^^^^^^
 
@@ -30,7 +30,7 @@ export type Constructor<T> = {
 }
 export function Configurable<T extends Constructor<{}>>(base: T): T {
 >Configurable : <T extends Constructor<{}>>(base: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ 
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ 
 >base : T
 > : ^
 

diff --git a/tests/baselines/reference/anonClassDeclarationEmitIsAnon.types b/tests/baselines/reference/anonClassDeclarationEmitIsAnon.types
@@ -29,8 +29,8 @@ export type Constructor<T = {}> = new (...args: any[]) => T;
 > : ^^^^^
 
 export function Timestamped<TBase extends Constructor>(Base: TBase) {
->Timestamped : <TBase extends Constructor<{}>>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Timestamped : <TBase extends Constructor>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
+> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Base : TBase
 > : ^^^^^
 
@@ -59,8 +59,8 @@ export function Timestamped<TBase extends Constructor>(Base: TBase) {
 import { wrapClass, Timestamped } from "./wrapClass";
 >wrapClass : (param: any) => typeof Wrapped
 > : ^ ^^ ^^^^^^^^^^^^^^^^^^^
->Timestamped : <TBase extends import("wrapClass").Constructor<{}>>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Timestamped : <TBase extends import("wrapClass").Constructor>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
+> : ^ ^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 export default wrapClass(0);
 >wrapClass(0) : typeof Wrapped
@@ -88,8 +88,8 @@ export class TimestampedUser extends Timestamped(User) {
 > : ^^^^^^^^^^^^^^^
 >Timestamped(User) : Timestamped<typeof User>.(Anonymous class) & User
 > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->Timestamped : <TBase extends import("wrapClass").Constructor<{}>>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Timestamped : <TBase extends import("wrapClass").Constructor>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
+> : ^ ^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >User : typeof User
 > : ^^^^^^^^^^^
 

diff --git a/tests/baselines/reference/anyAssignableToEveryType.types b/tests/baselines/reference/anyAssignableToEveryType.types
@@ -140,7 +140,7 @@ var q: String = a;
 
 function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
 >foo : <T, U, V extends Date>(x: T, y: U, z: V) => void
-> : ^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
+> : ^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
 >x : T
 > : ^
 >y : U

diff --git a/tests/baselines/reference/argumentsReferenceInFunction1_Js.types b/tests/baselines/reference/argumentsReferenceInFunction1_Js.types
@@ -93,11 +93,11 @@ const debuglog = function() {
 >format.apply(null, arguments) : string
 > : ^^^^^^
 >format.apply : { <T, R>(this: (this: T) => R, thisArg: T): R; <T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg: T, args: A): R; }
-> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^
+> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^
 >format : (f: any, ...args: any[]) => string
 > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >apply : { <T, R>(this: (this: T) => R, thisArg: T): R; <T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg: T, args: A): R; }
-> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^
+> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^
 >arguments : IArguments
 > : ^^^^^^^^^^
 

diff --git a/tests/baselines/reference/argumentsSpreadRestIterables(target=es5).types b/tests/baselines/reference/argumentsSpreadRestIterables(target=es5).types
@@ -59,7 +59,7 @@ declare const itNum: Iterable<number>
 
 declare function fn1<const T extends readonly unknown[]>(...args: T): T;
 >fn1 : <const T extends readonly unknown[]>(...args: T) => T
-> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ 
+> : ^^^^^^^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ 
 >args : T
 > : ^
 
@@ -69,7 +69,7 @@ const res1 = fn1(..."hello");
 >fn1(..."hello") : readonly any[]
 > : ^^^^^^^^^^^^^^
 >fn1 : <const T extends readonly unknown[]>(...args: T) => T
-> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^^^^^^^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^
 >..."hello" : any
 > : ^^^
 >"hello" : "hello"
@@ -81,7 +81,7 @@ const res2 = fn1(...itNum);
 >fn1(...itNum) : Iterable<number>
 > : ^^^^^^^^^^^^^^^^
 >fn1 : <const T extends readonly unknown[]>(...args: T) => T
-> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^^^^^^^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^
 >...itNum : Iterable<number>
 > : ^^^^^^^^^^^^^^^^
 >itNum : Iterable<number>
@@ -93,7 +93,7 @@ const res3 = fn1(true, ..."hello");
 >fn1(true, ..."hello") : readonly [true, ...any[]]
 > : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >fn1 : <const T extends readonly unknown[]>(...args: T) => T
-> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^^^^^^^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^
 >true : true
 > : ^^^^
 >..."hello" : any
@@ -107,7 +107,7 @@ const res4 = fn1(true, ...itNum);
 >fn1(true, ...itNum) : readonly [true, ...Iterable<number>[]]
 > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fn1 : <const T extends readonly unknown[]>(...args: T) => T
-> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^^^^^^^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^
 >true : true
 > : ^^^^
 >...itNum : Iterable<number>
@@ -118,7 +118,7 @@ const res4 = fn1(true, ...itNum);
 // repro from #52781
 declare function foo<T extends unknown[]>(...args: T): T;
 >foo : <T extends unknown[]>(...args: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ 
+> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ 
 >args : T
 > : ^
 
@@ -128,7 +128,7 @@ const p1 = foo(..."hello");
 >foo(..."hello") : any[]
 > : ^^^^^
 >foo : <T extends unknown[]>(...args: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^
 >..."hello" : any
 > : ^^^
 >"hello" : "hello"
@@ -140,7 +140,7 @@ const p2 = foo(...itNum);
 >foo(...itNum) : Iterable<number>
 > : ^^^^^^^^^^^^^^^^
 >foo : <T extends unknown[]>(...args: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^
 >...itNum : Iterable<number>
 > : ^^^^^^^^^^^^^^^^
 >itNum : Iterable<number>
@@ -152,7 +152,7 @@ const p3 = foo(true, ..."hello");
 >foo(true, ..."hello") : [boolean, ...any[]]
 > : ^^^^^^^^^^^^^^^^^^^
 >foo : <T extends unknown[]>(...args: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^
 >true : true
 > : ^^^^
 >..."hello" : any
@@ -166,7 +166,7 @@ const p4 = foo(true, ...itNum);
 >foo(true, ...itNum) : [boolean, ...Iterable<number>[]]
 > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >foo : <T extends unknown[]>(...args: T) => T
-> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
+> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^^
 >true : true
 > : ^^^^
 >...itNum : Iterable<number>