diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index f4504e67646..0d46dac4dba 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1077,18 +1077,19 @@ module ts {
                 return writeSymbolName(symbol);
             }
 
-            function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, typeStack?: Type[]) {
-                return writeType(type, flags | TypeFormatFlags.WriteArrowStyleSignature);
+            function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, typeStack?: Type[]) {
+                var globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike;
+                return writeType(type, globalFlags);
 
                 function writeType(type: Type, flags: TypeFormatFlags) {
                     // Write undefined/null type as any
                     if (type.flags & TypeFlags.Intrinsic) {
                         // Special handling for unknown / resolving types, they should show up as any and not unknown or __resolving
-                        writer.writeKeyword(!(flags & TypeFormatFlags.WriteOwnNameForAnyLike) &&
+                        writer.writeKeyword(!(globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike) &&
                             (type.flags & TypeFlags.Any) ? "any" : (<IntrinsicType>type).intrinsicName);
                     }
                     else if (type.flags & TypeFlags.Reference) {
-                        writeTypeReference(<TypeReference>type);
+                        writeTypeReference(<TypeReference>type, flags);
                     }
                     else if (type.flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) {
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type);
@@ -1097,7 +1098,7 @@ module ts {
                         writeTupleType(<TupleType>type);
                     }
                     else if (type.flags & TypeFlags.Union) {
-                        writeUnionType(<UnionType>type);
+                        writeUnionType(<UnionType>type, flags);
                     }
                     else if (type.flags & TypeFlags.Anonymous) {
                         writeAnonymousType(<ObjectType>type, flags);
@@ -1125,17 +1126,13 @@ module ts {
                             writePunctuation(writer, union ? SyntaxKind.BarToken : SyntaxKind.CommaToken);
                             writeSpace(writer);
                         }
-                        // Don't output function type literals in unions because '() => string | () => number' would be parsed
-                        // as a function type that returns a union type. Instead output '{ (): string; } | { (): number; }'.
-                        writeType(types[i], union ? flags & ~TypeFormatFlags.WriteArrowStyleSignature : flags | TypeFormatFlags.WriteArrowStyleSignature);
+                        writeType(types[i], union ? TypeFormatFlags.InElementType : TypeFormatFlags.None);
                     }
                 }
 
-                function writeTypeReference(type: TypeReference) {
-                    if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType) && !(type.typeArguments[0].flags & TypeFlags.Union)) {
-                        // If we are writing array element type the arrow style signatures are not allowed as 
-                        // we need to surround it by curlies, e.g. { (): T; }[]; as () => T[] would mean something different
-                        writeType(type.typeArguments[0], flags & ~TypeFormatFlags.WriteArrowStyleSignature);
+                function writeTypeReference(type: TypeReference, flags: TypeFormatFlags) {
+                    if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
+                        writeType(type.typeArguments[0], TypeFormatFlags.InElementType);
                         writePunctuation(writer, SyntaxKind.OpenBracketToken);
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                     }
@@ -1153,8 +1150,14 @@ module ts {
                     writePunctuation(writer, SyntaxKind.CloseBracketToken);
                 }
 
-                function writeUnionType(type: UnionType) {
+                function writeUnionType(type: UnionType, flags: TypeFormatFlags) {
+                    if (flags & TypeFormatFlags.InElementType) {
+                        writePunctuation(writer, SyntaxKind.OpenParenToken);
+                    }
                     writeTypeList(type.types, /*union*/ true);
+                    if (flags & TypeFormatFlags.InElementType) {
+                        writePunctuation(writer, SyntaxKind.CloseParenToken);
+                    }
                 }
 
                 function writeAnonymousType(type: ObjectType, flags: TypeFormatFlags) {
@@ -1212,17 +1215,27 @@ module ts {
                             return;
                         }
 
-                        if (flags & TypeFormatFlags.WriteArrowStyleSignature) {
-                            if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
-                                buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, flags, typeStack);
-                                return;
+                        if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
+                            if (flags & TypeFormatFlags.InElementType) {
+                                writePunctuation(writer, SyntaxKind.OpenParenToken);
                             }
-                            if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
-                                writeKeyword(writer, SyntaxKind.NewKeyword);
-                                writeSpace(writer);
-                                buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, flags, typeStack);
-                                return;
+                            buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | TypeFormatFlags.WriteArrowStyleSignature , typeStack);
+                            if (flags & TypeFormatFlags.InElementType) {
+                                writePunctuation(writer, SyntaxKind.CloseParenToken);
                             }
+                            return;
+                        }
+                        if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
+                            if (flags & TypeFormatFlags.InElementType) {
+                                writePunctuation(writer, SyntaxKind.OpenParenToken);
+                            }
+                            writeKeyword(writer, SyntaxKind.NewKeyword);
+                            writeSpace(writer);
+                            buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | TypeFormatFlags.WriteArrowStyleSignature, typeStack);
+                            if (flags & TypeFormatFlags.InElementType) {
+                                writePunctuation(writer, SyntaxKind.CloseParenToken);
+                            }
+                            return;
                         }
                     }
 
@@ -1230,7 +1243,7 @@ module ts {
                     writer.writeLine();
                     writer.increaseIndent();
                     for (var i = 0; i < resolved.callSignatures.length; i++) {
-                        buildSignatureDisplay(resolved.callSignatures[i], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
+                        buildSignatureDisplay(resolved.callSignatures[i], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
@@ -1238,7 +1251,7 @@ module ts {
                         writeKeyword(writer, SyntaxKind.NewKeyword);
                         writeSpace(writer);
 
-                        buildSignatureDisplay(resolved.constructSignatures[i], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
+                        buildSignatureDisplay(resolved.constructSignatures[i], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
@@ -1252,7 +1265,7 @@ module ts {
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                         writePunctuation(writer, SyntaxKind.ColonToken);
                         writeSpace(writer);
-                        writeType(resolved.stringIndexType, flags | TypeFormatFlags.WriteArrowStyleSignature);
+                        writeType(resolved.stringIndexType, TypeFormatFlags.None);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
@@ -1266,7 +1279,7 @@ module ts {
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                         writePunctuation(writer, SyntaxKind.ColonToken);
                         writeSpace(writer);
-                        writeType(resolved.numberIndexType, flags | TypeFormatFlags.WriteArrowStyleSignature);
+                        writeType(resolved.numberIndexType, TypeFormatFlags.None);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
@@ -1280,7 +1293,7 @@ module ts {
                                 if (isOptionalProperty(p)) {
                                     writePunctuation(writer, SyntaxKind.QuestionToken);
                                 }
-                                buildSignatureDisplay(signatures[j], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
+                                buildSignatureDisplay(signatures[j], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
                                 writePunctuation(writer, SyntaxKind.SemicolonToken);
                                 writer.writeLine();
                             }
@@ -1292,7 +1305,7 @@ module ts {
                             }
                             writePunctuation(writer, SyntaxKind.ColonToken);
                             writeSpace(writer);
-                            writeType(t, flags | TypeFormatFlags.WriteArrowStyleSignature);
+                            writeType(t, TypeFormatFlags.None);
                             writePunctuation(writer, SyntaxKind.SemicolonToken);
                             writer.writeLine();
                         }
@@ -1335,7 +1348,7 @@ module ts {
                             writePunctuation(writer, SyntaxKind.CommaToken);
                             writeSpace(writer);
                         }
-                        buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, TypeFormatFlags.WriteArrowStyleSignature);
+                        buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, TypeFormatFlags.None);
                     }
                     writePunctuation(writer, SyntaxKind.GreaterThanToken);
                 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index f8dd211dad2..b078407f846 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -708,6 +708,7 @@ module ts {
         WriteArrowStyleSignature        = 0x00000008,  // Write arrow style signature
         WriteOwnNameForAnyLike          = 0x00000010,  // Write symbol's own name instead of 'any' for any like types (eg. unknown, __resolving__ etc)
         WriteTypeArgumentsOfSignature   = 0x00000020,  // Write the type arguments instead of type parameters of the signature
+        InElementType                   = 0x00000040,  // Writing an array or union element type
     }
 
     export enum SymbolFormatFlags {
diff --git a/tests/baselines/reference/arrayBestCommonTypes.types b/tests/baselines/reference/arrayBestCommonTypes.types
index c9d39d5c1e8..5e34380673d 100644
--- a/tests/baselines/reference/arrayBestCommonTypes.types
+++ b/tests/baselines/reference/arrayBestCommonTypes.types
@@ -557,7 +557,7 @@ module NonEmptyTypes {
 >x : string
 >y : base
 >base : base
->[{ x: undefined, y: new base() }, { x: '', y: new derived() }] : Array<{ x: undefined; y: base; } | { x: string; y: derived; }>
+>[{ x: undefined, y: new base() }, { x: '', y: new derived() }] : ({ x: undefined; y: base; } | { x: string; y: derived; })[]
 >{ x: undefined, y: new base() } : { x: undefined; y: base; }
 >x : undefined
 >undefined : undefined
diff --git a/tests/baselines/reference/arrayLiteralContextualType.types b/tests/baselines/reference/arrayLiteralContextualType.types
index 12d08e986f7..5797999b7df 100644
--- a/tests/baselines/reference/arrayLiteralContextualType.types
+++ b/tests/baselines/reference/arrayLiteralContextualType.types
@@ -40,7 +40,7 @@ function bar(animals: { [n: number]: IAnimal }) { }
 foo([
 >foo([    new Giraffe(),    new Elephant()]) : void
 >foo : (animals: IAnimal[]) => void
->[    new Giraffe(),    new Elephant()] : Array<Giraffe | Elephant>
+>[    new Giraffe(),    new Elephant()] : (Giraffe | Elephant)[]
 
     new Giraffe(),
 >new Giraffe() : Giraffe
@@ -54,7 +54,7 @@ foo([
 bar([
 >bar([    new Giraffe(),    new Elephant()]) : void
 >bar : (animals: { [x: number]: IAnimal; }) => void
->[    new Giraffe(),    new Elephant()] : Array<Giraffe | Elephant>
+>[    new Giraffe(),    new Elephant()] : (Giraffe | Elephant)[]
 
     new Giraffe(),
 >new Giraffe() : Giraffe
@@ -67,8 +67,8 @@ bar([
 ]); // Legal because of the contextual type IAnimal provided by the parameter
 
 var arr = [new Giraffe(), new Elephant()];
->arr : Array<Giraffe | Elephant>
->[new Giraffe(), new Elephant()] : Array<Giraffe | Elephant>
+>arr : (Giraffe | Elephant)[]
+>[new Giraffe(), new Elephant()] : (Giraffe | Elephant)[]
 >new Giraffe() : Giraffe
 >Giraffe : typeof Giraffe
 >new Elephant() : Elephant
@@ -77,10 +77,10 @@ var arr = [new Giraffe(), new Elephant()];
 foo(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
 >foo(arr) : void
 >foo : (animals: IAnimal[]) => void
->arr : Array<Giraffe | Elephant>
+>arr : (Giraffe | Elephant)[]
 
 bar(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
 >bar(arr) : void
 >bar : (animals: { [x: number]: IAnimal; }) => void
->arr : Array<Giraffe | Elephant>
+>arr : (Giraffe | Elephant)[]
 
diff --git a/tests/baselines/reference/arrayLiteralTypeInference.types b/tests/baselines/reference/arrayLiteralTypeInference.types
index c80e5e17030..adcc28c7440 100644
--- a/tests/baselines/reference/arrayLiteralTypeInference.types
+++ b/tests/baselines/reference/arrayLiteralTypeInference.types
@@ -25,7 +25,7 @@ class ActionB extends Action {
 var x1: Action[] = [
 >x1 : Action[]
 >Action : Action
->[    { id: 2, trueness: false },    { id: 3, name: "three" }] : Array<{ id: number; trueness: boolean; } | { id: number; name: string; }>
+>[    { id: 2, trueness: false },    { id: 3, name: "three" }] : ({ id: number; trueness: boolean; } | { id: number; name: string; })[]
 
     { id: 2, trueness: false },
 >{ id: 2, trueness: false } : { id: number; trueness: boolean; }
@@ -42,7 +42,7 @@ var x1: Action[] = [
 var x2: Action[] = [
 >x2 : Action[]
 >Action : Action
->[    new ActionA(),    new ActionB()] : Array<ActionA | ActionB>
+>[    new ActionA(),    new ActionB()] : (ActionA | ActionB)[]
 
     new ActionA(),
 >new ActionA() : ActionA
@@ -78,7 +78,7 @@ var z1: { id: number }[] =
 >id : number
 
     [
->[        { id: 2, trueness: false },        { id: 3, name: "three" }    ] : Array<{ id: number; trueness: boolean; } | { id: number; name: string; }>
+>[        { id: 2, trueness: false },        { id: 3, name: "three" }    ] : ({ id: number; trueness: boolean; } | { id: number; name: string; })[]
 
         { id: 2, trueness: false },
 >{ id: 2, trueness: false } : { id: number; trueness: boolean; }
@@ -97,7 +97,7 @@ var z2: { id: number }[] =
 >id : number
 
     [
->[        new ActionA(),        new ActionB()    ] : Array<ActionA | ActionB>
+>[        new ActionA(),        new ActionB()    ] : (ActionA | ActionB)[]
 
         new ActionA(),
 >new ActionA() : ActionA
diff --git a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
index 49b65a86aa6..d2ddfa56de9 100644
--- a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
+++ b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
@@ -36,8 +36,8 @@ var cs = [a, b, c]; // { x: number; y?: number };[]
 >c : { x: number; a?: number; }
 
 var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
->ds : { (x: Object): number; }[]
->[(x: Object) => 1, (x: string) => 2] : { (x: Object): number; }[]
+>ds : ((x: Object) => number)[]
+>[(x: Object) => 1, (x: string) => 2] : ((x: Object) => number)[]
 >(x: Object) => 1 : (x: Object) => number
 >x : Object
 >Object : Object
@@ -45,8 +45,8 @@ var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
 >x : string
 
 var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
->es : { (x: string): number; }[]
->[(x: string) => 2, (x: Object) => 1] : { (x: string): number; }[]
+>es : ((x: string) => number)[]
+>[(x: string) => 2, (x: Object) => 1] : ((x: string) => number)[]
 >(x: string) => 2 : (x: string) => number
 >x : string
 >(x: Object) => 1 : (x: Object) => number
@@ -54,8 +54,8 @@ var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
 >Object : Object
 
 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; }[]
->[(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)[]
+>[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : ((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
@@ -66,8 +66,8 @@ var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) =>
 >z : number
 
 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; }[]
->[(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)[]
+>[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : ((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
diff --git a/tests/baselines/reference/arrayLiterals.types b/tests/baselines/reference/arrayLiterals.types
index 8c2fd942c62..62475fa2b4a 100644
--- a/tests/baselines/reference/arrayLiterals.types
+++ b/tests/baselines/reference/arrayLiterals.types
@@ -2,15 +2,15 @@
 // Empty array literal with no contextual type has type Undefined[]
 
 var arr1= [[], [1], ['']];
->arr1 : Array<string[] | number[]>
->[[], [1], ['']] : Array<string[] | number[]>
+>arr1 : (string[] | number[])[]
+>[[], [1], ['']] : (string[] | number[])[]
 >[] : undefined[]
 >[1] : number[]
 >[''] : string[]
 
 var arr2 = [[null], [1], ['']];
->arr2 : Array<string[] | number[]>
->[[null], [1], ['']] : Array<string[] | number[]>
+>arr2 : (string[] | number[])[]
+>[[null], [1], ['']] : (string[] | number[])[]
 >[null] : null[]
 >[1] : number[]
 >[''] : string[]
@@ -65,7 +65,7 @@ var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '
 >n : number
 >a : string
 >b : number
->[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : Array<{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }>
+>[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]
 >{ a: '', b: 0, c: '' } : { a: string; b: number; c: string; }
 >a : string
 >b : number
@@ -76,8 +76,8 @@ var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '
 >c : number
 
 var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
->context2 : Array<{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }>
->[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : Array<{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }>
+>context2 : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]
+>[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]
 >{ a: '', b: 0, c: '' } : { a: string; b: number; c: string; }
 >a : string
 >b : number
@@ -105,7 +105,7 @@ class Derived2 extends Base { private n };
 var context3: Base[] = [new Derived1(), new Derived2()];
 >context3 : Base[]
 >Base : Base
->[new Derived1(), new Derived2()] : Array<Derived1 | Derived2>
+>[new Derived1(), new Derived2()] : (Derived1 | Derived2)[]
 >new Derived1() : Derived1
 >Derived1 : typeof Derived1
 >new Derived2() : Derived2
diff --git a/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types b/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
index e99ca18673e..1496e99adca 100644
--- a/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
+++ b/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
@@ -61,8 +61,8 @@ var xs = [list, myList]; // {}[]
 >myList : MyList<number>
 
 var ys = [list, list2]; // {}[]
->ys : Array<List<number> | List<string>>
->[list, list2] : Array<List<number> | List<string>>
+>ys : (List<number> | List<string>)[]
+>[list, list2] : (List<number> | List<string>)[]
 >list : List<number>
 >list2 : List<string>
 
diff --git a/tests/baselines/reference/arrayOfFunctionTypes3.types b/tests/baselines/reference/arrayOfFunctionTypes3.types
index b224ff881e3..3ef5334382c 100644
--- a/tests/baselines/reference/arrayOfFunctionTypes3.types
+++ b/tests/baselines/reference/arrayOfFunctionTypes3.types
@@ -2,8 +2,8 @@
 // valid uses of arrays of function types
 
 var x = [() => 1, () => { }];
->x : { (): void; }[]
->[() => 1, () => { }] : { (): void; }[]
+>x : (() => void)[]
+>[() => 1, () => { }] : (() => void)[]
 >() => 1 : () => number
 >() => { } : () => void
 
@@ -11,7 +11,7 @@ var r2 = x[0]();
 >r2 : void
 >x[0]() : void
 >x[0] : () => void
->x : { (): void; }[]
+>x : (() => void)[]
 
 class C {
 >C : C
diff --git a/tests/baselines/reference/bestCommonTypeOfTuple.types b/tests/baselines/reference/bestCommonTypeOfTuple.types
index 87624c267aa..0516fc4af2b 100644
--- a/tests/baselines/reference/bestCommonTypeOfTuple.types
+++ b/tests/baselines/reference/bestCommonTypeOfTuple.types
@@ -75,8 +75,8 @@ t4 = [E1.one, E2.two, 20];
 >two : E2
 
 var e1 = t1[2];  // {}
->e1 : { (x: number): string; } | { (x: number): number; }
->t1[2] : { (x: number): string; } | { (x: number): number; }
+>e1 : ((x: number) => string) | ((x: number) => number)
+>t1[2] : ((x: number) => string) | ((x: number) => number)
 >t1 : [(x: number) => string, (x: number) => number]
 
 var e2 = t2[2];  // {}
diff --git a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
index edef88acfc3..f925f7f1db6 100644
--- a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
+++ b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
@@ -169,7 +169,7 @@ var result10: (t: X) => any = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
 >result10 : (t: X) => any
 >t : X
 >X : X
->true ? (m) => m.propertyX1 : (n) => n.propertyX2 : { (m: X): number; } | { (n: X): string; }
+>true ? (m) => m.propertyX1 : (n) => n.propertyX2 : ((m: X) => number) | ((n: X) => string)
 >(m) => m.propertyX1 : (m: X) => number
 >m : X
 >m.propertyX1 : number
diff --git a/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.errors.txt b/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.errors.txt
index fb2c02d1c28..b1dd23fc3e3 100644
--- a/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.errors.txt
+++ b/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.errors.txt
@@ -4,13 +4,13 @@ tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithou
 tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(16,5): error TS2322: Type 'A | B' is not assignable to type 'B':
   Type 'A' is not assignable to type 'B':
     Property 'propertyB' is missing in type 'A'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(18,5): error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => number':
+tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(18,5): error TS2322: Type '((m: X) => number) | ((n: X) => string)' is not assignable to type '(t: X) => number':
   Type '(n: X) => string' is not assignable to type '(t: X) => number':
     Type 'string' is not assignable to type 'number'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(19,5): error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => string':
+tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(19,5): error TS2322: Type '((m: X) => number) | ((n: X) => string)' is not assignable to type '(t: X) => string':
   Type '(m: X) => number' is not assignable to type '(t: X) => string':
     Type 'number' is not assignable to type 'string'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(20,5): error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => boolean':
+tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(20,5): error TS2322: Type '((m: X) => number) | ((n: X) => string)' is not assignable to type '(t: X) => boolean':
   Type '(m: X) => number' is not assignable to type '(t: X) => boolean':
     Type 'number' is not assignable to type 'boolean'.
 
@@ -43,16 +43,16 @@ tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithou
     
     var result4: (t: X) => number = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
         ~~~~~~~
-!!! error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => number':
+!!! error TS2322: Type '((m: X) => number) | ((n: X) => string)' is not assignable to type '(t: X) => number':
 !!! error TS2322:   Type '(n: X) => string' is not assignable to type '(t: X) => number':
 !!! error TS2322:     Type 'string' is not assignable to type 'number'.
     var result5: (t: X) => string = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
         ~~~~~~~
-!!! error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => string':
+!!! error TS2322: Type '((m: X) => number) | ((n: X) => string)' is not assignable to type '(t: X) => string':
 !!! error TS2322:   Type '(m: X) => number' is not assignable to type '(t: X) => string':
 !!! error TS2322:     Type 'number' is not assignable to type 'string'.
     var result6: (t: X) => boolean = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
         ~~~~~~~
-!!! error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => boolean':
+!!! error TS2322: Type '((m: X) => number) | ((n: X) => string)' is not assignable to type '(t: X) => boolean':
 !!! error TS2322:   Type '(m: X) => number' is not assignable to type '(t: X) => boolean':
 !!! error TS2322:     Type 'number' is not assignable to type 'boolean'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping21.errors.txt b/tests/baselines/reference/contextualTyping21.errors.txt
index 620b0635d12..c6ca82d87ac 100644
--- a/tests/baselines/reference/contextualTyping21.errors.txt
+++ b/tests/baselines/reference/contextualTyping21.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/contextualTyping21.ts(1,36): error TS2322: Type 'Array<number | { id: number; }>' is not assignable to type '{ id: number; }[]':
+tests/cases/compiler/contextualTyping21.ts(1,36): error TS2322: Type '(number | { id: number; })[]' is not assignable to type '{ id: number; }[]':
   Type 'number | { id: number; }' is not assignable to type '{ id: number; }':
     Type 'number' is not assignable to type '{ id: number; }':
       Property 'id' is missing in type 'Number'.
@@ -7,7 +7,7 @@ tests/cases/compiler/contextualTyping21.ts(1,36): error TS2322: Type 'Array<numb
 ==== tests/cases/compiler/contextualTyping21.ts (1 errors) ====
     var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, 1];
                                        ~~~
-!!! error TS2322: Type 'Array<number | { id: number; }>' is not assignable to type '{ id: number; }[]':
+!!! error TS2322: Type '(number | { id: number; })[]' is not assignable to type '{ id: number; }[]':
 !!! error TS2322:   Type 'number | { id: number; }' is not assignable to type '{ id: number; }':
 !!! error TS2322:     Type 'number' is not assignable to type '{ id: number; }':
 !!! error TS2322:       Property 'id' is missing in type 'Number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping30.errors.txt b/tests/baselines/reference/contextualTyping30.errors.txt
index 4c8d87d41b6..f7a9eeead35 100644
--- a/tests/baselines/reference/contextualTyping30.errors.txt
+++ b/tests/baselines/reference/contextualTyping30.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/contextualTyping30.ts(1,37): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+tests/cases/compiler/contextualTyping30.ts(1,37): error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
   Type 'string | number' is not assignable to type 'number':
     Type 'string' is not assignable to type 'number'.
 
@@ -6,6 +6,6 @@ tests/cases/compiler/contextualTyping30.ts(1,37): error TS2345: Argument of type
 ==== tests/cases/compiler/contextualTyping30.ts (1 errors) ====
     function foo(param:number[]){}; foo([1, "a"]);
                                         ~~~~~~~~
-!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+!!! error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
 !!! error TS2345:   Type 'string | number' is not assignable to type 'number':
 !!! error TS2345:     Type 'string' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping32.types b/tests/baselines/reference/contextualTyping32.types
index 383615aec3c..c273be967e3 100644
--- a/tests/baselines/reference/contextualTyping32.types
+++ b/tests/baselines/reference/contextualTyping32.types
@@ -5,7 +5,7 @@ function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){ret
 >i : number
 >foo([function(){return 1;}, function(){return 4}]) : void
 >foo : (param: { (): number; (i: number): number; }[]) => void
->[function(){return 1;}, function(){return 4}] : { (): number; }[]
+>[function(){return 1;}, function(){return 4}] : (() => number)[]
 >function(){return 1;} : () => number
 >function(){return 4} : () => number
 
diff --git a/tests/baselines/reference/contextualTyping33.errors.txt b/tests/baselines/reference/contextualTyping33.errors.txt
index 82799037ec6..4aafb6d9645 100644
--- a/tests/baselines/reference/contextualTyping33.errors.txt
+++ b/tests/baselines/reference/contextualTyping33.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/compiler/contextualTyping33.ts(1,66): error TS2345: Argument of type 'Array<{ (): number; } | { (): string; }>' is not assignable to parameter of type '{ (): number; (i: number): number; }[]'.
-  Type '{ (): number; } | { (): string; }' is not assignable to type '{ (): number; (i: number): number; }':
+tests/cases/compiler/contextualTyping33.ts(1,66): error TS2345: Argument of type '((() => number) | (() => string))[]' is not assignable to parameter of type '{ (): number; (i: number): number; }[]'.
+  Type '(() => number) | (() => string)' is not assignable to type '{ (): number; (i: number): number; }':
     Type '() => string' is not assignable to type '{ (): number; (i: number): number; }'.
 
 
 ==== tests/cases/compiler/contextualTyping33.ts (1 errors) ====
     function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){return 1;}, function(){return "foo"}]);
                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type 'Array<{ (): number; } | { (): string; }>' is not assignable to parameter of type '{ (): number; (i: number): number; }[]'.
-!!! error TS2345:   Type '{ (): number; } | { (): string; }' is not assignable to type '{ (): number; (i: number): number; }':
+!!! error TS2345: Argument of type '((() => number) | (() => string))[]' is not assignable to parameter of type '{ (): number; (i: number): number; }[]'.
+!!! error TS2345:   Type '(() => number) | (() => string)' is not assignable to type '{ (): number; (i: number): number; }':
 !!! error TS2345:     Type '() => string' is not assignable to type '{ (): number; (i: number): number; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTypingArrayOfLambdas.types b/tests/baselines/reference/contextualTypingArrayOfLambdas.types
index f3bb8bab70f..d3e5b9942e3 100644
--- a/tests/baselines/reference/contextualTypingArrayOfLambdas.types
+++ b/tests/baselines/reference/contextualTypingArrayOfLambdas.types
@@ -23,8 +23,8 @@ class C extends A {
 }
 
 var xs = [(x: A) => { }, (x: B) => { }, (x: C) => { }];
->xs : { (x: A): void; }[]
->[(x: A) => { }, (x: B) => { }, (x: C) => { }] : { (x: A): void; }[]
+>xs : ((x: A) => void)[]
+>[(x: A) => { }, (x: B) => { }, (x: C) => { }] : ((x: A) => void)[]
 >(x: A) => { } : (x: A) => void
 >x : A
 >A : A
diff --git a/tests/baselines/reference/contextualTypingOfArrayLiterals1.errors.txt b/tests/baselines/reference/contextualTypingOfArrayLiterals1.errors.txt
index cb3b439681e..92b74829e55 100644
--- a/tests/baselines/reference/contextualTypingOfArrayLiterals1.errors.txt
+++ b/tests/baselines/reference/contextualTypingOfArrayLiterals1.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/contextualTypingOfArrayLiterals1.ts(5,5): error TS2322: Type 'Array<number | Date>' is not assignable to type 'I':
+tests/cases/compiler/contextualTypingOfArrayLiterals1.ts(5,5): error TS2322: Type '(number | Date)[]' is not assignable to type 'I':
   Index signatures are incompatible:
     Type 'number | Date' is not assignable to type 'Date':
       Type 'number' is not assignable to type 'Date':
@@ -12,7 +12,7 @@ tests/cases/compiler/contextualTypingOfArrayLiterals1.ts(5,5): error TS2322: Typ
     
     var x3: I = [new Date(), 1]; 
         ~~
-!!! error TS2322: Type 'Array<number | Date>' is not assignable to type 'I':
+!!! error TS2322: Type '(number | Date)[]' is not assignable to type 'I':
 !!! error TS2322:   Index signatures are incompatible:
 !!! error TS2322:     Type 'number | Date' is not assignable to type 'Date':
 !!! error TS2322:       Type 'number' is not assignable to type 'Date':
diff --git a/tests/baselines/reference/contextualTypingOfConditionalExpression2.errors.txt b/tests/baselines/reference/contextualTypingOfConditionalExpression2.errors.txt
index 574e25c6f45..3bcfb557048 100644
--- a/tests/baselines/reference/contextualTypingOfConditionalExpression2.errors.txt
+++ b/tests/baselines/reference/contextualTypingOfConditionalExpression2.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/contextualTypingOfConditionalExpression2.ts(11,5): error TS2322: Type '{ (a: C): number; } | { (b: number): void; }' is not assignable to type '(a: A) => void':
+tests/cases/compiler/contextualTypingOfConditionalExpression2.ts(11,5): error TS2322: Type '((a: C) => number) | ((b: number) => void)' is not assignable to type '(a: A) => void':
   Type '(b: number) => void' is not assignable to type '(a: A) => void':
     Types of parameters 'b' and 'a' are incompatible:
       Type 'number' is not assignable to type 'A':
@@ -18,7 +18,7 @@ tests/cases/compiler/contextualTypingOfConditionalExpression2.ts(11,5): error TS
     
     var x2: (a: A) => void = true ? (a: C) => a.foo : (b: number) => { };
         ~~
-!!! error TS2322: Type '{ (a: C): number; } | { (b: number): void; }' is not assignable to type '(a: A) => void':
+!!! error TS2322: Type '((a: C) => number) | ((b: number) => void)' is not assignable to type '(a: A) => void':
 !!! error TS2322:   Type '(b: number) => void' is not assignable to type '(a: A) => void':
 !!! error TS2322:     Types of parameters 'b' and 'a' are incompatible:
 !!! error TS2322:       Type 'number' is not assignable to type 'A':
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator.types b/tests/baselines/reference/contextuallyTypingOrOperator.types
index 4b47ea763bc..47b78f5691d 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator.types
+++ b/tests/baselines/reference/contextuallyTypingOrOperator.types
@@ -17,10 +17,10 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >s : string
 
 var v2 = (s: string) => s.length || function (s) { s.length };
->v2 : (s: string) => number | { (s: any): void; }
->(s: string) => s.length || function (s) { s.length } : (s: string) => number | { (s: any): void; }
+>v2 : (s: string) => number | ((s: any) => void)
+>(s: string) => s.length || function (s) { s.length } : (s: string) => number | ((s: any) => void)
 >s : string
->s.length || function (s) { s.length } : number | { (s: any): void; }
+>s.length || function (s) { s.length } : number | ((s: any) => void)
 >s.length : number
 >s : string
 >length : number
@@ -31,10 +31,10 @@ var v2 = (s: string) => s.length || function (s) { s.length };
 >length : any
 
 var v3 = (s: string) => s.length || function (s: number) { return 1 };
->v3 : (s: string) => number | { (s: number): number; }
->(s: string) => s.length || function (s: number) { return 1 } : (s: string) => number | { (s: number): number; }
+>v3 : (s: string) => number | ((s: number) => number)
+>(s: string) => s.length || function (s: number) { return 1 } : (s: string) => number | ((s: number) => number)
 >s : string
->s.length || function (s: number) { return 1 } : number | { (s: number): number; }
+>s.length || function (s: number) { return 1 } : number | ((s: number) => number)
 >s.length : number
 >s : string
 >length : number
@@ -42,10 +42,10 @@ var v3 = (s: string) => s.length || function (s: number) { return 1 };
 >s : number
 
 var v4 = (s: number) => 1 || function (s: string) { return s.length };
->v4 : (s: number) => number | { (s: string): number; }
->(s: number) => 1 || function (s: string) { return s.length } : (s: number) => number | { (s: string): number; }
+>v4 : (s: number) => number | ((s: string) => number)
+>(s: number) => 1 || function (s: string) { return s.length } : (s: number) => number | ((s: string) => number)
 >s : number
->1 || function (s: string) { return s.length } : number | { (s: string): number; }
+>1 || function (s: string) { return s.length } : number | ((s: string) => number)
 >function (s: string) { return s.length } : (s: string) => number
 >s : string
 >s.length : number
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator2.types b/tests/baselines/reference/contextuallyTypingOrOperator2.types
index c233066d6dc..65ed442d5e9 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator2.types
+++ b/tests/baselines/reference/contextuallyTypingOrOperator2.types
@@ -17,10 +17,10 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >s : string
 
 var v2 = (s: string) => s.length || function (s) { s.aaa };
->v2 : (s: string) => number | { (s: any): void; }
->(s: string) => s.length || function (s) { s.aaa } : (s: string) => number | { (s: any): void; }
+>v2 : (s: string) => number | ((s: any) => void)
+>(s: string) => s.length || function (s) { s.aaa } : (s: string) => number | ((s: any) => void)
 >s : string
->s.length || function (s) { s.aaa } : number | { (s: any): void; }
+>s.length || function (s) { s.aaa } : number | ((s: any) => void)
 >s.length : number
 >s : string
 >length : number
diff --git a/tests/baselines/reference/derivedTypeDoesNotRequireExtendsClause.types b/tests/baselines/reference/derivedTypeDoesNotRequireExtendsClause.types
index 47b7ed95dc6..36b85d7950c 100644
--- a/tests/baselines/reference/derivedTypeDoesNotRequireExtendsClause.types
+++ b/tests/baselines/reference/derivedTypeDoesNotRequireExtendsClause.types
@@ -49,7 +49,7 @@ b = d2;
 var r: Base[] = [d1, d2];
 >r : Base[]
 >Base : Base
->[d1, d2] : Array<Derived | Derived2>
+>[d1, d2] : (Derived | Derived2)[]
 >d1 : Derived
 >d2 : Derived2
 
diff --git a/tests/baselines/reference/enumBasics.types b/tests/baselines/reference/enumBasics.types
index 696e68eded2..c0d7fb9bed1 100644
--- a/tests/baselines/reference/enumBasics.types
+++ b/tests/baselines/reference/enumBasics.types
@@ -157,8 +157,8 @@ enum E9 {
 // (refer to .js to validate)
 // Enum constant members are propagated
 var doNotPropagate = [
->doNotPropagate : Array<E3 | E4 | E7 | E8>
->[    E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z] : Array<E3 | E4 | E7 | E8>
+>doNotPropagate : (E3 | E4 | E7 | E8)[]
+>[    E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z] : (E3 | E4 | E7 | E8)[]
 
     E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z
 >E8.B : E8
@@ -183,8 +183,8 @@ var doNotPropagate = [
 ];
 // Enum computed members are not propagated
 var doPropagate = [
->doPropagate : Array<E5 | E6 | E9>
->[    E9.A, E9.B, E6.B, E6.C, E6.A, E5.A, E5.B, E5.C] : Array<E5 | E6 | E9>
+>doPropagate : (E5 | E6 | E9)[]
+>[    E9.A, E9.B, E6.B, E6.C, E6.A, E5.A, E5.B, E5.C] : (E5 | E6 | E9)[]
 
     E9.A, E9.B, E6.B, E6.C, E6.A, E5.A, E5.B, E5.C
 >E9.A : E9
diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
index 66e8a2a66df..53ecb88363d 100644
--- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
+++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
@@ -7,7 +7,7 @@ tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDec
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(43,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(46,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'Array<C | D<string>>'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(50,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(53,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
 
@@ -79,7 +79,7 @@ tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDec
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
     for( var arr = [new C(), new C2(), new D<string>()];;){}
              ~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'Array<C | D<string>>'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
     
     for(var arr2 = [new D<string>()];;){}
     for( var arr2 = new Array<D<number>>();;){}
diff --git a/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.js b/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.js
index 37bcf84669c..f58b1047b8f 100644
--- a/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.js
+++ b/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.js
@@ -11,6 +11,4 @@ function foo(args) {
 
 
 //// [functionDeclarationWithArgumentOfTypeFunctionTypeArray.d.ts]
-declare function foo(args: {
-    (x: any): number;
-}[]): number;
+declare function foo(args: ((x: any) => number)[]): number;
diff --git a/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.types b/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.types
index af751fbb0e9..a1d32a2a405 100644
--- a/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.types
+++ b/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.types
@@ -1,12 +1,12 @@
 === tests/cases/compiler/functionDeclarationWithArgumentOfTypeFunctionTypeArray.ts ===
 function foo(args: { (x): number }[]) {
->foo : (args: { (x: any): number; }[]) => number
->args : { (x: any): number; }[]
+>foo : (args: ((x: any) => number)[]) => number
+>args : ((x: any) => number)[]
 >x : any
 
     return args.length;
 >args.length : number
->args : { (x: any): number; }[]
+>args : ((x: any) => number)[]
 >length : number
 }
 
diff --git a/tests/baselines/reference/functionSubtypingOfVarArgs2.types b/tests/baselines/reference/functionSubtypingOfVarArgs2.types
index 2f81898c7de..5e2b14ffc7a 100644
--- a/tests/baselines/reference/functionSubtypingOfVarArgs2.types
+++ b/tests/baselines/reference/functionSubtypingOfVarArgs2.types
@@ -3,7 +3,7 @@ class EventBase {
 >EventBase : EventBase
 
     private _listeners: { (...args: any[]): void; }[] = [];
->_listeners : { (...args: any[]): void; }[]
+>_listeners : ((...args: any[]) => void)[]
 >args : any[]
 >[] : undefined[]
 
@@ -14,11 +14,11 @@ class EventBase {
 
         this._listeners.push(listener);
 >this._listeners.push(listener) : number
->this._listeners.push : (...items: { (...args: any[]): void; }[]) => number
->this._listeners : { (...args: any[]): void; }[]
+>this._listeners.push : (...items: ((...args: any[]) => void)[]) => number
+>this._listeners : ((...args: any[]) => void)[]
 >this : EventBase
->_listeners : { (...args: any[]): void; }[]
->push : (...items: { (...args: any[]): void; }[]) => number
+>_listeners : ((...args: any[]) => void)[]
+>push : (...items: ((...args: any[]) => void)[]) => number
 >listener : (...args: any[]) => void
     }
 }
diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types
index 78fc6f6cfef..79787f6d994 100644
--- a/tests/baselines/reference/generatedContextualTyping.types
+++ b/tests/baselines/reference/generatedContextualTyping.types
@@ -34,57 +34,57 @@ var b = new Base(), d1 = new Derived1(), d2 = new Derived2();
 var x1: () => Base[] = () => [d1, d2];
 >x1 : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x2: () => Base[] = function() { return [d1, d2] };
 >x2 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x3: () => Base[] = function named() { return [d1, d2] };
 >x3 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x4: { (): Base[]; } = () => [d1, d2];
 >x4 : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x5: { (): Base[]; } = function() { return [d1, d2] };
 >x5 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x6: { (): Base[]; } = function named() { return [d1, d2] };
 >x6 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x7: Base[] = [d1, d2];
 >x7 : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -92,7 +92,7 @@ var x8: Array<Base> = [d1, d2];
 >x8 : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -100,7 +100,7 @@ var x9: { [n: number]: Base; } = [d1, d2];
 >x9 : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -108,9 +108,9 @@ var x10: {n: Base[]; }  = { n: [d1, d2] };
 >x10 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -127,11 +127,11 @@ var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
 >x12 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -139,8 +139,8 @@ class x13 { member: () => Base[] = () => [d1, d2] }
 >x13 : x13
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -148,8 +148,8 @@ class x14 { member: () => Base[] = function() { return [d1, d2] } }
 >x14 : x14
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -157,9 +157,9 @@ class x15 { member: () => Base[] = function named() { return [d1, d2] } }
 >x15 : x15
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -167,8 +167,8 @@ class x16 { member: { (): Base[]; } = () => [d1, d2] }
 >x16 : x16
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -176,8 +176,8 @@ class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
 >x17 : x17
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -185,9 +185,9 @@ class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
 >x18 : x18
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -195,7 +195,7 @@ class x19 { member: Base[] = [d1, d2] }
 >x19 : x19
 >member : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -204,7 +204,7 @@ class x20 { member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -213,7 +213,7 @@ class x21 { member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -222,9 +222,9 @@ class x22 { member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -243,11 +243,11 @@ class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -255,8 +255,8 @@ class x25 { private member: () => Base[] = () => [d1, d2] }
 >x25 : x25
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -264,8 +264,8 @@ class x26 { private member: () => Base[] = function() { return [d1, d2] } }
 >x26 : x26
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -273,9 +273,9 @@ class x27 { private member: () => Base[] = function named() { return [d1, d2] }
 >x27 : x27
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -283,8 +283,8 @@ class x28 { private member: { (): Base[]; } = () => [d1, d2] }
 >x28 : x28
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -292,8 +292,8 @@ class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
 >x29 : x29
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -301,9 +301,9 @@ class x30 { private member: { (): Base[]; } = function named() { return [d1, d2]
 >x30 : x30
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -311,7 +311,7 @@ class x31 { private member: Base[] = [d1, d2] }
 >x31 : x31
 >member : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -320,7 +320,7 @@ class x32 { private member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -329,7 +329,7 @@ class x33 { private member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -338,9 +338,9 @@ class x34 { private member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -359,11 +359,11 @@ class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -371,8 +371,8 @@ class x37 { public member: () => Base[] = () => [d1, d2] }
 >x37 : x37
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -380,8 +380,8 @@ class x38 { public member: () => Base[] = function() { return [d1, d2] } }
 >x38 : x38
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -389,9 +389,9 @@ class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
 >x39 : x39
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -399,8 +399,8 @@ class x40 { public member: { (): Base[]; } = () => [d1, d2] }
 >x40 : x40
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -408,8 +408,8 @@ class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
 >x41 : x41
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -417,9 +417,9 @@ class x42 { public member: { (): Base[]; } = function named() { return [d1, d2]
 >x42 : x42
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -427,7 +427,7 @@ class x43 { public member: Base[] = [d1, d2] }
 >x43 : x43
 >member : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -436,7 +436,7 @@ class x44 { public member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -445,7 +445,7 @@ class x45 { public member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -454,9 +454,9 @@ class x46 { public member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -475,11 +475,11 @@ class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -487,8 +487,8 @@ class x49 { static member: () => Base[] = () => [d1, d2] }
 >x49 : x49
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -496,8 +496,8 @@ class x50 { static member: () => Base[] = function() { return [d1, d2] } }
 >x50 : x50
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -505,9 +505,9 @@ class x51 { static member: () => Base[] = function named() { return [d1, d2] } }
 >x51 : x51
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -515,8 +515,8 @@ class x52 { static member: { (): Base[]; } = () => [d1, d2] }
 >x52 : x52
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -524,8 +524,8 @@ class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } }
 >x53 : x53
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -533,9 +533,9 @@ class x54 { static member: { (): Base[]; } = function named() { return [d1, d2]
 >x54 : x54
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -543,7 +543,7 @@ class x55 { static member: Base[] = [d1, d2] }
 >x55 : x55
 >member : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -552,7 +552,7 @@ class x56 { static member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -561,7 +561,7 @@ class x57 { static member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -570,9 +570,9 @@ class x58 { static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -591,11 +591,11 @@ class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -603,8 +603,8 @@ class x61 { private static member: () => Base[] = () => [d1, d2] }
 >x61 : x61
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -612,8 +612,8 @@ class x62 { private static member: () => Base[] = function() { return [d1, d2] }
 >x62 : x62
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -621,9 +621,9 @@ class x63 { private static member: () => Base[] = function named() { return [d1,
 >x63 : x63
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -631,8 +631,8 @@ class x64 { private static member: { (): Base[]; } = () => [d1, d2] }
 >x64 : x64
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -640,8 +640,8 @@ class x65 { private static member: { (): Base[]; } = function() { return [d1, d2
 >x65 : x65
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -649,9 +649,9 @@ class x66 { private static member: { (): Base[]; } = function named() { return [
 >x66 : x66
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -659,7 +659,7 @@ class x67 { private static member: Base[] = [d1, d2] }
 >x67 : x67
 >member : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -668,7 +668,7 @@ class x68 { private static member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -677,7 +677,7 @@ class x69 { private static member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -686,9 +686,9 @@ class x70 { private static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -707,11 +707,11 @@ class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -719,8 +719,8 @@ class x73 { public static member: () => Base[] = () => [d1, d2] }
 >x73 : x73
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -728,8 +728,8 @@ class x74 { public static member: () => Base[] = function() { return [d1, d2] }
 >x74 : x74
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -737,9 +737,9 @@ class x75 { public static member: () => Base[] = function named() { return [d1,
 >x75 : x75
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -747,8 +747,8 @@ class x76 { public static member: { (): Base[]; } = () => [d1, d2] }
 >x76 : x76
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -756,8 +756,8 @@ class x77 { public static member: { (): Base[]; } = function() { return [d1, d2]
 >x77 : x77
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -765,9 +765,9 @@ class x78 { public static member: { (): Base[]; } = function named() { return [d
 >x78 : x78
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -775,7 +775,7 @@ class x79 { public static member: Base[] = [d1, d2] }
 >x79 : x79
 >member : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -784,7 +784,7 @@ class x80 { public static member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -793,7 +793,7 @@ class x81 { public static member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -802,9 +802,9 @@ class x82 { public static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -823,11 +823,11 @@ class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2];
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -835,8 +835,8 @@ class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } }
 >x85 : x85
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -844,8 +844,8 @@ class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { }
 >x86 : x86
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -853,9 +853,9 @@ class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2]
 >x87 : x87
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -863,8 +863,8 @@ class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x88 : x88
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -872,8 +872,8 @@ class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] })
 >x89 : x89
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -881,9 +881,9 @@ class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d
 >x90 : x90
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -891,7 +891,7 @@ class x91 { constructor(parm: Base[] = [d1, d2]) { } }
 >x91 : x91
 >parm : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -900,7 +900,7 @@ class x92 { constructor(parm: Array<Base> = [d1, d2]) { } }
 >parm : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -909,7 +909,7 @@ class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } }
 >parm : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -918,9 +918,9 @@ class x94 { constructor(parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -939,11 +939,11 @@ class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }
 >parm : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -951,8 +951,8 @@ class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } }
 >x97 : x97
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -960,8 +960,8 @@ class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2]
 >x98 : x98
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -969,9 +969,9 @@ class x99 { constructor(public parm: () => Base[] = function named() { return [d
 >x99 : x99
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -979,8 +979,8 @@ class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x100 : x100
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -988,8 +988,8 @@ class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1,
 >x101 : x101
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -997,9 +997,9 @@ class x102 { constructor(public parm: { (): Base[]; } = function named() { retur
 >x102 : x102
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1007,7 +1007,7 @@ class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
 >x103 : x103
 >parm : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1016,7 +1016,7 @@ class x104 { constructor(public parm: Array<Base> = [d1, d2]) { } }
 >parm : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1025,7 +1025,7 @@ class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } }
 >parm : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1034,9 +1034,9 @@ class x106 { constructor(public parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1055,11 +1055,11 @@ class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1,
 >parm : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1067,8 +1067,8 @@ class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } }
 >x109 : x109
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1076,8 +1076,8 @@ class x110 { constructor(private parm: () => Base[] = function() { return [d1, d
 >x110 : x110
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1085,9 +1085,9 @@ class x111 { constructor(private parm: () => Base[] = function named() { return
 >x111 : x111
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1095,8 +1095,8 @@ class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x112 : x112
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1104,8 +1104,8 @@ class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1
 >x113 : x113
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1113,9 +1113,9 @@ class x114 { constructor(private parm: { (): Base[]; } = function named() { retu
 >x114 : x114
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1123,7 +1123,7 @@ class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
 >x115 : x115
 >parm : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1132,7 +1132,7 @@ class x116 { constructor(private parm: Array<Base> = [d1, d2]) { } }
 >parm : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1141,7 +1141,7 @@ class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } }
 >parm : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1150,9 +1150,9 @@ class x118 { constructor(private parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1171,11 +1171,11 @@ class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1,
 >parm : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1183,8 +1183,8 @@ function x121(parm: () => Base[] = () => [d1, d2]) { }
 >x121 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1192,8 +1192,8 @@ function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
 >x122 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1201,9 +1201,9 @@ function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
 >x123 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1211,8 +1211,8 @@ function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
 >x124 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1220,8 +1220,8 @@ function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
 >x125 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1229,9 +1229,9 @@ function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
 >x126 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1239,7 +1239,7 @@ function x127(parm: Base[] = [d1, d2]) { }
 >x127 : (parm?: Base[]) => void
 >parm : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1248,7 +1248,7 @@ function x128(parm: Array<Base> = [d1, d2]) { }
 >parm : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1257,7 +1257,7 @@ function x129(parm: { [n: number]: Base; } = [d1, d2]) { }
 >parm : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1266,9 +1266,9 @@ function x130(parm: {n: Base[]; }  = { n: [d1, d2] }) { }
 >parm : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1287,68 +1287,68 @@ function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
 >parm : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x133(): () => Base[] { return () => [d1, d2]; }
 >x133 : () => () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x134(): () => Base[] { return function() { return [d1, d2] }; }
 >x134 : () => () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x135(): () => Base[] { return function named() { return [d1, d2] }; }
 >x135 : () => () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x136(): { (): Base[]; } { return () => [d1, d2]; }
 >x136 : () => () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x137(): { (): Base[]; } { return function() { return [d1, d2] }; }
 >x137 : () => () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; }
 >x138 : () => () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x139(): Base[] { return [d1, d2]; }
 >x139 : () => Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1356,7 +1356,7 @@ function x140(): Array<Base> { return [d1, d2]; }
 >x140 : () => Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1364,7 +1364,7 @@ function x141(): { [n: number]: Base; } { return [d1, d2]; }
 >x141 : () => { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1372,9 +1372,9 @@ function x142(): {n: Base[]; }  { return { n: [d1, d2] }; }
 >x142 : () => { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1391,97 +1391,97 @@ function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
 >x144 : () => Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; }
 >x145 : () => () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
 >x146 : () => () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
 >x147 : () => () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; }
 >x148 : () => () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
 >x149 : () => () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
 >x150 : () => () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 function x151(): Base[] { return [d1, d2]; return [d1, d2]; }
 >x151 : () => Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1489,10 +1489,10 @@ function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
 >x152 : () => Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1500,10 +1500,10 @@ function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; }
 >x153 : () => { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1511,14 +1511,14 @@ function x154(): {n: Base[]; }  { return { n: [d1, d2] }; return { n: [d1, d2] }
 >x154 : () => { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1539,82 +1539,82 @@ function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; retu
 >x156 : () => Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x157: () => () => Base[] = () => { return () => [d1, d2]; };
 >x157 : () => () => Base[]
 >Base : Base
->() => { return () => [d1, d2]; } : () => () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return () => [d1, d2]; } : () => () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; };
 >x158 : () => () => Base[]
 >Base : Base
->() => { return function() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return function() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; };
 >x159 : () => () => Base[]
 >Base : Base
->() => { return function named() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return function named() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; };
 >x160 : () => () => Base[]
 >Base : Base
->() => { return () => [d1, d2]; } : () => () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return () => [d1, d2]; } : () => () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; };
 >x161 : () => () => Base[]
 >Base : Base
->() => { return function() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return function() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; };
 >x162 : () => () => Base[]
 >Base : Base
->() => { return function named() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return function named() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x163: () => Base[] = () => { return [d1, d2]; };
 >x163 : () => Base[]
 >Base : Base
->() => { return [d1, d2]; } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1622,8 +1622,8 @@ var x164: () => Array<Base> = () => { return [d1, d2]; };
 >x164 : () => Base[]
 >Array : T[]
 >Base : Base
->() => { return [d1, d2]; } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1631,8 +1631,8 @@ var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
 >x165 : () => { [x: number]: Base; }
 >n : number
 >Base : Base
->() => { return [d1, d2]; } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1640,10 +1640,10 @@ var x166: () => {n: Base[]; }  = () => { return { n: [d1, d2] }; };
 >x166 : () => { n: Base[]; }
 >n : Base[]
 >Base : Base
->() => { return { n: [d1, d2] }; } : () => { n: Array<Derived1 | Derived2>; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => { return { n: [d1, d2] }; } : () => { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1661,76 +1661,76 @@ var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; }
 >x168 : () => Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->() => { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>() => { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x169: () => () => Base[] = function() { return () => [d1, d2]; };
 >x169 : () => () => Base[]
 >Base : Base
->function() { return () => [d1, d2]; } : () => () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return () => [d1, d2]; } : () => () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; };
 >x170 : () => () => Base[]
 >Base : Base
->function() { return function() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return function() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; };
 >x171 : () => () => Base[]
 >Base : Base
->function() { return function named() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return function named() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; };
 >x172 : () => () => Base[]
 >Base : Base
->function() { return () => [d1, d2]; } : () => () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return () => [d1, d2]; } : () => () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; };
 >x173 : () => () => Base[]
 >Base : Base
->function() { return function() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return function() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; };
 >x174 : () => () => Base[]
 >Base : Base
->function() { return function named() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return function named() { return [d1, d2] }; } : () => () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x175: () => Base[] = function() { return [d1, d2]; };
 >x175 : () => Base[]
 >Base : Base
->function() { return [d1, d2]; } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1738,8 +1738,8 @@ var x176: () => Array<Base> = function() { return [d1, d2]; };
 >x176 : () => Base[]
 >Array : T[]
 >Base : Base
->function() { return [d1, d2]; } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1747,8 +1747,8 @@ var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
 >x177 : () => { [x: number]: Base; }
 >n : number
 >Base : Base
->function() { return [d1, d2]; } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2]; } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1756,10 +1756,10 @@ var x178: () => {n: Base[]; }  = function() { return { n: [d1, d2] }; };
 >x178 : () => { n: Base[]; }
 >n : Base[]
 >Base : Base
->function() { return { n: [d1, d2] }; } : () => { n: Array<Derived1 | Derived2>; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return { n: [d1, d2] }; } : () => { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1777,12 +1777,12 @@ var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2
 >x180 : () => Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->function() { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>function() { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1790,8 +1790,8 @@ module x181 { var t: () => Base[] = () => [d1, d2]; }
 >x181 : typeof x181
 >t : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1799,8 +1799,8 @@ module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
 >x182 : typeof x182
 >t : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1808,9 +1808,9 @@ module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
 >x183 : typeof x183
 >t : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1818,8 +1818,8 @@ module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
 >x184 : typeof x184
 >t : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1827,8 +1827,8 @@ module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
 >x185 : typeof x185
 >t : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1836,9 +1836,9 @@ module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
 >x186 : typeof x186
 >t : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1846,7 +1846,7 @@ module x187 { var t: Base[] = [d1, d2]; }
 >x187 : typeof x187
 >t : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1855,7 +1855,7 @@ module x188 { var t: Array<Base> = [d1, d2]; }
 >t : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1864,7 +1864,7 @@ module x189 { var t: { [n: number]: Base; } = [d1, d2]; }
 >t : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1873,9 +1873,9 @@ module x190 { var t: {n: Base[]; }  = { n: [d1, d2] }; }
 >t : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1894,11 +1894,11 @@ module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
 >t : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1906,8 +1906,8 @@ module x193 { export var t: () => Base[] = () => [d1, d2]; }
 >x193 : typeof x193
 >t : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1915,8 +1915,8 @@ module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
 >x194 : typeof x194
 >t : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1924,9 +1924,9 @@ module x195 { export var t: () => Base[] = function named() { return [d1, d2] };
 >x195 : typeof x195
 >t : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1934,8 +1934,8 @@ module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
 >x196 : typeof x196
 >t : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1943,8 +1943,8 @@ module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
 >x197 : typeof x197
 >t : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1952,9 +1952,9 @@ module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2]
 >x198 : typeof x198
 >t : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1962,7 +1962,7 @@ module x199 { export var t: Base[] = [d1, d2]; }
 >x199 : typeof x199
 >t : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1971,7 +1971,7 @@ module x200 { export var t: Array<Base> = [d1, d2]; }
 >t : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1980,7 +1980,7 @@ module x201 { export var t: { [n: number]: Base; } = [d1, d2]; }
 >t : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1989,9 +1989,9 @@ module x202 { export var t: {n: Base[]; }  = { n: [d1, d2] }; }
 >t : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2010,11 +2010,11 @@ module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } };
 >t : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2022,8 +2022,8 @@ var x206 = <() => Base[]>function() { return [d1, d2] };
 >x206 : () => Base[]
 ><() => Base[]>function() { return [d1, d2] } : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2031,9 +2031,9 @@ var x207 = <() => Base[]>function named() { return [d1, d2] };
 >x207 : () => Base[]
 ><() => Base[]>function named() { return [d1, d2] } : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2041,8 +2041,8 @@ var x209 = <{ (): Base[]; }>function() { return [d1, d2] };
 >x209 : () => Base[]
 ><{ (): Base[]; }>function() { return [d1, d2] } : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2050,9 +2050,9 @@ var x210 = <{ (): Base[]; }>function named() { return [d1, d2] };
 >x210 : () => Base[]
 ><{ (): Base[]; }>function named() { return [d1, d2] } : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2060,7 +2060,7 @@ var x211 = <Base[]>[d1, d2];
 >x211 : Base[]
 ><Base[]>[d1, d2] : Base[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2069,7 +2069,7 @@ var x212 = <Array<Base>>[d1, d2];
 ><Array<Base>>[d1, d2] : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2078,7 +2078,7 @@ var x213 = <{ [n: number]: Base; }>[d1, d2];
 ><{ [n: number]: Base; }>[d1, d2] : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2087,9 +2087,9 @@ var x214 = <{n: Base[]; } >{ n: [d1, d2] };
 ><{n: Base[]; } >{ n: [d1, d2] } : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2098,11 +2098,11 @@ var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
 ><Genric<Base>>{ func: n => { return [d1, d2]; } } : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2113,8 +2113,8 @@ var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
 ><() => Base[]>undefined : () => Base[]
 >Base : Base
 >undefined : undefined
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2125,9 +2125,9 @@ var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
 ><() => Base[]>undefined : () => Base[]
 >Base : Base
 >undefined : undefined
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2138,8 +2138,8 @@ var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
 ><{ (): Base[]; }>undefined : () => Base[]
 >Base : Base
 >undefined : undefined
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2150,9 +2150,9 @@ var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
 ><{ (): Base[]; }>undefined : () => Base[]
 >Base : Base
 >undefined : undefined
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2163,7 +2163,7 @@ var x221 = (<Base[]>undefined) || [d1, d2];
 ><Base[]>undefined : Base[]
 >Base : Base
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2175,7 +2175,7 @@ var x222 = (<Array<Base>>undefined) || [d1, d2];
 >Array : T[]
 >Base : Base
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2187,7 +2187,7 @@ var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2];
 >n : number
 >Base : Base
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2199,80 +2199,80 @@ var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
 >n : Base[]
 >Base : Base
 >undefined : undefined
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x225: () => Base[]; x225 = () => [d1, d2];
 >x225 : () => Base[]
 >Base : Base
->x225 = () => [d1, d2] : () => Array<Derived1 | Derived2>
+>x225 = () => [d1, d2] : () => (Derived1 | Derived2)[]
 >x225 : () => Base[]
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x226: () => Base[]; x226 = function() { return [d1, d2] };
 >x226 : () => Base[]
 >Base : Base
->x226 = function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>x226 = function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >x226 : () => Base[]
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x227: () => Base[]; x227 = function named() { return [d1, d2] };
 >x227 : () => Base[]
 >Base : Base
->x227 = function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>x227 = function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >x227 : () => Base[]
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x228: { (): Base[]; }; x228 = () => [d1, d2];
 >x228 : () => Base[]
 >Base : Base
->x228 = () => [d1, d2] : () => Array<Derived1 | Derived2>
+>x228 = () => [d1, d2] : () => (Derived1 | Derived2)[]
 >x228 : () => Base[]
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x229: { (): Base[]; }; x229 = function() { return [d1, d2] };
 >x229 : () => Base[]
 >Base : Base
->x229 = function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>x229 = function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >x229 : () => Base[]
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] };
 >x230 : () => Base[]
 >Base : Base
->x230 = function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>x230 = function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >x230 : () => Base[]
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x231: Base[]; x231 = [d1, d2];
 >x231 : Base[]
 >Base : Base
->x231 = [d1, d2] : Array<Derived1 | Derived2>
+>x231 = [d1, d2] : (Derived1 | Derived2)[]
 >x231 : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2280,9 +2280,9 @@ var x232: Array<Base>; x232 = [d1, d2];
 >x232 : Base[]
 >Array : T[]
 >Base : Base
->x232 = [d1, d2] : Array<Derived1 | Derived2>
+>x232 = [d1, d2] : (Derived1 | Derived2)[]
 >x232 : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2290,9 +2290,9 @@ var x233: { [n: number]: Base; }; x233 = [d1, d2];
 >x233 : { [x: number]: Base; }
 >n : number
 >Base : Base
->x233 = [d1, d2] : Array<Derived1 | Derived2>
+>x233 = [d1, d2] : (Derived1 | Derived2)[]
 >x233 : { [x: number]: Base; }
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2300,11 +2300,11 @@ var x234: {n: Base[]; } ; x234 = { n: [d1, d2] };
 >x234 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->x234 = { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>x234 = { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
 >x234 : { n: Base[]; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2323,13 +2323,13 @@ var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
 >x236 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->x236 = { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>x236 = { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
 >x236 : Genric<Base>
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2337,10 +2337,10 @@ var x237: { n: () => Base[]; } = { n: () => [d1, d2] };
 >x237 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: () => [d1, d2] } : { n: () => Array<Derived1 | Derived2>; }
->n : () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: () => [d1, d2] } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2348,10 +2348,10 @@ var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
 >x238 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: function() { return [d1, d2] } } : { n: () => Array<Derived1 | Derived2>; }
->n : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: function() { return [d1, d2] } } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2359,11 +2359,11 @@ var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
 >x239 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: function named() { return [d1, d2] } } : { n: () => Array<Derived1 | Derived2>; }
->n : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: function named() { return [d1, d2] } } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2371,10 +2371,10 @@ var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
 >x240 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: () => [d1, d2] } : { n: () => Array<Derived1 | Derived2>; }
->n : () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: () => [d1, d2] } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2382,10 +2382,10 @@ var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
 >x241 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: function() { return [d1, d2] } } : { n: () => Array<Derived1 | Derived2>; }
->n : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: function() { return [d1, d2] } } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2393,11 +2393,11 @@ var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
 >x242 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: function named() { return [d1, d2] } } : { n: () => Array<Derived1 | Derived2>; }
->n : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: function named() { return [d1, d2] } } : { n: () => (Derived1 | Derived2)[]; }
+>n : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2405,9 +2405,9 @@ var x243: { n: Base[]; } = { n: [d1, d2] };
 >x243 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2416,9 +2416,9 @@ var x244: { n: Array<Base>; } = { n: [d1, d2] };
 >n : Base[]
 >Array : T[]
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2427,9 +2427,9 @@ var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
 >n : { [x: number]: Base; }
 >n : number
 >Base : Base
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2438,11 +2438,11 @@ var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } };
 >n : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: { n: [d1, d2] } } : { n: { n: Array<Derived1 | Derived2>; }; }
->n : { n: Array<Derived1 | Derived2>; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: { n: [d1, d2] } } : { n: { n: (Derived1 | Derived2)[]; }; }
+>n : { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2463,49 +2463,49 @@ var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
 >n : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ n: { func: n => { return [d1, d2]; } } } : { n: { func: (n: Base[]) => Array<Derived1 | Derived2>; }; }
->n : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ n: { func: n => { return [d1, d2]; } } } : { n: { func: (n: Base[]) => (Derived1 | Derived2)[]; }; }
+>n : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x252: { (): Base[]; }[] = [() => [d1, d2]];
->x252 : { (): Base[]; }[]
+>x252 : (() => Base[])[]
 >Base : Base
->[() => [d1, d2]] : { (): Array<Derived1 | Derived2>; }[]
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[() => [d1, d2]] : (() => (Derived1 | Derived2)[])[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x253: { (): Base[]; }[] = [function() { return [d1, d2] }];
->x253 : { (): Base[]; }[]
+>x253 : (() => Base[])[]
 >Base : Base
->[function() { return [d1, d2] }] : { (): Array<Derived1 | Derived2>; }[]
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[function() { return [d1, d2] }] : (() => (Derived1 | Derived2)[])[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }];
->x254 : { (): Base[]; }[]
+>x254 : (() => Base[])[]
 >Base : Base
->[function named() { return [d1, d2] }] : { (): Array<Derived1 | Derived2>; }[]
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[function named() { return [d1, d2] }] : (() => (Derived1 | Derived2)[])[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x255: Base[][] = [[d1, d2]];
 >x255 : Base[][]
 >Base : Base
->[[d1, d2]] : Array<Derived1 | Derived2>[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[[d1, d2]] : (Derived1 | Derived2)[][]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2513,8 +2513,8 @@ var x256: Array<Base>[] = [[d1, d2]];
 >x256 : Base[][]
 >Array : T[]
 >Base : Base
->[[d1, d2]] : Array<Derived1 | Derived2>[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[[d1, d2]] : (Derived1 | Derived2)[][]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2522,8 +2522,8 @@ var x257: { [n: number]: Base; }[] = [[d1, d2]];
 >x257 : { [x: number]: Base; }[]
 >n : number
 >Base : Base
->[[d1, d2]] : Array<Derived1 | Derived2>[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[[d1, d2]] : (Derived1 | Derived2)[][]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2531,10 +2531,10 @@ var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
 >x258 : { n: Base[]; }[]
 >n : Base[]
 >Base : Base
->[{ n: [d1, d2] }] : { n: Array<Derived1 | Derived2>; }[]
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[{ n: [d1, d2] }] : { n: (Derived1 | Derived2)[]; }[]
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2542,21 +2542,21 @@ var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
 >x260 : Genric<Base>[]
 >Genric : Genric<T>
 >Base : Base
->[{ func: n => { return [d1, d2]; } }] : { func: (n: Base[]) => Array<Derived1 | Derived2>; }[]
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>[{ func: n => { return [d1, d2]; } }] : { func: (n: Base[]) => (Derived1 | Derived2)[]; }[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x261: () => Base[] = function() { return [d1, d2] } || undefined;
 >x261 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } || undefined : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } || undefined : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2564,10 +2564,10 @@ var x261: () => Base[] = function() { return [d1, d2] } || undefined;
 var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
 >x262 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } || undefined : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } || undefined : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2575,9 +2575,9 @@ var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
 var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
 >x263 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } || undefined : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } || undefined : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2585,10 +2585,10 @@ var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
 var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
 >x264 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } || undefined : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } || undefined : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2596,8 +2596,8 @@ var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
 var x265: Base[] = [d1, d2] || undefined;
 >x265 : Base[]
 >Base : Base
->[d1, d2] || undefined : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] || undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2606,8 +2606,8 @@ var x266: Array<Base> = [d1, d2] || undefined;
 >x266 : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] || undefined : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] || undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2616,8 +2616,8 @@ var x267: { [n: number]: Base; } = [d1, d2] || undefined;
 >x267 : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] || undefined : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] || undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2626,10 +2626,10 @@ var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
 >x268 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } || undefined : { n: Array<Derived1 | Derived2>; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } || undefined : { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2637,51 +2637,51 @@ var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
 var x269: () => Base[] = undefined || function() { return [d1, d2] };
 >x269 : () => Base[]
 >Base : Base
->undefined || function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>undefined || function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >undefined : undefined
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x270: () => Base[] = undefined || function named() { return [d1, d2] };
 >x270 : () => Base[]
 >Base : Base
->undefined || function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>undefined || function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >undefined : undefined
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x271: { (): Base[]; } = undefined || function() { return [d1, d2] };
 >x271 : () => Base[]
 >Base : Base
->undefined || function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>undefined || function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >undefined : undefined
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] };
 >x272 : () => Base[]
 >Base : Base
->undefined || function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>undefined || function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >undefined : undefined
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x273: Base[] = undefined || [d1, d2];
 >x273 : Base[]
 >Base : Base
->undefined || [d1, d2] : Array<Derived1 | Derived2>
+>undefined || [d1, d2] : (Derived1 | Derived2)[]
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2689,9 +2689,9 @@ var x274: Array<Base> = undefined || [d1, d2];
 >x274 : Base[]
 >Array : T[]
 >Base : Base
->undefined || [d1, d2] : Array<Derived1 | Derived2>
+>undefined || [d1, d2] : (Derived1 | Derived2)[]
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2699,9 +2699,9 @@ var x275: { [n: number]: Base; } = undefined || [d1, d2];
 >x275 : { [x: number]: Base; }
 >n : number
 >Base : Base
->undefined || [d1, d2] : Array<Derived1 | Derived2>
+>undefined || [d1, d2] : (Derived1 | Derived2)[]
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2709,78 +2709,78 @@ var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
 >x276 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->undefined || { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>undefined || { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
 >undefined : undefined
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] };
 >x277 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } || function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } || function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] };
 >x278 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] };
 >x279 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } || function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } || function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] };
 >x280 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x281: Base[] = [d1, d2] || [d1, d2];
 >x281 : Base[]
 >Base : Base
->[d1, d2] || [d1, d2] : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] || [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2788,11 +2788,11 @@ var x282: Array<Base> = [d1, d2] || [d1, d2];
 >x282 : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] || [d1, d2] : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] || [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2800,11 +2800,11 @@ var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2];
 >x283 : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] || [d1, d2] : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] || [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2812,108 +2812,108 @@ var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
 >x284 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } || { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } || { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2];
 >x285 : () => Base[]
 >Base : Base
->true ? () => [d1, d2] : () => [d1, d2] : () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? () => [d1, d2] : () => [d1, d2] : () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
 >x286 : () => Base[]
 >Base : Base
->true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
 >x287 : () => Base[]
 >Base : Base
->true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2];
 >x288 : () => Base[]
 >Base : Base
->true ? () => [d1, d2] : () => [d1, d2] : () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? () => [d1, d2] : () => [d1, d2] : () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
 >x289 : () => Base[]
 >Base : Base
->true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
 >x290 : () => Base[]
 >Base : Base
->true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x291: Base[] = true ? [d1, d2] : [d1, d2];
 >x291 : Base[]
 >Base : Base
->true ? [d1, d2] : [d1, d2] : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? [d1, d2] : [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2921,11 +2921,11 @@ var x292: Array<Base> = true ? [d1, d2] : [d1, d2];
 >x292 : Base[]
 >Array : T[]
 >Base : Base
->true ? [d1, d2] : [d1, d2] : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? [d1, d2] : [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2933,11 +2933,11 @@ var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2];
 >x293 : { [x: number]: Base; }
 >n : number
 >Base : Base
->true ? [d1, d2] : [d1, d2] : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? [d1, d2] : [d1, d2] : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2945,15 +2945,15 @@ var x294: {n: Base[]; }  = true ? { n: [d1, d2] } : { n: [d1, d2] };
 >x294 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->true ? { n: [d1, d2] } : { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? { n: [d1, d2] } : { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2975,90 +2975,90 @@ var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n
 >x296 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x297: () => Base[] = true ? undefined : () => [d1, d2];
 >x297 : () => Base[]
 >Base : Base
->true ? undefined : () => [d1, d2] : () => Array<Derived1 | Derived2>
+>true ? undefined : () => [d1, d2] : () => (Derived1 | Derived2)[]
 >undefined : undefined
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x298: () => Base[] = true ? undefined : function() { return [d1, d2] };
 >x298 : () => Base[]
 >Base : Base
->true ? undefined : function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>true ? undefined : function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >undefined : undefined
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] };
 >x299 : () => Base[]
 >Base : Base
->true ? undefined : function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>true ? undefined : function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >undefined : undefined
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x300: { (): Base[]; } = true ? undefined : () => [d1, d2];
 >x300 : () => Base[]
 >Base : Base
->true ? undefined : () => [d1, d2] : () => Array<Derived1 | Derived2>
+>true ? undefined : () => [d1, d2] : () => (Derived1 | Derived2)[]
 >undefined : undefined
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] };
 >x301 : () => Base[]
 >Base : Base
->true ? undefined : function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>true ? undefined : function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >undefined : undefined
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] };
 >x302 : () => Base[]
 >Base : Base
->true ? undefined : function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>true ? undefined : function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
 >undefined : undefined
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x303: Base[] = true ? undefined : [d1, d2];
 >x303 : Base[]
 >Base : Base
->true ? undefined : [d1, d2] : Array<Derived1 | Derived2>
+>true ? undefined : [d1, d2] : (Derived1 | Derived2)[]
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3066,9 +3066,9 @@ var x304: Array<Base> = true ? undefined : [d1, d2];
 >x304 : Base[]
 >Array : T[]
 >Base : Base
->true ? undefined : [d1, d2] : Array<Derived1 | Derived2>
+>true ? undefined : [d1, d2] : (Derived1 | Derived2)[]
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3076,9 +3076,9 @@ var x305: { [n: number]: Base; } = true ? undefined : [d1, d2];
 >x305 : { [x: number]: Base; }
 >n : number
 >Base : Base
->true ? undefined : [d1, d2] : Array<Derived1 | Derived2>
+>true ? undefined : [d1, d2] : (Derived1 | Derived2)[]
 >undefined : undefined
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3086,11 +3086,11 @@ var x306: {n: Base[]; }  = true ? undefined : { n: [d1, d2] };
 >x306 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->true ? undefined : { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>true ? undefined : { n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
 >undefined : undefined
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3109,22 +3109,22 @@ var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
 >x308 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->true ? undefined : { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>true ? undefined : { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
 >undefined : undefined
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
 var x309: () => Base[] = true ? () => [d1, d2] : undefined;
 >x309 : () => Base[]
 >Base : Base
->true ? () => [d1, d2] : undefined : () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? () => [d1, d2] : undefined : () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3132,9 +3132,9 @@ var x309: () => Base[] = true ? () => [d1, d2] : undefined;
 var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
 >x310 : () => Base[]
 >Base : Base
->true ? function() { return [d1, d2] } : undefined : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? function() { return [d1, d2] } : undefined : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3142,10 +3142,10 @@ var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
 var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined;
 >x311 : () => Base[]
 >Base : Base
->true ? function named() { return [d1, d2] } : undefined : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? function named() { return [d1, d2] } : undefined : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3153,9 +3153,9 @@ var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined
 var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
 >x312 : () => Base[]
 >Base : Base
->true ? () => [d1, d2] : undefined : () => Array<Derived1 | Derived2>
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? () => [d1, d2] : undefined : () => (Derived1 | Derived2)[]
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3163,9 +3163,9 @@ var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
 var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
 >x313 : () => Base[]
 >Base : Base
->true ? function() { return [d1, d2] } : undefined : () => Array<Derived1 | Derived2>
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? function() { return [d1, d2] } : undefined : () => (Derived1 | Derived2)[]
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3173,10 +3173,10 @@ var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
 var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined;
 >x314 : () => Base[]
 >Base : Base
->true ? function named() { return [d1, d2] } : undefined : () => Array<Derived1 | Derived2>
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? function named() { return [d1, d2] } : undefined : () => (Derived1 | Derived2)[]
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3184,8 +3184,8 @@ var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefi
 var x315: Base[] = true ? [d1, d2] : undefined;
 >x315 : Base[]
 >Base : Base
->true ? [d1, d2] : undefined : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? [d1, d2] : undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3194,8 +3194,8 @@ var x316: Array<Base> = true ? [d1, d2] : undefined;
 >x316 : Base[]
 >Array : T[]
 >Base : Base
->true ? [d1, d2] : undefined : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? [d1, d2] : undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3204,8 +3204,8 @@ var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined;
 >x317 : { [x: number]: Base; }
 >n : number
 >Base : Base
->true ? [d1, d2] : undefined : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? [d1, d2] : undefined : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3214,10 +3214,10 @@ var x318: {n: Base[]; }  = true ? { n: [d1, d2] } : undefined;
 >x318 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->true ? { n: [d1, d2] } : undefined : { n: Array<Derived1 | Derived2>; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>true ? { n: [d1, d2] } : undefined : { n: (Derived1 | Derived2)[]; }
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3237,12 +3237,12 @@ var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
 >x320 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->true ? { func: n => { return [d1, d2]; } } : undefined : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>true ? { func: n => { return [d1, d2]; } } : undefined : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3253,8 +3253,8 @@ function x321(n: () => Base[]) { }; x321(() => [d1, d2]);
 >Base : Base
 >x321(() => [d1, d2]) : void
 >x321 : (n: () => Base[]) => void
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3264,8 +3264,8 @@ function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
 >Base : Base
 >x322(function() { return [d1, d2] }) : void
 >x322 : (n: () => Base[]) => void
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3275,9 +3275,9 @@ function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
 >Base : Base
 >x323(function named() { return [d1, d2] }) : void
 >x323 : (n: () => Base[]) => void
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3287,8 +3287,8 @@ function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
 >Base : Base
 >x324(() => [d1, d2]) : void
 >x324 : (n: () => Base[]) => void
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3298,8 +3298,8 @@ function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
 >Base : Base
 >x325(function() { return [d1, d2] }) : void
 >x325 : (n: () => Base[]) => void
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3309,9 +3309,9 @@ function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] }
 >Base : Base
 >x326(function named() { return [d1, d2] }) : void
 >x326 : (n: () => Base[]) => void
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3321,7 +3321,7 @@ function x327(n: Base[]) { }; x327([d1, d2]);
 >Base : Base
 >x327([d1, d2]) : void
 >x327 : (n: Base[]) => void
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3332,7 +3332,7 @@ function x328(n: Array<Base>) { }; x328([d1, d2]);
 >Base : Base
 >x328([d1, d2]) : void
 >x328 : (n: Base[]) => void
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3343,7 +3343,7 @@ function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]);
 >Base : Base
 >x329([d1, d2]) : void
 >x329 : (n: { [x: number]: Base; }) => void
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3354,9 +3354,9 @@ function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] });
 >Base : Base
 >x330({ n: [d1, d2] }) : void
 >x330 : (n: { n: Base[]; }) => void
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3379,11 +3379,11 @@ function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
 >Base : Base
 >x332({ func: n => { return [d1, d2]; } }) : void
 >x332 : (n: Genric<Base>) => void
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3395,8 +3395,8 @@ var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]);
 >n : () => Base[]
 >x333(() => [d1, d2]) : () => Base[]
 >x333 : (n: () => Base[]) => () => Base[]
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3408,8 +3408,8 @@ var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] });
 >n : () => Base[]
 >x334(function() { return [d1, d2] }) : () => Base[]
 >x334 : (n: () => Base[]) => () => Base[]
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3421,9 +3421,9 @@ var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] });
 >n : () => Base[]
 >x335(function named() { return [d1, d2] }) : () => Base[]
 >x335 : (n: () => Base[]) => () => Base[]
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3435,8 +3435,8 @@ var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]);
 >n : () => Base[]
 >x336(() => [d1, d2]) : () => Base[]
 >x336 : (n: () => Base[]) => () => Base[]
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3448,8 +3448,8 @@ var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] });
 >n : () => Base[]
 >x337(function() { return [d1, d2] }) : () => Base[]
 >x337 : (n: () => Base[]) => () => Base[]
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3461,9 +3461,9 @@ var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] })
 >n : () => Base[]
 >x338(function named() { return [d1, d2] }) : () => Base[]
 >x338 : (n: () => Base[]) => () => Base[]
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3475,7 +3475,7 @@ var x339 = (n: Base[]) => n; x339([d1, d2]);
 >n : Base[]
 >x339([d1, d2]) : Base[]
 >x339 : (n: Base[]) => Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3488,7 +3488,7 @@ var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 >n : Base[]
 >x340([d1, d2]) : Base[]
 >x340 : (n: Base[]) => Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3501,7 +3501,7 @@ var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
 >n : { [x: number]: Base; }
 >x341([d1, d2]) : { [x: number]: Base; }
 >x341 : (n: { [x: number]: Base; }) => { [x: number]: Base; }
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3514,9 +3514,9 @@ var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
 >n : { n: Base[]; }
 >x342({ n: [d1, d2] }) : { n: Base[]; }
 >x342 : (n: { n: Base[]; }) => { n: Base[]; }
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3543,11 +3543,11 @@ var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
 >n : Genric<Base>
 >x344({ func: n => { return [d1, d2]; } }) : Genric<Base>
 >x344 : (n: Genric<Base>) => Genric<Base>
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3558,8 +3558,8 @@ var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]);
 >Base : Base
 >x345(() => [d1, d2]) : void
 >x345 : (n: () => Base[]) => void
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3570,8 +3570,8 @@ var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
 >Base : Base
 >x346(function() { return [d1, d2] }) : void
 >x346 : (n: () => Base[]) => void
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3582,9 +3582,9 @@ var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2
 >Base : Base
 >x347(function named() { return [d1, d2] }) : void
 >x347 : (n: () => Base[]) => void
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3595,8 +3595,8 @@ var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
 >Base : Base
 >x348(() => [d1, d2]) : void
 >x348 : (n: () => Base[]) => void
->() => [d1, d2] : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>() => [d1, d2] : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3607,8 +3607,8 @@ var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] }
 >Base : Base
 >x349(function() { return [d1, d2] }) : void
 >x349 : (n: () => Base[]) => void
->function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3619,9 +3619,9 @@ var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1,
 >Base : Base
 >x350(function named() { return [d1, d2] }) : void
 >x350 : (n: () => Base[]) => void
->function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
->named : () => Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => (Derived1 | Derived2)[]
+>named : () => (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3632,7 +3632,7 @@ var x351 = function(n: Base[]) { }; x351([d1, d2]);
 >Base : Base
 >x351([d1, d2]) : void
 >x351 : (n: Base[]) => void
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3644,7 +3644,7 @@ var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 >Base : Base
 >x352([d1, d2]) : void
 >x352 : (n: Base[]) => void
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3656,7 +3656,7 @@ var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
 >Base : Base
 >x353([d1, d2]) : void
 >x353 : (n: { [x: number]: Base; }) => void
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3668,9 +3668,9 @@ var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
 >Base : Base
 >x354({ n: [d1, d2] }) : void
 >x354 : (n: { n: Base[]; }) => void
->{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
->n : Array<Derived1 | Derived2>
->[d1, d2] : Array<Derived1 | Derived2>
+>{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
+>n : (Derived1 | Derived2)[]
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3695,11 +3695,11 @@ var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; }
 >Base : Base
 >x356({ func: n => { return [d1, d2]; } }) : void
 >x356 : (n: Genric<Base>) => void
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
->func : (n: Base[]) => Array<Derived1 | Derived2>
->n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => (Derived1 | Derived2)[]; }
+>func : (n: Base[]) => (Derived1 | Derived2)[]
+>n => { return [d1, d2]; } : (n: Base[]) => (Derived1 | Derived2)[]
 >n : Base[]
->[d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
 >d2 : Derived2
 
diff --git a/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types b/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types
index f16e747d41e..768b8846880 100644
--- a/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types
+++ b/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types
@@ -49,7 +49,7 @@ _.all([true, 1, null, 'yes'], _.identity);
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => boolean
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => boolean
->[true, 1, null, 'yes'] : Array<string | number | boolean>
+>[true, 1, null, 'yes'] : (string | number | boolean)[]
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
diff --git a/tests/baselines/reference/genericCallWithArrayLiteralArgs.types b/tests/baselines/reference/genericCallWithArrayLiteralArgs.types
index 84082a68ebd..f4965940436 100644
--- a/tests/baselines/reference/genericCallWithArrayLiteralArgs.types
+++ b/tests/baselines/reference/genericCallWithArrayLiteralArgs.types
@@ -40,21 +40,21 @@ var r3 = foo<number[]>([]); // number[]
 >[] : undefined[]
 
 var r4 = foo([1, '']); // {}[]
->r4 : Array<string | number>
->foo([1, '']) : Array<string | number>
+>r4 : (string | number)[]
+>foo([1, '']) : (string | number)[]
 >foo : <T>(t: T) => T
->[1, ''] : Array<string | number>
+>[1, ''] : (string | number)[]
 
 var r5 = foo<any[]>([1, '']); // any[]
 >r5 : any[]
 >foo<any[]>([1, '']) : any[]
 >foo : <T>(t: T) => T
->[1, ''] : Array<string | number>
+>[1, ''] : (string | number)[]
 
 var r6 = foo<Object[]>([1, '']); // Object[]
 >r6 : Object[]
 >foo<Object[]>([1, '']) : Object[]
 >foo : <T>(t: T) => T
 >Object : Object
->[1, ''] : Array<string | number>
+>[1, ''] : (string | number)[]
 
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgs2.types b/tests/baselines/reference/genericCallWithObjectTypeArgs2.types
index aa1eeaf4670..3e178a7062d 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgs2.types
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgs2.types
@@ -22,7 +22,7 @@ class Derived2 extends Base {
 
 // returns {}[]
 function f<T extends Base, U extends Base>(a: { x: T; y: U }) {
->f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => Array<T | U>
+>f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => (T | U)[]
 >T : T
 >Base : Base
 >U : U
@@ -34,7 +34,7 @@ function f<T extends Base, U extends Base>(a: { x: T; y: U }) {
 >U : U
 
     return [a.x, a.y];
->[a.x, a.y] : Array<T | U>
+>[a.x, a.y] : (T | U)[]
 >a.x : T
 >a : { x: T; y: U; }
 >x : T
@@ -44,9 +44,9 @@ function f<T extends Base, U extends Base>(a: { x: T; y: U }) {
 }
 
 var r = f({ x: new Derived(), y: new Derived2() }); // {}[]
->r : Array<Derived | Derived2>
->f({ x: new Derived(), y: new Derived2() }) : Array<Derived | Derived2>
->f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => Array<T | U>
+>r : (Derived | Derived2)[]
+>f({ x: new Derived(), y: new Derived2() }) : (Derived | Derived2)[]
+>f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => (T | U)[]
 >{ x: new Derived(), y: new Derived2() } : { x: Derived; y: Derived2; }
 >x : Derived
 >new Derived() : Derived
@@ -57,8 +57,8 @@ var r = f({ x: new Derived(), y: new Derived2() }); // {}[]
 
 var r2 = f({ x: new Base(), y: new Derived2() }); // {}[]
 >r2 : Base[]
->f({ x: new Base(), y: new Derived2() }) : Array<Base | Derived2>
->f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => Array<T | U>
+>f({ x: new Base(), y: new Derived2() }) : (Base | Derived2)[]
+>f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => (T | U)[]
 >{ x: new Base(), y: new Derived2() } : { x: Base; y: Derived2; }
 >x : Base
 >new Base() : Base
diff --git a/tests/baselines/reference/genericTypeArgumentInference1.types b/tests/baselines/reference/genericTypeArgumentInference1.types
index be7a3e9226d..c718ccca620 100644
--- a/tests/baselines/reference/genericTypeArgumentInference1.types
+++ b/tests/baselines/reference/genericTypeArgumentInference1.types
@@ -47,7 +47,7 @@ var r = _.all([true, 1, null, 'yes'], _.identity);
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
->[true, 1, null, 'yes'] : Array<string | number | boolean>
+>[true, 1, null, 'yes'] : (string | number | boolean)[]
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
diff --git a/tests/baselines/reference/genericsManyTypeParameters.types b/tests/baselines/reference/genericsManyTypeParameters.types
index df2144de866..cb492c30623 100644
--- a/tests/baselines/reference/genericsManyTypeParameters.types
+++ b/tests/baselines/reference/genericsManyTypeParameters.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/genericsManyTypeParameters.ts ===
 function Foo<
->Foo : <a1, a21, a31, a41, a51, a61, a119, a22, a32, a42, a52, a62, a219, a23, a33, a43, a53, a63, a319, a24, a34, a44, a54, a64, a419, a25, a35, a45, a55, a65, a519, a26, a36, a46, a56, a66, a619, a27, a37, a47, a57, a67, a71, a28, a38, a48, a58, a68, a81, a29, a39, a49, a59, a69, a91, a210, a310, a410, a510, a610, a111, a211, a311, a411, a511, a611, a112, a212, a312, a412, a512, a612, a113, a213, a313, a413, a513, a613, a114, a214, a314, a414, a514, a614, a115, a215, a315, a415, a515, a615, a116, a216, a316, a416, a516, a616, a117, a217, a317, a417, a517, a617, a118, a218, a318, a418, a518, a618>(x1: a1, y1: a21, z1: a31, a1: a41, b1: a51, c1: a61, x2: a119, y2: a22, z2: a32, a2: a42, b2: a52, c2: a62, x3: a219, y3: a23, z3: a33, a3: a43, b3: a53, c3: a63, x4: a319, y4: a24, z4: a34, a4: a44, b4: a54, c4: a64, x5: a419, y5: a25, z5: a35, a5: a45, b5: a55, c5: a65, x6: a519, y6: a26, z6: a36, a6: a46, b6: a56, c6: a66, x7: a619, y7: a27, z7: a37, a7: a47, b7: a57, c7: a67, x8: a71, y8: a28, z8: a38, a8: a48, b8: a58, c8: a68, x9: a81, y9: a29, z9: a39, a9: a49, b9: a59, c9: a69, x10: a91, y12: a210, z10: a310, a10: a410, b10: a510, c10: a610, x11: a111, y13: a211, z11: a311, a11: a411, b11: a511, c11: a611, x12: a112, y14: a212, z12: a312, a12: a412, b12: a512, c12: a612, x13: a113, y15: a213, z13: a313, a13: a413, b13: a513, c13: a613, x14: a114, y16: a214, z14: a314, a14: a414, b14: a514, c14: a614, x15: a115, y17: a215, z15: a315, a15: a415, b15: a515, c15: a615, x16: a116, y18: a216, z16: a316, a16: a416, b16: a516, c16: a616, x17: a117, y19: a217, z17: a317, a17: a417, b17: a517, c17: a617, x18: a118, y10: a218, z18: a318, a18: a418, b18: a518, c18: a618) => Array<a1 | a21 | a31 | a41 | a51 | a61 | a119 | a22 | a32 | a42 | a52 | a62 | a219 | a23 | a33 | a43 | a53 | a63 | a319 | a24 | a34 | a44 | a54 | a64 | a419 | a25 | a35 | a45 | a55 | a65 | a519 | a26 | a36 | a46 | a56 | a66 | a619 | a27 | a37 | a47 | a57 | a67 | a71 | a28 | a38 | a48 | a58 | a68 | a81 | a29 | a39 | a49 | a59 | a69 | a91 | a210 | a310 | a410 | a510 | a610 | a111 | a211 | a311 | a411 | a511 | a611 | a112 | a212 | a312 | a412 | a512 | a612 | a113 | a213 | a313 | a413 | a513 | a613 | a114 | a214 | a314 | a414 | a514 | a614 | a115 | a215 | a315 | a415 | a515 | a615 | a116 | a216 | a316 | a416 | a516 | a616 | a117 | a217 | a317 | a417 | a517 | a617 | a118 | a218 | a318 | a418 | a518 | a618>
+>Foo : <a1, a21, a31, a41, a51, a61, a119, a22, a32, a42, a52, a62, a219, a23, a33, a43, a53, a63, a319, a24, a34, a44, a54, a64, a419, a25, a35, a45, a55, a65, a519, a26, a36, a46, a56, a66, a619, a27, a37, a47, a57, a67, a71, a28, a38, a48, a58, a68, a81, a29, a39, a49, a59, a69, a91, a210, a310, a410, a510, a610, a111, a211, a311, a411, a511, a611, a112, a212, a312, a412, a512, a612, a113, a213, a313, a413, a513, a613, a114, a214, a314, a414, a514, a614, a115, a215, a315, a415, a515, a615, a116, a216, a316, a416, a516, a616, a117, a217, a317, a417, a517, a617, a118, a218, a318, a418, a518, a618>(x1: a1, y1: a21, z1: a31, a1: a41, b1: a51, c1: a61, x2: a119, y2: a22, z2: a32, a2: a42, b2: a52, c2: a62, x3: a219, y3: a23, z3: a33, a3: a43, b3: a53, c3: a63, x4: a319, y4: a24, z4: a34, a4: a44, b4: a54, c4: a64, x5: a419, y5: a25, z5: a35, a5: a45, b5: a55, c5: a65, x6: a519, y6: a26, z6: a36, a6: a46, b6: a56, c6: a66, x7: a619, y7: a27, z7: a37, a7: a47, b7: a57, c7: a67, x8: a71, y8: a28, z8: a38, a8: a48, b8: a58, c8: a68, x9: a81, y9: a29, z9: a39, a9: a49, b9: a59, c9: a69, x10: a91, y12: a210, z10: a310, a10: a410, b10: a510, c10: a610, x11: a111, y13: a211, z11: a311, a11: a411, b11: a511, c11: a611, x12: a112, y14: a212, z12: a312, a12: a412, b12: a512, c12: a612, x13: a113, y15: a213, z13: a313, a13: a413, b13: a513, c13: a613, x14: a114, y16: a214, z14: a314, a14: a414, b14: a514, c14: a614, x15: a115, y17: a215, z15: a315, a15: a415, b15: a515, c15: a615, x16: a116, y18: a216, z16: a316, a16: a416, b16: a516, c16: a616, x17: a117, y19: a217, z17: a317, a17: a417, b17: a517, c17: a617, x18: a118, y10: a218, z18: a318, a18: a418, b18: a518, c18: a618) => (a1 | a21 | a31 | a41 | a51 | a61 | a119 | a22 | a32 | a42 | a52 | a62 | a219 | a23 | a33 | a43 | a53 | a63 | a319 | a24 | a34 | a44 | a54 | a64 | a419 | a25 | a35 | a45 | a55 | a65 | a519 | a26 | a36 | a46 | a56 | a66 | a619 | a27 | a37 | a47 | a57 | a67 | a71 | a28 | a38 | a48 | a58 | a68 | a81 | a29 | a39 | a49 | a59 | a69 | a91 | a210 | a310 | a410 | a510 | a610 | a111 | a211 | a311 | a411 | a511 | a611 | a112 | a212 | a312 | a412 | a512 | a612 | a113 | a213 | a313 | a413 | a513 | a613 | a114 | a214 | a314 | a414 | a514 | a614 | a115 | a215 | a315 | a415 | a515 | a615 | a116 | a216 | a316 | a416 | a516 | a616 | a117 | a217 | a317 | a417 | a517 | a617 | a118 | a218 | a318 | a418 | a518 | a618)[]
 
     a1, a21, a31, a41, a51, a61,
 >a1 : a1
@@ -402,7 +402,7 @@ function Foo<
     )
     {
         return [x1 , y1 , z1 , a1 , b1 , c1,
->[x1 , y1 , z1 , a1 , b1 , c1,           x2 , y2 , z2 , a2 , b2 , c2,           x3 , y3 , z3 , a3 , b3 , c3,           x4 , y4 , z4 , a4 , b4 , c4,           x5 , y5 , z5 , a5 , b5 , c5,           x6 , y6 , z6 , a6 , b6 , c6,           x7 , y7 , z7 , a7 , b7 , c7,           x8 , y8 , z8 , a8 , b8 , c8,           x9 , y9 , z9 , a9 , b9 , c9,           x10 , y12 , z10 , a10 , b10 , c10,           x11 , y13 , z11 , a11 , b11 , c11,           x12 , y14 , z12 , a12 , b12 , c12,           x13 , y15 , z13 , a13 , b13 , c13,           x14 , y16 , z14 , a14 , b14 , c14,           x15 , y17 , z15 , a15 , b15 , c15,           x16 , y18 , z16 , a16 , b16 , c16,           x17 , y19 , z17 , a17 , b17 , c17,           x18 , y10 , z18 , a18 , b18 , c18] : Array<a1 | a21 | a31 | a41 | a51 | a61 | a119 | a22 | a32 | a42 | a52 | a62 | a219 | a23 | a33 | a43 | a53 | a63 | a319 | a24 | a34 | a44 | a54 | a64 | a419 | a25 | a35 | a45 | a55 | a65 | a519 | a26 | a36 | a46 | a56 | a66 | a619 | a27 | a37 | a47 | a57 | a67 | a71 | a28 | a38 | a48 | a58 | a68 | a81 | a29 | a39 | a49 | a59 | a69 | a91 | a210 | a310 | a410 | a510 | a610 | a111 | a211 | a311 | a411 | a511 | a611 | a112 | a212 | a312 | a412 | a512 | a612 | a113 | a213 | a313 | a413 | a513 | a613 | a114 | a214 | a314 | a414 | a514 | a614 | a115 | a215 | a315 | a415 | a515 | a615 | a116 | a216 | a316 | a416 | a516 | a616 | a117 | a217 | a317 | a417 | a517 | a617 | a118 | a218 | a318 | a418 | a518 | a618>
+>[x1 , y1 , z1 , a1 , b1 , c1,           x2 , y2 , z2 , a2 , b2 , c2,           x3 , y3 , z3 , a3 , b3 , c3,           x4 , y4 , z4 , a4 , b4 , c4,           x5 , y5 , z5 , a5 , b5 , c5,           x6 , y6 , z6 , a6 , b6 , c6,           x7 , y7 , z7 , a7 , b7 , c7,           x8 , y8 , z8 , a8 , b8 , c8,           x9 , y9 , z9 , a9 , b9 , c9,           x10 , y12 , z10 , a10 , b10 , c10,           x11 , y13 , z11 , a11 , b11 , c11,           x12 , y14 , z12 , a12 , b12 , c12,           x13 , y15 , z13 , a13 , b13 , c13,           x14 , y16 , z14 , a14 , b14 , c14,           x15 , y17 , z15 , a15 , b15 , c15,           x16 , y18 , z16 , a16 , b16 , c16,           x17 , y19 , z17 , a17 , b17 , c17,           x18 , y10 , z18 , a18 , b18 , c18] : (a1 | a21 | a31 | a41 | a51 | a61 | a119 | a22 | a32 | a42 | a52 | a62 | a219 | a23 | a33 | a43 | a53 | a63 | a319 | a24 | a34 | a44 | a54 | a64 | a419 | a25 | a35 | a45 | a55 | a65 | a519 | a26 | a36 | a46 | a56 | a66 | a619 | a27 | a37 | a47 | a57 | a67 | a71 | a28 | a38 | a48 | a58 | a68 | a81 | a29 | a39 | a49 | a59 | a69 | a91 | a210 | a310 | a410 | a510 | a610 | a111 | a211 | a311 | a411 | a511 | a611 | a112 | a212 | a312 | a412 | a512 | a612 | a113 | a213 | a313 | a413 | a513 | a613 | a114 | a214 | a314 | a414 | a514 | a614 | a115 | a215 | a315 | a415 | a515 | a615 | a116 | a216 | a316 | a416 | a516 | a616 | a117 | a217 | a317 | a417 | a517 | a617 | a118 | a218 | a318 | a418 | a518 | a618)[]
 >x1 : a1
 >y1 : a21
 >z1 : a31
diff --git a/tests/baselines/reference/heterogeneousArrayAndOverloads.errors.txt b/tests/baselines/reference/heterogeneousArrayAndOverloads.errors.txt
index 985aaa7948c..15f8f21b8f3 100644
--- a/tests/baselines/reference/heterogeneousArrayAndOverloads.errors.txt
+++ b/tests/baselines/reference/heterogeneousArrayAndOverloads.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/heterogeneousArrayAndOverloads.ts(9,19): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'string[]'.
+tests/cases/compiler/heterogeneousArrayAndOverloads.ts(9,19): error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'string[]'.
   Type 'string | number' is not assignable to type 'string':
     Type 'number' is not assignable to type 'string'.
 
@@ -14,7 +14,7 @@ tests/cases/compiler/heterogeneousArrayAndOverloads.ts(9,19): error TS2345: Argu
             this.test([]);
             this.test([1, 2, "hi", 5]); // Error
                       ~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'string[]'.
+!!! error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'string[]'.
 !!! error TS2345:   Type 'string | number' is not assignable to type 'string':
 !!! error TS2345:     Type 'number' is not assignable to type 'string'.
         }
diff --git a/tests/baselines/reference/heterogeneousArrayLiterals.types b/tests/baselines/reference/heterogeneousArrayLiterals.types
index c236fe7ff6d..7ea7d4196a6 100644
--- a/tests/baselines/reference/heterogeneousArrayLiterals.types
+++ b/tests/baselines/reference/heterogeneousArrayLiterals.types
@@ -2,16 +2,16 @@
 // type of an array is the best common type of its elements (plus its contextual type if it exists)
 
 var a = [1, '']; // {}[]
->a : Array<string | number>
->[1, ''] : Array<string | number>
+>a : (string | number)[]
+>[1, ''] : (string | number)[]
 
 var b = [1, null]; // number[]
 >b : number[]
 >[1, null] : number[]
 
 var c = [1, '', null]; // {}[]
->c : Array<string | number>
->[1, '', null] : Array<string | number>
+>c : (string | number)[]
+>[1, '', null] : (string | number)[]
 
 var d = [{}, 1]; // {}[]
 >d : {}[]
@@ -31,8 +31,8 @@ var f = [[], [1]]; // number[][]
 >[1] : number[]
 
 var g = [[1], ['']]; // {}[]
->g : Array<string[] | number[]>
->[[1], ['']] : Array<string[] | number[]>
+>g : (string[] | number[])[]
+>[[1], ['']] : (string[] | number[])[]
 >[1] : number[]
 >[''] : string[]
 
@@ -46,8 +46,8 @@ var h = [{ foo: 1, bar: '' }, { foo: 2 }]; // {foo: number}[]
 >foo : number
 
 var i = [{ foo: 1, bar: '' }, { foo: '' }]; // {}[]
->i : Array<{ foo: number; bar: string; } | { foo: string; }>
->[{ foo: 1, bar: '' }, { foo: '' }] : Array<{ foo: number; bar: string; } | { foo: string; }>
+>i : ({ foo: number; bar: string; } | { foo: string; })[]
+>[{ foo: 1, bar: '' }, { foo: '' }] : ({ foo: number; bar: string; } | { foo: string; })[]
 >{ foo: 1, bar: '' } : { foo: number; bar: string; }
 >foo : number
 >bar : string
@@ -55,36 +55,36 @@ var i = [{ foo: 1, bar: '' }, { foo: '' }]; // {}[]
 >foo : string
 
 var j = [() => 1, () => '']; // {}[]
->j : Array<{ (): number; } | { (): string; }>
->[() => 1, () => ''] : Array<{ (): number; } | { (): string; }>
+>j : ((() => number) | (() => string))[]
+>[() => 1, () => ''] : ((() => number) | (() => string))[]
 >() => 1 : () => number
 >() => '' : () => string
 
 var k = [() => 1, () => 1]; // { (): number }[]
->k : { (): number; }[]
->[() => 1, () => 1] : { (): number; }[]
+>k : (() => number)[]
+>[() => 1, () => 1] : (() => number)[]
 >() => 1 : () => number
 >() => 1 : () => number
 
 var l = [() => 1, () => null]; // { (): any }[]
->l : { (): any; }[]
->[() => 1, () => null] : { (): any; }[]
+>l : (() => any)[]
+>[() => 1, () => null] : (() => any)[]
 >() => 1 : () => number
 >() => null : () => any
 
 var m = [() => 1, () => '', () => null]; // { (): any }[]
->m : { (): any; }[]
->[() => 1, () => '', () => null] : { (): any; }[]
+>m : (() => any)[]
+>[() => 1, () => '', () => null] : (() => any)[]
 >() => 1 : () => number
 >() => '' : () => string
 >() => null : () => any
 
 var n = [[() => 1], [() => '']]; // {}[]
->n : Array<{ (): number; }[] | { (): string; }[]>
->[[() => 1], [() => '']] : Array<{ (): number; }[] | { (): string; }[]>
->[() => 1] : { (): number; }[]
+>n : ((() => number)[] | (() => string)[])[]
+>[[() => 1], [() => '']] : ((() => number)[] | (() => string)[])[]
+>[() => 1] : (() => number)[]
 >() => 1 : () => number
->[() => ''] : { (): string; }[]
+>[() => ''] : (() => string)[]
 >() => '' : () => string
 
 class Base { foo: string; }
@@ -129,8 +129,8 @@ module Derived {
 >base : Base
 
     var i = [{ foo: base, basear: derived }, { foo: derived }]; // {foo: Derived}[]
->i : Array<{ foo: Base; basear: Derived; } | { foo: Derived; }>
->[{ foo: base, basear: derived }, { foo: derived }] : Array<{ foo: Base; basear: Derived; } | { foo: Derived; }>
+>i : ({ foo: Base; basear: Derived; } | { foo: Derived; })[]
+>[{ foo: base, basear: derived }, { foo: derived }] : ({ foo: Base; basear: Derived; } | { foo: Derived; })[]
 >{ foo: base, basear: derived } : { foo: Base; basear: Derived; }
 >foo : Base
 >base : Base
@@ -141,30 +141,30 @@ module Derived {
 >derived : Derived
 
     var j = [() => base, () => derived]; // { {}: Base }
->j : { (): Base; }[]
->[() => base, () => derived] : { (): Base; }[]
+>j : (() => Base)[]
+>[() => base, () => derived] : (() => Base)[]
 >() => base : () => Base
 >base : Base
 >() => derived : () => Derived
 >derived : Derived
 
     var k = [() => base, () => 1]; // {}[]~
->k : Array<{ (): Base; } | { (): number; }>
->[() => base, () => 1] : Array<{ (): Base; } | { (): number; }>
+>k : ((() => Base) | (() => number))[]
+>[() => base, () => 1] : ((() => Base) | (() => number))[]
 >() => base : () => Base
 >base : Base
 >() => 1 : () => number
 
     var l = [() => base, () => null]; // { (): any }[]
->l : { (): any; }[]
->[() => base, () => null] : { (): any; }[]
+>l : (() => any)[]
+>[() => base, () => null] : (() => any)[]
 >() => base : () => Base
 >base : Base
 >() => null : () => any
 
     var m = [() => base, () => derived, () => null]; // { (): any }[]
->m : { (): any; }[]
->[() => base, () => derived, () => null] : { (): any; }[]
+>m : (() => any)[]
+>[() => base, () => derived, () => null] : (() => any)[]
 >() => base : () => Base
 >base : Base
 >() => derived : () => Derived
@@ -172,18 +172,18 @@ module Derived {
 >() => null : () => any
 
     var n = [[() => base], [() => derived]]; // { (): Base }[]
->n : { (): Base; }[][]
->[[() => base], [() => derived]] : { (): Base; }[][]
->[() => base] : { (): Base; }[]
+>n : (() => Base)[][]
+>[[() => base], [() => derived]] : (() => Base)[][]
+>[() => base] : (() => Base)[]
 >() => base : () => Base
 >base : Base
->[() => derived] : { (): Derived; }[]
+>[() => derived] : (() => Derived)[]
 >() => derived : () => Derived
 >derived : Derived
 
     var o = [derived, derived2]; // {}[]
->o : Array<Derived | Derived2>
->[derived, derived2] : Array<Derived | Derived2>
+>o : (Derived | Derived2)[]
+>[derived, derived2] : (Derived | Derived2)[]
 >derived : Derived
 >derived2 : Derived2
 
@@ -195,12 +195,12 @@ module Derived {
 >base : Base
 
     var q = [[() => derived2], [() => derived]]; // {}[]
->q : Array<{ (): Derived2; }[] | { (): Derived; }[]>
->[[() => derived2], [() => derived]] : Array<{ (): Derived2; }[] | { (): Derived; }[]>
->[() => derived2] : { (): Derived2; }[]
+>q : ((() => Derived2)[] | (() => Derived)[])[]
+>[[() => derived2], [() => derived]] : ((() => Derived2)[] | (() => Derived)[])[]
+>[() => derived2] : (() => Derived2)[]
 >() => derived2 : () => Derived2
 >derived2 : Derived2
->[() => derived] : { (): Derived; }[]
+>[() => derived] : (() => Derived)[]
 >() => derived : () => Derived
 >derived : Derived
 }
@@ -212,7 +212,7 @@ module WithContextualType {
     var a: Base[] = [derived, derived2];
 >a : Base[]
 >Base : Base
->[derived, derived2] : Array<Derived | Derived2>
+>[derived, derived2] : (Derived | Derived2)[]
 >derived : Derived
 >derived2 : Derived2
 
@@ -227,9 +227,9 @@ module WithContextualType {
 >[] : undefined[]
 
     var d: { (): Base }[] = [() => derived, () => derived2];
->d : { (): Base; }[]
+>d : (() => Base)[]
 >Base : Base
->[() => derived, () => derived2] : Array<{ (): Derived; } | { (): Derived2; }>
+>[() => derived, () => derived2] : ((() => Derived) | (() => Derived2))[]
 >() => derived : () => Derived
 >derived : Derived
 >() => derived2 : () => Derived2
@@ -257,27 +257,27 @@ function foo<T, U>(t: T, u: U) {
 >t : T
 
     var c = [t, u]; // {}[]
->c : Array<T | U>
->[t, u] : Array<T | U>
+>c : (T | U)[]
+>[t, u] : (T | U)[]
 >t : T
 >u : U
 
     var d = [t, 1]; // {}[]
->d : Array<number | T>
->[t, 1] : Array<number | T>
+>d : (number | T)[]
+>[t, 1] : (number | T)[]
 >t : T
 
     var e = [() => t, () => u]; // {}[]
->e : Array<{ (): T; } | { (): U; }>
->[() => t, () => u] : Array<{ (): T; } | { (): U; }>
+>e : ((() => T) | (() => U))[]
+>[() => t, () => u] : ((() => T) | (() => U))[]
 >() => t : () => T
 >t : T
 >() => u : () => U
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : { (): any; }[]
->[() => t, () => u, () => null] : { (): any; }[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -308,27 +308,27 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 >t : T
 
     var c = [t, u]; // {}[]
->c : Array<T | U>
->[t, u] : Array<T | U>
+>c : (T | U)[]
+>[t, u] : (T | U)[]
 >t : T
 >u : U
 
     var d = [t, 1]; // {}[]
->d : Array<number | T>
->[t, 1] : Array<number | T>
+>d : (number | T)[]
+>[t, 1] : (number | T)[]
 >t : T
 
     var e = [() => t, () => u]; // {}[]
->e : Array<{ (): T; } | { (): U; }>
->[() => t, () => u] : Array<{ (): T; } | { (): U; }>
+>e : ((() => T) | (() => U))[]
+>[() => t, () => u] : ((() => T) | (() => U))[]
 >() => t : () => T
 >t : T
 >() => u : () => U
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : { (): any; }[]
->[() => t, () => u, () => null] : { (): any; }[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -342,8 +342,8 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 >base : Base
 
     var h = [t, derived]; // Derived[]
->h : Array<Derived | T>
->[t, derived] : Array<Derived | T>
+>h : (Derived | T)[]
+>[t, derived] : (Derived | T)[]
 >t : T
 >derived : Derived
 
@@ -383,27 +383,27 @@ function foo3<T extends Derived, U extends Derived>(t: T, u: U) {
 >t : T
 
     var c = [t, u]; // {}[]
->c : Array<T | U>
->[t, u] : Array<T | U>
+>c : (T | U)[]
+>[t, u] : (T | U)[]
 >t : T
 >u : U
 
     var d = [t, 1]; // {}[]
->d : Array<number | T>
->[t, 1] : Array<number | T>
+>d : (number | T)[]
+>[t, 1] : (number | T)[]
 >t : T
 
     var e = [() => t, () => u]; // {}[]
->e : Array<{ (): T; } | { (): U; }>
->[() => t, () => u] : Array<{ (): T; } | { (): U; }>
+>e : ((() => T) | (() => U))[]
+>[() => t, () => u] : ((() => T) | (() => U))[]
 >() => t : () => T
 >t : T
 >() => u : () => U
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : { (): any; }[]
->[() => t, () => u, () => null] : { (): any; }[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -458,27 +458,27 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >t : T
 
     var c = [t, u]; // BUG 821629
->c : Array<T | U>
->[t, u] : Array<T | U>
+>c : (T | U)[]
+>[t, u] : (T | U)[]
 >t : T
 >u : U
 
     var d = [t, 1]; // {}[]
->d : Array<number | T>
->[t, 1] : Array<number | T>
+>d : (number | T)[]
+>[t, 1] : (number | T)[]
 >t : T
 
     var e = [() => t, () => u]; // {}[]
->e : Array<{ (): T; } | { (): U; }>
->[() => t, () => u] : Array<{ (): T; } | { (): U; }>
+>e : ((() => T) | (() => U))[]
+>[() => t, () => u] : ((() => T) | (() => U))[]
 >() => t : () => T
 >t : T
 >() => u : () => U
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : { (): any; }[]
->[() => t, () => u, () => null] : { (): any; }[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -492,8 +492,8 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >base : Base
 
     var h = [t, derived]; // Derived[]
->h : Array<Derived | T>
->[t, derived] : Array<Derived | T>
+>h : (Derived | T)[]
+>[t, derived] : (Derived | T)[]
 >t : T
 >derived : Derived
 
@@ -504,15 +504,15 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >base : Base
 
     var j = [u, derived]; // Derived[]
->j : Array<Derived | U>
->[u, derived] : Array<Derived | U>
+>j : (Derived | U)[]
+>[u, derived] : (Derived | U)[]
 >u : U
 >derived : Derived
 
     var k: Base[] = [t, u];
 >k : Base[]
 >Base : Base
->[t, u] : Array<T | U>
+>[t, u] : (T | U)[]
 >t : T
 >u : U
 }
diff --git a/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt b/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
index b82c82b9eb5..3ec718f3b25 100644
--- a/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
+++ b/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
@@ -7,7 +7,7 @@ tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDec
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(40,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(43,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(46,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
-tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(47,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'Array<C | D<string>>'.
+tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(47,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(50,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(53,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
 
@@ -79,7 +79,7 @@ tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDec
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
     var arr = [new C(), new C2(), new D<string>()];
         ~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'Array<C | D<string>>'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
     
     var arr2 = [new D<string>()];
     var arr2 = new Array<D<number>>();
diff --git a/tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt b/tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt
index ed4f45ec1de..cc93b716d2e 100644
--- a/tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt
+++ b/tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(10,30): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(10,30): error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
   Type 'string | number' is not assignable to type 'number':
     Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(11,11): error TS2346: Supplied parameters do not match any signature of call target.
@@ -16,7 +16,7 @@ tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(11,11): e
     var r6 = map<Object, Object>([1, ""], (x) => x.toString());
     var r7 = map<number, string>([1, ""], (x) => x.toString()); // error
                                  ~~~~~~~
-!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+!!! error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
 !!! error TS2345:   Type 'string | number' is not assignable to type 'number':
 !!! error TS2345:     Type 'string' is not assignable to type 'number'.
     var r7b = map<number>([1, ""], (x) => x.toString()); // error
diff --git a/tests/baselines/reference/nestedRecursiveLambda.types b/tests/baselines/reference/nestedRecursiveLambda.types
index 358ebda8abf..864daea3e1f 100644
--- a/tests/baselines/reference/nestedRecursiveLambda.types
+++ b/tests/baselines/reference/nestedRecursiveLambda.types
@@ -35,7 +35,7 @@ void(r =>(r => r));
 >r : any
 
 [(r =>(r => r))]
->[(r =>(r => r))] : { (r: any): (r: any) => any; }[]
+>[(r =>(r => r))] : ((r: any) => (r: any) => any)[]
 >(r =>(r => r)) : (r: any) => (r: any) => any
 >r =>(r => r) : (r: any) => (r: any) => any
 >r : any
diff --git a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
index b71b04263b1..8039cdf01f0 100644
--- a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
+++ b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
@@ -24,9 +24,9 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(71,5): error TS2411: Property 'foo' of type '() => string' is not assignable to string index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(73,5): error TS2411: Property '"4.0"' of type 'number' is not assignable to string index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(74,5): error TS2411: Property 'f' of type 'MyString' is not assignable to string index type 'string'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: string]: string | number | MyString | { (): void; }; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo: () => string; }' is not assignable to type '{ [x: string]: string; }':
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: string]: string | number | MyString | (() => void); 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo: () => string; }' is not assignable to type '{ [x: string]: string; }':
   Index signatures are incompatible:
-    Type 'string | number | MyString | { (): void; }' is not assignable to type 'string':
+    Type 'string | number | MyString | (() => void)' is not assignable to type 'string':
       Type 'number' is not assignable to type 'string'.
 
 
@@ -160,9 +160,9 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
     // error
     var b: { [x: string]: string; } = {
         ~
-!!! error TS2322: Type '{ [x: string]: string | number | MyString | { (): void; }; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo: () => string; }' is not assignable to type '{ [x: string]: string; }':
+!!! error TS2322: Type '{ [x: string]: string | number | MyString | (() => void); 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo: () => string; }' is not assignable to type '{ [x: string]: string; }':
 !!! error TS2322:   Index signatures are incompatible:
-!!! error TS2322:     Type 'string | number | MyString | { (): void; }' is not assignable to type 'string':
+!!! error TS2322:     Type 'string | number | MyString | (() => void)' is not assignable to type 'string':
 !!! error TS2322:       Type 'number' is not assignable to type 'string'.
         a: '',
         b: 1, 
diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.types b/tests/baselines/reference/subtypingWithCallSignatures2.types
index 12344a46f3f..a2669bf6e65 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures2.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures2.types
@@ -330,14 +330,14 @@ var r1 = foo1(r1arg1); // any, return types are not subtype of first overload
 >r1arg1 : <T>(x: T) => T[]
 
 var r1a = [r1arg2, r1arg1]; // generic signature, subtype in both directions
->r1a : { <T>(x: T): T[]; }[]
->[r1arg2, r1arg1] : { <T>(x: T): T[]; }[]
+>r1a : (<T>(x: T) => T[])[]
+>[r1arg2, r1arg1] : (<T>(x: T) => T[])[]
 >r1arg2 : (x: number) => number[]
 >r1arg1 : <T>(x: T) => T[]
 
 var r1b = [r1arg1, r1arg2]; // generic signature, subtype in both directions
->r1b : { <T>(x: T): T[]; }[]
->[r1arg1, r1arg2] : { <T>(x: T): T[]; }[]
+>r1b : (<T>(x: T) => T[])[]
+>[r1arg1, r1arg2] : (<T>(x: T) => T[])[]
 >r1arg1 : <T>(x: T) => T[]
 >r1arg2 : (x: number) => number[]
 
@@ -362,14 +362,14 @@ var r2 = foo2(r2arg1);
 >r2arg1 : <T>(x: T) => string[]
 
 var r2a = [r2arg1, r2arg2];
->r2a : { <T>(x: T): string[]; }[]
->[r2arg1, r2arg2] : { <T>(x: T): string[]; }[]
+>r2a : (<T>(x: T) => string[])[]
+>[r2arg1, r2arg2] : (<T>(x: T) => string[])[]
 >r2arg1 : <T>(x: T) => string[]
 >r2arg2 : (x: number) => string[]
 
 var r2b = [r2arg2, r2arg1];
->r2b : { <T>(x: T): string[]; }[]
->[r2arg2, r2arg1] : { <T>(x: T): string[]; }[]
+>r2b : (<T>(x: T) => string[])[]
+>[r2arg2, r2arg1] : (<T>(x: T) => string[])[]
 >r2arg2 : (x: number) => string[]
 >r2arg1 : <T>(x: T) => string[]
 
@@ -393,14 +393,14 @@ var r3 = foo3(r3arg1);
 >r3arg1 : <T>(x: T) => T
 
 var r3a = [r3arg1, r3arg2];
->r3a : { <T>(x: T): T; }[]
->[r3arg1, r3arg2] : { <T>(x: T): T; }[]
+>r3a : (<T>(x: T) => T)[]
+>[r3arg1, r3arg2] : (<T>(x: T) => T)[]
 >r3arg1 : <T>(x: T) => T
 >r3arg2 : (x: number) => void
 
 var r3b = [r3arg2, r3arg1];
->r3b : { <T>(x: T): T; }[]
->[r3arg2, r3arg1] : { <T>(x: T): T; }[]
+>r3b : (<T>(x: T) => T)[]
+>[r3arg2, r3arg1] : (<T>(x: T) => T)[]
 >r3arg2 : (x: number) => void
 >r3arg1 : <T>(x: T) => T
 
@@ -428,14 +428,14 @@ var r4 = foo4(r4arg1); // any
 >r4arg1 : <T, U>(x: T, y: U) => T
 
 var r4a = [r4arg1, r4arg2];
->r4a : { <T, U>(x: T, y: U): T; }[]
->[r4arg1, r4arg2] : { <T, U>(x: T, y: U): T; }[]
+>r4a : (<T, U>(x: T, y: U) => T)[]
+>[r4arg1, r4arg2] : (<T, U>(x: T, y: U) => T)[]
 >r4arg1 : <T, U>(x: T, y: U) => T
 >r4arg2 : (x: string, y: number) => string
 
 var r4b = [r4arg2, r4arg1];
->r4b : { <T, U>(x: T, y: U): T; }[]
->[r4arg2, r4arg1] : { <T, U>(x: T, y: U): T; }[]
+>r4b : (<T, U>(x: T, y: U) => T)[]
+>[r4arg2, r4arg1] : (<T, U>(x: T, y: U) => T)[]
 >r4arg2 : (x: string, y: number) => string
 >r4arg1 : <T, U>(x: T, y: U) => T
 
@@ -464,14 +464,14 @@ var r5 = foo5(r5arg1); // any
 >r5arg1 : <T, U>(x: (arg: T) => U) => T
 
 var r5a = [r5arg1, r5arg2];
->r5a : { <T, U>(x: (arg: T) => U): T; }[]
->[r5arg1, r5arg2] : { <T, U>(x: (arg: T) => U): T; }[]
+>r5a : (<T, U>(x: (arg: T) => U) => T)[]
+>[r5arg1, r5arg2] : (<T, U>(x: (arg: T) => U) => T)[]
 >r5arg1 : <T, U>(x: (arg: T) => U) => T
 >r5arg2 : (x: (arg: string) => number) => string
 
 var r5b = [r5arg2, r5arg1];
->r5b : { <T, U>(x: (arg: T) => U): T; }[]
->[r5arg2, r5arg1] : { <T, U>(x: (arg: T) => U): T; }[]
+>r5b : (<T, U>(x: (arg: T) => U) => T)[]
+>[r5arg2, r5arg1] : (<T, U>(x: (arg: T) => U) => T)[]
 >r5arg2 : (x: (arg: string) => number) => string
 >r5arg1 : <T, U>(x: (arg: T) => U) => T
 
@@ -506,14 +506,14 @@ var r6 = foo6(r6arg1); // any
 >r6arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
 var r6a = [r6arg1, r6arg2];
->r6a : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
->[r6arg1, r6arg2] : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
+>r6a : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
+>[r6arg1, r6arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
 >r6arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 >r6arg2 : (x: (arg: Base) => Derived) => Base
 
 var r6b = [r6arg2, r6arg1];
->r6b : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
->[r6arg2, r6arg1] : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
+>r6b : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
+>[r6arg2, r6arg1] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
 >r6arg2 : (x: (arg: Base) => Derived) => Base
 >r6arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
@@ -554,14 +554,14 @@ var r7 = foo7(r7arg1); // any
 >r7arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U
 
 var r7a = [r7arg1, r7arg2];
->r7a : { <T extends Base, U extends Derived>(x: (arg: T) => U): (r: T) => U; }[]
->[r7arg1, r7arg2] : { <T extends Base, U extends Derived>(x: (arg: T) => U): (r: T) => U; }[]
+>r7a : (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U)[]
+>[r7arg1, r7arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U)[]
 >r7arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U
 >r7arg2 : (x: (arg: Base) => Derived) => (r: Base) => Derived
 
 var r7b = [r7arg2, r7arg1];
->r7b : { <T extends Base, U extends Derived>(x: (arg: T) => U): (r: T) => U; }[]
->[r7arg2, r7arg1] : { <T extends Base, U extends Derived>(x: (arg: T) => U): (r: T) => U; }[]
+>r7b : (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U)[]
+>[r7arg2, r7arg1] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U)[]
 >r7arg2 : (x: (arg: Base) => Derived) => (r: Base) => Derived
 >r7arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U
 
@@ -610,14 +610,14 @@ var r8 = foo8(r8arg1); // any
 >r8arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U
 
 var r8a = [r8arg1, r8arg2];
->r8a : { <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U): (r: T) => U; }[]
->[r8arg1, r8arg2] : { <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U): (r: T) => U; }[]
+>r8a : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U)[]
+>[r8arg1, r8arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U)[]
 >r8arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U
 >r8arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 
 var r8b = [r8arg2, r8arg1];
->r8b : { <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U): (r: T) => U; }[]
->[r8arg2, r8arg1] : { <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U): (r: T) => U; }[]
+>r8b : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U)[]
+>[r8arg2, r8arg1] : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U)[]
 >r8arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 >r8arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U
 
@@ -667,14 +667,14 @@ var r9 = foo9(r9arg1); // any
 >r9arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
 
 var r9a = [r9arg1, r9arg2];
->r9a : { <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): (r: T) => U; }[]
->[r9arg1, r9arg2] : { <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): (r: T) => U; }[]
+>r9a : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U)[]
+>[r9arg1, r9arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U)[]
 >r9arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
 >r9arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 
 var r9b = [r9arg2, r9arg1];
->r9b : { <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): (r: T) => U; }[]
->[r9arg2, r9arg1] : { <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): (r: T) => U; }[]
+>r9b : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U)[]
+>[r9arg2, r9arg1] : (<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U)[]
 >r9arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 >r9arg1 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
 
@@ -703,14 +703,14 @@ var r10 = foo10(r10arg1); // any
 >r10arg1 : <T extends Derived>(...x: T[]) => T
 
 var r10a = [r10arg1, r10arg2];
->r10a : { <T extends Derived>(...x: T[]): T; }[]
->[r10arg1, r10arg2] : { <T extends Derived>(...x: T[]): T; }[]
+>r10a : (<T extends Derived>(...x: T[]) => T)[]
+>[r10arg1, r10arg2] : (<T extends Derived>(...x: T[]) => T)[]
 >r10arg1 : <T extends Derived>(...x: T[]) => T
 >r10arg2 : (...x: Derived[]) => Derived
 
 var r10b = [r10arg2, r10arg1];
->r10b : { <T extends Derived>(...x: T[]): T; }[]
->[r10arg2, r10arg1] : { <T extends Derived>(...x: T[]): T; }[]
+>r10b : (<T extends Derived>(...x: T[]) => T)[]
+>[r10arg2, r10arg1] : (<T extends Derived>(...x: T[]) => T)[]
 >r10arg2 : (...x: Derived[]) => Derived
 >r10arg1 : <T extends Derived>(...x: T[]) => T
 
@@ -743,14 +743,14 @@ var r11 = foo11(r11arg1); // any
 >r11arg1 : <T extends Base>(x: T, y: T) => T
 
 var r11a = [r11arg1, r11arg2];
->r11a : { <T extends Base>(x: T, y: T): T; }[]
->[r11arg1, r11arg2] : { <T extends Base>(x: T, y: T): T; }[]
+>r11a : (<T extends Base>(x: T, y: T) => T)[]
+>[r11arg1, r11arg2] : (<T extends Base>(x: T, y: T) => T)[]
 >r11arg1 : <T extends Base>(x: T, y: T) => T
 >r11arg2 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
 var r11b = [r11arg2, r11arg1];
->r11b : { <T extends Base>(x: T, y: T): T; }[]
->[r11arg2, r11arg1] : { <T extends Base>(x: T, y: T): T; }[]
+>r11b : (<T extends Base>(x: T, y: T) => T)[]
+>[r11arg2, r11arg1] : (<T extends Base>(x: T, y: T) => T)[]
 >r11arg2 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >r11arg1 : <T extends Base>(x: T, y: T) => T
 
@@ -789,14 +789,14 @@ var r12 = foo12(r12arg1); // any
 >r12arg1 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 
 var r12a = [r12arg1, r12arg2];
->r12a : { <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
->[r12arg1, r12arg2] : { <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
+>r12a : (<T extends Base[]>(x: Base[], y: T) => Derived[])[]
+>[r12arg1, r12arg2] : (<T extends Base[]>(x: Base[], y: T) => Derived[])[]
 >r12arg1 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 >r12arg2 : (x: Base[], y: Derived2[]) => Derived[]
 
 var r12b = [r12arg2, r12arg1];
->r12b : { <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
->[r12arg2, r12arg1] : { <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
+>r12b : (<T extends Base[]>(x: Base[], y: T) => Derived[])[]
+>[r12arg2, r12arg1] : (<T extends Base[]>(x: Base[], y: T) => Derived[])[]
 >r12arg2 : (x: Base[], y: Derived2[]) => Derived[]
 >r12arg1 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 
@@ -833,14 +833,14 @@ var r13 = foo13(r13arg1); // any
 >r13arg1 : <T extends Derived[]>(x: Base[], y: T) => T
 
 var r13a = [r13arg1, r13arg2];
->r13a : { <T extends Derived[]>(x: Base[], y: T): T; }[]
->[r13arg1, r13arg2] : { <T extends Derived[]>(x: Base[], y: T): T; }[]
+>r13a : (<T extends Derived[]>(x: Base[], y: T) => T)[]
+>[r13arg1, r13arg2] : (<T extends Derived[]>(x: Base[], y: T) => T)[]
 >r13arg1 : <T extends Derived[]>(x: Base[], y: T) => T
 >r13arg2 : (x: Base[], y: Derived[]) => Derived[]
 
 var r13b = [r13arg2, r13arg1];
->r13b : { <T extends Derived[]>(x: Base[], y: T): T; }[]
->[r13arg2, r13arg1] : { <T extends Derived[]>(x: Base[], y: T): T; }[]
+>r13b : (<T extends Derived[]>(x: Base[], y: T) => T)[]
+>[r13arg2, r13arg1] : (<T extends Derived[]>(x: Base[], y: T) => T)[]
 >r13arg2 : (x: Base[], y: Derived[]) => Derived[]
 >r13arg1 : <T extends Derived[]>(x: Base[], y: T) => T
 
@@ -873,14 +873,14 @@ var r14 = foo14(r14arg1); // any
 >r14arg1 : <T>(x: { a: T; b: T; }) => T
 
 var r14a = [r14arg1, r14arg2];
->r14a : { <T>(x: { a: T; b: T; }): T; }[]
->[r14arg1, r14arg2] : { <T>(x: { a: T; b: T; }): T; }[]
+>r14a : (<T>(x: { a: T; b: T; }) => T)[]
+>[r14arg1, r14arg2] : (<T>(x: { a: T; b: T; }) => T)[]
 >r14arg1 : <T>(x: { a: T; b: T; }) => T
 >r14arg2 : (x: { a: string; b: number; }) => Object
 
 var r14b = [r14arg2, r14arg1];
->r14b : { <T>(x: { a: T; b: T; }): T; }[]
->[r14arg2, r14arg1] : { <T>(x: { a: T; b: T; }): T; }[]
+>r14b : (<T>(x: { a: T; b: T; }) => T)[]
+>[r14arg2, r14arg1] : (<T>(x: { a: T; b: T; }) => T)[]
 >r14arg2 : (x: { a: string; b: number; }) => Object
 >r14arg1 : <T>(x: { a: T; b: T; }) => T
 
diff --git a/tests/baselines/reference/subtypingWithCallSignatures3.types b/tests/baselines/reference/subtypingWithCallSignatures3.types
index be5fb44c9c7..cc2d47d3a33 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures3.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures3.types
@@ -218,8 +218,8 @@ module Errors {
 >U : U
 
     var r1a = [(x: number) => [''], <T, U>(x: T) => <U[]>null];
->r1a : { <T, U>(x: T): U[]; }[]
->[(x: number) => [''], <T, U>(x: T) => <U[]>null] : { <T, U>(x: T): U[]; }[]
+>r1a : (<T, U>(x: T) => U[])[]
+>[(x: number) => [''], <T, U>(x: T) => <U[]>null] : (<T, U>(x: T) => U[])[]
 >(x: number) => [''] : (x: number) => string[]
 >x : number
 >[''] : string[]
@@ -232,8 +232,8 @@ module Errors {
 >U : U
 
     var r1b = [<T, U>(x: T) => <U[]>null, (x: number) => ['']];
->r1b : { <T, U>(x: T): U[]; }[]
->[<T, U>(x: T) => <U[]>null, (x: number) => ['']] : { <T, U>(x: T): U[]; }[]
+>r1b : (<T, U>(x: T) => U[])[]
+>[<T, U>(x: T) => <U[]>null, (x: number) => ['']] : (<T, U>(x: T) => U[])[]
 ><T, U>(x: T) => <U[]>null : <T, U>(x: T) => U[]
 >T : T
 >U : U
@@ -284,14 +284,14 @@ module Errors {
 >r2arg : <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
 
     var r2a = [r2arg2, r2arg];
->r2a : { <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U): (r: T) => V; }[]
->[r2arg2, r2arg] : { <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U): (r: T) => V; }[]
+>r2a : (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V)[]
+>[r2arg2, r2arg] : (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V)[]
 >r2arg2 : (x: (arg: Base) => Derived) => (r: Base) => Derived2
 >r2arg : <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
 
     var r2b = [r2arg, r2arg2];
->r2b : { <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U): (r: T) => V; }[]
->[r2arg, r2arg2] : { <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U): (r: T) => V; }[]
+>r2b : (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V)[]
+>[r2arg, r2arg2] : (<T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V)[]
 >r2arg : <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
 >r2arg2 : (x: (arg: Base) => Derived) => (r: Base) => Derived2
 
@@ -340,14 +340,14 @@ module Errors {
 >r3arg : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
 
     var r3a = [r3arg2, r3arg];
->r3a : Array<{ <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U): (r: T) => U; } | { (x: (arg: Base) => Derived, y: (arg2: Base) => Derived): (r: Base) => Derived; }>
->[r3arg2, r3arg] : Array<{ <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U): (r: T) => U; } | { (x: (arg: Base) => Derived, y: (arg2: Base) => Derived): (r: Base) => Derived; }>
+>r3a : ((<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U) | ((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived))[]
+>[r3arg2, r3arg] : ((<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U) | ((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived))[]
 >r3arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 >r3arg : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
 
     var r3b = [r3arg, r3arg2];
->r3b : Array<{ <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U): (r: T) => U; } | { (x: (arg: Base) => Derived, y: (arg2: Base) => Derived): (r: Base) => Derived; }>
->[r3arg, r3arg2] : Array<{ <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U): (r: T) => U; } | { (x: (arg: Base) => Derived, y: (arg2: Base) => Derived): (r: Base) => Derived; }>
+>r3b : ((<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U) | ((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived))[]
+>[r3arg, r3arg2] : ((<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U) | ((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived))[]
 >r3arg : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
 >r3arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 
@@ -376,14 +376,14 @@ module Errors {
 >r4arg : <T extends Derived>(...x: T[]) => T
 
     var r4a = [r4arg2, r4arg];
->r4a : { <T extends Derived>(...x: T[]): T; }[]
->[r4arg2, r4arg] : { <T extends Derived>(...x: T[]): T; }[]
+>r4a : (<T extends Derived>(...x: T[]) => T)[]
+>[r4arg2, r4arg] : (<T extends Derived>(...x: T[]) => T)[]
 >r4arg2 : (...x: Base[]) => Base
 >r4arg : <T extends Derived>(...x: T[]) => T
 
     var r4b = [r4arg, r4arg2];
->r4b : { <T extends Derived>(...x: T[]): T; }[]
->[r4arg, r4arg2] : { <T extends Derived>(...x: T[]): T; }[]
+>r4b : (<T extends Derived>(...x: T[]) => T)[]
+>[r4arg, r4arg2] : (<T extends Derived>(...x: T[]) => T)[]
 >r4arg : <T extends Derived>(...x: T[]) => T
 >r4arg2 : (...x: Base[]) => Base
 
@@ -417,14 +417,14 @@ module Errors {
 >r5arg : <T extends Derived>(x: T, y: T) => T
 
     var r5a = [r5arg2, r5arg];
->r5a : { <T extends Derived>(x: T, y: T): T; }[]
->[r5arg2, r5arg] : { <T extends Derived>(x: T, y: T): T; }[]
+>r5a : (<T extends Derived>(x: T, y: T) => T)[]
+>[r5arg2, r5arg] : (<T extends Derived>(x: T, y: T) => T)[]
 >r5arg2 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >r5arg : <T extends Derived>(x: T, y: T) => T
 
     var r5b = [r5arg, r5arg2];
->r5b : { <T extends Derived>(x: T, y: T): T; }[]
->[r5arg, r5arg2] : { <T extends Derived>(x: T, y: T): T; }[]
+>r5b : (<T extends Derived>(x: T, y: T) => T)[]
+>[r5arg, r5arg2] : (<T extends Derived>(x: T, y: T) => T)[]
 >r5arg : <T extends Derived>(x: T, y: T) => T
 >r5arg2 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
@@ -463,14 +463,14 @@ module Errors {
 >r6arg : (x: Base[], y: Derived2[]) => Derived[]
 
     var r6a = [r6arg2, r6arg];
->r6a : { <T extends Derived2[]>(x: Base[], y: Base[]): T; }[]
->[r6arg2, r6arg] : { <T extends Derived2[]>(x: Base[], y: Base[]): T; }[]
+>r6a : (<T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
+>[r6arg2, r6arg] : (<T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
 >r6arg2 : <T extends Derived2[]>(x: Base[], y: Base[]) => T
 >r6arg : (x: Base[], y: Derived2[]) => Derived[]
 
     var r6b = [r6arg, r6arg2];
->r6b : { <T extends Derived2[]>(x: Base[], y: Base[]): T; }[]
->[r6arg, r6arg2] : { <T extends Derived2[]>(x: Base[], y: Base[]): T; }[]
+>r6b : (<T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
+>[r6arg, r6arg2] : (<T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
 >r6arg : (x: Base[], y: Derived2[]) => Derived[]
 >r6arg2 : <T extends Derived2[]>(x: Base[], y: Base[]) => T
 
@@ -500,14 +500,14 @@ module Errors {
 >r7arg : <T>(x: { a: T; b: T; }) => T
 
     var r7a = [r7arg2, r7arg];
->r7a : { <T>(x: { a: T; b: T; }): T; }[]
->[r7arg2, r7arg] : { <T>(x: { a: T; b: T; }): T; }[]
+>r7a : (<T>(x: { a: T; b: T; }) => T)[]
+>[r7arg2, r7arg] : (<T>(x: { a: T; b: T; }) => T)[]
 >r7arg2 : (x: { a: string; b: number; }) => number
 >r7arg : <T>(x: { a: T; b: T; }) => T
 
     var r7b = [r7arg, r7arg2];
->r7b : { <T>(x: { a: T; b: T; }): T; }[]
->[r7arg, r7arg2] : { <T>(x: { a: T; b: T; }): T; }[]
+>r7b : (<T>(x: { a: T; b: T; }) => T)[]
+>[r7arg, r7arg2] : (<T>(x: { a: T; b: T; }) => T)[]
 >r7arg : <T>(x: { a: T; b: T; }) => T
 >r7arg2 : (x: { a: string; b: number; }) => number
 
@@ -529,14 +529,14 @@ module Errors {
 >r7arg3 : <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7d = [r7arg2, r7arg3];
->r7d : { (x: { a: string; b: number; }): number; }[]
->[r7arg2, r7arg3] : { (x: { a: string; b: number; }): number; }[]
+>r7d : ((x: { a: string; b: number; }) => number)[]
+>[r7arg2, r7arg3] : ((x: { a: string; b: number; }) => number)[]
 >r7arg2 : (x: { a: string; b: number; }) => number
 >r7arg3 : <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7e = [r7arg3, r7arg2];
->r7e : { (x: { a: string; b: number; }): number; }[]
->[r7arg3, r7arg2] : { (x: { a: string; b: number; }): number; }[]
+>r7e : ((x: { a: string; b: number; }) => number)[]
+>[r7arg3, r7arg2] : ((x: { a: string; b: number; }) => number)[]
 >r7arg3 : <T extends Base>(x: { a: T; b: T; }) => number
 >r7arg2 : (x: { a: string; b: number; }) => number
 
diff --git a/tests/baselines/reference/subtypingWithCallSignatures4.types b/tests/baselines/reference/subtypingWithCallSignatures4.types
index f31a4fa928e..0325552187b 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures4.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures4.types
@@ -244,14 +244,14 @@ var r1 = foo1(r1arg);
 >r1arg : <T>(x: T) => T[]
 
 var r1a = [r1arg, r1arg2];
->r1a : { <T>(x: T): T[]; }[]
->[r1arg, r1arg2] : { <T>(x: T): T[]; }[]
+>r1a : (<T>(x: T) => T[])[]
+>[r1arg, r1arg2] : (<T>(x: T) => T[])[]
 >r1arg : <T>(x: T) => T[]
 >r1arg2 : <T>(x: T) => T[]
 
 var r1b = [r1arg2, r1arg];
->r1b : { <T>(x: T): T[]; }[]
->[r1arg2, r1arg] : { <T>(x: T): T[]; }[]
+>r1b : (<T>(x: T) => T[])[]
+>[r1arg2, r1arg] : (<T>(x: T) => T[])[]
 >r1arg2 : <T>(x: T) => T[]
 >r1arg : <T>(x: T) => T[]
 
@@ -278,14 +278,14 @@ var r2 = foo2(r2arg);
 >r2arg : <T>(x: T) => string[]
 
 var r2a = [r2arg, r2arg2];
->r2a : { <T>(x: T): string[]; }[]
->[r2arg, r2arg2] : { <T>(x: T): string[]; }[]
+>r2a : (<T>(x: T) => string[])[]
+>[r2arg, r2arg2] : (<T>(x: T) => string[])[]
 >r2arg : <T>(x: T) => string[]
 >r2arg2 : <T>(x: T) => string[]
 
 var r2b = [r2arg2, r2arg];
->r2b : { <T>(x: T): string[]; }[]
->[r2arg2, r2arg] : { <T>(x: T): string[]; }[]
+>r2b : (<T>(x: T) => string[])[]
+>[r2arg2, r2arg] : (<T>(x: T) => string[])[]
 >r2arg2 : <T>(x: T) => string[]
 >r2arg : <T>(x: T) => string[]
 
@@ -312,14 +312,14 @@ var r3 = foo3(r3arg);
 >r3arg : <T>(x: T) => T
 
 var r3a = [r3arg, r3arg2];
->r3a : { <T>(x: T): T; }[]
->[r3arg, r3arg2] : { <T>(x: T): T; }[]
+>r3a : (<T>(x: T) => T)[]
+>[r3arg, r3arg2] : (<T>(x: T) => T)[]
 >r3arg : <T>(x: T) => T
 >r3arg2 : <T>(x: T) => void
 
 var r3b = [r3arg2, r3arg];
->r3b : { <T>(x: T): T; }[]
->[r3arg2, r3arg] : { <T>(x: T): T; }[]
+>r3b : (<T>(x: T) => T)[]
+>[r3arg2, r3arg] : (<T>(x: T) => T)[]
 >r3arg2 : <T>(x: T) => void
 >r3arg : <T>(x: T) => T
 
@@ -350,14 +350,14 @@ var r4 = foo4(r4arg);
 >r4arg : <T, U>(x: T, y: U) => string
 
 var r4a = [r4arg, r4arg2];
->r4a : { <T, U>(x: T, y: U): string; }[]
->[r4arg, r4arg2] : { <T, U>(x: T, y: U): string; }[]
+>r4a : (<T, U>(x: T, y: U) => string)[]
+>[r4arg, r4arg2] : (<T, U>(x: T, y: U) => string)[]
 >r4arg : <T, U>(x: T, y: U) => string
 >r4arg2 : <T, U>(x: T, y: U) => string
 
 var r4b = [r4arg2, r4arg];
->r4b : { <T, U>(x: T, y: U): string; }[]
->[r4arg2, r4arg] : { <T, U>(x: T, y: U): string; }[]
+>r4b : (<T, U>(x: T, y: U) => string)[]
+>[r4arg2, r4arg] : (<T, U>(x: T, y: U) => string)[]
 >r4arg2 : <T, U>(x: T, y: U) => string
 >r4arg : <T, U>(x: T, y: U) => string
 
@@ -392,14 +392,14 @@ var r5 = foo5(r5arg);
 >r5arg : <T, U>(x: (arg: T) => U) => T
 
 var r5a = [r5arg, r5arg2];
->r5a : { <T, U>(x: (arg: T) => U): T; }[]
->[r5arg, r5arg2] : { <T, U>(x: (arg: T) => U): T; }[]
+>r5a : (<T, U>(x: (arg: T) => U) => T)[]
+>[r5arg, r5arg2] : (<T, U>(x: (arg: T) => U) => T)[]
 >r5arg : <T, U>(x: (arg: T) => U) => T
 >r5arg2 : <T, U>(x: (arg: T) => U) => T
 
 var r5b = [r5arg2, r5arg];
->r5b : { <T, U>(x: (arg: T) => U): T; }[]
->[r5arg2, r5arg] : { <T, U>(x: (arg: T) => U): T; }[]
+>r5b : (<T, U>(x: (arg: T) => U) => T)[]
+>[r5arg2, r5arg] : (<T, U>(x: (arg: T) => U) => T)[]
 >r5arg2 : <T, U>(x: (arg: T) => U) => T
 >r5arg : <T, U>(x: (arg: T) => U) => T
 
@@ -436,14 +436,14 @@ var r6 = foo6(r6arg);
 >r6arg : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
 var r6a = [r6arg, r6arg2];
->r6a : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
->[r6arg, r6arg2] : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
+>r6a : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
+>[r6arg, r6arg2] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
 >r6arg : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 >r6arg2 : <T extends Base>(x: (arg: T) => Derived) => T
 
 var r6b = [r6arg2, r6arg];
->r6b : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
->[r6arg2, r6arg] : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
+>r6b : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
+>[r6arg2, r6arg] : (<T extends Base, U extends Derived>(x: (arg: T) => U) => T)[]
 >r6arg2 : <T extends Base>(x: (arg: T) => Derived) => T
 >r6arg : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
@@ -485,14 +485,14 @@ var r11 = foo11(r11arg);
 >r11arg : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
 var r11a = [r11arg, r11arg2];
->r11a : { <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
->[r11arg, r11arg2] : { <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
+>r11a : (<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
+>[r11arg, r11arg2] : (<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
 >r11arg : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 >r11arg2 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 
 var r11b = [r11arg2, r11arg];
->r11b : { <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
->[r11arg2, r11arg] : { <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
+>r11b : (<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
+>[r11arg2, r11arg] : (<T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
 >r11arg2 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 >r11arg : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
@@ -528,14 +528,14 @@ var r15 = foo15(r15arg);
 >r15arg : <U, V>(x: { a: U; b: V; }) => U[]
 
 var r15a = [r15arg, r15arg2];
->r15a : { <U, V>(x: { a: U; b: V; }): U[]; }[]
->[r15arg, r15arg2] : { <U, V>(x: { a: U; b: V; }): U[]; }[]
+>r15a : (<U, V>(x: { a: U; b: V; }) => U[])[]
+>[r15arg, r15arg2] : (<U, V>(x: { a: U; b: V; }) => U[])[]
 >r15arg : <U, V>(x: { a: U; b: V; }) => U[]
 >r15arg2 : <T>(x: { a: T; b: T; }) => T[]
 
 var r15b = [r15arg2, r15arg];
->r15b : { <U, V>(x: { a: U; b: V; }): U[]; }[]
->[r15arg2, r15arg] : { <U, V>(x: { a: U; b: V; }): U[]; }[]
+>r15b : (<U, V>(x: { a: U; b: V; }) => U[])[]
+>[r15arg2, r15arg] : (<U, V>(x: { a: U; b: V; }) => U[])[]
 >r15arg2 : <T>(x: { a: T; b: T; }) => T[]
 >r15arg : <U, V>(x: { a: U; b: V; }) => U[]
 
@@ -572,14 +572,14 @@ var r16 = foo16(r16arg);
 >r16arg : <T extends Base>(x: { a: T; b: T; }) => T[]
 
 var r16a = [r16arg, r16arg2];
->r16a : { <T extends Base>(x: { a: T; b: T; }): T[]; }[]
->[r16arg, r16arg2] : { <T extends Base>(x: { a: T; b: T; }): T[]; }[]
+>r16a : (<T extends Base>(x: { a: T; b: T; }) => T[])[]
+>[r16arg, r16arg2] : (<T extends Base>(x: { a: T; b: T; }) => T[])[]
 >r16arg : <T extends Base>(x: { a: T; b: T; }) => T[]
 >r16arg2 : <T extends Base>(x: { a: T; b: T; }) => T[]
 
 var r16b = [r16arg2, r16arg];
->r16b : { <T extends Base>(x: { a: T; b: T; }): T[]; }[]
->[r16arg2, r16arg] : { <T extends Base>(x: { a: T; b: T; }): T[]; }[]
+>r16b : (<T extends Base>(x: { a: T; b: T; }) => T[])[]
+>[r16arg2, r16arg] : (<T extends Base>(x: { a: T; b: T; }) => T[])[]
 >r16arg2 : <T extends Base>(x: { a: T; b: T; }) => T[]
 >r16arg : <T extends Base>(x: { a: T; b: T; }) => T[]
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures2.types b/tests/baselines/reference/subtypingWithConstructSignatures2.types
index 3832697d04c..d723a367ecb 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures2.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures2.types
@@ -326,14 +326,14 @@ var r1 = foo1(r1arg1); // any, return types are not subtype of first overload
 >r1arg1 : new <T>(x: T) => T[]
 
 var r1a = [r1arg2, r1arg1]; // generic signature, subtype in both directions
->r1a : { new <T>(x: T): T[]; }[]
->[r1arg2, r1arg1] : { new <T>(x: T): T[]; }[]
+>r1a : (new <T>(x: T) => T[])[]
+>[r1arg2, r1arg1] : (new <T>(x: T) => T[])[]
 >r1arg2 : new (x: number) => number[]
 >r1arg1 : new <T>(x: T) => T[]
 
 var r1b = [r1arg1, r1arg2]; // generic signature, subtype in both directions
->r1b : { new <T>(x: T): T[]; }[]
->[r1arg1, r1arg2] : { new <T>(x: T): T[]; }[]
+>r1b : (new <T>(x: T) => T[])[]
+>[r1arg1, r1arg2] : (new <T>(x: T) => T[])[]
 >r1arg1 : new <T>(x: T) => T[]
 >r1arg2 : new (x: number) => number[]
 
@@ -354,14 +354,14 @@ var r2 = foo2(r2arg1);
 >r2arg1 : new <T>(x: T) => string[]
 
 var r2a = [r2arg1, r2arg2];
->r2a : { new <T>(x: T): string[]; }[]
->[r2arg1, r2arg2] : { new <T>(x: T): string[]; }[]
+>r2a : (new <T>(x: T) => string[])[]
+>[r2arg1, r2arg2] : (new <T>(x: T) => string[])[]
 >r2arg1 : new <T>(x: T) => string[]
 >r2arg2 : new (x: number) => string[]
 
 var r2b = [r2arg2, r2arg1];
->r2b : { new <T>(x: T): string[]; }[]
->[r2arg2, r2arg1] : { new <T>(x: T): string[]; }[]
+>r2b : (new <T>(x: T) => string[])[]
+>[r2arg2, r2arg1] : (new <T>(x: T) => string[])[]
 >r2arg2 : new (x: number) => string[]
 >r2arg1 : new <T>(x: T) => string[]
 
@@ -383,14 +383,14 @@ var r3 = foo3(r3arg1);
 >r3arg1 : new <T>(x: T) => T
 
 var r3a = [r3arg1, r3arg2];
->r3a : { new <T>(x: T): T; }[]
->[r3arg1, r3arg2] : { new <T>(x: T): T; }[]
+>r3a : (new <T>(x: T) => T)[]
+>[r3arg1, r3arg2] : (new <T>(x: T) => T)[]
 >r3arg1 : new <T>(x: T) => T
 >r3arg2 : new (x: number) => void
 
 var r3b = [r3arg2, r3arg1];
->r3b : { new <T>(x: T): T; }[]
->[r3arg2, r3arg1] : { new <T>(x: T): T; }[]
+>r3b : (new <T>(x: T) => T)[]
+>[r3arg2, r3arg1] : (new <T>(x: T) => T)[]
 >r3arg2 : new (x: number) => void
 >r3arg1 : new <T>(x: T) => T
 
@@ -416,14 +416,14 @@ var r4 = foo4(r4arg1); // any
 >r4arg1 : new <T, U>(x: T, y: U) => T
 
 var r4a = [r4arg1, r4arg2];
->r4a : { new <T, U>(x: T, y: U): T; }[]
->[r4arg1, r4arg2] : { new <T, U>(x: T, y: U): T; }[]
+>r4a : (new <T, U>(x: T, y: U) => T)[]
+>[r4arg1, r4arg2] : (new <T, U>(x: T, y: U) => T)[]
 >r4arg1 : new <T, U>(x: T, y: U) => T
 >r4arg2 : new (x: string, y: number) => string
 
 var r4b = [r4arg2, r4arg1];
->r4b : { new <T, U>(x: T, y: U): T; }[]
->[r4arg2, r4arg1] : { new <T, U>(x: T, y: U): T; }[]
+>r4b : (new <T, U>(x: T, y: U) => T)[]
+>[r4arg2, r4arg1] : (new <T, U>(x: T, y: U) => T)[]
 >r4arg2 : new (x: string, y: number) => string
 >r4arg1 : new <T, U>(x: T, y: U) => T
 
@@ -449,14 +449,14 @@ var r5 = foo5(r5arg1); // any
 >r5arg1 : new <T, U>(x: new (arg: T) => U) => T
 
 var r5a = [r5arg1, r5arg2];
->r5a : { new <T, U>(x: new (arg: T) => U): T; }[]
->[r5arg1, r5arg2] : { new <T, U>(x: new (arg: T) => U): T; }[]
+>r5a : (new <T, U>(x: new (arg: T) => U) => T)[]
+>[r5arg1, r5arg2] : (new <T, U>(x: new (arg: T) => U) => T)[]
 >r5arg1 : new <T, U>(x: new (arg: T) => U) => T
 >r5arg2 : new (x: new (arg: string) => number) => string
 
 var r5b = [r5arg2, r5arg1];
->r5b : { new <T, U>(x: new (arg: T) => U): T; }[]
->[r5arg2, r5arg1] : { new <T, U>(x: new (arg: T) => U): T; }[]
+>r5b : (new <T, U>(x: new (arg: T) => U) => T)[]
+>[r5arg2, r5arg1] : (new <T, U>(x: new (arg: T) => U) => T)[]
 >r5arg2 : new (x: new (arg: string) => number) => string
 >r5arg1 : new <T, U>(x: new (arg: T) => U) => T
 
@@ -487,14 +487,14 @@ var r6 = foo6(r6arg1); // any
 >r6arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
 var r6a = [r6arg1, r6arg2];
->r6a : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
->[r6arg1, r6arg2] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
+>r6a : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
+>[r6arg1, r6arg2] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
 >r6arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 >r6arg2 : new (x: new (arg: Base) => Derived) => Base
 
 var r6b = [r6arg2, r6arg1];
->r6b : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
->[r6arg2, r6arg1] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
+>r6b : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
+>[r6arg2, r6arg1] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
 >r6arg2 : new (x: new (arg: Base) => Derived) => Base
 >r6arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
@@ -529,14 +529,14 @@ var r7 = foo7(r7arg1); // any
 >r7arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U
 
 var r7a = [r7arg1, r7arg2];
->r7a : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): new (r: T) => U; }[]
->[r7arg1, r7arg2] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): new (r: T) => U; }[]
+>r7a : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U)[]
+>[r7arg1, r7arg2] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U)[]
 >r7arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U
 >r7arg2 : new (x: new (arg: Base) => Derived) => new (r: Base) => Derived
 
 var r7b = [r7arg2, r7arg1];
->r7b : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): new (r: T) => U; }[]
->[r7arg2, r7arg1] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): new (r: T) => U; }[]
+>r7b : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U)[]
+>[r7arg2, r7arg1] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U)[]
 >r7arg2 : new (x: new (arg: Base) => Derived) => new (r: Base) => Derived
 >r7arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U
 
@@ -579,14 +579,14 @@ var r8 = foo8(r8arg1); // any
 >r8arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U
 
 var r8a = [r8arg1, r8arg2];
->r8a : { new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U): new (r: T) => U; }[]
->[r8arg1, r8arg2] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U): new (r: T) => U; }[]
+>r8a : (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U)[]
+>[r8arg1, r8arg2] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U)[]
 >r8arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U
 >r8arg2 : new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 
 var r8b = [r8arg2, r8arg1];
->r8b : { new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U): new (r: T) => U; }[]
->[r8arg2, r8arg1] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U): new (r: T) => U; }[]
+>r8b : (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U)[]
+>[r8arg2, r8arg1] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U)[]
 >r8arg2 : new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 >r8arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U
 
@@ -630,14 +630,14 @@ var r9 = foo9(r9arg1); // any
 >r9arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U
 
 var r9a = [r9arg1, r9arg2];
->r9a : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): new (r: T) => U; } | { new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
->[r9arg1, r9arg2] : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): new (r: T) => U; } | { new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
+>r9a : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U) | (new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
+>[r9arg1, r9arg2] : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U) | (new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
 >r9arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U
 >r9arg2 : new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 
 var r9b = [r9arg2, r9arg1];
->r9b : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): new (r: T) => U; } | { new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
->[r9arg2, r9arg1] : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): new (r: T) => U; } | { new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
+>r9b : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U) | (new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
+>[r9arg2, r9arg1] : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U) | (new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
 >r9arg2 : new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 >r9arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U
 
@@ -662,14 +662,14 @@ var r10 = foo10(r10arg1); // any
 >r10arg1 : new <T extends Derived>(...x: T[]) => T
 
 var r10a = [r10arg1, r10arg2];
->r10a : { new <T extends Derived>(...x: T[]): T; }[]
->[r10arg1, r10arg2] : { new <T extends Derived>(...x: T[]): T; }[]
+>r10a : (new <T extends Derived>(...x: T[]) => T)[]
+>[r10arg1, r10arg2] : (new <T extends Derived>(...x: T[]) => T)[]
 >r10arg1 : new <T extends Derived>(...x: T[]) => T
 >r10arg2 : new (...x: Derived[]) => Derived
 
 var r10b = [r10arg2, r10arg1];
->r10b : { new <T extends Derived>(...x: T[]): T; }[]
->[r10arg2, r10arg1] : { new <T extends Derived>(...x: T[]): T; }[]
+>r10b : (new <T extends Derived>(...x: T[]) => T)[]
+>[r10arg2, r10arg1] : (new <T extends Derived>(...x: T[]) => T)[]
 >r10arg2 : new (...x: Derived[]) => Derived
 >r10arg1 : new <T extends Derived>(...x: T[]) => T
 
@@ -699,14 +699,14 @@ var r11 = foo11(r11arg1); // any
 >r11arg1 : new <T extends Base>(x: T, y: T) => T
 
 var r11a = [r11arg1, r11arg2];
->r11a : { new <T extends Base>(x: T, y: T): T; }[]
->[r11arg1, r11arg2] : { new <T extends Base>(x: T, y: T): T; }[]
+>r11a : (new <T extends Base>(x: T, y: T) => T)[]
+>[r11arg1, r11arg2] : (new <T extends Base>(x: T, y: T) => T)[]
 >r11arg1 : new <T extends Base>(x: T, y: T) => T
 >r11arg2 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
 var r11b = [r11arg2, r11arg1];
->r11b : { new <T extends Base>(x: T, y: T): T; }[]
->[r11arg2, r11arg1] : { new <T extends Base>(x: T, y: T): T; }[]
+>r11b : (new <T extends Base>(x: T, y: T) => T)[]
+>[r11arg2, r11arg1] : (new <T extends Base>(x: T, y: T) => T)[]
 >r11arg2 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >r11arg1 : new <T extends Base>(x: T, y: T) => T
 
@@ -741,14 +741,14 @@ var r12 = foo12(r12arg1); // any
 >r12arg1 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 
 var r12a = [r12arg1, r12arg2];
->r12a : { new <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
->[r12arg1, r12arg2] : { new <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
+>r12a : (new <T extends Base[]>(x: Base[], y: T) => Derived[])[]
+>[r12arg1, r12arg2] : (new <T extends Base[]>(x: Base[], y: T) => Derived[])[]
 >r12arg1 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 >r12arg2 : new (x: Base[], y: Derived2[]) => Derived[]
 
 var r12b = [r12arg2, r12arg1];
->r12b : { new <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
->[r12arg2, r12arg1] : { new <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
+>r12b : (new <T extends Base[]>(x: Base[], y: T) => Derived[])[]
+>[r12arg2, r12arg1] : (new <T extends Base[]>(x: Base[], y: T) => Derived[])[]
 >r12arg2 : new (x: Base[], y: Derived2[]) => Derived[]
 >r12arg1 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 
@@ -782,14 +782,14 @@ var r13 = foo13(r13arg1); // any
 >r13arg1 : new <T extends Derived[]>(x: Base[], y: T) => T
 
 var r13a = [r13arg1, r13arg2];
->r13a : { new <T extends Derived[]>(x: Base[], y: T): T; }[]
->[r13arg1, r13arg2] : { new <T extends Derived[]>(x: Base[], y: T): T; }[]
+>r13a : (new <T extends Derived[]>(x: Base[], y: T) => T)[]
+>[r13arg1, r13arg2] : (new <T extends Derived[]>(x: Base[], y: T) => T)[]
 >r13arg1 : new <T extends Derived[]>(x: Base[], y: T) => T
 >r13arg2 : new (x: Base[], y: Derived[]) => Derived[]
 
 var r13b = [r13arg2, r13arg1];
->r13b : { new <T extends Derived[]>(x: Base[], y: T): T; }[]
->[r13arg2, r13arg1] : { new <T extends Derived[]>(x: Base[], y: T): T; }[]
+>r13b : (new <T extends Derived[]>(x: Base[], y: T) => T)[]
+>[r13arg2, r13arg1] : (new <T extends Derived[]>(x: Base[], y: T) => T)[]
 >r13arg2 : new (x: Base[], y: Derived[]) => Derived[]
 >r13arg1 : new <T extends Derived[]>(x: Base[], y: T) => T
 
@@ -817,14 +817,14 @@ var r14 = foo14(r14arg1); // any
 >r14arg1 : new <T>(x: { a: T; b: T; }) => T
 
 var r14a = [r14arg1, r14arg2];
->r14a : { new <T>(x: { a: T; b: T; }): T; }[]
->[r14arg1, r14arg2] : { new <T>(x: { a: T; b: T; }): T; }[]
+>r14a : (new <T>(x: { a: T; b: T; }) => T)[]
+>[r14arg1, r14arg2] : (new <T>(x: { a: T; b: T; }) => T)[]
 >r14arg1 : new <T>(x: { a: T; b: T; }) => T
 >r14arg2 : new (x: { a: string; b: number; }) => Object
 
 var r14b = [r14arg2, r14arg1];
->r14b : { new <T>(x: { a: T; b: T; }): T; }[]
->[r14arg2, r14arg1] : { new <T>(x: { a: T; b: T; }): T; }[]
+>r14b : (new <T>(x: { a: T; b: T; }) => T)[]
+>[r14arg2, r14arg1] : (new <T>(x: { a: T; b: T; }) => T)[]
 >r14arg2 : new (x: { a: string; b: number; }) => Object
 >r14arg1 : new <T>(x: { a: T; b: T; }) => T
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures3.types b/tests/baselines/reference/subtypingWithConstructSignatures3.types
index ff6b9adef0a..b0f0680c7a0 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures3.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures3.types
@@ -224,14 +224,14 @@ module Errors {
 >r1arg1 : new <T, U>(x: T) => U[]
 
     var r1a = [r1arg2, r1arg1];
->r1a : { new <T, U>(x: T): U[]; }[]
->[r1arg2, r1arg1] : { new <T, U>(x: T): U[]; }[]
+>r1a : (new <T, U>(x: T) => U[])[]
+>[r1arg2, r1arg1] : (new <T, U>(x: T) => U[])[]
 >r1arg2 : new (x: number) => string[]
 >r1arg1 : new <T, U>(x: T) => U[]
 
     var r1b = [r1arg1, r1arg2];
->r1b : { new <T, U>(x: T): U[]; }[]
->[r1arg1, r1arg2] : { new <T, U>(x: T): U[]; }[]
+>r1b : (new <T, U>(x: T) => U[])[]
+>[r1arg1, r1arg2] : (new <T, U>(x: T) => U[])[]
 >r1arg1 : new <T, U>(x: T) => U[]
 >r1arg2 : new (x: number) => string[]
 
@@ -268,14 +268,14 @@ module Errors {
 >r2arg1 : new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V
 
     var r2a = [r2arg2, r2arg1];
->r2a : { new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U): new (r: T) => V; }[]
->[r2arg2, r2arg1] : { new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U): new (r: T) => V; }[]
+>r2a : (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V)[]
+>[r2arg2, r2arg1] : (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V)[]
 >r2arg2 : new (x: new (arg: Base) => Derived) => new (r: Base) => Derived2
 >r2arg1 : new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V
 
     var r2b = [r2arg1, r2arg2];
->r2b : { new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U): new (r: T) => V; }[]
->[r2arg1, r2arg2] : { new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U): new (r: T) => V; }[]
+>r2b : (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V)[]
+>[r2arg1, r2arg2] : (new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V)[]
 >r2arg1 : new <T extends Base, U extends Derived, V extends Derived2>(x: new (arg: T) => U) => new (r: T) => V
 >r2arg2 : new (x: new (arg: Base) => Derived) => new (r: Base) => Derived2
 
@@ -318,14 +318,14 @@ module Errors {
 >r3arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U
 
     var r3a = [r3arg2, r3arg1];
->r3a : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U): new (r: T) => U; } | { new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
->[r3arg2, r3arg1] : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U): new (r: T) => U; } | { new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
+>r3a : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U) | (new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
+>[r3arg2, r3arg1] : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U) | (new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
 >r3arg2 : new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 >r3arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U
 
     var r3b = [r3arg1, r3arg2];
->r3b : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U): new (r: T) => U; } | { new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
->[r3arg1, r3arg2] : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U): new (r: T) => U; } | { new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
+>r3b : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U) | (new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
+>[r3arg1, r3arg2] : ((new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U) | (new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived))[]
 >r3arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U
 >r3arg2 : new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 
@@ -350,14 +350,14 @@ module Errors {
 >r4arg1 : new <T extends Derived>(...x: T[]) => T
 
     var r4a = [r4arg2, r4arg1];
->r4a : { new <T extends Derived>(...x: T[]): T; }[]
->[r4arg2, r4arg1] : { new <T extends Derived>(...x: T[]): T; }[]
+>r4a : (new <T extends Derived>(...x: T[]) => T)[]
+>[r4arg2, r4arg1] : (new <T extends Derived>(...x: T[]) => T)[]
 >r4arg2 : new (...x: Base[]) => Base
 >r4arg1 : new <T extends Derived>(...x: T[]) => T
 
     var r4b = [r4arg1, r4arg2];
->r4b : { new <T extends Derived>(...x: T[]): T; }[]
->[r4arg1, r4arg2] : { new <T extends Derived>(...x: T[]): T; }[]
+>r4b : (new <T extends Derived>(...x: T[]) => T)[]
+>[r4arg1, r4arg2] : (new <T extends Derived>(...x: T[]) => T)[]
 >r4arg1 : new <T extends Derived>(...x: T[]) => T
 >r4arg2 : new (...x: Base[]) => Base
 
@@ -387,14 +387,14 @@ module Errors {
 >r5arg1 : new <T extends Derived>(x: T, y: T) => T
 
     var r5a = [r5arg2, r5arg1];
->r5a : { new <T extends Derived>(x: T, y: T): T; }[]
->[r5arg2, r5arg1] : { new <T extends Derived>(x: T, y: T): T; }[]
+>r5a : (new <T extends Derived>(x: T, y: T) => T)[]
+>[r5arg2, r5arg1] : (new <T extends Derived>(x: T, y: T) => T)[]
 >r5arg2 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 >r5arg1 : new <T extends Derived>(x: T, y: T) => T
 
     var r5b = [r5arg1, r5arg2];
->r5b : { new <T extends Derived>(x: T, y: T): T; }[]
->[r5arg1, r5arg2] : { new <T extends Derived>(x: T, y: T): T; }[]
+>r5b : (new <T extends Derived>(x: T, y: T) => T)[]
+>[r5arg1, r5arg2] : (new <T extends Derived>(x: T, y: T) => T)[]
 >r5arg1 : new <T extends Derived>(x: T, y: T) => T
 >r5arg2 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
 
@@ -429,14 +429,14 @@ module Errors {
 >r6arg1 : new (x: Base[], y: Derived2[]) => Derived[]
 
     var r6a = [r6arg2, r6arg1];
->r6a : { new <T extends Derived2[]>(x: Base[], y: Base[]): T; }[]
->[r6arg2, r6arg1] : { new <T extends Derived2[]>(x: Base[], y: Base[]): T; }[]
+>r6a : (new <T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
+>[r6arg2, r6arg1] : (new <T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
 >r6arg2 : new <T extends Derived2[]>(x: Base[], y: Base[]) => T
 >r6arg1 : new (x: Base[], y: Derived2[]) => Derived[]
 
     var r6b = [r6arg1, r6arg2];
->r6b : { new <T extends Derived2[]>(x: Base[], y: Base[]): T; }[]
->[r6arg1, r6arg2] : { new <T extends Derived2[]>(x: Base[], y: Base[]): T; }[]
+>r6b : (new <T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
+>[r6arg1, r6arg2] : (new <T extends Derived2[]>(x: Base[], y: Base[]) => T)[]
 >r6arg1 : new (x: Base[], y: Derived2[]) => Derived[]
 >r6arg2 : new <T extends Derived2[]>(x: Base[], y: Base[]) => T
 
@@ -463,14 +463,14 @@ module Errors {
 >r7arg1 : new <T>(x: { a: T; b: T; }) => T
 
     var r7a = [r7arg2, r7arg1];
->r7a : { new <T>(x: { a: T; b: T; }): T; }[]
->[r7arg2, r7arg1] : { new <T>(x: { a: T; b: T; }): T; }[]
+>r7a : (new <T>(x: { a: T; b: T; }) => T)[]
+>[r7arg2, r7arg1] : (new <T>(x: { a: T; b: T; }) => T)[]
 >r7arg2 : new (x: { a: string; b: number; }) => number
 >r7arg1 : new <T>(x: { a: T; b: T; }) => T
 
     var r7b = [r7arg1, r7arg2];
->r7b : { new <T>(x: { a: T; b: T; }): T; }[]
->[r7arg1, r7arg2] : { new <T>(x: { a: T; b: T; }): T; }[]
+>r7b : (new <T>(x: { a: T; b: T; }) => T)[]
+>[r7arg1, r7arg2] : (new <T>(x: { a: T; b: T; }) => T)[]
 >r7arg1 : new <T>(x: { a: T; b: T; }) => T
 >r7arg2 : new (x: { a: string; b: number; }) => number
 
@@ -491,14 +491,14 @@ module Errors {
 >r7arg3 : new <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7d = [r7arg2, r7arg3];
->r7d : { new (x: { a: string; b: number; }): number; }[]
->[r7arg2, r7arg3] : { new (x: { a: string; b: number; }): number; }[]
+>r7d : (new (x: { a: string; b: number; }) => number)[]
+>[r7arg2, r7arg3] : (new (x: { a: string; b: number; }) => number)[]
 >r7arg2 : new (x: { a: string; b: number; }) => number
 >r7arg3 : new <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7e = [r7arg3, r7arg2];
->r7e : { new (x: { a: string; b: number; }): number; }[]
->[r7arg3, r7arg2] : { new (x: { a: string; b: number; }): number; }[]
+>r7e : (new (x: { a: string; b: number; }) => number)[]
+>[r7arg3, r7arg2] : (new (x: { a: string; b: number; }) => number)[]
 >r7arg3 : new <T extends Base>(x: { a: T; b: T; }) => number
 >r7arg2 : new (x: { a: string; b: number; }) => number
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures4.types b/tests/baselines/reference/subtypingWithConstructSignatures4.types
index 473bbe9a205..21a40ecf7fc 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures4.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures4.types
@@ -240,14 +240,14 @@ var r1 = foo1(r1arg);
 >r1arg : new <T>(x: T) => T[]
 
 var r1a = [r1arg, r1arg2];
->r1a : { new <T>(x: T): T[]; }[]
->[r1arg, r1arg2] : { new <T>(x: T): T[]; }[]
+>r1a : (new <T>(x: T) => T[])[]
+>[r1arg, r1arg2] : (new <T>(x: T) => T[])[]
 >r1arg : new <T>(x: T) => T[]
 >r1arg2 : new <T>(x: T) => T[]
 
 var r1b = [r1arg2, r1arg];
->r1b : { new <T>(x: T): T[]; }[]
->[r1arg2, r1arg] : { new <T>(x: T): T[]; }[]
+>r1b : (new <T>(x: T) => T[])[]
+>[r1arg2, r1arg] : (new <T>(x: T) => T[])[]
 >r1arg2 : new <T>(x: T) => T[]
 >r1arg : new <T>(x: T) => T[]
 
@@ -270,14 +270,14 @@ var r2 = foo2(r2arg);
 >r2arg : new <T>(x: T) => string[]
 
 var r2a = [r2arg, r2arg2];
->r2a : { new <T>(x: T): string[]; }[]
->[r2arg, r2arg2] : { new <T>(x: T): string[]; }[]
+>r2a : (new <T>(x: T) => string[])[]
+>[r2arg, r2arg2] : (new <T>(x: T) => string[])[]
 >r2arg : new <T>(x: T) => string[]
 >r2arg2 : new <T>(x: T) => string[]
 
 var r2b = [r2arg2, r2arg];
->r2b : { new <T>(x: T): string[]; }[]
->[r2arg2, r2arg] : { new <T>(x: T): string[]; }[]
+>r2b : (new <T>(x: T) => string[])[]
+>[r2arg2, r2arg] : (new <T>(x: T) => string[])[]
 >r2arg2 : new <T>(x: T) => string[]
 >r2arg : new <T>(x: T) => string[]
 
@@ -301,14 +301,14 @@ var r3 = foo3(r3arg);
 >r3arg : new <T>(x: T) => T
 
 var r3a = [r3arg, r3arg2];
->r3a : { new <T>(x: T): T; }[]
->[r3arg, r3arg2] : { new <T>(x: T): T; }[]
+>r3a : (new <T>(x: T) => T)[]
+>[r3arg, r3arg2] : (new <T>(x: T) => T)[]
 >r3arg : new <T>(x: T) => T
 >r3arg2 : new <T>(x: T) => void
 
 var r3b = [r3arg2, r3arg];
->r3b : { new <T>(x: T): T; }[]
->[r3arg2, r3arg] : { new <T>(x: T): T; }[]
+>r3b : (new <T>(x: T) => T)[]
+>[r3arg2, r3arg] : (new <T>(x: T) => T)[]
 >r3arg2 : new <T>(x: T) => void
 >r3arg : new <T>(x: T) => T
 
@@ -337,14 +337,14 @@ var r4 = foo4(r4arg);
 >r4arg : new <T, U>(x: T, y: U) => string
 
 var r4a = [r4arg, r4arg2];
->r4a : { new <T, U>(x: T, y: U): string; }[]
->[r4arg, r4arg2] : { new <T, U>(x: T, y: U): string; }[]
+>r4a : (new <T, U>(x: T, y: U) => string)[]
+>[r4arg, r4arg2] : (new <T, U>(x: T, y: U) => string)[]
 >r4arg : new <T, U>(x: T, y: U) => string
 >r4arg2 : new <T, U>(x: T, y: U) => string
 
 var r4b = [r4arg2, r4arg];
->r4b : { new <T, U>(x: T, y: U): string; }[]
->[r4arg2, r4arg] : { new <T, U>(x: T, y: U): string; }[]
+>r4b : (new <T, U>(x: T, y: U) => string)[]
+>[r4arg2, r4arg] : (new <T, U>(x: T, y: U) => string)[]
 >r4arg2 : new <T, U>(x: T, y: U) => string
 >r4arg : new <T, U>(x: T, y: U) => string
 
@@ -375,14 +375,14 @@ var r5 = foo5(r5arg);
 >r5arg : new <T, U>(x: new (arg: T) => U) => T
 
 var r5a = [r5arg, r5arg2];
->r5a : { new <T, U>(x: new (arg: T) => U): T; }[]
->[r5arg, r5arg2] : { new <T, U>(x: new (arg: T) => U): T; }[]
+>r5a : (new <T, U>(x: new (arg: T) => U) => T)[]
+>[r5arg, r5arg2] : (new <T, U>(x: new (arg: T) => U) => T)[]
 >r5arg : new <T, U>(x: new (arg: T) => U) => T
 >r5arg2 : new <T, U>(x: new (arg: T) => U) => T
 
 var r5b = [r5arg2, r5arg];
->r5b : { new <T, U>(x: new (arg: T) => U): T; }[]
->[r5arg2, r5arg] : { new <T, U>(x: new (arg: T) => U): T; }[]
+>r5b : (new <T, U>(x: new (arg: T) => U) => T)[]
+>[r5arg2, r5arg] : (new <T, U>(x: new (arg: T) => U) => T)[]
 >r5arg2 : new <T, U>(x: new (arg: T) => U) => T
 >r5arg : new <T, U>(x: new (arg: T) => U) => T
 
@@ -415,14 +415,14 @@ var r6 = foo6(r6arg);
 >r6arg : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
 var r6a = [r6arg, r6arg2];
->r6a : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
->[r6arg, r6arg2] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
+>r6a : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
+>[r6arg, r6arg2] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
 >r6arg : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 >r6arg2 : new <T extends Base>(x: new (arg: T) => Derived) => T
 
 var r6b = [r6arg2, r6arg];
->r6b : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
->[r6arg2, r6arg] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
+>r6b : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
+>[r6arg2, r6arg] : (new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T)[]
 >r6arg2 : new <T extends Base>(x: new (arg: T) => Derived) => T
 >r6arg : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
@@ -460,14 +460,14 @@ var r11 = foo11(r11arg);
 >r11arg : new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
 var r11a = [r11arg, r11arg2];
->r11a : { new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
->[r11arg, r11arg2] : { new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
+>r11a : (new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
+>[r11arg, r11arg2] : (new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
 >r11arg : new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 >r11arg2 : new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 
 var r11b = [r11arg2, r11arg];
->r11b : { new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
->[r11arg2, r11arg] : { new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
+>r11b : (new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
+>[r11arg2, r11arg] : (new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base)[]
 >r11arg2 : new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 >r11arg : new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
@@ -499,14 +499,14 @@ var r15 = foo15(r15arg);
 >r15arg : new <U, V>(x: { a: U; b: V; }) => U[]
 
 var r15a = [r15arg, r15arg2];
->r15a : { new <U, V>(x: { a: U; b: V; }): U[]; }[]
->[r15arg, r15arg2] : { new <U, V>(x: { a: U; b: V; }): U[]; }[]
+>r15a : (new <U, V>(x: { a: U; b: V; }) => U[])[]
+>[r15arg, r15arg2] : (new <U, V>(x: { a: U; b: V; }) => U[])[]
 >r15arg : new <U, V>(x: { a: U; b: V; }) => U[]
 >r15arg2 : new <T>(x: { a: T; b: T; }) => T[]
 
 var r15b = [r15arg2, r15arg];
->r15b : { new <U, V>(x: { a: U; b: V; }): U[]; }[]
->[r15arg2, r15arg] : { new <U, V>(x: { a: U; b: V; }): U[]; }[]
+>r15b : (new <U, V>(x: { a: U; b: V; }) => U[])[]
+>[r15arg2, r15arg] : (new <U, V>(x: { a: U; b: V; }) => U[])[]
 >r15arg2 : new <T>(x: { a: T; b: T; }) => T[]
 >r15arg : new <U, V>(x: { a: U; b: V; }) => U[]
 
@@ -539,14 +539,14 @@ var r16 = foo16(r16arg);
 >r16arg : new <T extends Base>(x: { a: T; b: T; }) => T[]
 
 var r16a = [r16arg, r16arg2];
->r16a : { new <T extends Base>(x: { a: T; b: T; }): T[]; }[]
->[r16arg, r16arg2] : { new <T extends Base>(x: { a: T; b: T; }): T[]; }[]
+>r16a : (new <T extends Base>(x: { a: T; b: T; }) => T[])[]
+>[r16arg, r16arg2] : (new <T extends Base>(x: { a: T; b: T; }) => T[])[]
 >r16arg : new <T extends Base>(x: { a: T; b: T; }) => T[]
 >r16arg2 : new <T extends Base>(x: { a: T; b: T; }) => T[]
 
 var r16b = [r16arg2, r16arg];
->r16b : { new <T extends Base>(x: { a: T; b: T; }): T[]; }[]
->[r16arg2, r16arg] : { new <T extends Base>(x: { a: T; b: T; }): T[]; }[]
+>r16b : (new <T extends Base>(x: { a: T; b: T; }) => T[])[]
+>[r16arg2, r16arg] : (new <T extends Base>(x: { a: T; b: T; }) => T[])[]
 >r16arg2 : new <T extends Base>(x: { a: T; b: T; }) => T[]
 >r16arg : new <T extends Base>(x: { a: T; b: T; }) => T[]
 
diff --git a/tests/baselines/reference/targetTypeTest2.types b/tests/baselines/reference/targetTypeTest2.types
index f40d68d075a..0000e65b8a7 100644
--- a/tests/baselines/reference/targetTypeTest2.types
+++ b/tests/baselines/reference/targetTypeTest2.types
@@ -4,7 +4,7 @@
 
 var a : any[] = [1,2,"3"];
 >a : any[]
->[1,2,"3"] : Array<string | number>
+>[1,2,"3"] : (string | number)[]
 
 
 function func1(stuff:any[]) { return stuff; }
@@ -21,7 +21,7 @@ function func2(stuff1:string, stuff2:number, stuff3:number) {
 	return func1([stuff1, stuff2, stuff3]);
 >func1([stuff1, stuff2, stuff3]) : any[]
 >func1 : (stuff: any[]) => any[]
->[stuff1, stuff2, stuff3] : Array<string | number>
+>[stuff1, stuff2, stuff3] : (string | number)[]
 >stuff1 : string
 >stuff2 : number
 >stuff3 : number
diff --git a/tests/baselines/reference/targetTypeTest3.errors.txt b/tests/baselines/reference/targetTypeTest3.errors.txt
index d9dbec41150..41b2d027fb5 100644
--- a/tests/baselines/reference/targetTypeTest3.errors.txt
+++ b/tests/baselines/reference/targetTypeTest3.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/targetTypeTest3.ts(4,5): error TS2322: Type 'Array<string | number>' is not assignable to type 'string[]':
+tests/cases/compiler/targetTypeTest3.ts(4,5): error TS2322: Type '(string | number)[]' is not assignable to type 'string[]':
   Type 'string | number' is not assignable to type 'string':
     Type 'number' is not assignable to type 'string'.
 
@@ -9,7 +9,7 @@ tests/cases/compiler/targetTypeTest3.ts(4,5): error TS2322: Type 'Array<string |
     
     var a : string[] = [1,2,"3"]; // should produce an error
         ~
-!!! error TS2322: Type 'Array<string | number>' is not assignable to type 'string[]':
+!!! error TS2322: Type '(string | number)[]' is not assignable to type 'string[]':
 !!! error TS2322:   Type 'string | number' is not assignable to type 'string':
 !!! error TS2322:     Type 'number' is not assignable to type 'string'.
     
diff --git a/tests/baselines/reference/thisInPropertyBoundDeclarations.types b/tests/baselines/reference/thisInPropertyBoundDeclarations.types
index 899aa41a684..196cf4e2ddc 100644
--- a/tests/baselines/reference/thisInPropertyBoundDeclarations.types
+++ b/tests/baselines/reference/thisInPropertyBoundDeclarations.types
@@ -8,7 +8,7 @@ class Bug {
     private static func: Function[] = [
 >func : Function[]
 >Function : Function
->[     (that: Bug, name: string) => {         that.foo(name);     }    ] : { (that: Bug, name: string): void; }[]
+>[     (that: Bug, name: string) => {         that.foo(name);     }    ] : ((that: Bug, name: string) => void)[]
 
      (that: Bug, name: string) => {
 >(that: Bug, name: string) => {         that.foo(name);     } : (that: Bug, name: string) => void
diff --git a/tests/baselines/reference/throwStatements.types b/tests/baselines/reference/throwStatements.types
index 7f106daced9..eeef863f6eb 100644
--- a/tests/baselines/reference/throwStatements.types
+++ b/tests/baselines/reference/throwStatements.types
@@ -219,7 +219,7 @@ throw [];
 >[] : undefined[]
 
 throw ['a', ['b']];
->['a', ['b']] : Array<string | string[]>
+>['a', ['b']] : (string | string[])[]
 >['b'] : string[]
 
 throw /[a-z]/;
diff --git a/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt b/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt
index 823bf93e535..9b068b62e68 100644
--- a/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt
+++ b/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(5,19): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(5,19): error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
   Type 'string | number' is not assignable to type 'number':
     Type 'string' is not assignable to type 'number'.
-tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(6,19): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(6,19): error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
   Type 'string | number' is not assignable to type 'number':
     Type 'string' is not assignable to type 'number'.
 
@@ -13,12 +13,12 @@ tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(6,19): error TS
             // these two should give the same error
             this.test([1, 2, "hi", 5, ]);
                       ~~~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+!!! error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
 !!! error TS2345:   Type 'string | number' is not assignable to type 'number':
 !!! error TS2345:     Type 'string' is not assignable to type 'number'.
             this.test([1, 2, "hi", 5]); 
                       ~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+!!! error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
 !!! error TS2345:   Type 'string | number' is not assignable to type 'number':
 !!! error TS2345:     Type 'string' is not assignable to type 'number'.
         }
diff --git a/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.types b/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.types
index 1cee9140a01..27fcd05bb28 100644
--- a/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.types
+++ b/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.types
@@ -23,7 +23,7 @@ interface IMenuItem {
 var menuData: IMenuItem[] = [
 >menuData : IMenuItem[]
 >IMenuItem : IMenuItem
->[    {        "id": "ourLogo",        "type": "image",        "link": "",        "icon": "modules/menu/logo.svg"    }, {        "id": "productName",        "type": "default",        "link": "",        "text": "Product Name"    }] : Array<{ "id": string; "type": string; "link": string; "icon": string; } | { "id": string; "type": string; "link": string; "text": string; }>
+>[    {        "id": "ourLogo",        "type": "image",        "link": "",        "icon": "modules/menu/logo.svg"    }, {        "id": "productName",        "type": "default",        "link": "",        "text": "Product Name"    }] : ({ "id": string; "type": string; "link": string; "icon": string; } | { "id": string; "type": string; "link": string; "text": string; })[]
     {
 >{        "id": "ourLogo",        "type": "image",        "link": "",        "icon": "modules/menu/logo.svg"    } : { "id": string; "type": string; "link": string; "icon": string; }
 
diff --git a/tests/baselines/reference/typeParameterAsElementType.types b/tests/baselines/reference/typeParameterAsElementType.types
index 828c7034a58..5cbad56c5f1 100644
--- a/tests/baselines/reference/typeParameterAsElementType.types
+++ b/tests/baselines/reference/typeParameterAsElementType.types
@@ -8,7 +8,7 @@ function fee<T>() {
 >T : T
 
     var arr = [t, ""];
->arr : Array<string | T>
->[t, ""] : Array<string | T>
+>arr : (string | T)[]
+>[t, ""] : (string | T)[]
 >t : T
 }
diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types
index 5337a4971d1..752c39b5e51 100644
--- a/tests/baselines/reference/underscoreTest1.types
+++ b/tests/baselines/reference/underscoreTest1.types
@@ -176,7 +176,7 @@ _.all([true, 1, null, 'yes'], _.identity);
 >_.all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
 >_ : Underscore.Static
 >all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
->[true, 1, null, 'yes'] : Array<string | number | boolean>
+>[true, 1, null, 'yes'] : (string | number | boolean)[]
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
@@ -186,7 +186,7 @@ _.any([null, 0, 'yes', false]);
 >_.any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
 >_ : Underscore.Static
 >any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
->[null, 0, 'yes', false] : Array<string | number | boolean>
+>[null, 0, 'yes', false] : (string | number | boolean)[]
 
 _.contains([1, 2, 3], 3);
 >_.contains([1, 2, 3], 3) : boolean
@@ -364,11 +364,11 @@ _.rest([5, 4, 3, 2, 1]);
 >[5, 4, 3, 2, 1] : number[]
 
 _.compact([0, 1, false, 2, '', 3]);
->_.compact([0, 1, false, 2, '', 3]) : Array<string | number | boolean>
+>_.compact([0, 1, false, 2, '', 3]) : (string | number | boolean)[]
 >_.compact : <T>(list: T[]) => T[]
 >_ : Underscore.Static
 >compact : <T>(list: T[]) => T[]
->[0, 1, false, 2, '', 3] : Array<string | number | boolean>
+>[0, 1, false, 2, '', 3] : (string | number | boolean)[]
 
 _.flatten([1, 2, 3, 4]);
 >_.flatten([1, 2, 3, 4]) : {}[]
@@ -382,7 +382,7 @@ _.flatten([1, [2]]);
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, [2]] : Array<number | number[]>
+>[1, [2]] : (number | number[])[]
 >[2] : number[]
 
 // typescript doesn't like the elements being different
@@ -391,9 +391,9 @@ _.flatten([1, [2], [3, [[4]]]]);
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, [2], [3, [[4]]]] : Array<number | Array<number | number[][]>>
+>[1, [2], [3, [[4]]]] : (number | (number | number[][])[])[]
 >[2] : number[]
->[3, [[4]]] : Array<number | number[][]>
+>[3, [[4]]] : (number | number[][])[]
 >[[4]] : number[][]
 >[4] : number[]
 
@@ -402,9 +402,9 @@ _.flatten([1, [2], [3, [[4]]]], true);
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, [2], [3, [[4]]]] : Array<number | Array<number | number[][]>>
+>[1, [2], [3, [[4]]]] : (number | (number | number[][])[])[]
 >[2] : number[]
->[3, [[4]]] : Array<number | number[][]>
+>[3, [[4]]] : (number | number[][])[]
 >[[4]] : number[][]
 >[4] : number[]
 
@@ -470,10 +470,10 @@ _.object([['moe', 30], ['larry', 40], ['curly', 50]]);
 >_.object : { (list: any[][]): any; (keys: string[], values: any[]): any; }
 >_ : Underscore.Static
 >object : { (list: any[][]): any; (keys: string[], values: any[]): any; }
->[['moe', 30], ['larry', 40], ['curly', 50]] : Array<string | number>[]
->['moe', 30] : Array<string | number>
->['larry', 40] : Array<string | number>
->['curly', 50] : Array<string | number>
+>[['moe', 30], ['larry', 40], ['curly', 50]] : (string | number)[][]
+>['moe', 30] : (string | number)[]
+>['larry', 40] : (string | number)[]
+>['curly', 50] : (string | number)[]
 
 _.indexOf([1, 2, 3], 2);
 >_.indexOf([1, 2, 3], 2) : number
diff --git a/tests/baselines/reference/varArgParamTypeCheck.types b/tests/baselines/reference/varArgParamTypeCheck.types
index 1b5b20adbec..9cd2fad7aca 100644
--- a/tests/baselines/reference/varArgParamTypeCheck.types
+++ b/tests/baselines/reference/varArgParamTypeCheck.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/varArgParamTypeCheck.ts ===
 function sequence(...sequences:{():void;}[]) {
->sequence : (...sequences: { (): void; }[]) => void
->sequences : { (): void; }[]
+>sequence : (...sequences: (() => void)[]) => void
+>sequences : (() => void)[]
 }
 
 function callback(clb:()=>void) {
@@ -11,7 +11,7 @@ function callback(clb:()=>void) {
 
 sequence(
 >sequence(    function bar() {    },    function foo() {        callback(()=>{            this();        });    },    function baz() {        callback(()=>{            this();        });    }) : void
->sequence : (...sequences: { (): void; }[]) => void
+>sequence : (...sequences: (() => void)[]) => void
 
     function bar() {
 >function bar() {    } : () => void
diff --git a/tests/baselines/reference/varArgsOnConstructorTypes.types b/tests/baselines/reference/varArgsOnConstructorTypes.types
index 17993a32fda..5ac9babd426 100644
--- a/tests/baselines/reference/varArgsOnConstructorTypes.types
+++ b/tests/baselines/reference/varArgsOnConstructorTypes.types
@@ -45,14 +45,14 @@ export interface I1 {
 >I1 : I1
 
     register(inputClass: new(...params: any[]) => A);
->register : { (inputClass: new (...params: any[]) => A): any; (inputClass: { new (...params: any[]): A; }[]): any; }
+>register : { (inputClass: new (...params: any[]) => A): any; (inputClass: (new (...params: any[]) => A)[]): any; }
 >inputClass : new (...params: any[]) => A
 >params : any[]
 >A : A
 
     register(inputClass: { new (...params: any[]): A; }[]);
->register : { (inputClass: new (...params: any[]) => A): any; (inputClass: { new (...params: any[]): A; }[]): any; }
->inputClass : { new (...params: any[]): A; }[]
+>register : { (inputClass: new (...params: any[]) => A): any; (inputClass: (new (...params: any[]) => A)[]): any; }
+>inputClass : (new (...params: any[]) => A)[]
 >params : any[]
 >A : A
 }
@@ -64,8 +64,8 @@ var reg: I1;
 
 reg.register(B);
 >reg.register(B) : any
->reg.register : { (inputClass: new (...params: any[]) => A): any; (inputClass: { new (...params: any[]): A; }[]): any; }
+>reg.register : { (inputClass: new (...params: any[]) => A): any; (inputClass: (new (...params: any[]) => A)[]): any; }
 >reg : I1
->register : { (inputClass: new (...params: any[]) => A): any; (inputClass: { new (...params: any[]): A; }[]): any; }
+>register : { (inputClass: new (...params: any[]) => A): any; (inputClass: (new (...params: any[]) => A)[]): any; }
 >B : typeof B
 
diff --git a/tests/baselines/reference/vardecl.js b/tests/baselines/reference/vardecl.js
index 326a639ca91..5ce8e095020 100644
--- a/tests/baselines/reference/vardecl.js
+++ b/tests/baselines/reference/vardecl.js
@@ -213,9 +213,7 @@ declare var d2: {
     };
 };
 declare var n2: () => void;
-declare var n4: {
-    (): void;
-}[];
+declare var n4: (() => void)[];
 declare var d4: {
     foo(n: string, x: {
         x: number;
diff --git a/tests/baselines/reference/vardecl.types b/tests/baselines/reference/vardecl.types
index f757562c103..25257e57d78 100644
--- a/tests/baselines/reference/vardecl.types
+++ b/tests/baselines/reference/vardecl.types
@@ -107,7 +107,7 @@ var n2: {
     (): void;
 }
 var n4: {
->n4 : { (): void; }[]
+>n4 : (() => void)[]
 
     (): void;
 }[];
diff --git a/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts b/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
index 917ed526d69..79d3174b542 100644
--- a/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
+++ b/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
@@ -28,7 +28,7 @@ goTo.marker('2');
 verify.quickInfoIs('(var) c1: {\n    name: string;\n    age: number;\n}[]');
 
 goTo.marker('3');
-verify.quickInfoIs('(var) c2: Array<{\n\
+verify.quickInfoIs('(var) c2: ({\n\
     name: string;\n\
     age: number;\n\
     address: string;\n\
@@ -36,7 +36,7 @@ verify.quickInfoIs('(var) c2: Array<{\n\
     name: string;\n\
     age: number;\n\
     dob: Date;\n\
-}>');
+})[]');
 
 goTo.marker('4');
 verify.quickInfoIs('(var) c2a: {\n    name: string;\n    age: number;\n}[]');
diff --git a/tests/cases/fourslash/contextualTyping.ts b/tests/cases/fourslash/contextualTyping.ts
index dad6ee8b587..623f92e97c3 100644
--- a/tests/cases/fourslash/contextualTyping.ts
+++ b/tests/cases/fourslash/contextualTyping.ts
@@ -242,7 +242,7 @@ verify.quickInfoIs("(var) c3t9: number[][]");
 goTo.marker('23');
 verify.quickInfoIs("(var) c3t10: IFoo[]");
 goTo.marker('24');
-verify.quickInfoIs("(var) c3t11: {\n    (n: number, s: string): string;\n}[]");
+verify.quickInfoIs("(var) c3t11: ((n: number, s: string) => string)[]");
 goTo.marker('25');
 verify.quickInfoIs("(parameter) n: number");
 goTo.marker('26');
diff --git a/tests/cases/fourslash/genericTypeArgumentInference1.ts b/tests/cases/fourslash/genericTypeArgumentInference1.ts
index eadec7ad0ce..5c30363d35c 100644
--- a/tests/cases/fourslash/genericTypeArgumentInference1.ts
+++ b/tests/cases/fourslash/genericTypeArgumentInference1.ts
@@ -20,7 +20,7 @@
 goTo.marker('1');
 verify.quickInfoIs('(var) r: string | number | boolean');
 goTo.marker('11');
-verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: Array<string | number | boolean>, iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
+verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: (string | number | boolean)[], iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
 
 goTo.marker('2');
 verify.quickInfoIs('(var) r2: boolean');
diff --git a/tests/cases/fourslash/genericTypeArgumentInference2.ts b/tests/cases/fourslash/genericTypeArgumentInference2.ts
index a660675c51e..bb59cc8eed6 100644
--- a/tests/cases/fourslash/genericTypeArgumentInference2.ts
+++ b/tests/cases/fourslash/genericTypeArgumentInference2.ts
@@ -20,7 +20,7 @@
 goTo.marker('1');
 verify.quickInfoIs('(var) r: string | number | boolean');
 goTo.marker('11');
-verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: Array<string | number | boolean>, iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
+verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: (string | number | boolean)[], iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
 
 goTo.marker('2');
 verify.quickInfoIs('(var) r2: boolean');