More aggressive parens to match existing DT tests

Author: rbuckton

src/compiler/factory/nodeFactory.ts

@@ -44,6 +44,8 @@ namespace ts {
         const factory: NodeFactory = {
             get parenthesizer() { return parenthesizerRules(); },
             get converters() { return converters(); },
+            baseFactory,
+            flags,
             createNodeArray,
             createNumericLiteral,
             createBigIntLiteral,

src/compiler/factory/parenthesizerRules.ts

@@ -434,6 +434,7 @@ namespace ts {
         function parenthesizeConstituentTypeOfUnionType(type: TypeNode) {
             switch (type.kind) {
                 case SyntaxKind.UnionType: // Not strictly necessary, but a union containing a union should have been flattened
+                case SyntaxKind.IntersectionType: // Not strictly necessary, but makes generated output more readable and avoids breaks in DT tests
                     return factory.createParenthesizedType(type);
             }
             return parenthesizeCheckTypeOfConditionalType(type);
@@ -501,6 +502,7 @@ namespace ts {
             switch (type.kind) {
                 case SyntaxKind.InferType:
                 case SyntaxKind.TypeOperator:
+                case SyntaxKind.TypeQuery: // Not strictly necessary, but makes generated output more readable and avoids breaks in DT tests
                     return factory.createParenthesizedType(type);
             }
             return parenthesizeOperandOfTypeOperator(type);

src/compiler/types.ts

@@ -7158,6 +7158,8 @@ namespace ts {
     export interface NodeFactory {
         /* @internal */ readonly parenthesizer: ParenthesizerRules;
         /* @internal */ readonly converters: NodeConverters;
+        /* @internal */ readonly baseFactory: BaseNodeFactory;
+        /* @internal */ readonly flags: NodeFactoryFlags;
         createNodeArray<T extends Node>(elements?: readonly T[], hasTrailingComma?: boolean): NodeArray<T>;
 
         //

src/services/textChanges.ts

@@ -1123,8 +1123,17 @@ namespace ts.textChanges {
         return skipTrivia(s, 0) === s.length;
     }
 
+    // A transformation context that won't perform parenthesization, as some parenthesization rules
+    // are more aggressive than is strictly necessary.
+    const textChangesTransformationContext: TransformationContext = {
+        ...nullTransformationContext,
+        factory: createNodeFactory(
+            nullTransformationContext.factory.flags | NodeFactoryFlags.NoParenthesizerRules,
+            nullTransformationContext.factory.baseFactory),
+    };
+
     export function assignPositionsToNode(node: Node): Node {
-        const visited = visitEachChild(node, assignPositionsToNode, nullTransformationContext, assignPositionsToNodeArray, assignPositionsToNode);
+        const visited = visitEachChild(node, assignPositionsToNode, textChangesTransformationContext, assignPositionsToNodeArray, assignPositionsToNode);
         // create proxy node for non synthesized nodes
         const newNode = nodeIsSynthesized(visited) ? visited : Object.create(visited) as Node;
         setTextRangePosEnd(newNode, getPos(node), getEnd(node));

tests/baselines/reference/abstractClassUnionInstantiation.types

@@ -75,11 +75,11 @@ new cls3(); // should work
 
 [ConcreteA, ConcreteB].map(cls => new cls()); // should work
 >[ConcreteA, ConcreteB].map(cls => new cls()) : ConcreteA[]
->[ConcreteA, ConcreteB].map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: typeof ConcreteA[]) => U, thisArg?: any) => U[]
->[ConcreteA, ConcreteB] : typeof ConcreteA[]
+>[ConcreteA, ConcreteB].map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: (typeof ConcreteA)[]) => U, thisArg?: any) => U[]
+>[ConcreteA, ConcreteB] : (typeof ConcreteA)[]
 >ConcreteA : typeof ConcreteA
 >ConcreteB : typeof ConcreteB
->map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: typeof ConcreteA[]) => U, thisArg?: any) => U[]
+>map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: (typeof ConcreteA)[]) => U, thisArg?: any) => U[]
 >cls => new cls() : (cls: typeof ConcreteA) => ConcreteA
 >cls : typeof ConcreteA
 >new cls() : ConcreteA

tests/baselines/reference/aliasUsageInArray.types

@@ -15,13 +15,13 @@ interface IHasVisualizationModel {
 
 var xs: IHasVisualizationModel[] = [moduleA];
 >xs : IHasVisualizationModel[]
->[moduleA] : typeof moduleA[]
+>[moduleA] : (typeof moduleA)[]
 >moduleA : typeof moduleA
 
 var xs2: typeof moduleA[] = [moduleA];
->xs2 : typeof moduleA[]
+>xs2 : (typeof moduleA)[]
 >moduleA : typeof moduleA
->[moduleA] : typeof moduleA[]
+>[moduleA] : (typeof moduleA)[]
 >moduleA : typeof moduleA
 
 === tests/cases/compiler/aliasUsageInArray_backbone.ts ===

tests/baselines/reference/ambientConstLiterals.types

@@ -12,7 +12,7 @@ enum E { A, B, C, "non identifier" }
 >A : E.A
 >B : E.B
 >C : E.C
->"non identifier" : typeof E["non identifier"]
+>"non identifier" : (typeof E)["non identifier"]
 
 const c1 = "abc";
 >c1 : "abc"
@@ -54,8 +54,8 @@ const c8 = E.A;
 >A : E.A
 
 const c8b = E["non identifier"];
->c8b : typeof E["non identifier"]
->E["non identifier"] : typeof E["non identifier"]
+>c8b : (typeof E)["non identifier"]
+>E["non identifier"] : (typeof E)["non identifier"]
 >E : typeof E
 >"non identifier" : "non identifier"
 

tests/baselines/reference/arrayLiterals.types

@@ -65,14 +65,14 @@ var classArr = [new C(), new C()];
 >C : typeof C
 
 var classTypeArray = [C, C, C];
->classTypeArray : typeof C[]
->[C, C, C] : typeof C[]
+>classTypeArray : (typeof C)[]
+>[C, C, C] : (typeof C)[]
 >C : typeof C
 >C : typeof C
 >C : typeof C
 
 var classTypeArray: Array<typeof C>; // Should OK, not be a parse error
->classTypeArray : typeof C[]
+>classTypeArray : (typeof C)[]
 >C : typeof C
 
 // Contextual type C with numeric index signature makes array literal of EveryType E of type BCT(E,C)[]

tests/baselines/reference/arrayOfFunctionTypes3.types

@@ -22,16 +22,16 @@ class C {
 >foo : string
 }
 var y = [C, C];
->y : typeof C[]
->[C, C] : typeof C[]
+>y : (typeof C)[]
+>[C, C] : (typeof C)[]
 >C : typeof C
 >C : typeof C
 
 var r3 = new y[0]();
 >r3 : C
 >new y[0]() : C
 >y[0] : typeof C
->y : typeof C[]
+>y : (typeof C)[]
 >0 : 0
 
 var a: { (x: number): number; (x: string): string; };

tests/baselines/reference/bitwiseNotOperatorWithEnumType.types

@@ -5,7 +5,7 @@ enum ENUM1 { A, B, "" };
 >ENUM1 : ENUM1
 >A : ENUM1.A
 >B : ENUM1.B
->"" : typeof ENUM1[""]
+>"" : (typeof ENUM1)[""]
 
 // enum type var
 var ResultIsNumber1 = ~ENUM1;