Apply same single-line style to copied nodes as manufactured ones (#57890)

Co-authored-by: TypeScript Bot <[email protected]>

Author: weswigham

src/compiler/checker.ts

@@ -272,6 +272,7 @@ import {
     getEffectiveTypeParameterDeclarations,
     getElementOrPropertyAccessName,
     getEmitDeclarations,
+    getEmitFlags,
     getEmitModuleKind,
     getEmitModuleResolutionKind,
     getEmitScriptTarget,
@@ -632,6 +633,7 @@ import {
     isLiteralTypeNode,
     isLogicalOrCoalescingBinaryExpression,
     isLogicalOrCoalescingBinaryOperator,
+    isMappedTypeNode,
     isMetaProperty,
     isMethodDeclaration,
     isMethodSignature,
@@ -8620,7 +8622,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 cancellationToken.throwIfCancellationRequested();
             }
             let hadError = false;
-            const file = getSourceFileOfNode(existing);
             const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode);
             if (hadError) {
                 return undefined;
@@ -8756,8 +8757,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     }
                 }
 
-                if (file && isTupleTypeNode(node) && !nodeIsSynthesized(node) && (getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line)) {
-                    setEmitFlags(node, EmitFlags.SingleLine);
+                if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
+                    const visited = visitEachChild(node, visitExistingNodeTreeSymbols, /*context*/ undefined);
+                    const clone = setTextRange(visited === node ? factory.cloneNode(node) : visited, node);
+                    const flags = getEmitFlags(clone);
+                    setEmitFlags(clone, flags | (context.flags & NodeBuilderFlags.MultilineObjectLiterals && isTypeLiteralNode(node) ? 0 : EmitFlags.SingleLine));
+                    return clone;
                 }
 
                 return visitEachChild(node, visitExistingNodeTreeSymbols, /*context*/ undefined);

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/annotatedThisPropertyInitializerDoesntNarrow.types

@@ -4,7 +4,7 @@
 // from webpack/lib/Compilation.js and filed at #26427
 /** @param {{ [s: string]: number }} map */
 function mappy(map) {}
->mappy : (map: {    [s: string]: number;}) => void
+>mappy : (map: { [s: string]: number; }) => void
 >map : { [s: string]: number; }
 
 export class C {

tests/baselines/reference/anonterface.types

@@ -8,7 +8,7 @@ module M {
 >C : C
 
         m(fn:{ (n:number):string; },n2:number):string {
->m : (fn: {    (n: number): string;}, n2: number) => string
+>m : (fn: { (n: number): string; }, n2: number) => string
 >fn : (n: number) => string
 >n : number
 >n2 : number

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/arrayLiteralContextualType.types

@@ -35,7 +35,7 @@ function foo(animals: IAnimal[]) { }
 >animals : IAnimal[]
 
 function bar(animals: { [n: number]: IAnimal }) { }
->bar : (animals: {    [n: number]: IAnimal;}) => void
+>bar : (animals: { [n: number]: IAnimal; }) => void
 >animals : { [n: number]: IAnimal; }
 >n : number
 

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
@@ -130,7 +130,7 @@ var a17: {
 
 };
 var a18: {
->a18 : { (x: {    (a: number): number;    (a: string): string;}): any[]; (x: {    (a: boolean): boolean;    (a: Date): Date;}): any[]; }
+>a18 : { (x: { (a: number): number; (a: string): string; }): any[]; (x: { (a: boolean): boolean; (a: Date): Date; }): any[]; }
 
     (x: {
 >x : { (a: number): number; (a: string): string; }
@@ -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
@@ -355,7 +355,7 @@ b13 = a13; // ok
 >a13 : (x: Base[], y: Derived[]) => Derived[]
 
 var b14: <T>(x: { a: T; b: T }) => T; 
->b14 : <T>(x: {    a: T;    b: T;}) => T
+>b14 : <T>(x: { a: T; b: T; }) => T
 >x : { a: T; b: T; }
 >a : T
 >b : T

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,13 +75,13 @@ 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
 
         var a16: {
->a16 : { (x: {    (a: number): number;    (a?: number): number;}): number[]; (x: {    (a: boolean): boolean;    (a?: boolean): boolean;}): boolean[]; }
+>a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; }
 
                 (x: {
 >x : { (a: number): number; (a?: number): 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
@@ -224,7 +224,7 @@ module Errors {
 >a12 : (x: Base[], y: Derived2[]) => Derived[]
 
         var b15: <T>(x: { a: T; b: T }) => T; 
->b15 : <T>(x: {    a: T;    b: T;}) => T
+>b15 : <T>(x: { a: T; b: T; }) => T
 >x : { a: T; b: T; }
 >a : T
 >b : T
@@ -240,7 +240,7 @@ module Errors {
 >a15 : (x: { a: string; b: number; }) => number
 
         var b15a: <T extends Base>(x: { a: T; b: T }) => number; 
->b15a : <T extends Base>(x: {    a: T;    b: T;}) => number
+>b15a : <T extends Base>(x: { a: T; b: T; }) => number
 >x : { a: T; b: T; }
 >a : T
 >b : T

tests/baselines/reference/assignmentCompatWithCallSignatures5.types

@@ -50,21 +50,21 @@ var a6: <T extends Base>(x: (arg: T) => Derived) => T;
 >arg : T
 
 var a11: <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
->a11 : <T>(x: {    foo: T;}, y: {    foo: T;    bar: T;}) => Base
+>a11 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 >x : { foo: T; }
 >foo : T
 >y : { foo: T; bar: T; }
 >foo : T
 >bar : T
 
 var a15: <T>(x: { a: T; b: T }) => T[];
->a15 : <T>(x: {    a: T;    b: T;}) => T[]
+>a15 : <T>(x: { a: T; b: T; }) => T[]
 >x : { a: T; b: T; }
 >a : T
 >b : T
 
 var a16: <T extends Base>(x: { a: T; b: T }) => T[];
->a16 : <T extends Base>(x: {    a: T;    b: T;}) => T[]
+>a16 : <T extends Base>(x: { a: T; b: T; }) => T[]
 >x : { a: T; b: T; }
 >a : T
 >b : T
@@ -194,7 +194,7 @@ b6 = a6; // ok
 >a6 : <T extends Base>(x: (arg: T) => Derived) => T
 
 var b11: <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base; 
->b11 : <T, U>(x: {    foo: T;}, y: {    foo: U;    bar: U;}) => Base
+>b11 : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 >x : { foo: T; }
 >foo : T
 >y : { foo: U; bar: U; }
@@ -212,7 +212,7 @@ b11 = a11; // ok
 >a11 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 
 var b15: <U, V>(x: { a: U; b: V; }) => U[]; 
->b15 : <U, V>(x: {    a: U;    b: V;}) => U[]
+>b15 : <U, V>(x: { a: U; b: V; }) => U[]
 >x : { a: U; b: V; }
 >a : U
 >b : V
@@ -228,7 +228,7 @@ b15 = a15; // ok
 >a15 : <T>(x: { a: T; b: T; }) => T[]
 
 var b16: <T>(x: { a: T; b: T }) => T[]; 
->b16 : <T>(x: {    a: T;    b: T;}) => T[]
+>b16 : <T>(x: { a: T; b: T; }) => T[]
 >x : { a: T; b: T; }
 >a : T
 >b : T