Reuse input type nodes when serializing signature parameter and return types (#37444)

* Accept change

* Accept the huge set of ever so slightly changed baselines

* Update return type logic to only reuse nodes if original nodes share scope with current node, like property types, only reuse nodes if symbols referened are acessible, reuse nodes for property signatures, too

* Only reuse nodes when a context is provided (otherwise identifier printback may fail)

* Only track symbol if symbol is found and no error is recorded

* Fix type parameter reuse lookup

* Forbid cjs module.exports references in retained nodes

* Adjust check for cjs export references to not include bad module type in output

* Add symbol to all identifiers we see in existing nodes for quickinfo

* Accept fourslash baseline updates

* Accept slightly updated baseline post-merge

* Do not copy original nodes for error types, replace empty type references with any

Author: weswigham

src/compiler/checker.ts

@@ -2114,10 +2114,13 @@ namespace ts {
         return isIdentifier(node) && node.escapedText === "exports";
     }
 
+    export function isModuleIdentifier(node: Node) {
+        return isIdentifier(node) && node.escapedText === "module";
+    }
+
     export function isModuleExportsAccessExpression(node: Node): node is LiteralLikeElementAccessExpression & { expression: Identifier } {
         return (isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node))
-            && isIdentifier(node.expression)
-            && node.expression.escapedText === "module"
+            && isModuleIdentifier(node.expression)
             && getElementOrPropertyAccessName(node) === "exports";
     }
 

src/compiler/utilities.ts

@@ -1884,7 +1884,7 @@ interface Array<T> {
 >n : number
 }
 declare var Array: {
->Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: Array<any>; }
 
     new (arrayLength?: number): any[];
 >arrayLength : number

tests/baselines/reference/1.0lib-noErrors.types

@@ -11,7 +11,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/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.types

@@ -33,7 +33,7 @@ module A {
 
 === tests/cases/conformance/internalModules/DeclarationMerging/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/FunctionAndModuleWithSameNameAndCommonRoot.types

@@ -33,7 +33,7 @@ module B {
 
 === tests/cases/conformance/internalModules/DeclarationMerging/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

@@ -82,7 +82,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/ModuleWithExportedAndNonExportedImportAlias.types

@@ -6,7 +6,7 @@ enum Color { R, G, B }
 >B : Color.B
 
 function f1(x: Color | string) {
->f1 : (x: string | Color) => void
+>f1 : (x: Color | string) => void
 >x : string | Color
 
     if (typeof x === "number") {
@@ -33,7 +33,7 @@ function f1(x: Color | string) {
 }
 
 function f2(x: Color | string | string[]) {
->f2 : (x: string | Color | string[]) => void
+>f2 : (x: Color | string | string[]) => void
 >x : string | Color | string[]
 
     if (typeof x === "object") {

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -28,7 +28,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/aliasUsageInObjectLiteral.types

@@ -10,7 +10,7 @@ declare function fn(x: number): string;
 >x : number
 
 declare function fn(x: 'foo'): number;
->fn : { (x: number): string; (x: "foo"): number; }
+>fn : { (x: number): string; (x: 'foo'): number; }
 >x : "foo"
 
 // Ambient functions with duplicate signatures

tests/baselines/reference/ambientErrors.types

@@ -83,7 +83,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/anyAssignabilityInInheritance.types

@@ -45,7 +45,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/argumentExpressionContextualTyping.types

@@ -5,7 +5,7 @@ type Fn<T extends object> = <U extends T>(subj: U) => U
 >subj : U
 
 function doStuff<T extends object, T1 extends T>(a: Array<Fn<T>>, b: Array<Fn<T1>>) {
->doStuff : <T extends object, T1 extends T>(a: Fn<T>[], b: Fn<T1>[]) => void
+>doStuff : <T extends object, T1 extends T>(a: Array<Fn<T>>, b: Array<Fn<T1>>) => void
 >a : Fn<T>[]
 >b : Fn<T1>[]
 

tests/baselines/reference/arrayConcat3.types

@@ -12,14 +12,14 @@ array.flatMap((): ReadonlyArray<number> => []); // ok
 >array.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
 >array : number[]
 >flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
->(): ReadonlyArray<number> => [] : () => readonly number[]
+>(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
 >[] : undefined[]
 
 readonlyArray.flatMap((): ReadonlyArray<number> => []); // ok
 >readonlyArray.flatMap((): ReadonlyArray<number> => []) : number[]
 >readonlyArray.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
 >readonlyArray : readonly number[]
 >flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
->(): ReadonlyArray<number> => [] : () => readonly number[]
+>(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
 >[] : undefined[]
 

tests/baselines/reference/arrayFlatMap.types

@@ -56,28 +56,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/arrayLiteralWithMultipleBestCommonTypes.types

@@ -50,7 +50,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/arraySigChecking.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/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/assignmentCompatBug5.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/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/assignmentCompatFunctionsWithOptionalArgs.types

@@ -3,7 +3,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/assignmentCompatOnNew.types

@@ -74,25 +74,25 @@ 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; }
 >foo : string
 >bar : string
 
 var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
->a12 : (x: Base[], y: Derived2[]) => Derived[]
+>a12 : (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
 >x : Base[]
 >y : Derived2[]
 
 var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
->a13 : (x: Base[], y: Derived[]) => Derived[]
+>a13 : (x: Array<Base>, y: Array<Derived>) => Array<Derived>
 >x : Base[]
 >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
@@ -274,10 +274,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
@@ -323,7 +323,7 @@ b11 = a11; // ok
 >a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
 var b12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
->b12 : <T extends Base[]>(x: Base[], y: T) => Derived[]
+>b12 : <T extends Base[]>(x: Array<Base>, y: T) => Array<Derived>
 >x : Base[]
 >y : T
 
@@ -338,7 +338,7 @@ b12 = a12; // ok
 >a12 : (x: Base[], y: Derived2[]) => Derived[]
 
 var b13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
->b13 : <T extends Derived[]>(x: Base[], y: T) => T
+>b13 : <T extends Derived[]>(x: Array<Base>, y: T) => T
 >x : Base[]
 >y : T
 

tests/baselines/reference/assignmentCompatWithCallSignatures3.types

@@ -50,15 +50,15 @@ 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; }
 >foo : string
 >bar : string
 
         var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
->a12 : (x: Base[], y: Derived2[]) => Derived[]
+>a12 : (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
 >x : Base[]
 >y : Derived2[]
 
@@ -73,7 +73,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
@@ -158,10 +158,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
@@ -207,7 +207,7 @@ module Errors {
 >a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
         var b12: <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T; 
->b12 : <T extends Derived2[]>(x: Base[], y: Base[]) => T
+>b12 : <T extends Derived2[]>(x: Array<Base>, y: Array<Base>) => T
 >x : Base[]
 >y : Base[]
 

tests/baselines/reference/assignmentCompatWithCallSignatures4.types

@@ -74,25 +74,25 @@ 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; }
 >foo : string
 >bar : string
 
 var a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
->a12 : new (x: Base[], y: Derived2[]) => Derived[]
+>a12 : new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
 >x : Base[]
 >y : Derived2[]
 
 var a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
->a13 : new (x: Base[], y: Derived[]) => Derived[]
+>a13 : new (x: Array<Base>, y: Array<Derived>) => Array<Derived>
 >x : Base[]
 >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
@@ -274,10 +274,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
@@ -323,7 +323,7 @@ b11 = a11; // ok
 >a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
 var b12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
->b12 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
+>b12 : new <T extends Base[]>(x: Array<Base>, y: T) => Array<Derived>
 >x : Base[]
 >y : T
 
@@ -338,7 +338,7 @@ b12 = a12; // ok
 >a12 : new (x: Base[], y: Derived2[]) => Derived[]
 
 var b13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
->b13 : new <T extends Derived[]>(x: Base[], y: T) => T
+>b13 : new <T extends Derived[]>(x: Array<Base>, y: T) => T
 >x : Base[]
 >y : T