Reuse more input nodes when they contain local type parameter references

src/compiler/checker.ts

@@ -6620,8 +6620,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 }
                 if (
                     context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams &&
-                    type.flags & TypeFlags.TypeParameter &&
-                    !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)
+                    type.flags & TypeFlags.TypeParameter
                 ) {
                     const name = typeParameterToName(type, context);
                     context.approximateLength += idText(name).length;
@@ -7510,7 +7509,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 && signature.declaration
                 && signature.declaration !== context.enclosingDeclaration
                 && !isInJSFile(signature.declaration)
-                && some(expandedParams)
+                && (some(expandedParams) || some(signature.typeParameters))
             ) {
                 // As a performance optimization, reuse the same fake scope within this chain.
                 // This is especially needed when we are working on an excessively deep type;
@@ -7534,7 +7533,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const locals = existingFakeScope?.locals ?? createSymbolTable();
 
                 let newLocals: __String[] | undefined;
-                for (const param of expandedParams) {
+                for (const param of concatenate(expandedParams, map(signature.typeParameters, p => p.symbol))) {
                     if (!locals.has(param.escapedName)) {
                         newLocals = append(newLocals, param.escapedName);
                         locals.set(param.escapedName, param);
@@ -8149,7 +8148,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 // `i` we've used thus far, to save work later
                 (context.typeParameterNamesByTextNextNameCount ||= new Map()).set(rawtext, i);
                 (context.typeParameterNames ||= new Map()).set(getTypeId(type), result);
-                (context.typeParameterNamesByText ||= new Set()).add(rawtext);
+                (context.typeParameterNamesByText ||= new Set()).add(text);
             }
             return result;
         }
@@ -8407,8 +8406,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     includePrivateSymbol?.(sym);
                 }
                 if (isIdentifier(node)) {
-                    const type = getDeclaredTypeOfSymbol(sym);
-                    const name = sym.flags & SymbolFlags.TypeParameter && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : factory.cloneNode(node);
+                    const name = sym.flags & SymbolFlags.TypeParameter && context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams ? typeParameterToName(getDeclaredTypeOfSymbol(sym), context) : factory.cloneNode(node);
                     name.symbol = sym; // for quickinfo, which uses identifier symbol information
                     return { introducesError, node: setEmitFlags(setOriginalNode(name, node), EmitFlags.NoAsciiEscaping) };
                 }
@@ -8552,6 +8550,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     setEmitFlags(node, EmitFlags.SingleLine);
                 }
 
+                if (isTypeLiteralNode(node) && !(context.flags & NodeBuilderFlags.MultilineObjectLiterals)) {
+                    // always clone to add node builder format flags
+                    let visited = visitEachChild(node, visitExistingNodeTreeSymbols, nullTransformationContext);
+                    visited = visited === node ? factory.cloneNode(visited) : visited;
+                    setEmitFlags(visited, EmitFlags.SingleLine);
+                    return visited;
+                }
+
                 return visitEachChild(node, visitExistingNodeTreeSymbols, nullTransformationContext);
 
                 function getEffectiveDotDotDotForParameter(p: ParameterDeclaration) {

tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.types

@@ -13,7 +13,7 @@ module A {
     }
 
     export var UnitSquare : {
->UnitSquare : { top: {    left: Point;    right: Point;}; bottom: {    left: Point;    right: Point;}; }
+>UnitSquare : { top: { left: Point; right: Point; }; bottom: { left: Point; right: Point; }; }
 
         top: { left: Point, right: Point },
 >top : { left: Point; right: Point; }

tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.types

@@ -35,7 +35,7 @@ module A {
 
 === test.ts ===
 var fn: () => { x: number; y: number };
->fn : () => {    x: number;    y: number;}
+>fn : () => { x: number; y: number; }
 >x : number
 >y : number
 

tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.types

@@ -35,7 +35,7 @@ module B {
 
 === test.ts ===
 var fn: () => { x: number; y: number };
->fn : () => {    x: number;    y: number;}
+>fn : () => { x: number; y: number; }
 >x : number
 >y : number
 

tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.types

@@ -84,7 +84,7 @@ var p = Geometry.Origin;
 >Origin : A.Point
 
 var line: { start: { x: number; y: number }; end: { x: number; y: number; } };
->line : { start: {    x: number;    y: number;}; end: {    x: number;    y: number;}; }
+>line : { start: { x: number; y: number; }; end: { x: number; y: number; }; }
 >start : { x: number; y: number; }
 >x : number
 >y : number

tests/baselines/reference/accessorsOverrideProperty8.types

@@ -16,7 +16,7 @@ type AnyCtor<P extends object> = new (...a: any[]) => P
 >a : any[]
 
 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>;}
+>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
 >klass : AnyCtor<P>

tests/baselines/reference/aliasUsageInObjectLiteral.types

@@ -30,7 +30,7 @@ var b: { x: IHasVisualizationModel } = { x: moduleA };
 >moduleA : typeof moduleA
 
 var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
->c : { y: {    z: IHasVisualizationModel;}; }
+>c : { y: { z: IHasVisualizationModel; }; }
 >y : { z: IHasVisualizationModel; }
 >z : IHasVisualizationModel
 >{ y: { z: moduleA } } : { y: { z: typeof moduleA; }; }

tests/baselines/reference/anyAssignabilityInInheritance.types

@@ -85,7 +85,7 @@ var r3 = foo3(a); // any
 >a : any
 
 declare function foo7(x: { bar: number }): { bar: number };
->foo7 : { (x: {    bar: number;}): {    bar: number;}; (x: any): any; }
+>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
 >x : { bar: number; }
 >bar : number
 >bar : number

tests/baselines/reference/argumentExpressionContextualTyping.types

@@ -47,7 +47,7 @@ var o = { x: ["string", 1], y: { c: true, d: "world", e: 3 } };
 >3 : 3
 
 var o1: { x: [string, number], y: { c: boolean, d: string, e: number } } = { x: ["string", 1], y: { c: true, d: "world", e: 3 } };
->o1 : { x: [string, number]; y: {    c: boolean;    d: string;    e: number;}; }
+>o1 : { x: [string, number]; y: { c: boolean; d: string; e: number; }; }
 >x : [string, number]
 >y : { c: boolean; d: string; e: number; }
 >c : boolean

tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types

@@ -58,28 +58,28 @@ var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
 >1 : 1
 
 var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2]; // (a: { x: number; y?: number }) => number[]
->fs : (((a: {    x: number;    y?: number;}) => number) | ((b: {    x: number;    z?: number;}) => number))[]
->[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : (((a: {    x: number;    y?: number;}) => number) | ((b: {    x: number;    z?: number;}) => number))[]
->(a: { x: number; y?: number }) => 1 : (a: {    x: number;    y?: number;}) => number
+>fs : (((a: { x: number; y?: number; }) => number) | ((b: { x: number; z?: number; }) => number))[]
+>[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : (((a: { x: number; y?: number; }) => number) | ((b: { x: number; z?: number; }) => number))[]
+>(a: { x: number; y?: number }) => 1 : (a: { x: number; y?: number; }) => number
 >a : { x: number; y?: number; }
 >x : number
 >y : number
 >1 : 1
->(b: { x: number; z?: number }) => 2 : (b: {    x: number;    z?: number;}) => number
+>(b: { x: number; z?: number }) => 2 : (b: { x: number; z?: number; }) => number
 >b : { x: number; z?: number; }
 >x : number
 >z : number
 >2 : 2
 
 var gs = [(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1]; // (b: { x: number; z?: number }) => number[]
->gs : (((b: {    x: number;    z?: number;}) => number) | ((a: {    x: number;    y?: number;}) => number))[]
->[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : (((b: {    x: number;    z?: number;}) => number) | ((a: {    x: number;    y?: number;}) => number))[]
->(b: { x: number; z?: number }) => 2 : (b: {    x: number;    z?: number;}) => number
+>gs : (((b: { x: number; z?: number; }) => number) | ((a: { x: number; y?: number; }) => number))[]
+>[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : (((b: { x: number; z?: number; }) => number) | ((a: { x: number; y?: number; }) => number))[]
+>(b: { x: number; z?: number }) => 2 : (b: { x: number; z?: number; }) => number
 >b : { x: number; z?: number; }
 >x : number
 >z : number
 >2 : 2
->(a: { x: number; y?: number }) => 1 : (a: {    x: number;    y?: number;}) => number
+>(a: { x: number; y?: number }) => 1 : (a: { x: number; y?: number; }) => number
 >a : { x: number; y?: number; }
 >x : number
 >y : number

tests/baselines/reference/arraySigChecking.types

@@ -52,7 +52,7 @@ myArray = [[1, 2]];
 >2 : 2
 
 function isEmpty(l: { length: number }) {
->isEmpty : (l: {    length: number;}) => boolean
+>isEmpty : (l: { length: number; }) => boolean
 >l : { length: number; }
 >length : number
 

tests/baselines/reference/assignmentCompatBug5.types

@@ -2,7 +2,7 @@
 
 === assignmentCompatBug5.ts ===
 function foo1(x: { a: number; }) { }
->foo1 : (x: {    a: number;}) => void
+>foo1 : (x: { a: number; }) => void
 >x : { a: number; }
 >a : number
 

tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.types

@@ -2,7 +2,7 @@
 
 === assignmentCompatFunctionsWithOptionalArgs.ts ===
 function foo(x: { id: number; name?: string; }): void;
->foo : (x: {    id: number;    name?: string;}) => void
+>foo : (x: { id: number; name?: string; }) => void
 >x : { id: number; name?: string; }
 >id : number
 >name : string

tests/baselines/reference/assignmentCompatOnNew.types

@@ -5,7 +5,7 @@ class Foo{};
 >Foo : Foo
 
 function bar(x: {new(): Foo;}){}
->bar : (x: {    new (): Foo;}) => void
+>bar : (x: { new (): Foo; }) => void
 >x : new () => Foo
 
 bar(Foo); // Error, but should be allowed

tests/baselines/reference/assignmentCompatWithCallSignatures3.types

@@ -76,7 +76,7 @@ var a10: (...x: Derived[]) => Derived;
 >x : Derived[]
 
 var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
->a11 : (x: {    foo: string;}, y: {    foo: string;    bar: string;}) => Base
+>a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >x : { foo: string; }
 >foo : string
 >y : { foo: string; bar: string; }
@@ -94,7 +94,7 @@ var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >y : Derived[]
 
 var a14: (x: { a: string; b: number }) => Object;
->a14 : (x: {    a: string;    b: number;}) => Object
+>a14 : (x: { a: string; b: number; }) => Object
 >x : { a: string; b: number; }
 >a : string
 >b : number
@@ -276,10 +276,10 @@ b8 = a8; // ok
 >a8 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 
 var b9: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => U; 
->b9 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: {    foo: string;    bing: number;}) => U) => (r: T) => U
+>b9 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
 >x : (arg: T) => U
 >arg : T
->y : (arg2: {    foo: string;    bing: number;}) => U
+>y : (arg2: { foo: string; bing: number; }) => U
 >arg2 : { foo: string; bing: number; }
 >foo : string
 >bing : number

tests/baselines/reference/assignmentCompatWithCallSignatures4.types

@@ -52,7 +52,7 @@ module Errors {
 >x : Base[]
 
         var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
->a11 : (x: {    foo: string;}, y: {    foo: string;    bar: string;}) => Base
+>a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >x : { foo: string; }
 >foo : string
 >y : { foo: string; bar: string; }
@@ -75,7 +75,7 @@ module Errors {
 
             };
         var a15: (x: { a: string; b: number }) => number;
->a15 : (x: {    a: string;    b: number;}) => number
+>a15 : (x: { a: string; b: number; }) => number
 >x : { a: string; b: number; }
 >a : string
 >b : number
@@ -160,10 +160,10 @@ module Errors {
 >a7 : (x: (arg: Base) => Derived) => (r: Base) => Derived2
 
         var b8: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; 
->b8 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: {    foo: number;}) => U) => (r: T) => U
+>b8 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
 >x : (arg: T) => U
 >arg : T
->y : (arg2: {    foo: number;}) => U
+>y : (arg2: { foo: number; }) => U
 >arg2 : { foo: number; }
 >foo : number
 >r : T

tests/baselines/reference/assignmentCompatWithConstructSignatures3.types

@@ -76,7 +76,7 @@ var a10: new (...x: Derived[]) => Derived;
 >x : Derived[]
 
 var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
->a11 : new (x: {    foo: string;}, y: {    foo: string;    bar: string;}) => Base
+>a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >x : { foo: string; }
 >foo : string
 >y : { foo: string; bar: string; }
@@ -94,7 +94,7 @@ var a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >y : Derived[]
 
 var a14: new (x: { a: string; b: number }) => Object;
->a14 : new (x: {    a: string;    b: number;}) => Object
+>a14 : new (x: { a: string; b: number; }) => Object
 >x : { a: string; b: number; }
 >a : string
 >b : number
@@ -276,10 +276,10 @@ b8 = a8; // ok
 >a8 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 
 var b9: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => U; 
->b9 : new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: {    foo: string;    bing: number;}) => U) => (r: T) => U
+>b9 : new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
 >x : (arg: T) => U
 >arg : T
->y : (arg2: {    foo: string;    bing: number;}) => U
+>y : (arg2: { foo: string; bing: number; }) => U
 >arg2 : { foo: string; bing: number; }
 >foo : string
 >bing : number

tests/baselines/reference/assignmentCompatWithConstructSignatures4.types

@@ -52,7 +52,7 @@ module Errors {
 >x : Base[]
 
         var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
->a11 : new (x: {    foo: string;}, y: {    foo: string;    bar: string;}) => Base
+>a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >x : { foo: string; }
 >foo : string
 >y : { foo: string; bar: string; }
@@ -75,7 +75,7 @@ module Errors {
 
             };
         var a15: new (x: { a: string; b: number }) => number;
->a15 : new (x: {    a: string;    b: number;}) => number
+>a15 : new (x: { a: string; b: number; }) => number
 >x : { a: string; b: number; }
 >a : string
 >b : number
@@ -160,10 +160,10 @@ module Errors {
 >a7 : new (x: (arg: Base) => Derived) => (r: Base) => Derived2
 
         var b8: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; 
->b8 : new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: {    foo: number;}) => U) => (r: T) => U
+>b8 : new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
 >x : (arg: T) => U
 >arg : T
->y : (arg2: {    foo: number;}) => U
+>y : (arg2: { foo: number; }) => U
 >arg2 : { foo: number; }
 >foo : number
 >r : T

tests/baselines/reference/assignmentToParenthesizedIdentifiers.types

@@ -186,7 +186,7 @@ fn = () => 3; // Bug 823548: Should be error (fn is not a reference)
 >3 : 3
 
 function fn2(x: number, y: { t: number }) {
->fn2 : (x: number, y: {    t: number;}) => void
+>fn2 : (x: number, y: { t: number; }) => void
 >x : number
 >y : { t: number; }
 >t : number

tests/baselines/reference/asyncFunctionReturnExpressionErrorSpans.types

@@ -3,10 +3,10 @@
 === asyncFunctionReturnExpressionErrorSpans.ts ===
 interface Foo {
     bar: {
->bar : { baz: {    inner: {        thing: string;    };}; }
+>bar : { baz: { inner: { thing: string; }; }; }
 
         baz: {
->baz : { inner: {    thing: string;}; }
+>baz : { inner: { thing: string; }; }
 
             inner: {
 >inner : { thing: string; }

tests/baselines/reference/awaitUnionPromise.types

@@ -17,7 +17,7 @@ interface IAsyncEnumerator<T> {
 >next3 : () => Promise<T | {}>
 
     next4(): Promise<T | { x: string }>;
->next4 : () => Promise<T | {    x: string;}>
+>next4 : () => Promise<T | { x: string; }>
 >x : string
 }
 

tests/baselines/reference/callChain.2.types

@@ -19,8 +19,8 @@ o2?.b();
 >b : () => number
 
 declare const o3: { b: (() => { c: string }) | undefined };
->o3 : { b: (() => {    c: string;}) | undefined; }
->b : () => {    c: string;}
+>o3 : { b: (() => { c: string; }) | undefined; }
+>b : () => { c: string; }
 >c : string
 
 o3.b?.().c;

tests/baselines/reference/callChain.3.types

@@ -6,7 +6,7 @@ declare function absorb<T>(): T;
 
 declare const a: { m?<T>(obj: {x: T}): T } | undefined;
 >a : { m?<T>(obj: { x: T; }): T; } | undefined
->m : (<T>(obj: {    x: T;}) => T) | undefined
+>m : (<T>(obj: { x: T; }) => T) | undefined
 >obj : { x: T; }
 >x : T
 

tests/baselines/reference/callChain.types

@@ -108,8 +108,8 @@ o2?.["b"](1, ...[2, 3], 4);
 >4 : 4
 
 declare const o3: { b: ((...args: any[]) => { c: string }) | undefined };
->o3 : { b: ((...args: any[]) => {    c: string;}) | undefined; }
->b : ((...args: any[]) => {    c: string;}) | undefined
+>o3 : { b: ((...args: any[]) => { c: string; }) | undefined; }
+>b : ((...args: any[]) => { c: string; }) | undefined
 >args : any[]
 >c : string