Merge branch 'master' into letAndConst

.gitignore

@@ -37,4 +37,5 @@ tests/*.d.ts
 scripts/debug.bat
 scripts/run.bat
 scripts/word2md.js
+scripts/ior.js
 coverage/

Jakefile

@@ -279,7 +279,6 @@ var word2mdJs = path.join(scriptsDirectory, "word2md.js");
 var word2mdTs = path.join(scriptsDirectory, "word2md.ts");
 var specWord = path.join(docDirectory, "TypeScript Language Specification.docx");
 var specMd = path.join(docDirectory, "spec.md");
-var headerMd = path.join(docDirectory, "header.md");
 
 file(word2mdTs);
 
@@ -292,9 +291,8 @@ compileFile(word2mdJs,
 
 // The generated spec.md; built for the 'generate-spec' task
 file(specMd, [word2mdJs, specWord], function () {
-    jake.cpR(headerMd, specMd, {silent: true});
     var specWordFullPath = path.resolve(specWord);
-    var cmd = "cscript //nologo " + word2mdJs + ' "' + specWordFullPath + '" >>' + specMd;
+    var cmd = "cscript //nologo " + word2mdJs + ' "' + specWordFullPath + '" ' + specMd;
     console.log(cmd);
     child_process.exec(cmd, function () {
         complete();

doc/header.md

@@ -1,2 +0,0 @@
-# TypeScript Language Specification
-

scripts/ior.ts

@@ -0,0 +1,123 @@
+/// <reference path="../src/harness/external/node.d.ts" />
+
+import fs = require('fs');
+import path = require('path');
+
+interface IOLog {
+    filesRead: {
+        path: string;
+        result: { contents: string; };
+    }[];
+    arguments: string[];
+}
+
+module Commands {
+    export function dir(obj: IOLog) {
+        obj.filesRead.filter(f => f.result !== undefined).forEach(f => {
+            console.log(f.path);
+        });
+    }
+    dir['description'] = ': displays a list of files';
+
+    export function find(obj: IOLog, str: string) {
+        obj.filesRead.filter(f => f.result !== undefined).forEach(f => {
+            var lines = f.result.contents.split('\n');
+            var printedHeader = false;
+            lines.forEach(line => {
+                if (line.indexOf(str) >= 0) {
+                    if (!printedHeader) {
+                        console.log(' === ' + f.path + ' ===');
+                        printedHeader = true;
+                    }
+                    console.log(line);
+                }
+            });
+        });
+    }
+    find['description'] = ' string: finds text in files';
+
+    export function grab(obj: IOLog, filename: string) {
+        obj.filesRead.filter(f => f.result !== undefined).forEach(f => {
+            if (path.basename(f.path) === filename) {
+                fs.writeFile(filename, f.result.contents);
+            }
+        });
+    }
+    grab['description'] = ' filename.ts: writes out the specified file to disk';
+
+    export function extract(obj: IOLog, outputFolder: string) {
+        var directorySeparator = "/";
+        function directoryExists(path: string): boolean {
+            return fs.existsSync(path) && fs.statSync(path).isDirectory();
+        }
+        function getDirectoryPath(path: string) {
+            return path.substr(0, Math.max(getRootLength(path), path.lastIndexOf(directorySeparator)));
+        }
+        function getRootLength(path: string): number {
+            if (path.charAt(0) === directorySeparator) {
+                if (path.charAt(1) !== directorySeparator) return 1;
+                var p1 = path.indexOf(directorySeparator, 2);
+                if (p1 < 0) return 2;
+                var p2 = path.indexOf(directorySeparator, p1 + 1);
+                if (p2 < 0) return p1 + 1;
+                return p2 + 1;
+            }
+            if (path.charAt(1) === ":") {
+                if (path.charAt(2) === directorySeparator) return 3;
+                return 2;
+            }
+            return 0;
+        }
+        function ensureDirectoriesExist(directoryPath: string) {
+            if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) {
+                var parentDirectory = getDirectoryPath(directoryPath);
+                ensureDirectoriesExist(parentDirectory);
+                console.log("creating directory: " + directoryPath);
+                fs.mkdirSync(directoryPath);
+            }
+        }
+        function transalatePath(outputFolder:string, path: string): string {
+            return outputFolder + directorySeparator + path.replace(":", "");
+        }
+        function fileExists(path: string): boolean {
+            return fs.existsSync(path);
+        }
+        obj.filesRead.forEach(f => {
+            var filename = transalatePath(outputFolder, f.path);
+            ensureDirectoriesExist(getDirectoryPath(filename));
+            console.log("writing filename:   " + filename);
+            fs.writeFile(filename, f.result.contents, (err) => { });
+        });
+
+        console.log("Command:   tsc ");
+        obj.arguments.forEach(a => {
+            if (getRootLength(a) > 0) {
+                console.log(transalatePath(outputFolder, a));
+            }
+            else {
+                console.log(a);
+            }
+            console.log(" ");
+        });
+    }
+    extract['description'] = ' outputFolder: extract all input files to <outputFolder>';
+}
+
+var args = process.argv.slice(2);
+if (args.length < 2) {
+    console.log('Usage: node ior.js path_to_file.json [command]');
+    console.log('List of commands: ');
+    Object.keys(Commands).forEach(k => console.log('   ' + k + Commands[k]['description']));
+} else {
+    var cmd: Function = Commands[args[1]];
+    if (cmd === undefined) {
+        console.log('Unknown command ' + args[1]);
+    } else {
+        fs.readFile(args[0], 'utf-8', (err, data) => {
+            if (err) throw err;
+            var json = JSON.parse(data);
+            cmd.apply(undefined, [json].concat(args.slice(2)));
+        });
+    }
+}
+

scripts/word2md.js

@@ -1,4 +1,8 @@
 var sys = (function () {
+    var fileStream = new ActiveXObject("ADODB.Stream");
+    fileStream.Type = 2;
+    var binaryStream = new ActiveXObject("ADODB.Stream");
+    binaryStream.Type = 1;
     var args = [];
     for (var i = 0; i < WScript.Arguments.length; i++) {
         args[i] = WScript.Arguments.Item(i);
@@ -6,7 +10,24 @@ var sys = (function () {
     return {
         args: args,
         createObject: function (typeName) { return new ActiveXObject(typeName); },
-        write: function (s) { return WScript.StdOut.Write(s); }
+        write: function (s) {
+            WScript.StdOut.Write(s);
+        },
+        writeFile: function (fileName, data) {
+            fileStream.Open();
+            binaryStream.Open();
+            try {
+                fileStream.Charset = "utf-8";
+                fileStream.WriteText(data);
+                fileStream.Position = 3;
+                fileStream.CopyTo(binaryStream);
+                binaryStream.SaveToFile(fileName, 2);
+            }
+            finally {
+                binaryStream.Close();
+                fileStream.Close();
+            }
+        }
     };
 })();
 function convertDocumentToMarkdown(doc) {
@@ -149,6 +170,10 @@ function convertDocumentToMarkdown(doc) {
         lastInTable = inTable;
     }
     function writeDocument() {
+        var title = doc.builtInDocumentProperties.item(1) + "";
+        if (title.length) {
+            write("# " + title + "\n\n");
+        }
         for (var p = doc.paragraphs.first; p; p = p.next()) {
             writeParagraph(p);
         }
@@ -168,16 +193,19 @@ function convertDocumentToMarkdown(doc) {
     findReplace("^19 REF", {}, "[^&](#^&)", {});
     doc.fields.toggleShowCodes();
     writeDocument();
+    result = result.replace(/\x85/g, "\u2026");
+    result = result.replace(/\x96/g, "\u2013");
+    result = result.replace(/\x97/g, "\u2014");
     return result;
 }
 function main(args) {
-    if (args.length !== 1) {
-        sys.write("Syntax: word2md <filename>\n");
+    if (args.length !== 2) {
+        sys.write("Syntax: word2md <inputfile> <outputfile>\n");
         return;
     }
     var app = sys.createObject("Word.Application");
     var doc = app.documents.open(args[0]);
-    sys.write(convertDocumentToMarkdown(doc));
+    sys.writeFile(args[1], convertDocumentToMarkdown(doc));
     doc.close(false);
     app.quit();
 }

scripts/word2md.ts

@@ -103,6 +103,7 @@ module Word {
     export interface Document {
         fields: Fields;
         paragraphs: Paragraphs;
+        builtInDocumentProperties: Collection<any>;
         close(saveChanges: boolean): void;
         range(): Range;
     }
@@ -118,6 +119,10 @@ module Word {
 }
 
 var sys = (function () {
+    var fileStream = new ActiveXObject("ADODB.Stream");
+    fileStream.Type = 2 /*text*/;
+    var binaryStream = new ActiveXObject("ADODB.Stream");
+    binaryStream.Type = 1 /*binary*/;
     var args: string[] = [];
     for (var i = 0; i < WScript.Arguments.length; i++) {
         args[i] = WScript.Arguments.Item(i);
@@ -125,7 +130,26 @@ var sys = (function () {
     return {
         args: args,
         createObject: (typeName: string) => new ActiveXObject(typeName),
-        write: (s: string) => WScript.StdOut.Write(s)
+        write(s: string): void {
+            WScript.StdOut.Write(s);
+        },
+        writeFile: (fileName: string, data: string): void => {
+            fileStream.Open();
+            binaryStream.Open();
+            try {
+                // Write characters in UTF-8 encoding
+                fileStream.Charset = "utf-8";
+                fileStream.WriteText(data);
+                // We don't want the BOM, skip it by setting the starting location to 3 (size of BOM).
+                fileStream.Position = 3;
+                fileStream.CopyTo(binaryStream);
+                binaryStream.SaveToFile(fileName, 2 /*overwrite*/);
+            }
+            finally {
+                binaryStream.Close();
+                fileStream.Close();
+            }
+        }
     };
 })();
 
@@ -298,6 +322,10 @@ function convertDocumentToMarkdown(doc: Word.Document): string {
     }
 
     function writeDocument() {
+        var title = doc.builtInDocumentProperties.item(1) + "";
+        if (title.length) {
+            write("# " + title + "\n\n");
+        }
         for (var p = doc.paragraphs.first; p; p = p.next()) {
             writeParagraph(p);
         }
@@ -321,17 +349,21 @@ function convertDocumentToMarkdown(doc: Word.Document): string {
 
     writeDocument();
 
+    result = result.replace(/\x85/g, "\u2026");
+    result = result.replace(/\x96/g, "\u2013");
+    result = result.replace(/\x97/g, "\u2014");
+
     return result;
 }
 
 function main(args: string[]) {
-    if (args.length !== 1) {
-        sys.write("Syntax: word2md <filename>\n");
+    if (args.length !== 2) {
+        sys.write("Syntax: word2md <inputfile> <outputfile>\n");
         return;
     }
     var app: Word.Application = sys.createObject("Word.Application");
     var doc = app.documents.open(args[0]);
-    sys.write(convertDocumentToMarkdown(doc));
+    sys.writeFile(args[1], convertDocumentToMarkdown(doc));
     doc.close(false);
     app.quit();
 }

src/compiler/emitter.ts

@@ -2899,7 +2899,7 @@ module ts {
                         }
                         return {
                             diagnosticMessage: diagnosticMessage,
-                            errorNode: node.parameters[0],
+                            errorNode: <Node>node.parameters[0],
                             typeName: node.name
                         };
                     }
@@ -2920,7 +2920,7 @@ module ts {
                         }
                         return {
                             diagnosticMessage: diagnosticMessage,
-                            errorNode: node.name,
+                            errorNode: <Node>node.name,
                             typeName: undefined
                         };
                     }

src/compiler/parser.ts

@@ -227,6 +227,8 @@ module ts {
                 return children((<TupleTypeNode>node).elementTypes);
             case SyntaxKind.UnionType:
                 return children((<UnionTypeNode>node).types);
+            case SyntaxKind.ParenType:
+                return child((<ParenTypeNode>node).type);
             case SyntaxKind.ArrayLiteral:
                 return children((<ArrayLiteral>node).elements);
             case SyntaxKind.ObjectLiteral:
@@ -1078,7 +1080,7 @@ module ts {
                     return isParameter();
                 case ParsingContext.TypeArguments:
                 case ParsingContext.TupleElementTypes:
-                    return isType();
+                    return token === SyntaxKind.CommaToken || isType();
             }
 
             Debug.fail("Non-exhaustive case in 'isListElement'.");
@@ -1660,6 +1662,14 @@ module ts {
             return finishNode(node);
         }
 
+        function parseParenType(): ParenTypeNode {
+            var node = <ParenTypeNode>createNode(SyntaxKind.ParenType);
+            parseExpected(SyntaxKind.OpenParenToken);
+            node.type = parseType();
+            parseExpected(SyntaxKind.CloseParenToken);
+            return finishNode(node);
+        }
+
         function parseFunctionType(signatureKind: SyntaxKind): TypeLiteralNode {
             var node = <TypeLiteralNode>createNode(SyntaxKind.TypeLiteral);
             var member = <SignatureDeclaration>createNode(signatureKind);
@@ -1693,10 +1703,7 @@ module ts {
                 case SyntaxKind.OpenBracketToken:
                     return parseTupleType();
                 case SyntaxKind.OpenParenToken:
-                case SyntaxKind.LessThanToken:
-                    return parseFunctionType(SyntaxKind.CallSignature);
-                case SyntaxKind.NewKeyword:
-                    return parseFunctionType(SyntaxKind.ConstructSignature);
+                    return parseParenType();
                 default:
                     if (isIdentifier()) {
                         return parseTypeReference();
@@ -1720,18 +1727,18 @@ module ts {
                 case SyntaxKind.NewKeyword:
                     return true;
                 case SyntaxKind.OpenParenToken:
-                    // Only consider an ( as the start of a type if we have  ()  or  (id
-                    // We don't want to consider things like  (1)  as a function type.
+                    // Only consider '(' the start of a type if followed by ')', '...', an identifier, a modifier,
+                    // or something that starts a type. We don't want to consider things like '(1)' a type.
                     return lookAhead(() => {
                         nextToken();
-                        return token === SyntaxKind.CloseParenToken || isParameter();
+                        return token === SyntaxKind.CloseParenToken || isParameter() || isType();
                     });
                 default:
                     return isIdentifier();
             }
         }
 
-        function parseNonUnionType(): TypeNode {
+        function parsePrimaryType(): TypeNode {
             var type = parseNonArrayType();
             while (!scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) {
                 parseExpected(SyntaxKind.CloseBracketToken);
@@ -1742,13 +1749,13 @@ module ts {
             return type;
         }
 
-        function parseType(): TypeNode {
-            var type = parseNonUnionType();
+        function parseUnionType(): TypeNode {
+            var type = parsePrimaryType();
             if (token === SyntaxKind.BarToken) {
                 var types = <NodeArray<TypeNode>>[type];
                 types.pos = type.pos;
                 while (parseOptional(SyntaxKind.BarToken)) {
-                    types.push(parseNonUnionType());
+                    types.push(parsePrimaryType());
                 }
                 types.end = getNodeEnd();
                 var node = <UnionTypeNode>createNode(SyntaxKind.UnionType, type.pos);
@@ -1758,6 +1765,48 @@ module ts {
             return type;
         }
 
+        function isFunctionType(): boolean {
+            return token === SyntaxKind.LessThanToken || token === SyntaxKind.OpenParenToken && lookAhead(() => {
+                nextToken();
+                if (token === SyntaxKind.CloseParenToken || token === SyntaxKind.DotDotDotToken) {
+                    // ( )
+                    // ( ...
+                    return true;
+                }
+                if (isIdentifier() || isModifier(token)) {
+                    nextToken();
+                    if (token === SyntaxKind.ColonToken || token === SyntaxKind.CommaToken ||
+                        token === SyntaxKind.QuestionToken || token === SyntaxKind.EqualsToken ||
+                        isIdentifier() || isModifier(token)) {
+                        // ( id :
+                        // ( id ,
+                        // ( id ?
+                        // ( id =
+                        // ( modifier id
+                        return true;
+                    }
+                    if (token === SyntaxKind.CloseParenToken) {
+                        nextToken();
+                        if (token === SyntaxKind.EqualsGreaterThanToken) {
+                            // ( id ) =>
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            });
+        }
+
+        function parseType(): TypeNode {
+            if (isFunctionType()) {
+                return parseFunctionType(SyntaxKind.CallSignature);
+            }
+            if (token === SyntaxKind.NewKeyword) {
+                return parseFunctionType(SyntaxKind.ConstructSignature);
+            }
+            return parseUnionType();
+        }
+
         function parseTypeAnnotation(): TypeNode {
             return parseOptional(SyntaxKind.ColonToken) ? parseType() : undefined;
         }
@@ -2344,13 +2393,29 @@ module ts {
         function parseTypeArguments(): NodeArray<TypeNode> {
             var typeArgumentListStart = scanner.getTokenPos();
             var errorCountBeforeTypeParameterList = file.syntacticErrors.length;
-            var result = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken);
+            // We pass parseSingleTypeArgument instead of parseType as the element parser
+            // because parseSingleTypeArgument knows how to parse a missing type argument.
+            // This is useful for signature help. parseType has the disadvantage that when
+            // it sees a missing type, it changes the LookAheadMode to Error, and the result
+            // is a broken binary expression, which breaks signature help.
+            var result = parseBracketedList(ParsingContext.TypeArguments, parseSingleTypeArgument, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken);
             if (!result.length && file.syntacticErrors.length === errorCountBeforeTypeParameterList) {
                 grammarErrorAtPos(typeArgumentListStart, scanner.getStartPos() - typeArgumentListStart, Diagnostics.Type_argument_list_cannot_be_empty);
             }
             return result;
         }
 
+        function parseSingleTypeArgument(): TypeNode {
+            if (token === SyntaxKind.CommaToken) {
+                var errorStart = scanner.getTokenPos();
+                var errorLength = scanner.getTextPos() - errorStart;
+                grammarErrorAtPos(errorStart, errorLength, Diagnostics.Type_expected);
+                return createNode(SyntaxKind.Missing);
+            }
+
+            return parseType();
+        }
+
         function parsePrimaryExpression(): Expression {
             switch (token) {
                 case SyntaxKind.ThisKeyword:

src/compiler/types.ts

@@ -155,6 +155,7 @@ module ts {
         ArrayType,
         TupleType,
         UnionType,
+        ParenType,
         // Expression
         ArrayLiteral,
         ObjectLiteral,
@@ -225,7 +226,7 @@ module ts {
         FirstFutureReservedWord = ImplementsKeyword,
         LastFutureReservedWord = YieldKeyword,
         FirstTypeNode = TypeReference,
-        LastTypeNode = UnionType,
+        LastTypeNode = ParenType,
         FirstPunctuation = OpenBraceToken,
         LastPunctuation = CaretEqualsToken,
         FirstToken = EndOfFileToken,
@@ -345,6 +346,10 @@ module ts {
         types: NodeArray<TypeNode>;
     }
 
+    export interface ParenTypeNode extends TypeNode {
+        type: TypeNode;
+    }
+
     export interface StringLiteralTypeNode extends TypeNode {
         text: string;
     }
@@ -651,18 +656,14 @@ module ts {
         getTypeOfNode(node: Node): Type;
         getApparentType(type: Type): ApparentType;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
-        writeType(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
-        writeSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;
+        getSymbolDisplayBuilder(): SymbolDisplayBuilder;
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfApparentType(type: Type): Symbol[];
         getRootSymbols(symbol: Symbol): Symbol[];
         getContextualType(node: Node): Type;
         getResolvedSignature(node: CallExpression, candidatesOutArray?: Signature[]): Signature;
         getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
-        writeSignature(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
-        writeTypeParameter(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
-        writeTypeParametersOfSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void;
         isImplementationOfOverload(node: FunctionDeclaration): boolean;
         isUndefinedSymbol(symbol: Symbol): boolean;
         isArgumentsSymbol(symbol: Symbol): boolean;
@@ -675,6 +676,18 @@ module ts {
         getAliasedSymbol(symbol: Symbol): Symbol;
     }
 
+    export interface SymbolDisplayBuilder {
+        buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;
+        buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void;
+        buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+    }
+
     export interface SymbolWriter {
         writeKeyword(text: string): void;
         writeOperator(text: string): void;
@@ -702,6 +715,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 {
@@ -1017,6 +1031,7 @@ module ts {
 
     export interface InferenceContext {
         typeParameters: TypeParameter[];  // Type parameters for which inferences are made
+        inferUnionTypes: boolean;         // Infer union types for disjoint candidates (otherwise undefinedType)
         inferenceCount: number;           // Incremented for every inference made (whether new or not)
         inferences: Type[][];             // Inferences made for each type parameter
         inferredTypes: Type[];            // Inferred type for each type parameter

src/harness/compilerRunner.ts

@@ -61,9 +61,11 @@ class CompilerBaselineRunner extends RunnerBase {
             var otherFiles: { unitName: string; content: string }[];
             var harnessCompiler: Harness.Compiler.HarnessCompiler;
 
-            var declToBeCompiled: { unitName: string; content: string }[] = [];
-            var declOtherFiles: { unitName: string; content: string }[] = [];
-            var declResult: Harness.Compiler.CompilerResult;
+            var declFileCompilationResult: {
+                declInputFiles: { unitName: string; content: string }[];
+                declOtherFiles: { unitName: string; content: string }[];
+                declResult: Harness.Compiler.CompilerResult;
+            };
 
             var createNewInstance = false;
 
@@ -147,9 +149,7 @@ class CompilerBaselineRunner extends RunnerBase {
                 toBeCompiled = undefined;
                 otherFiles = undefined;
                 harnessCompiler = undefined;
-                declToBeCompiled = undefined;
-                declOtherFiles = undefined;
-                declResult = undefined;
+                declFileCompilationResult = undefined;
             });
 
             function getByteOrderMarkText(file: Harness.Compiler.GeneratedFile): string {
@@ -173,61 +173,18 @@ class CompilerBaselineRunner extends RunnerBase {
 
             // Source maps?
             it('Correct sourcemap content for ' + fileName, () => {
-                if (result.sourceMapRecord) {
+                if (options.sourceMap) {
                     Harness.Baseline.runBaseline('Correct sourcemap content for ' + fileName, justName.replace(/\.ts$/, '.sourcemap.txt'), () => {
-                        return result.sourceMapRecord;
+                        return result.getSourceMapRecord();
                     });
                 }
             });
 
             // Compile .d.ts files
             it('Correct compiler generated.d.ts for ' + fileName, () => {
-                if (options.declaration && result.errors.length === 0 && result.declFilesCode.length !== result.files.length) {
-                    throw new Error('There were no errors and declFiles generated did not match number of js files generated');
-                }
-
-                // if the .d.ts is non-empty, confirm it compiles correctly as well
-                if (options.declaration && result.errors.length === 0 && result.declFilesCode.length > 0) {
-                    function addDtsFile(file: { unitName: string; content: string }, dtsFiles: { unitName: string; content: string }[]) {
-                        if (Harness.Compiler.isDTS(file.unitName)) {
-                            dtsFiles.push(file);
-                        }
-                        else {
-                            var declFile = findResultCodeFile(file.unitName);
-                            // Look if there is --out file corresponding to this ts file
-                            if (!declFile && options.out) {
-                                declFile = findResultCodeFile(options.out);
-                                if (!declFile || findUnit(declFile.fileName, declToBeCompiled) ||
-                                    findUnit(declFile.fileName, declOtherFiles)) {
-                                    return;
-                                }
-                            }
-
-                            if (declFile) {
-                                dtsFiles.push({ unitName: declFile.fileName, content: declFile.code });
-                                return;
-                            }
-                        }
-
-                        function findResultCodeFile(fileName: string) {
-                            return ts.forEach(result.declFilesCode,
-                                declFile => declFile.fileName === (fileName.substr(0, fileName.length - ".ts".length) + ".d.ts")
-                                    ? declFile : undefined);
-                        }
-
-                        function findUnit(fileName: string, units: { unitName: string; content: string }[]) {
-                            return ts.forEach(units, unit => unit.unitName === fileName ? unit : undefined);
-                        }
-                    }
-
-                    ts.forEach(toBeCompiled, file => addDtsFile(file, declToBeCompiled));
-                    ts.forEach(otherFiles, file => addDtsFile(file, declOtherFiles));
-                    harnessCompiler.compileFiles(declToBeCompiled, declOtherFiles, function (compileResult) {
-                        declResult = compileResult;
-                    }, function (settings) {
-                            harnessCompiler.setCompilerSettings(tcSettings);
-                    });
-                }
+                declFileCompilationResult = harnessCompiler.compileDeclarationFiles(toBeCompiled, otherFiles, result, function (settings) {
+                    harnessCompiler.setCompilerSettings(tcSettings);
+                }, options);
             });
 
 
@@ -267,10 +224,10 @@ class CompilerBaselineRunner extends RunnerBase {
                             }
                         }
 
-                        if (declResult && declResult.errors.length) {
+                        if (declFileCompilationResult && declFileCompilationResult.declResult.errors.length) {
                             jsCode += '\r\n\r\n//// [DtsFileErrors]\r\n';
                             jsCode += '\r\n\r\n';
-                            jsCode += getErrorBaseline(declToBeCompiled, declOtherFiles, declResult);
+                            jsCode += getErrorBaseline(declFileCompilationResult.declInputFiles, declFileCompilationResult.declOtherFiles, declFileCompilationResult.declResult);
                         }
 
                         if (jsCode.length > 0) {

src/harness/harness.ts

@@ -139,6 +139,7 @@ module Harness {
         deleteFile(filename: string): void;
         listFiles(path: string, filter: RegExp, options?: { recursive?: boolean }): string[];
         log(text: string): void;
+        getMemoryUsage? (): number;
     }
 
     module IOImpl {
@@ -275,6 +276,13 @@ module Harness {
 
                 return filesInFolder(path);
             }
+
+            export var getMemoryUsage: typeof IO.getMemoryUsage = () => {
+                if (global.gc) {
+                    global.gc();
+                }
+                return process.memoryUsage().heapUsed;
+            }
         }
 
         export module Network {
@@ -806,15 +814,81 @@ module Harness {
                 });
                 this.lastErrors = errors;
 
-                var result = new CompilerResult(fileOutputs, errors, []);
-                // Covert the source Map data into the baseline
-                result.updateSourceMapRecord(program, emitResult ? emitResult.sourceMaps : undefined);
+                var result = new CompilerResult(fileOutputs, errors, program, sys.getCurrentDirectory(), emitResult ? emitResult.sourceMaps : undefined);
                 onComplete(result, checker);
 
                 // reset what newline means in case the last test changed it
                 sys.newLine = '\r\n';
                 return options;
             }
+
+            public compileDeclarationFiles(inputFiles: { unitName: string; content: string; }[],
+                otherFiles: { unitName: string; content: string; }[],
+                result: CompilerResult,
+                settingsCallback?: (settings: ts.CompilerOptions) => void,
+                options?: ts.CompilerOptions) {
+                if (options.declaration && result.errors.length === 0 && result.declFilesCode.length !== result.files.length) {
+                    throw new Error('There were no errors and declFiles generated did not match number of js files generated');
+                }
+
+                // if the .d.ts is non-empty, confirm it compiles correctly as well
+                if (options.declaration && result.errors.length === 0 && result.declFilesCode.length > 0) {
+                    var declInputFiles: { unitName: string; content: string }[] = [];
+                    var declOtherFiles: { unitName: string; content: string }[] = [];
+                    var declResult: Harness.Compiler.CompilerResult;
+
+                    ts.forEach(inputFiles, file => addDtsFile(file, declInputFiles));
+                    ts.forEach(otherFiles, file => addDtsFile(file, declOtherFiles));
+                    this.compileFiles(declInputFiles, declOtherFiles, function (compileResult) {
+                        declResult = compileResult;
+                    }, settingsCallback, options);
+
+                    return { declInputFiles: declInputFiles, declOtherFiles: declOtherFiles, declResult: declResult };
+                }
+
+                function addDtsFile(file: { unitName: string; content: string }, dtsFiles: { unitName: string; content: string }[]) {
+                    if (isDTS(file.unitName)) {
+                        dtsFiles.push(file);
+                    }
+                    else if (isTS(file.unitName)) {
+                        var declFile = findResultCodeFile(file.unitName);
+                        if (!findUnit(declFile.fileName, declInputFiles) && !findUnit(declFile.fileName, declOtherFiles)) {
+                            dtsFiles.push({ unitName: declFile.fileName, content: declFile.code });
+                        }
+                    }
+
+                    function findResultCodeFile(fileName: string) {
+                        var dTsFileName = ts.forEach(result.program.getSourceFiles(), sourceFile => {
+                            if (sourceFile.filename === fileName) {
+                                // Is this file going to be emitted separately
+                                var sourceFileName: string;
+                                if (ts.isExternalModule(sourceFile) || !options.out) {
+                                    if (options.outDir) {
+                                        var sourceFilePath = ts.getNormalizedPathFromPathComponents(ts.getNormalizedPathComponents(sourceFile.filename, result.currentDirectoryForProgram));
+                                        sourceFilePath = sourceFilePath.replace(result.program.getCommonSourceDirectory(), "");
+                                        sourceFileName = ts.combinePaths(options.outDir, sourceFilePath);
+                                    }
+                                    else {
+                                        sourceFileName = sourceFile.filename;
+                                    }
+                                }
+                                else {
+                                    // Goes to single --out file
+                                    sourceFileName = options.out;
+                                }
+
+                                return ts.removeFileExtension(sourceFileName) + ".d.ts";
+                            }
+                        });
+                        
+                        return ts.forEach(result.declFilesCode, declFile => declFile.fileName === dTsFileName ? declFile : undefined);
+                    }
+
+                    function findUnit(fileName: string, units: { unitName: string; content: string; }[]) {
+                        return ts.forEach(units, unit => unit.unitName === fileName ? unit : undefined);
+                    }
+                }
+            }
         }
 
         export function getMinimalDiagnostic(err: ts.Diagnostic): HarnessDiagnostic {
@@ -950,10 +1024,6 @@ module Harness {
         }
         */
 
-        /** Recreate the harness compiler instance to its default settings */
-        export function recreate(options?: { useMinimalDefaultLib: boolean; noImplicitAny: boolean; }) {
-        }
-
         /** The harness' compiler instance used when tests are actually run. Reseting or changing settings of this compiler instance must be done within a test case (i.e., describe/it) */
         var harnessCompiler: HarnessCompiler;
 
@@ -993,6 +1063,10 @@ module Harness {
             return str.substr(str.length - end.length) === end;
         }
 
+        export function isTS(fileName: string) {
+            return stringEndsWith(fileName, '.ts');
+        }
+
         export function isDTS(fileName: string) {
             return stringEndsWith(fileName, '.d.ts');
         }
@@ -1011,10 +1085,10 @@ module Harness {
             public errors: HarnessDiagnostic[] = [];
             public declFilesCode: GeneratedFile[] = [];
             public sourceMaps: GeneratedFile[] = [];
-            public sourceMapRecord: string;
 
             /** @param fileResults an array of strings for the fileName and an ITextWriter with its code */
-            constructor(fileResults: GeneratedFile[], errors: HarnessDiagnostic[], sourceMapRecordLines: string[]) {
+            constructor(fileResults: GeneratedFile[], errors: HarnessDiagnostic[], public program: ts.Program,
+                public currentDirectoryForProgram: string, private sourceMapData: ts.SourceMapData[]) {
                 var lines: string[] = [];
 
                 fileResults.forEach(emittedFile => {
@@ -1032,12 +1106,11 @@ module Harness {
                 });
 
                 this.errors = errors;
-                this.sourceMapRecord = sourceMapRecordLines.join('\r\n');
             }
 
-            public updateSourceMapRecord(program: ts.Program, sourceMapData: ts.SourceMapData[]) {
-                if (sourceMapData) {
-                    this.sourceMapRecord = Harness.SourceMapRecoder.getSourceMapRecord(sourceMapData, program, this.files);
+            public getSourceMapRecord() {
+                if (this.sourceMapData) {
+                    return Harness.SourceMapRecoder.getSourceMapRecord(this.sourceMapData, this.program, this.files);
                 }
             }
 

src/harness/projectsRunner.ts

@@ -419,6 +419,16 @@ class ProjectRunner extends RunnerBase {
                 //    })
                 //});
             }
+
+            after(() => {
+                // Mocha holds onto the closure environment of the describe callback even after the test is done.
+                // Therefore we have to clean out large objects after the test is done.
+                nodeCompilerResult = undefined;
+                amdCompilerResult = undefined;
+                testCase = undefined;
+                testFileText = undefined;
+                testCaseJustName = undefined;
+            });
         });
     }
 }

src/harness/rwcRunner.ts

@@ -46,144 +46,171 @@ module RWC {
     }
 
     export function runRWCTest(jsonPath: string) {
-        var harnessCompiler = Harness.Compiler.getCompiler();
-        var opts: ts.ParsedCommandLine;
+        describe("Testing a RWC project: " + jsonPath, () => {
+            var inputFiles: { unitName: string; content: string; }[] = [];
+            var otherFiles: { unitName: string; content: string; }[] = [];
+            var compilerResult: Harness.Compiler.CompilerResult;
+            var compilerOptions: ts.CompilerOptions;
+            var baselineOpts: Harness.Baseline.BaselineOptions = { Subfolder: 'rwc' };
+            var baseName = /(.*)\/(.*).json/.exec(Harness.Path.switchToForwardSlashes(jsonPath))[2];
+            // Compile .d.ts files
+            var declFileCompilationResult: {
+                declInputFiles: { unitName: string; content: string }[];
+                declOtherFiles: { unitName: string; content: string }[];
+                declResult: Harness.Compiler.CompilerResult;
+            };
 
-        var ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath));
-        var errors = '';
-
-        it('has parsable options', () => {
-            runWithIOLog(ioLog, () => {
-                opts = ts.parseCommandLine(ioLog.arguments);
-                assert.equal(opts.errors.length, 0);
-            });
-        });
-
-        var inputFiles: { unitName: string; content: string; }[] = [];
-        var otherFiles: { unitName: string; content: string; }[] = [];
-        var compilerResult: Harness.Compiler.CompilerResult;
-        it('can compile', () => {
-            runWithIOLog(ioLog, () => {
-                harnessCompiler.reset();
-
-                // Load the files
-                ts.forEach(opts.filenames, fileName => {
-                    inputFiles.push(getHarnessCompilerInputUnit(fileName));
-                });
-
-                if (!opts.options.noLib) {
-                    // Find the lib.d.ts file in the input file and add it to the input files list
-                    var libFile = ts.forEach(ioLog.filesRead, fileRead=> Harness.isLibraryFile(fileRead.path) ? fileRead.path : undefined);
-                    if (libFile) {
-                        inputFiles.push(getHarnessCompilerInputUnit(libFile));
-                    }
-                }
-
-                ts.forEach(ioLog.filesRead, fileRead => {
-                    var resolvedPath = Harness.Path.switchToForwardSlashes(sys.resolvePath(fileRead.path));
-                    var inInputList = ts.forEach(inputFiles, inputFile=> inputFile.unitName === resolvedPath);
-                    if (!inInputList) {
-                        // Add the file to other files
-                        otherFiles.push(getHarnessCompilerInputUnit(fileRead.path));
-                    }
-                });
-
-                // do not use lib since we already read it in above
-                opts.options.noLib = true;
-
-                // Emit the results
-                harnessCompiler.compileFiles(inputFiles, otherFiles, compileResult => {
-                    compilerResult = compileResult;
-                }, /*settingsCallback*/ undefined, opts.options);
+            after(() => {
+                // Mocha holds onto the closure environment of the describe callback even after the test is done.
+                // Therefore we have to clean out large objects after the test is done.
+                inputFiles = undefined;
+                otherFiles = undefined;
+                compilerResult = undefined;
+                compilerOptions = undefined;
+                baselineOpts = undefined;
+                baseName = undefined;
+                declFileCompilationResult = undefined;
             });
 
-            function getHarnessCompilerInputUnit(fileName: string) {
-                var resolvedPath = Harness.Path.switchToForwardSlashes(sys.resolvePath(fileName));
-                try {
-                    var content = sys.readFile(resolvedPath);
+            it('can compile', () => {
+                var harnessCompiler = Harness.Compiler.getCompiler();
+                var opts: ts.ParsedCommandLine;
+
+                var ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath));
+                runWithIOLog(ioLog, () => {
+                    opts = ts.parseCommandLine(ioLog.arguments);
+                    assert.equal(opts.errors.length, 0);
+                });
+
+                runWithIOLog(ioLog, () => {
+                    harnessCompiler.reset();
+
+                    // Load the files
+                    ts.forEach(opts.filenames, fileName => {
+                        inputFiles.push(getHarnessCompilerInputUnit(fileName));
+                    });
+
+                    if (!opts.options.noLib) {
+                        // Find the lib.d.ts file in the input file and add it to the input files list
+                        var libFile = ts.forEach(ioLog.filesRead, fileRead=> Harness.isLibraryFile(fileRead.path) ? fileRead.path : undefined);
+                        if (libFile) {
+                            inputFiles.push(getHarnessCompilerInputUnit(libFile));
+                        }
+                    }
+
+                    ts.forEach(ioLog.filesRead, fileRead => {
+                        var resolvedPath = Harness.Path.switchToForwardSlashes(sys.resolvePath(fileRead.path));
+                        var inInputList = ts.forEach(inputFiles, inputFile=> inputFile.unitName === resolvedPath);
+                        if (!inInputList) {
+                            // Add the file to other files
+                            otherFiles.push(getHarnessCompilerInputUnit(fileRead.path));
+                        }
+                    });
+
+                    // do not use lib since we already read it in above
+                    opts.options.noLib = true;
+
+                    // Emit the results
+                    compilerOptions = harnessCompiler.compileFiles(inputFiles, otherFiles, compileResult => {
+                        compilerResult = compileResult;
+                    }, /*settingsCallback*/ undefined, opts.options);
+                });
+
+                function getHarnessCompilerInputUnit(fileName: string) {
+                    var resolvedPath = Harness.Path.switchToForwardSlashes(sys.resolvePath(fileName));
+                    try {
+                        var content = sys.readFile(resolvedPath);
+                    }
+                    catch (e) {
+                        // Leave content undefined.
+                    }
+                    return { unitName: resolvedPath, content: content };
                 }
-                catch (e) {
-                    // Leave content undefined.
-                }
-                return { unitName: resolvedPath, content: content };
-            }
-        });
+            });
 
-        // Baselines
-        var baselineOpts: Harness.Baseline.BaselineOptions = { Subfolder: 'rwc' };
-        var baseName = /(.*)\/(.*).json/.exec(Harness.Path.switchToForwardSlashes(jsonPath))[2];
+            // Baselines
+            it('Correct compiler generated.d.ts', () => {
+                declFileCompilationResult = Harness.Compiler.getCompiler().compileDeclarationFiles(inputFiles, otherFiles, compilerResult, /*settingscallback*/ undefined, compilerOptions);
+            });
 
-        it('has the expected emitted code', () => {
-            Harness.Baseline.runBaseline('has the expected emitted code', baseName + '.output.js', () => {
-                return collateOutputs(compilerResult.files, s => SyntacticCleaner.clean(s));
-            }, false, baselineOpts);
-        });
 
-        it('has the expected declaration file content', () => {
-            Harness.Baseline.runBaseline('has the expected declaration file content', baseName + '.d.ts', () => {
-                if (compilerResult.errors.length || !compilerResult.declFilesCode.length) {
-                    return null;
-                }
-                return collateOutputs(compilerResult.declFilesCode);
-            }, false, baselineOpts);
-        });
-
-        it('has the expected source maps', () => {
-            Harness.Baseline.runBaseline('has the expected source maps', baseName + '.map', () => {
-                if (!compilerResult.sourceMaps.length) {
-                    return null;
-                }
-
-                return collateOutputs(compilerResult.sourceMaps);
-            }, false, baselineOpts);
-        });
-
-        it('has correct source map record', () => {
-            if (compilerResult.sourceMapRecord) {
-                Harness.Baseline.runBaseline('has correct source map record', baseName + '.sourcemap.txt', () => {
-                    return compilerResult.sourceMapRecord;
+            it('has the expected emitted code', () => {
+                Harness.Baseline.runBaseline('has the expected emitted code', baseName + '.output.js', () => {
+                    return collateOutputs(compilerResult.files, s => SyntacticCleaner.clean(s));
                 }, false, baselineOpts);
-            }
-        });
+            });
 
-        it('has the expected errors', () => {
-            Harness.Baseline.runBaseline('has the expected errors', baseName + '.errors.txt', () => {
-                if (compilerResult.errors.length === 0) {
-                    return null;
+            it('has the expected declaration file content', () => {
+                Harness.Baseline.runBaseline('has the expected declaration file content', baseName + '.d.ts', () => {
+                    if (compilerResult.errors.length || !compilerResult.declFilesCode.length) {
+                        return null;
+                    }
+                    return collateOutputs(compilerResult.declFilesCode);
+                }, false, baselineOpts);
+            });
+
+            it('has the expected source maps', () => {
+                Harness.Baseline.runBaseline('has the expected source maps', baseName + '.map', () => {
+                    if (!compilerResult.sourceMaps.length) {
+                        return null;
+                    }
+
+                    return collateOutputs(compilerResult.sourceMaps);
+                }, false, baselineOpts);
+            });
+
+            //it('has correct source map record', () => {
+            //    if (compilerOptions.sourceMap) {
+            //        Harness.Baseline.runBaseline('has correct source map record', baseName + '.sourcemap.txt', () => {
+            //            return compilerResult.getSourceMapRecord();
+            //        }, false, baselineOpts);
+            //    }
+            //});
+
+            it('has the expected errors', () => {
+                Harness.Baseline.runBaseline('has the expected errors', baseName + '.errors.txt', () => {
+                    if (compilerResult.errors.length === 0) {
+                        return null;
+                    }
+
+                    return Harness.Compiler.getErrorBaseline(inputFiles.concat(otherFiles), compilerResult.errors);
+                }, false, baselineOpts);
+            });
+
+            it('has no errors in generated declaration files', () => {
+                if (compilerOptions.declaration && !compilerResult.errors.length) {
+                    Harness.Baseline.runBaseline('has no errors in generated declaration files', baseName + '.dts.errors.txt', () => {
+                        if (declFileCompilationResult.declResult.errors.length === 0) {
+                            return null;
+                        }
+
+                        return Harness.Compiler.minimalDiagnosticsToString(declFileCompilationResult.declResult.errors) +
+                            sys.newLine + sys.newLine +
+                            Harness.Compiler.getErrorBaseline(declFileCompilationResult.declInputFiles.concat(declFileCompilationResult.declOtherFiles), declFileCompilationResult.declResult.errors);
+                    }, false, baselineOpts);
                 }
+            });
 
-                return Harness.Compiler.getErrorBaseline(inputFiles.concat(otherFiles), compilerResult.errors);
-            }, false, baselineOpts);
+            // TODO: Type baselines (need to refactor out from compilerRunner)
         });
-
-        // TODO: Type baselines (need to refactor out from compilerRunner)
     }
 }
 
 class RWCRunner extends RunnerBase {
-    private runnerPath = "tests/runners/rwc";
-    private sourcePath = "tests/cases/rwc/";
-
-    private harnessCompiler: Harness.Compiler.HarnessCompiler;
+    private static sourcePath = "tests/cases/rwc/";
 
     /** Setup the runner's tests so that they are ready to be executed by the harness
      *  The first test should be a describe/it block that sets up the harness's compiler instance appropriately
      */
     public initializeTests(): void {
-        // Recreate the compiler with the default lib
-        Harness.Compiler.recreate({ useMinimalDefaultLib: false, noImplicitAny: false });
-        this.harnessCompiler = Harness.Compiler.getCompiler();
-
         // Read in and evaluate the test list
-        var testList = Harness.IO.listFiles(this.sourcePath, /.+\.json$/);
+        var testList = Harness.IO.listFiles(RWCRunner.sourcePath, /.+\.json$/);
         for (var i = 0; i < testList.length; i++) {
             this.runTest(testList[i]);
         }
     }
 
     private runTest(jsonFilename: string) {
-        describe("Testing a RWC project: " + jsonFilename, () => {
-            RWC.runRWCTest(jsonFilename);
-        });
+        RWC.runRWCTest(jsonFilename);
     }
 }

src/services/services.ts

@@ -1462,7 +1462,7 @@ module ts {
         }
     }
 
-    function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[] {
+    export function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[] {
         writeDisplayParts(displayPartWriter);
         var result = displayPartWriter.displayParts();
         displayPartWriter.clear();
@@ -1471,19 +1471,19 @@ module ts {
 
     export function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
         return mapToDisplayParts(writer => {
-            typechecker.writeType(type, writer, enclosingDeclaration, flags);
+            typechecker.getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
         });
     }
 
     export function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): SymbolDisplayPart[] {
         return mapToDisplayParts(writer => {
-            typeChecker.writeSymbol(symbol, writer, enclosingDeclaration, meaning, flags);
+            typeChecker.getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags);
         });
     }
 
     function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[]{
         return mapToDisplayParts(writer => {
-            typechecker.writeSignature(signature, writer, enclosingDeclaration, flags);
+            typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags);
         });
     }
 
@@ -2694,7 +2694,7 @@ module ts {
 
         // TODO(drosen): use contextual SemanticMeaning.
         function getSymbolKind(symbol: Symbol, typeResolver: TypeChecker): string {
-            var flags = typeInfoResolver.getRootSymbols(symbol)[0].getFlags();
+            var flags = symbol.getFlags();
 
             if (flags & SymbolFlags.Class) return ScriptElementKind.classElement;
             if (flags & SymbolFlags.Enum) return ScriptElementKind.enumElement;
@@ -2734,6 +2734,18 @@ module ts {
             if (flags & SymbolFlags.Property) return ScriptElementKind.memberVariableElement;
             if (flags & SymbolFlags.Constructor) return ScriptElementKind.constructorImplementationElement;
 
+            if (flags & SymbolFlags.UnionProperty) {
+                return forEach(typeInfoResolver.getRootSymbols(symbol), rootSymbol => {
+                    var rootSymbolFlags = rootSymbol.getFlags();
+                    if (rootSymbolFlags & SymbolFlags.Property) {
+                        return ScriptElementKind.memberVariableElement;
+                    }
+                    if (rootSymbolFlags & SymbolFlags.GetAccessor) return ScriptElementKind.memberVariableElement;
+                    if (rootSymbolFlags & SymbolFlags.SetAccessor) return ScriptElementKind.memberVariableElement;
+                    Debug.assert(rootSymbolFlags & SymbolFlags.Method);
+                }) || ScriptElementKind.memberFunctionElement;
+            }
+
             return ScriptElementKind.unknown;
         }
         
@@ -2785,7 +2797,7 @@ module ts {
             semanticMeaning = getMeaningFromLocation(location)) {
             var displayParts: SymbolDisplayPart[] = [];
             var documentation: SymbolDisplayPart[];
-            var symbolFlags = typeResolver.getRootSymbols(symbol)[0].flags;
+            var symbolFlags = symbol.flags;
             var symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, symbolFlags, typeResolver);
             var hasAddedSymbolInfo: boolean;
             // Class at constructor site need to be shown as constructor apart from property,method, vars
@@ -3001,7 +3013,7 @@ module ts {
                             // If the type is type parameter, format it specially
                             if (type.symbol && type.symbol.flags & SymbolFlags.TypeParameter) {
                                 var typeParameterParts = mapToDisplayParts(writer => {
-                                    typeResolver.writeTypeParameter(<TypeParameter>type, writer, enclosingDeclaration);
+                                    typeResolver.getSymbolDisplayBuilder().buildTypeParameterDisplay(<TypeParameter>type, writer, enclosingDeclaration);
                                 });
                                 displayParts.push.apply(displayParts, typeParameterParts);
                             }
@@ -3013,7 +3025,8 @@ module ts {
                             symbolFlags & SymbolFlags.Method ||
                             symbolFlags & SymbolFlags.Constructor ||
                             symbolFlags & SymbolFlags.Signature ||
-                            symbolFlags & SymbolFlags.Accessor) {
+                            symbolFlags & SymbolFlags.Accessor || 
+                            symbolKind === ScriptElementKind.memberFunctionElement) {
                             var allSignatures = type.getCallSignatures();
                             addSignatureDisplayParts(allSignatures[0], allSignatures);
                         }
@@ -3069,7 +3082,7 @@ module ts {
 
             function writeTypeParametersOfSymbol(symbol: Symbol, enclosingDeclaration: Node) {
                 var typeParameterParts = mapToDisplayParts(writer => {
-                    typeResolver.writeTypeParametersOfSymbol(symbol, writer, enclosingDeclaration);
+                    typeResolver.getSymbolDisplayBuilder().buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaration);
                 });
                 displayParts.push.apply(displayParts, typeParameterParts);
             }

src/services/signatureHelp.ts

@@ -258,6 +258,13 @@ module ts.SignatureHelp {
             return undefined;
         }
 
+        function getChildListThatStartsWithOpenerToken(parent: Node, openerToken: Node, sourceFile: SourceFile): Node {
+            var children = parent.getChildren(sourceFile);
+            var indexOfOpenerToken = children.indexOf(openerToken);
+            Debug.assert(indexOfOpenerToken >= 0 && children.length > indexOfOpenerToken + 1);
+            return children[indexOfOpenerToken + 1];
+        }
+
         /**
          * The selectedItemIndex could be negative for several reasons.
          *     1. There are too many arguments for all of the overloads
@@ -287,74 +294,51 @@ module ts.SignatureHelp {
 
         function createSignatureHelpItems(candidates: Signature[], bestSignature: Signature, argumentInfoOrTypeArgumentInfo: ListItemInfo): SignatureHelpItems {
             var argumentListOrTypeArgumentList = argumentInfoOrTypeArgumentInfo.list;
+            var parent = <CallExpression>argumentListOrTypeArgumentList.parent;
+            var isTypeParameterHelp = parent.typeArguments && parent.typeArguments.pos === argumentListOrTypeArgumentList.pos;
+            Debug.assert(isTypeParameterHelp || parent.arguments.pos === argumentListOrTypeArgumentList.pos);
+
+            var callTargetNode = (<CallExpression>argumentListOrTypeArgumentList.parent).func;
+            var callTargetSymbol = typeInfoResolver.getSymbolInfo(callTargetNode);
+            var callTargetDisplayParts = callTargetSymbol && symbolToDisplayParts(typeInfoResolver, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined);
             var items: SignatureHelpItem[] = map(candidates, candidateSignature => {
-                var parameters = candidateSignature.parameters;
-                var parameterHelpItems: SignatureHelpParameter[] = parameters.length === 0 ? emptyArray : map(parameters, p => {
-                    var displayParts: SymbolDisplayPart[] = [];
+                var signatureHelpParameters: SignatureHelpParameter[];
+                var prefixParts: SymbolDisplayPart[] = [];
+                var suffixParts: SymbolDisplayPart[] = [];
 
-                    if (candidateSignature.hasRestParameter && parameters[parameters.length - 1] === p) {
-                        displayParts.push(punctuationPart(SyntaxKind.DotDotDotToken));
-                    }
-
-                    displayParts.push(symbolPart(p.name, p));
-
-                    var isOptional = !!(p.valueDeclaration.flags & NodeFlags.QuestionMark);
-                    if (isOptional) {
-                        displayParts.push(punctuationPart(SyntaxKind.QuestionToken));
-                    }
-
-                    displayParts.push(punctuationPart(SyntaxKind.ColonToken));
-                    displayParts.push(spacePart());
-
-                    var typeParts = typeToDisplayParts(typeInfoResolver, typeInfoResolver.getTypeOfSymbol(p), argumentListOrTypeArgumentList);
-                    displayParts.push.apply(displayParts, typeParts);
-
-                    return {
-                        name: p.name,
-                        documentation: p.getDocumentationComment(),
-                        displayParts: displayParts,
-                        isOptional: isOptional
-                    };
-                });
-
-                var callTargetNode = (<CallExpression>argumentListOrTypeArgumentList.parent).func;
-                var callTargetSymbol = typeInfoResolver.getSymbolInfo(callTargetNode);
-
-                var prefixParts = callTargetSymbol ? symbolToDisplayParts(typeInfoResolver, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined) : [];
-
-                var separatorParts = [punctuationPart(SyntaxKind.CommaToken), spacePart()];
-
-                // TODO(jfreeman): Constraints?
-                if (candidateSignature.typeParameters && candidateSignature.typeParameters.length) {
-                    prefixParts.push(punctuationPart(SyntaxKind.LessThanToken));
-
-                    for (var i = 0, n = candidateSignature.typeParameters.length; i < n; i++) {
-                        if (i) {
-                            prefixParts.push.apply(prefixParts, separatorParts);
-                        }
-
-                        var tp = candidateSignature.typeParameters[i].symbol;
-                        prefixParts.push(symbolPart(tp.name, tp));
-                    }
-
-                    prefixParts.push(punctuationPart(SyntaxKind.GreaterThanToken));
+                if (callTargetDisplayParts) {
+                    prefixParts.push.apply(prefixParts, callTargetDisplayParts);
                 }
 
-                prefixParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                if (isTypeParameterHelp) {
+                    prefixParts.push(punctuationPart(SyntaxKind.LessThanToken));
+                    var typeParameters = candidateSignature.typeParameters;
+                    signatureHelpParameters = typeParameters && typeParameters.length > 0 ? map(typeParameters, createSignatureHelpParameterForTypeParameter) : emptyArray;
+                    suffixParts.push(punctuationPart(SyntaxKind.GreaterThanToken));
+                    var parameterParts = mapToDisplayParts(writer =>
+                        typeInfoResolver.getSymbolDisplayBuilder().buildDisplayForParametersAndDelimiters(candidateSignature.parameters, writer, argumentListOrTypeArgumentList));
+                    suffixParts.push.apply(suffixParts, parameterParts);
+                }
+                else {
+                    var typeParameterParts = mapToDisplayParts(writer =>
+                        typeInfoResolver.getSymbolDisplayBuilder().buildDisplayForTypeParametersAndDelimiters(candidateSignature.typeParameters, writer, argumentListOrTypeArgumentList));
+                    prefixParts.push.apply(prefixParts, typeParameterParts);
+                    prefixParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                    var parameters = candidateSignature.parameters;
+                    signatureHelpParameters = parameters.length > 0 ? map(parameters, createSignatureHelpParameterForParameter) : emptyArray;
+                    suffixParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+                }
 
-                var suffixParts = [punctuationPart(SyntaxKind.CloseParenToken)];
-                suffixParts.push(punctuationPart(SyntaxKind.ColonToken));
-                suffixParts.push(spacePart());
-
-                var typeParts = typeToDisplayParts(typeInfoResolver, candidateSignature.getReturnType(), argumentListOrTypeArgumentList);
-                suffixParts.push.apply(suffixParts, typeParts);
+                var returnTypeParts = mapToDisplayParts(writer =>
+                    typeInfoResolver.getSymbolDisplayBuilder().buildReturnTypeDisplay(candidateSignature, writer, argumentListOrTypeArgumentList));
+                suffixParts.push.apply(suffixParts, returnTypeParts);
                 
                 return {
                     isVariadic: candidateSignature.hasRestParameter,
                     prefixDisplayParts: prefixParts,
                     suffixDisplayParts: suffixParts,
-                    separatorDisplayParts: separatorParts,
-                    parameters: parameterHelpItems,
+                    separatorDisplayParts: [punctuationPart(SyntaxKind.CommaToken), spacePart()],
+                    parameters: signatureHelpParameters,
                     documentation: candidateSignature.getDocumentationComment()
                 };
             });
@@ -400,12 +384,32 @@ module ts.SignatureHelp {
                 argumentIndex: argumentIndex,
                 argumentCount: argumentCount
             };
+
+            function createSignatureHelpParameterForParameter(parameter: Symbol): SignatureHelpParameter {
+                var displayParts = mapToDisplayParts(writer =>
+                    typeInfoResolver.getSymbolDisplayBuilder().buildParameterDisplay(parameter, writer, argumentListOrTypeArgumentList));
+
+                var isOptional = !!(parameter.valueDeclaration.flags & NodeFlags.QuestionMark);
+
+                return {
+                    name: parameter.name,
+                    documentation: parameter.getDocumentationComment(),
+                    displayParts: displayParts,
+                    isOptional: isOptional
+                };
+            }
+
+            function createSignatureHelpParameterForTypeParameter(typeParameter: TypeParameter): SignatureHelpParameter {
+                var displayParts = mapToDisplayParts(writer =>
+                    typeInfoResolver.getSymbolDisplayBuilder().buildTypeParameterDisplay(typeParameter, writer, argumentListOrTypeArgumentList));
+
+                return {
+                    name: typeParameter.symbol.name,
+                    documentation: emptyArray,
+                    displayParts: displayParts,
+                    isOptional: false
+                };
+            }
         }
     }
-
-    function getChildListThatStartsWithOpenerToken(parent: Node, openerToken: Node, sourceFile: SourceFile): Node {
-        var children = parent.getChildren(sourceFile);
-        var indexOfOpenerToken = children.indexOf(openerToken);
-        return children[indexOfOpenerToken + 1];
-    }
 }

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

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)[]
 

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

tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types

@@ -17,27 +17,27 @@ var c: { x: number; a?: number };
 >a : number
 
 var as = [a, b]; // { x: number; y?: number };[]
->as : { x: number; y?: number; }[]
->[a, b] : { x: number; y?: number; }[]
+>as : ({ x: number; y?: number; } | { x: number; z?: number; })[]
+>[a, b] : ({ x: number; y?: number; } | { x: number; z?: number; })[]
 >a : { x: number; y?: number; }
 >b : { x: number; z?: number; }
 
 var bs = [b, a]; // { x: number; z?: number };[]
->bs : { x: number; y?: number; }[]
->[b, a] : { x: number; y?: number; }[]
+>bs : ({ x: number; y?: number; } | { x: number; z?: number; })[]
+>[b, a] : ({ x: number; y?: number; } | { x: number; z?: number; })[]
 >b : { x: number; z?: number; }
 >a : { x: number; y?: number; }
 
 var cs = [a, b, c]; // { x: number; y?: number };[]
->cs : { x: number; y?: number; }[]
->[a, b, c] : { x: number; y?: number; }[]
+>cs : ({ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: number; })[]
+>[a, b, c] : ({ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: number; })[]
 >a : { x: number; y?: number; }
 >b : { x: number; z?: 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) | ((b: { x: number; z?: number; }) => number))[]
+>[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : (((a: { x: number; y?: number; }) => number) | ((b: { x: number; z?: number; }) => number))[]
 >(a: { x: number; y?: number }) => 1 : (a: { x: number; y?: number; }) => number
 >a : { x: number; y?: number; }
 >x : number
@@ -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) | ((a: { x: number; y?: number; }) => number))[]
+>[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : (((b: { x: number; z?: number; }) => number) | ((a: { x: number; y?: number; }) => number))[]
 >(b: { x: number; z?: number }) => 2 : (b: { x: number; z?: number; }) => number
 >b : { x: number; z?: number; }
 >x : number

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

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>
 

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

tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types

@@ -48,14 +48,14 @@ var r3 = true ? 1 : {};
 >{} : {}
 
 var r4 = true ? a : b; // typeof a
->r4 : { x: number; y?: number; }
->true ? a : b : { x: number; y?: number; }
+>r4 : { x: number; y?: number; } | { x: number; z?: number; }
+>true ? a : b : { x: number; y?: number; } | { x: number; z?: number; }
 >a : { x: number; y?: number; }
 >b : { x: number; z?: number; }
 
 var r5 = true ? b : a; // typeof b
->r5 : { x: number; y?: number; }
->true ? b : a : { x: number; y?: number; }
+>r5 : { x: number; y?: number; } | { x: number; z?: number; }
+>true ? b : a : { x: number; y?: number; } | { x: number; z?: number; }
 >b : { x: number; z?: number; }
 >a : { x: number; y?: number; }
 

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];  // {}

tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.errors.txt

@@ -1,215 +0,0 @@
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(32,12): error TS2365: Operator '<' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(40,12): error TS2365: Operator '<' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(49,12): error TS2365: Operator '>' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(57,12): error TS2365: Operator '>' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(66,12): error TS2365: Operator '<=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(74,12): error TS2365: Operator '<=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(83,12): error TS2365: Operator '>=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(91,12): error TS2365: Operator '>=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(100,12): error TS2365: Operator '==' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(108,12): error TS2365: Operator '==' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(117,12): error TS2365: Operator '!=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(125,12): error TS2365: Operator '!=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(134,12): error TS2365: Operator '===' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(142,12): error TS2365: Operator '===' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(151,12): error TS2365: Operator '!==' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts(159,12): error TS2365: Operator '!==' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-
-
-==== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts (16 errors) ====
-    class Base {
-        public a: string;
-    }
-    
-    class Derived extends Base {
-        public b: string;
-    }
-    
-    var a1: { fn<T>(x: T): T };
-    var b1: { fn(x: string): string };
-    
-    var a2: { fn<T>(x: T): T };
-    var b2: { fn(x: string, y: number): string };
-    
-    var a3: { fn<T, U>(x: T, y: U): T };
-    var b3: { fn(x: string, y: number): string };
-    
-    var a4: { fn<T>(x?: T): T };
-    var b4: { fn(x?: string): string };
-    
-    var a5: { fn<T>(...x: T[]): T };
-    var b5: { fn(...x: string[]): string };
-    
-    var a6: { fn<T>(x: T, y: T): T };
-    var b6: { fn(x: string, y: number): {} };
-    
-    //var a7: { fn<T, U extends T>(x: T, y: U): T };
-    var b7: { fn(x: Base, y: Derived): Base };
-    
-    // operator <
-    var r1a1 = a1 < b1;
-    var r1a2 = a2 < b2;
-               ~~~~~~~
-!!! error TS2365: Operator '<' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-    var r1a3 = a3 < b3;
-    var r1a4 = a4 < b4;
-    var r1a5 = a5 < b5;
-    var r1a6 = a6 < b6;
-    //var r1a7 = a7 < b7;
-    
-    var r1b1 = b1 < a1;
-    var r1b2 = b2 < a2;
-               ~~~~~~~
-!!! error TS2365: Operator '<' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-    var r1b3 = b3 < a3;
-    var r1b4 = b4 < a4;
-    var r1b5 = b5 < a5;
-    var r1b6 = b6 < a6;
-    //var r1b7 = b7 < a7;
-    
-    // operator >
-    var r2a1 = a1 > b1;
-    var r2a2 = a2 > b2;
-               ~~~~~~~
-!!! error TS2365: Operator '>' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-    var r2a3 = a3 > b3;
-    var r2a4 = a4 > b4;
-    var r2a5 = a5 > b5;
-    var r2a6 = a6 > b6;
-    //var r2a7 = a7 > b7;
-    
-    var r2b1 = b1 > a1;
-    var r2b2 = b2 > a2;
-               ~~~~~~~
-!!! error TS2365: Operator '>' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-    var r2b3 = b3 > a3;
-    var r2b4 = b4 > a4;
-    var r2b5 = b5 > a5;
-    var r2b6 = b6 > a6;
-    //var r2b7 = b7 > a7;
-    
-    // operator <=
-    var r3a1 = a1 <= b1;
-    var r3a2 = a2 <= b2;
-               ~~~~~~~~
-!!! error TS2365: Operator '<=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-    var r3a3 = a3 <= b3;
-    var r3a4 = a4 <= b4;
-    var r3a5 = a5 <= b5;
-    var r3a6 = a6 <= b6;
-    //var r3a7 = a7 <= b7;
-    
-    var r3b1 = b1 <= a1;
-    var r3b2 = b2 <= a2;
-               ~~~~~~~~
-!!! error TS2365: Operator '<=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-    var r3b3 = b3 <= a3;
-    var r3b4 = b4 <= a4;
-    var r3b5 = b5 <= a5;
-    var r3b6 = b6 <= a6;
-    //var r3b7 = b7 <= a7;
-    
-    // operator >=
-    var r4a1 = a1 >= b1;
-    var r4a2 = a2 >= b2;
-               ~~~~~~~~
-!!! error TS2365: Operator '>=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-    var r4a3 = a3 >= b3;
-    var r4a4 = a4 >= b4;
-    var r4a5 = a5 >= b5;
-    var r4a6 = a6 >= b6;
-    //var r4a7 = a7 >= b7;
-    
-    var r4b1 = b1 >= a1;
-    var r4b2 = b2 >= a2;
-               ~~~~~~~~
-!!! error TS2365: Operator '>=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-    var r4b3 = b3 >= a3;
-    var r4b4 = b4 >= a4;
-    var r4b5 = b5 >= a5;
-    var r4b6 = b6 >= a6;
-    //var r4b7 = b7 >= a7;
-    
-    // operator ==
-    var r5a1 = a1 == b1;
-    var r5a2 = a2 == b2;
-               ~~~~~~~~
-!!! error TS2365: Operator '==' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-    var r5a3 = a3 == b3;
-    var r5a4 = a4 == b4;
-    var r5a5 = a5 == b5;
-    var r5a6 = a6 == b6;
-    //var r5a7 = a7 == b7;
-    
-    var r5b1 = b1 == a1;
-    var r5b2 = b2 == a2;
-               ~~~~~~~~
-!!! error TS2365: Operator '==' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-    var r5b3 = b3 == a3;
-    var r5b4 = b4 == a4;
-    var r5b5 = b5 == a5;
-    var r5b6 = b6 == a6;
-    //var r5b7 = b7 == a7;
-    
-    // operator !=
-    var r6a1 = a1 != b1;
-    var r6a2 = a2 != b2;
-               ~~~~~~~~
-!!! error TS2365: Operator '!=' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-    var r6a3 = a3 != b3;
-    var r6a4 = a4 != b4;
-    var r6a5 = a5 != b5;
-    var r6a6 = a6 != b6;
-    //var r6a7 = a7 != b7;
-    
-    var r6b1 = b1 != a1;
-    var r6b2 = b2 != a2;
-               ~~~~~~~~
-!!! error TS2365: Operator '!=' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-    var r6b3 = b3 != a3;
-    var r6b4 = b4 != a4;
-    var r6b5 = b5 != a5;
-    var r6b6 = b6 != a6;
-    //var r6b7 = b7 != a7;
-    
-    // operator ===
-    var r7a1 = a1 === b1;
-    var r7a2 = a2 === b2;
-               ~~~~~~~~~
-!!! error TS2365: Operator '===' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-    var r7a3 = a3 === b3;
-    var r7a4 = a4 === b4;
-    var r7a5 = a5 === b5;
-    var r7a6 = a6 === b6;
-    //var r7a7 = a7 === b7;
-    
-    var r7b1 = b1 === a1;
-    var r7b2 = b2 === a2;
-               ~~~~~~~~~
-!!! error TS2365: Operator '===' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-    var r7b3 = b3 === a3;
-    var r7b4 = b4 === a4;
-    var r7b5 = b5 === a5;
-    var r7b6 = b6 === a6;
-    //var r7b7 = b7 === a7;
-    
-    // operator !==
-    var r8a1 = a1 !== b1;
-    var r8a2 = a2 !== b2;
-               ~~~~~~~~~
-!!! error TS2365: Operator '!==' cannot be applied to types '{ fn<T>(x: T): T; }' and '{ fn(x: string, y: number): string; }'.
-    var r8a3 = a3 !== b3;
-    var r8a4 = a4 !== b4;
-    var r8a5 = a5 !== b5;
-    var r8a6 = a6 !== b6;
-    //var r8a7 = a7 !== b7;
-    
-    var r8b1 = b1 !== a1;
-    var r8b2 = b2 !== a2;
-               ~~~~~~~~~
-!!! error TS2365: Operator '!==' cannot be applied to types '{ fn(x: string, y: number): string; }' and '{ fn<T>(x: T): T; }'.
-    var r8b3 = b3 !== a3;
-    var r8b4 = b4 !== a4;
-    var r8b5 = b5 !== a5;
-    var r8b6 = b6 !== a6;
-    //var r8b7 = b7 !== a7;

tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.types

@@ -0,0 +1,727 @@
+=== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedCallSignature.ts ===
+class Base {
+>Base : Base
+
+    public a: string;
+>a : string
+}
+
+class Derived extends Base {
+>Derived : Derived
+>Base : Base
+
+    public b: string;
+>b : string
+}
+
+var a1: { fn<T>(x: T): T };
+>a1 : { fn<T>(x: T): T; }
+>fn : <T>(x: T) => T
+>T : T
+>x : T
+>T : T
+>T : T
+
+var b1: { fn(x: string): string };
+>b1 : { fn(x: string): string; }
+>fn : (x: string) => string
+>x : string
+
+var a2: { fn<T>(x: T): T };
+>a2 : { fn<T>(x: T): T; }
+>fn : <T>(x: T) => T
+>T : T
+>x : T
+>T : T
+>T : T
+
+var b2: { fn(x: string, y: number): string };
+>b2 : { fn(x: string, y: number): string; }
+>fn : (x: string, y: number) => string
+>x : string
+>y : number
+
+var a3: { fn<T, U>(x: T, y: U): T };
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>fn : <T, U>(x: T, y: U) => T
+>T : T
+>U : U
+>x : T
+>T : T
+>y : U
+>U : U
+>T : T
+
+var b3: { fn(x: string, y: number): string };
+>b3 : { fn(x: string, y: number): string; }
+>fn : (x: string, y: number) => string
+>x : string
+>y : number
+
+var a4: { fn<T>(x?: T): T };
+>a4 : { fn<T>(x?: T): T; }
+>fn : <T>(x?: T) => T
+>T : T
+>x : T
+>T : T
+>T : T
+
+var b4: { fn(x?: string): string };
+>b4 : { fn(x?: string): string; }
+>fn : (x?: string) => string
+>x : string
+
+var a5: { fn<T>(...x: T[]): T };
+>a5 : { fn<T>(...x: T[]): T; }
+>fn : <T>(...x: T[]) => T
+>T : T
+>x : T[]
+>T : T
+>T : T
+
+var b5: { fn(...x: string[]): string };
+>b5 : { fn(...x: string[]): string; }
+>fn : (...x: string[]) => string
+>x : string[]
+
+var a6: { fn<T>(x: T, y: T): T };
+>a6 : { fn<T>(x: T, y: T): T; }
+>fn : <T>(x: T, y: T) => T
+>T : T
+>x : T
+>T : T
+>y : T
+>T : T
+>T : T
+
+var b6: { fn(x: string, y: number): {} };
+>b6 : { fn(x: string, y: number): {}; }
+>fn : (x: string, y: number) => {}
+>x : string
+>y : number
+
+//var a7: { fn<T, U extends T>(x: T, y: U): T };
+var b7: { fn(x: Base, y: Derived): Base };
+>b7 : { fn(x: Base, y: Derived): Base; }
+>fn : (x: Base, y: Derived) => Base
+>x : Base
+>Base : Base
+>y : Derived
+>Derived : Derived
+>Base : Base
+
+// operator <
+var r1a1 = a1 < b1;
+>r1a1 : boolean
+>a1 < b1 : boolean
+>a1 : { fn<T>(x: T): T; }
+>b1 : { fn(x: string): string; }
+
+var r1a2 = a2 < b2;
+>r1a2 : boolean
+>a2 < b2 : boolean
+>a2 : { fn<T>(x: T): T; }
+>b2 : { fn(x: string, y: number): string; }
+
+var r1a3 = a3 < b3;
+>r1a3 : boolean
+>a3 < b3 : boolean
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>b3 : { fn(x: string, y: number): string; }
+
+var r1a4 = a4 < b4;
+>r1a4 : boolean
+>a4 < b4 : boolean
+>a4 : { fn<T>(x?: T): T; }
+>b4 : { fn(x?: string): string; }
+
+var r1a5 = a5 < b5;
+>r1a5 : boolean
+>a5 < b5 : boolean
+>a5 : { fn<T>(...x: T[]): T; }
+>b5 : { fn(...x: string[]): string; }
+
+var r1a6 = a6 < b6;
+>r1a6 : boolean
+>a6 < b6 : boolean
+>a6 : { fn<T>(x: T, y: T): T; }
+>b6 : { fn(x: string, y: number): {}; }
+
+//var r1a7 = a7 < b7;
+
+var r1b1 = b1 < a1;
+>r1b1 : boolean
+>b1 < a1 : boolean
+>b1 : { fn(x: string): string; }
+>a1 : { fn<T>(x: T): T; }
+
+var r1b2 = b2 < a2;
+>r1b2 : boolean
+>b2 < a2 : boolean
+>b2 : { fn(x: string, y: number): string; }
+>a2 : { fn<T>(x: T): T; }
+
+var r1b3 = b3 < a3;
+>r1b3 : boolean
+>b3 < a3 : boolean
+>b3 : { fn(x: string, y: number): string; }
+>a3 : { fn<T, U>(x: T, y: U): T; }
+
+var r1b4 = b4 < a4;
+>r1b4 : boolean
+>b4 < a4 : boolean
+>b4 : { fn(x?: string): string; }
+>a4 : { fn<T>(x?: T): T; }
+
+var r1b5 = b5 < a5;
+>r1b5 : boolean
+>b5 < a5 : boolean
+>b5 : { fn(...x: string[]): string; }
+>a5 : { fn<T>(...x: T[]): T; }
+
+var r1b6 = b6 < a6;
+>r1b6 : boolean
+>b6 < a6 : boolean
+>b6 : { fn(x: string, y: number): {}; }
+>a6 : { fn<T>(x: T, y: T): T; }
+
+//var r1b7 = b7 < a7;
+
+// operator >
+var r2a1 = a1 > b1;
+>r2a1 : boolean
+>a1 > b1 : boolean
+>a1 : { fn<T>(x: T): T; }
+>b1 : { fn(x: string): string; }
+
+var r2a2 = a2 > b2;
+>r2a2 : boolean
+>a2 > b2 : boolean
+>a2 : { fn<T>(x: T): T; }
+>b2 : { fn(x: string, y: number): string; }
+
+var r2a3 = a3 > b3;
+>r2a3 : boolean
+>a3 > b3 : boolean
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>b3 : { fn(x: string, y: number): string; }
+
+var r2a4 = a4 > b4;
+>r2a4 : boolean
+>a4 > b4 : boolean
+>a4 : { fn<T>(x?: T): T; }
+>b4 : { fn(x?: string): string; }
+
+var r2a5 = a5 > b5;
+>r2a5 : boolean
+>a5 > b5 : boolean
+>a5 : { fn<T>(...x: T[]): T; }
+>b5 : { fn(...x: string[]): string; }
+
+var r2a6 = a6 > b6;
+>r2a6 : boolean
+>a6 > b6 : boolean
+>a6 : { fn<T>(x: T, y: T): T; }
+>b6 : { fn(x: string, y: number): {}; }
+
+//var r2a7 = a7 > b7;
+
+var r2b1 = b1 > a1;
+>r2b1 : boolean
+>b1 > a1 : boolean
+>b1 : { fn(x: string): string; }
+>a1 : { fn<T>(x: T): T; }
+
+var r2b2 = b2 > a2;
+>r2b2 : boolean
+>b2 > a2 : boolean
+>b2 : { fn(x: string, y: number): string; }
+>a2 : { fn<T>(x: T): T; }
+
+var r2b3 = b3 > a3;
+>r2b3 : boolean
+>b3 > a3 : boolean
+>b3 : { fn(x: string, y: number): string; }
+>a3 : { fn<T, U>(x: T, y: U): T; }
+
+var r2b4 = b4 > a4;
+>r2b4 : boolean
+>b4 > a4 : boolean
+>b4 : { fn(x?: string): string; }
+>a4 : { fn<T>(x?: T): T; }
+
+var r2b5 = b5 > a5;
+>r2b5 : boolean
+>b5 > a5 : boolean
+>b5 : { fn(...x: string[]): string; }
+>a5 : { fn<T>(...x: T[]): T; }
+
+var r2b6 = b6 > a6;
+>r2b6 : boolean
+>b6 > a6 : boolean
+>b6 : { fn(x: string, y: number): {}; }
+>a6 : { fn<T>(x: T, y: T): T; }
+
+//var r2b7 = b7 > a7;
+
+// operator <=
+var r3a1 = a1 <= b1;
+>r3a1 : boolean
+>a1 <= b1 : boolean
+>a1 : { fn<T>(x: T): T; }
+>b1 : { fn(x: string): string; }
+
+var r3a2 = a2 <= b2;
+>r3a2 : boolean
+>a2 <= b2 : boolean
+>a2 : { fn<T>(x: T): T; }
+>b2 : { fn(x: string, y: number): string; }
+
+var r3a3 = a3 <= b3;
+>r3a3 : boolean
+>a3 <= b3 : boolean
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>b3 : { fn(x: string, y: number): string; }
+
+var r3a4 = a4 <= b4;
+>r3a4 : boolean
+>a4 <= b4 : boolean
+>a4 : { fn<T>(x?: T): T; }
+>b4 : { fn(x?: string): string; }
+
+var r3a5 = a5 <= b5;
+>r3a5 : boolean
+>a5 <= b5 : boolean
+>a5 : { fn<T>(...x: T[]): T; }
+>b5 : { fn(...x: string[]): string; }
+
+var r3a6 = a6 <= b6;
+>r3a6 : boolean
+>a6 <= b6 : boolean
+>a6 : { fn<T>(x: T, y: T): T; }
+>b6 : { fn(x: string, y: number): {}; }
+
+//var r3a7 = a7 <= b7;
+
+var r3b1 = b1 <= a1;
+>r3b1 : boolean
+>b1 <= a1 : boolean
+>b1 : { fn(x: string): string; }
+>a1 : { fn<T>(x: T): T; }
+
+var r3b2 = b2 <= a2;
+>r3b2 : boolean
+>b2 <= a2 : boolean
+>b2 : { fn(x: string, y: number): string; }
+>a2 : { fn<T>(x: T): T; }
+
+var r3b3 = b3 <= a3;
+>r3b3 : boolean
+>b3 <= a3 : boolean
+>b3 : { fn(x: string, y: number): string; }
+>a3 : { fn<T, U>(x: T, y: U): T; }
+
+var r3b4 = b4 <= a4;
+>r3b4 : boolean
+>b4 <= a4 : boolean
+>b4 : { fn(x?: string): string; }
+>a4 : { fn<T>(x?: T): T; }
+
+var r3b5 = b5 <= a5;
+>r3b5 : boolean
+>b5 <= a5 : boolean
+>b5 : { fn(...x: string[]): string; }
+>a5 : { fn<T>(...x: T[]): T; }
+
+var r3b6 = b6 <= a6;
+>r3b6 : boolean
+>b6 <= a6 : boolean
+>b6 : { fn(x: string, y: number): {}; }
+>a6 : { fn<T>(x: T, y: T): T; }
+
+//var r3b7 = b7 <= a7;
+
+// operator >=
+var r4a1 = a1 >= b1;
+>r4a1 : boolean
+>a1 >= b1 : boolean
+>a1 : { fn<T>(x: T): T; }
+>b1 : { fn(x: string): string; }
+
+var r4a2 = a2 >= b2;
+>r4a2 : boolean
+>a2 >= b2 : boolean
+>a2 : { fn<T>(x: T): T; }
+>b2 : { fn(x: string, y: number): string; }
+
+var r4a3 = a3 >= b3;
+>r4a3 : boolean
+>a3 >= b3 : boolean
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>b3 : { fn(x: string, y: number): string; }
+
+var r4a4 = a4 >= b4;
+>r4a4 : boolean
+>a4 >= b4 : boolean
+>a4 : { fn<T>(x?: T): T; }
+>b4 : { fn(x?: string): string; }
+
+var r4a5 = a5 >= b5;
+>r4a5 : boolean
+>a5 >= b5 : boolean
+>a5 : { fn<T>(...x: T[]): T; }
+>b5 : { fn(...x: string[]): string; }
+
+var r4a6 = a6 >= b6;
+>r4a6 : boolean
+>a6 >= b6 : boolean
+>a6 : { fn<T>(x: T, y: T): T; }
+>b6 : { fn(x: string, y: number): {}; }
+
+//var r4a7 = a7 >= b7;
+
+var r4b1 = b1 >= a1;
+>r4b1 : boolean
+>b1 >= a1 : boolean
+>b1 : { fn(x: string): string; }
+>a1 : { fn<T>(x: T): T; }
+
+var r4b2 = b2 >= a2;
+>r4b2 : boolean
+>b2 >= a2 : boolean
+>b2 : { fn(x: string, y: number): string; }
+>a2 : { fn<T>(x: T): T; }
+
+var r4b3 = b3 >= a3;
+>r4b3 : boolean
+>b3 >= a3 : boolean
+>b3 : { fn(x: string, y: number): string; }
+>a3 : { fn<T, U>(x: T, y: U): T; }
+
+var r4b4 = b4 >= a4;
+>r4b4 : boolean
+>b4 >= a4 : boolean
+>b4 : { fn(x?: string): string; }
+>a4 : { fn<T>(x?: T): T; }
+
+var r4b5 = b5 >= a5;
+>r4b5 : boolean
+>b5 >= a5 : boolean
+>b5 : { fn(...x: string[]): string; }
+>a5 : { fn<T>(...x: T[]): T; }
+
+var r4b6 = b6 >= a6;
+>r4b6 : boolean
+>b6 >= a6 : boolean
+>b6 : { fn(x: string, y: number): {}; }
+>a6 : { fn<T>(x: T, y: T): T; }
+
+//var r4b7 = b7 >= a7;
+
+// operator ==
+var r5a1 = a1 == b1;
+>r5a1 : boolean
+>a1 == b1 : boolean
+>a1 : { fn<T>(x: T): T; }
+>b1 : { fn(x: string): string; }
+
+var r5a2 = a2 == b2;
+>r5a2 : boolean
+>a2 == b2 : boolean
+>a2 : { fn<T>(x: T): T; }
+>b2 : { fn(x: string, y: number): string; }
+
+var r5a3 = a3 == b3;
+>r5a3 : boolean
+>a3 == b3 : boolean
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>b3 : { fn(x: string, y: number): string; }
+
+var r5a4 = a4 == b4;
+>r5a4 : boolean
+>a4 == b4 : boolean
+>a4 : { fn<T>(x?: T): T; }
+>b4 : { fn(x?: string): string; }
+
+var r5a5 = a5 == b5;
+>r5a5 : boolean
+>a5 == b5 : boolean
+>a5 : { fn<T>(...x: T[]): T; }
+>b5 : { fn(...x: string[]): string; }
+
+var r5a6 = a6 == b6;
+>r5a6 : boolean
+>a6 == b6 : boolean
+>a6 : { fn<T>(x: T, y: T): T; }
+>b6 : { fn(x: string, y: number): {}; }
+
+//var r5a7 = a7 == b7;
+
+var r5b1 = b1 == a1;
+>r5b1 : boolean
+>b1 == a1 : boolean
+>b1 : { fn(x: string): string; }
+>a1 : { fn<T>(x: T): T; }
+
+var r5b2 = b2 == a2;
+>r5b2 : boolean
+>b2 == a2 : boolean
+>b2 : { fn(x: string, y: number): string; }
+>a2 : { fn<T>(x: T): T; }
+
+var r5b3 = b3 == a3;
+>r5b3 : boolean
+>b3 == a3 : boolean
+>b3 : { fn(x: string, y: number): string; }
+>a3 : { fn<T, U>(x: T, y: U): T; }
+
+var r5b4 = b4 == a4;
+>r5b4 : boolean
+>b4 == a4 : boolean
+>b4 : { fn(x?: string): string; }
+>a4 : { fn<T>(x?: T): T; }
+
+var r5b5 = b5 == a5;
+>r5b5 : boolean
+>b5 == a5 : boolean
+>b5 : { fn(...x: string[]): string; }
+>a5 : { fn<T>(...x: T[]): T; }
+
+var r5b6 = b6 == a6;
+>r5b6 : boolean
+>b6 == a6 : boolean
+>b6 : { fn(x: string, y: number): {}; }
+>a6 : { fn<T>(x: T, y: T): T; }
+
+//var r5b7 = b7 == a7;
+
+// operator !=
+var r6a1 = a1 != b1;
+>r6a1 : boolean
+>a1 != b1 : boolean
+>a1 : { fn<T>(x: T): T; }
+>b1 : { fn(x: string): string; }
+
+var r6a2 = a2 != b2;
+>r6a2 : boolean
+>a2 != b2 : boolean
+>a2 : { fn<T>(x: T): T; }
+>b2 : { fn(x: string, y: number): string; }
+
+var r6a3 = a3 != b3;
+>r6a3 : boolean
+>a3 != b3 : boolean
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>b3 : { fn(x: string, y: number): string; }
+
+var r6a4 = a4 != b4;
+>r6a4 : boolean
+>a4 != b4 : boolean
+>a4 : { fn<T>(x?: T): T; }
+>b4 : { fn(x?: string): string; }
+
+var r6a5 = a5 != b5;
+>r6a5 : boolean
+>a5 != b5 : boolean
+>a5 : { fn<T>(...x: T[]): T; }
+>b5 : { fn(...x: string[]): string; }
+
+var r6a6 = a6 != b6;
+>r6a6 : boolean
+>a6 != b6 : boolean
+>a6 : { fn<T>(x: T, y: T): T; }
+>b6 : { fn(x: string, y: number): {}; }
+
+//var r6a7 = a7 != b7;
+
+var r6b1 = b1 != a1;
+>r6b1 : boolean
+>b1 != a1 : boolean
+>b1 : { fn(x: string): string; }
+>a1 : { fn<T>(x: T): T; }
+
+var r6b2 = b2 != a2;
+>r6b2 : boolean
+>b2 != a2 : boolean
+>b2 : { fn(x: string, y: number): string; }
+>a2 : { fn<T>(x: T): T; }
+
+var r6b3 = b3 != a3;
+>r6b3 : boolean
+>b3 != a3 : boolean
+>b3 : { fn(x: string, y: number): string; }
+>a3 : { fn<T, U>(x: T, y: U): T; }
+
+var r6b4 = b4 != a4;
+>r6b4 : boolean
+>b4 != a4 : boolean
+>b4 : { fn(x?: string): string; }
+>a4 : { fn<T>(x?: T): T; }
+
+var r6b5 = b5 != a5;
+>r6b5 : boolean
+>b5 != a5 : boolean
+>b5 : { fn(...x: string[]): string; }
+>a5 : { fn<T>(...x: T[]): T; }
+
+var r6b6 = b6 != a6;
+>r6b6 : boolean
+>b6 != a6 : boolean
+>b6 : { fn(x: string, y: number): {}; }
+>a6 : { fn<T>(x: T, y: T): T; }
+
+//var r6b7 = b7 != a7;
+
+// operator ===
+var r7a1 = a1 === b1;
+>r7a1 : boolean
+>a1 === b1 : boolean
+>a1 : { fn<T>(x: T): T; }
+>b1 : { fn(x: string): string; }
+
+var r7a2 = a2 === b2;
+>r7a2 : boolean
+>a2 === b2 : boolean
+>a2 : { fn<T>(x: T): T; }
+>b2 : { fn(x: string, y: number): string; }
+
+var r7a3 = a3 === b3;
+>r7a3 : boolean
+>a3 === b3 : boolean
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>b3 : { fn(x: string, y: number): string; }
+
+var r7a4 = a4 === b4;
+>r7a4 : boolean
+>a4 === b4 : boolean
+>a4 : { fn<T>(x?: T): T; }
+>b4 : { fn(x?: string): string; }
+
+var r7a5 = a5 === b5;
+>r7a5 : boolean
+>a5 === b5 : boolean
+>a5 : { fn<T>(...x: T[]): T; }
+>b5 : { fn(...x: string[]): string; }
+
+var r7a6 = a6 === b6;
+>r7a6 : boolean
+>a6 === b6 : boolean
+>a6 : { fn<T>(x: T, y: T): T; }
+>b6 : { fn(x: string, y: number): {}; }
+
+//var r7a7 = a7 === b7;
+
+var r7b1 = b1 === a1;
+>r7b1 : boolean
+>b1 === a1 : boolean
+>b1 : { fn(x: string): string; }
+>a1 : { fn<T>(x: T): T; }
+
+var r7b2 = b2 === a2;
+>r7b2 : boolean
+>b2 === a2 : boolean
+>b2 : { fn(x: string, y: number): string; }
+>a2 : { fn<T>(x: T): T; }
+
+var r7b3 = b3 === a3;
+>r7b3 : boolean
+>b3 === a3 : boolean
+>b3 : { fn(x: string, y: number): string; }
+>a3 : { fn<T, U>(x: T, y: U): T; }
+
+var r7b4 = b4 === a4;
+>r7b4 : boolean
+>b4 === a4 : boolean
+>b4 : { fn(x?: string): string; }
+>a4 : { fn<T>(x?: T): T; }
+
+var r7b5 = b5 === a5;
+>r7b5 : boolean
+>b5 === a5 : boolean
+>b5 : { fn(...x: string[]): string; }
+>a5 : { fn<T>(...x: T[]): T; }
+
+var r7b6 = b6 === a6;
+>r7b6 : boolean
+>b6 === a6 : boolean
+>b6 : { fn(x: string, y: number): {}; }
+>a6 : { fn<T>(x: T, y: T): T; }
+
+//var r7b7 = b7 === a7;
+
+// operator !==
+var r8a1 = a1 !== b1;
+>r8a1 : boolean
+>a1 !== b1 : boolean
+>a1 : { fn<T>(x: T): T; }
+>b1 : { fn(x: string): string; }
+
+var r8a2 = a2 !== b2;
+>r8a2 : boolean
+>a2 !== b2 : boolean
+>a2 : { fn<T>(x: T): T; }
+>b2 : { fn(x: string, y: number): string; }
+
+var r8a3 = a3 !== b3;
+>r8a3 : boolean
+>a3 !== b3 : boolean
+>a3 : { fn<T, U>(x: T, y: U): T; }
+>b3 : { fn(x: string, y: number): string; }
+
+var r8a4 = a4 !== b4;
+>r8a4 : boolean
+>a4 !== b4 : boolean
+>a4 : { fn<T>(x?: T): T; }
+>b4 : { fn(x?: string): string; }
+
+var r8a5 = a5 !== b5;
+>r8a5 : boolean
+>a5 !== b5 : boolean
+>a5 : { fn<T>(...x: T[]): T; }
+>b5 : { fn(...x: string[]): string; }
+
+var r8a6 = a6 !== b6;
+>r8a6 : boolean
+>a6 !== b6 : boolean
+>a6 : { fn<T>(x: T, y: T): T; }
+>b6 : { fn(x: string, y: number): {}; }
+
+//var r8a7 = a7 !== b7;
+
+var r8b1 = b1 !== a1;
+>r8b1 : boolean
+>b1 !== a1 : boolean
+>b1 : { fn(x: string): string; }
+>a1 : { fn<T>(x: T): T; }
+
+var r8b2 = b2 !== a2;
+>r8b2 : boolean
+>b2 !== a2 : boolean
+>b2 : { fn(x: string, y: number): string; }
+>a2 : { fn<T>(x: T): T; }
+
+var r8b3 = b3 !== a3;
+>r8b3 : boolean
+>b3 !== a3 : boolean
+>b3 : { fn(x: string, y: number): string; }
+>a3 : { fn<T, U>(x: T, y: U): T; }
+
+var r8b4 = b4 !== a4;
+>r8b4 : boolean
+>b4 !== a4 : boolean
+>b4 : { fn(x?: string): string; }
+>a4 : { fn<T>(x?: T): T; }
+
+var r8b5 = b5 !== a5;
+>r8b5 : boolean
+>b5 !== a5 : boolean
+>b5 : { fn(...x: string[]): string; }
+>a5 : { fn<T>(...x: T[]): T; }
+
+var r8b6 = b6 !== a6;
+>r8b6 : boolean
+>b6 !== a6 : boolean
+>b6 : { fn(x: string, y: number): {}; }
+>a6 : { fn<T>(x: T, y: T): T; }
+
+//var r8b7 = b7 !== a7;

tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.errors.txt

@@ -1,215 +0,0 @@
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(32,12): error TS2365: Operator '<' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(40,12): error TS2365: Operator '<' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(49,12): error TS2365: Operator '>' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(57,12): error TS2365: Operator '>' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(66,12): error TS2365: Operator '<=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(74,12): error TS2365: Operator '<=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(83,12): error TS2365: Operator '>=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(91,12): error TS2365: Operator '>=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(100,12): error TS2365: Operator '==' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(108,12): error TS2365: Operator '==' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(117,12): error TS2365: Operator '!=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(125,12): error TS2365: Operator '!=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(134,12): error TS2365: Operator '===' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(142,12): error TS2365: Operator '===' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(151,12): error TS2365: Operator '!==' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts(159,12): error TS2365: Operator '!==' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-
-
-==== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts (16 errors) ====
-    class Base {
-        public a: string;
-    }
-    
-    class Derived extends Base {
-        public b: string;
-    }
-    
-    var a1: { new <T>(x: T): T };
-    var b1: { new (x: string): string };
-    
-    var a2: { new <T>(x: T): T };
-    var b2: { new (x: string, y: number): string };
-    
-    var a3: { new <T, U>(x: T, y: U): T };
-    var b3: { new (x: string, y: number): string };
-    
-    var a4: { new <T>(x?: T): T };
-    var b4: { new (x?: string): string };
-    
-    var a5: { new <T>(...x: T[]): T };
-    var b5: { new (...x: string[]): string };
-    
-    var a6: { new <T>(x: T, y: T): T };
-    var b6: { new (x: string, y: number): {} };
-    
-    //var a7: { new <T, U extends T>(x: T, y: U): T };
-    var b7: { new (x: Base, y: Derived): Base };
-    
-    // operator <
-    var r1a1 = a1 < b1;
-    var r1a2 = a2 < b2;
-               ~~~~~~~
-!!! error TS2365: Operator '<' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-    var r1a3 = a3 < b3;
-    var r1a4 = a4 < b4;
-    var r1a5 = a5 < b5;
-    var r1a6 = a6 < b6;
-    //var r1a7 = a7 < b7;
-    
-    var r1b1 = b1 < a1;
-    var r1b2 = b2 < a2;
-               ~~~~~~~
-!!! error TS2365: Operator '<' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-    var r1b3 = b3 < a3;
-    var r1b4 = b4 < a4;
-    var r1b5 = b5 < a5;
-    var r1b6 = b6 < a6;
-    //var r1b7 = b7 < a7;
-    
-    // operator >
-    var r2a1 = a1 > b1;
-    var r2a2 = a2 > b2;
-               ~~~~~~~
-!!! error TS2365: Operator '>' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-    var r2a3 = a3 > b3;
-    var r2a4 = a4 > b4;
-    var r2a5 = a5 > b5;
-    var r2a6 = a6 > b6;
-    //var r2a7 = a7 > b7;
-    
-    var r2b1 = b1 > a1;
-    var r2b2 = b2 > a2;
-               ~~~~~~~
-!!! error TS2365: Operator '>' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-    var r2b3 = b3 > a3;
-    var r2b4 = b4 > a4;
-    var r2b5 = b5 > a5;
-    var r2b6 = b6 > a6;
-    //var r2b7 = b7 > a7;
-    
-    // operator <=
-    var r3a1 = a1 <= b1;
-    var r3a2 = a2 <= b2;
-               ~~~~~~~~
-!!! error TS2365: Operator '<=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-    var r3a3 = a3 <= b3;
-    var r3a4 = a4 <= b4;
-    var r3a5 = a5 <= b5;
-    var r3a6 = a6 <= b6;
-    //var r3a7 = a7 <= b7;
-    
-    var r3b1 = b1 <= a1;
-    var r3b2 = b2 <= a2;
-               ~~~~~~~~
-!!! error TS2365: Operator '<=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-    var r3b3 = b3 <= a3;
-    var r3b4 = b4 <= a4;
-    var r3b5 = b5 <= a5;
-    var r3b6 = b6 <= a6;
-    //var r3b7 = b7 <= a7;
-    
-    // operator >=
-    var r4a1 = a1 >= b1;
-    var r4a2 = a2 >= b2;
-               ~~~~~~~~
-!!! error TS2365: Operator '>=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-    var r4a3 = a3 >= b3;
-    var r4a4 = a4 >= b4;
-    var r4a5 = a5 >= b5;
-    var r4a6 = a6 >= b6;
-    //var r4a7 = a7 >= b7;
-    
-    var r4b1 = b1 >= a1;
-    var r4b2 = b2 >= a2;
-               ~~~~~~~~
-!!! error TS2365: Operator '>=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-    var r4b3 = b3 >= a3;
-    var r4b4 = b4 >= a4;
-    var r4b5 = b5 >= a5;
-    var r4b6 = b6 >= a6;
-    //var r4b7 = b7 >= a7;
-    
-    // operator ==
-    var r5a1 = a1 == b1;
-    var r5a2 = a2 == b2;
-               ~~~~~~~~
-!!! error TS2365: Operator '==' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-    var r5a3 = a3 == b3;
-    var r5a4 = a4 == b4;
-    var r5a5 = a5 == b5;
-    var r5a6 = a6 == b6;
-    //var r5a7 = a7 == b7;
-    
-    var r5b1 = b1 == a1;
-    var r5b2 = b2 == a2;
-               ~~~~~~~~
-!!! error TS2365: Operator '==' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-    var r5b3 = b3 == a3;
-    var r5b4 = b4 == a4;
-    var r5b5 = b5 == a5;
-    var r5b6 = b6 == a6;
-    //var r5b7 = b7 == a7;
-    
-    // operator !=
-    var r6a1 = a1 != b1;
-    var r6a2 = a2 != b2;
-               ~~~~~~~~
-!!! error TS2365: Operator '!=' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-    var r6a3 = a3 != b3;
-    var r6a4 = a4 != b4;
-    var r6a5 = a5 != b5;
-    var r6a6 = a6 != b6;
-    //var r6a7 = a7 != b7;
-    
-    var r6b1 = b1 != a1;
-    var r6b2 = b2 != a2;
-               ~~~~~~~~
-!!! error TS2365: Operator '!=' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-    var r6b3 = b3 != a3;
-    var r6b4 = b4 != a4;
-    var r6b5 = b5 != a5;
-    var r6b6 = b6 != a6;
-    //var r6b7 = b7 != a7;
-    
-    // operator ===
-    var r7a1 = a1 === b1;
-    var r7a2 = a2 === b2;
-               ~~~~~~~~~
-!!! error TS2365: Operator '===' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-    var r7a3 = a3 === b3;
-    var r7a4 = a4 === b4;
-    var r7a5 = a5 === b5;
-    var r7a6 = a6 === b6;
-    //var r7a7 = a7 === b7;
-    
-    var r7b1 = b1 === a1;
-    var r7b2 = b2 === a2;
-               ~~~~~~~~~
-!!! error TS2365: Operator '===' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-    var r7b3 = b3 === a3;
-    var r7b4 = b4 === a4;
-    var r7b5 = b5 === a5;
-    var r7b6 = b6 === a6;
-    //var r7b7 = b7 === a7;
-    
-    // operator !==
-    var r8a1 = a1 !== b1;
-    var r8a2 = a2 !== b2;
-               ~~~~~~~~~
-!!! error TS2365: Operator '!==' cannot be applied to types 'new <T>(x: T) => T' and 'new (x: string, y: number) => string'.
-    var r8a3 = a3 !== b3;
-    var r8a4 = a4 !== b4;
-    var r8a5 = a5 !== b5;
-    var r8a6 = a6 !== b6;
-    //var r8a7 = a7 !== b7;
-    
-    var r8b1 = b1 !== a1;
-    var r8b2 = b2 !== a2;
-               ~~~~~~~~~
-!!! error TS2365: Operator '!==' cannot be applied to types 'new (x: string, y: number) => string' and 'new <T>(x: T) => T'.
-    var r8b3 = b3 !== a3;
-    var r8b4 = b4 !== a4;
-    var r8b5 = b5 !== a5;
-    var r8b6 = b6 !== a6;
-    //var r8b7 = b7 !== a7;

tests/baselines/reference/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.types

@@ -0,0 +1,714 @@
+=== tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnInstantiatedConstructorSignature.ts ===
+class Base {
+>Base : Base
+
+    public a: string;
+>a : string
+}
+
+class Derived extends Base {
+>Derived : Derived
+>Base : Base
+
+    public b: string;
+>b : string
+}
+
+var a1: { new <T>(x: T): T };
+>a1 : new <T>(x: T) => T
+>T : T
+>x : T
+>T : T
+>T : T
+
+var b1: { new (x: string): string };
+>b1 : new (x: string) => string
+>x : string
+
+var a2: { new <T>(x: T): T };
+>a2 : new <T>(x: T) => T
+>T : T
+>x : T
+>T : T
+>T : T
+
+var b2: { new (x: string, y: number): string };
+>b2 : new (x: string, y: number) => string
+>x : string
+>y : number
+
+var a3: { new <T, U>(x: T, y: U): T };
+>a3 : new <T, U>(x: T, y: U) => T
+>T : T
+>U : U
+>x : T
+>T : T
+>y : U
+>U : U
+>T : T
+
+var b3: { new (x: string, y: number): string };
+>b3 : new (x: string, y: number) => string
+>x : string
+>y : number
+
+var a4: { new <T>(x?: T): T };
+>a4 : new <T>(x?: T) => T
+>T : T
+>x : T
+>T : T
+>T : T
+
+var b4: { new (x?: string): string };
+>b4 : new (x?: string) => string
+>x : string
+
+var a5: { new <T>(...x: T[]): T };
+>a5 : new <T>(...x: T[]) => T
+>T : T
+>x : T[]
+>T : T
+>T : T
+
+var b5: { new (...x: string[]): string };
+>b5 : new (...x: string[]) => string
+>x : string[]
+
+var a6: { new <T>(x: T, y: T): T };
+>a6 : new <T>(x: T, y: T) => T
+>T : T
+>x : T
+>T : T
+>y : T
+>T : T
+>T : T
+
+var b6: { new (x: string, y: number): {} };
+>b6 : new (x: string, y: number) => {}
+>x : string
+>y : number
+
+//var a7: { new <T, U extends T>(x: T, y: U): T };
+var b7: { new (x: Base, y: Derived): Base };
+>b7 : new (x: Base, y: Derived) => Base
+>x : Base
+>Base : Base
+>y : Derived
+>Derived : Derived
+>Base : Base
+
+// operator <
+var r1a1 = a1 < b1;
+>r1a1 : boolean
+>a1 < b1 : boolean
+>a1 : new <T>(x: T) => T
+>b1 : new (x: string) => string
+
+var r1a2 = a2 < b2;
+>r1a2 : boolean
+>a2 < b2 : boolean
+>a2 : new <T>(x: T) => T
+>b2 : new (x: string, y: number) => string
+
+var r1a3 = a3 < b3;
+>r1a3 : boolean
+>a3 < b3 : boolean
+>a3 : new <T, U>(x: T, y: U) => T
+>b3 : new (x: string, y: number) => string
+
+var r1a4 = a4 < b4;
+>r1a4 : boolean
+>a4 < b4 : boolean
+>a4 : new <T>(x?: T) => T
+>b4 : new (x?: string) => string
+
+var r1a5 = a5 < b5;
+>r1a5 : boolean
+>a5 < b5 : boolean
+>a5 : new <T>(...x: T[]) => T
+>b5 : new (...x: string[]) => string
+
+var r1a6 = a6 < b6;
+>r1a6 : boolean
+>a6 < b6 : boolean
+>a6 : new <T>(x: T, y: T) => T
+>b6 : new (x: string, y: number) => {}
+
+//var r1a7 = a7 < b7;
+
+var r1b1 = b1 < a1;
+>r1b1 : boolean
+>b1 < a1 : boolean
+>b1 : new (x: string) => string
+>a1 : new <T>(x: T) => T
+
+var r1b2 = b2 < a2;
+>r1b2 : boolean
+>b2 < a2 : boolean
+>b2 : new (x: string, y: number) => string
+>a2 : new <T>(x: T) => T
+
+var r1b3 = b3 < a3;
+>r1b3 : boolean
+>b3 < a3 : boolean
+>b3 : new (x: string, y: number) => string
+>a3 : new <T, U>(x: T, y: U) => T
+
+var r1b4 = b4 < a4;
+>r1b4 : boolean
+>b4 < a4 : boolean
+>b4 : new (x?: string) => string
+>a4 : new <T>(x?: T) => T
+
+var r1b5 = b5 < a5;
+>r1b5 : boolean
+>b5 < a5 : boolean
+>b5 : new (...x: string[]) => string
+>a5 : new <T>(...x: T[]) => T
+
+var r1b6 = b6 < a6;
+>r1b6 : boolean
+>b6 < a6 : boolean
+>b6 : new (x: string, y: number) => {}
+>a6 : new <T>(x: T, y: T) => T
+
+//var r1b7 = b7 < a7;
+
+// operator >
+var r2a1 = a1 > b1;
+>r2a1 : boolean
+>a1 > b1 : boolean
+>a1 : new <T>(x: T) => T
+>b1 : new (x: string) => string
+
+var r2a2 = a2 > b2;
+>r2a2 : boolean
+>a2 > b2 : boolean
+>a2 : new <T>(x: T) => T
+>b2 : new (x: string, y: number) => string
+
+var r2a3 = a3 > b3;
+>r2a3 : boolean
+>a3 > b3 : boolean
+>a3 : new <T, U>(x: T, y: U) => T
+>b3 : new (x: string, y: number) => string
+
+var r2a4 = a4 > b4;
+>r2a4 : boolean
+>a4 > b4 : boolean
+>a4 : new <T>(x?: T) => T
+>b4 : new (x?: string) => string
+
+var r2a5 = a5 > b5;
+>r2a5 : boolean
+>a5 > b5 : boolean
+>a5 : new <T>(...x: T[]) => T
+>b5 : new (...x: string[]) => string
+
+var r2a6 = a6 > b6;
+>r2a6 : boolean
+>a6 > b6 : boolean
+>a6 : new <T>(x: T, y: T) => T
+>b6 : new (x: string, y: number) => {}
+
+//var r2a7 = a7 > b7;
+
+var r2b1 = b1 > a1;
+>r2b1 : boolean
+>b1 > a1 : boolean
+>b1 : new (x: string) => string
+>a1 : new <T>(x: T) => T
+
+var r2b2 = b2 > a2;
+>r2b2 : boolean
+>b2 > a2 : boolean
+>b2 : new (x: string, y: number) => string
+>a2 : new <T>(x: T) => T
+
+var r2b3 = b3 > a3;
+>r2b3 : boolean
+>b3 > a3 : boolean
+>b3 : new (x: string, y: number) => string
+>a3 : new <T, U>(x: T, y: U) => T
+
+var r2b4 = b4 > a4;
+>r2b4 : boolean
+>b4 > a4 : boolean
+>b4 : new (x?: string) => string
+>a4 : new <T>(x?: T) => T
+
+var r2b5 = b5 > a5;
+>r2b5 : boolean
+>b5 > a5 : boolean
+>b5 : new (...x: string[]) => string
+>a5 : new <T>(...x: T[]) => T
+
+var r2b6 = b6 > a6;
+>r2b6 : boolean
+>b6 > a6 : boolean
+>b6 : new (x: string, y: number) => {}
+>a6 : new <T>(x: T, y: T) => T
+
+//var r2b7 = b7 > a7;
+
+// operator <=
+var r3a1 = a1 <= b1;
+>r3a1 : boolean
+>a1 <= b1 : boolean
+>a1 : new <T>(x: T) => T
+>b1 : new (x: string) => string
+
+var r3a2 = a2 <= b2;
+>r3a2 : boolean
+>a2 <= b2 : boolean
+>a2 : new <T>(x: T) => T
+>b2 : new (x: string, y: number) => string
+
+var r3a3 = a3 <= b3;
+>r3a3 : boolean
+>a3 <= b3 : boolean
+>a3 : new <T, U>(x: T, y: U) => T
+>b3 : new (x: string, y: number) => string
+
+var r3a4 = a4 <= b4;
+>r3a4 : boolean
+>a4 <= b4 : boolean
+>a4 : new <T>(x?: T) => T
+>b4 : new (x?: string) => string
+
+var r3a5 = a5 <= b5;
+>r3a5 : boolean
+>a5 <= b5 : boolean
+>a5 : new <T>(...x: T[]) => T
+>b5 : new (...x: string[]) => string
+
+var r3a6 = a6 <= b6;
+>r3a6 : boolean
+>a6 <= b6 : boolean
+>a6 : new <T>(x: T, y: T) => T
+>b6 : new (x: string, y: number) => {}
+
+//var r3a7 = a7 <= b7;
+
+var r3b1 = b1 <= a1;
+>r3b1 : boolean
+>b1 <= a1 : boolean
+>b1 : new (x: string) => string
+>a1 : new <T>(x: T) => T
+
+var r3b2 = b2 <= a2;
+>r3b2 : boolean
+>b2 <= a2 : boolean
+>b2 : new (x: string, y: number) => string
+>a2 : new <T>(x: T) => T
+
+var r3b3 = b3 <= a3;
+>r3b3 : boolean
+>b3 <= a3 : boolean
+>b3 : new (x: string, y: number) => string
+>a3 : new <T, U>(x: T, y: U) => T
+
+var r3b4 = b4 <= a4;
+>r3b4 : boolean
+>b4 <= a4 : boolean
+>b4 : new (x?: string) => string
+>a4 : new <T>(x?: T) => T
+
+var r3b5 = b5 <= a5;
+>r3b5 : boolean
+>b5 <= a5 : boolean
+>b5 : new (...x: string[]) => string
+>a5 : new <T>(...x: T[]) => T
+
+var r3b6 = b6 <= a6;
+>r3b6 : boolean
+>b6 <= a6 : boolean
+>b6 : new (x: string, y: number) => {}
+>a6 : new <T>(x: T, y: T) => T
+
+//var r3b7 = b7 <= a7;
+
+// operator >=
+var r4a1 = a1 >= b1;
+>r4a1 : boolean
+>a1 >= b1 : boolean
+>a1 : new <T>(x: T) => T
+>b1 : new (x: string) => string
+
+var r4a2 = a2 >= b2;
+>r4a2 : boolean
+>a2 >= b2 : boolean
+>a2 : new <T>(x: T) => T
+>b2 : new (x: string, y: number) => string
+
+var r4a3 = a3 >= b3;
+>r4a3 : boolean
+>a3 >= b3 : boolean
+>a3 : new <T, U>(x: T, y: U) => T
+>b3 : new (x: string, y: number) => string
+
+var r4a4 = a4 >= b4;
+>r4a4 : boolean
+>a4 >= b4 : boolean
+>a4 : new <T>(x?: T) => T
+>b4 : new (x?: string) => string
+
+var r4a5 = a5 >= b5;
+>r4a5 : boolean
+>a5 >= b5 : boolean
+>a5 : new <T>(...x: T[]) => T
+>b5 : new (...x: string[]) => string
+
+var r4a6 = a6 >= b6;
+>r4a6 : boolean
+>a6 >= b6 : boolean
+>a6 : new <T>(x: T, y: T) => T
+>b6 : new (x: string, y: number) => {}
+
+//var r4a7 = a7 >= b7;
+
+var r4b1 = b1 >= a1;
+>r4b1 : boolean
+>b1 >= a1 : boolean
+>b1 : new (x: string) => string
+>a1 : new <T>(x: T) => T
+
+var r4b2 = b2 >= a2;
+>r4b2 : boolean
+>b2 >= a2 : boolean
+>b2 : new (x: string, y: number) => string
+>a2 : new <T>(x: T) => T
+
+var r4b3 = b3 >= a3;
+>r4b3 : boolean
+>b3 >= a3 : boolean
+>b3 : new (x: string, y: number) => string
+>a3 : new <T, U>(x: T, y: U) => T
+
+var r4b4 = b4 >= a4;
+>r4b4 : boolean
+>b4 >= a4 : boolean
+>b4 : new (x?: string) => string
+>a4 : new <T>(x?: T) => T
+
+var r4b5 = b5 >= a5;
+>r4b5 : boolean
+>b5 >= a5 : boolean
+>b5 : new (...x: string[]) => string
+>a5 : new <T>(...x: T[]) => T
+
+var r4b6 = b6 >= a6;
+>r4b6 : boolean
+>b6 >= a6 : boolean
+>b6 : new (x: string, y: number) => {}
+>a6 : new <T>(x: T, y: T) => T
+
+//var r4b7 = b7 >= a7;
+
+// operator ==
+var r5a1 = a1 == b1;
+>r5a1 : boolean
+>a1 == b1 : boolean
+>a1 : new <T>(x: T) => T
+>b1 : new (x: string) => string
+
+var r5a2 = a2 == b2;
+>r5a2 : boolean
+>a2 == b2 : boolean
+>a2 : new <T>(x: T) => T
+>b2 : new (x: string, y: number) => string
+
+var r5a3 = a3 == b3;
+>r5a3 : boolean
+>a3 == b3 : boolean
+>a3 : new <T, U>(x: T, y: U) => T
+>b3 : new (x: string, y: number) => string
+
+var r5a4 = a4 == b4;
+>r5a4 : boolean
+>a4 == b4 : boolean
+>a4 : new <T>(x?: T) => T
+>b4 : new (x?: string) => string
+
+var r5a5 = a5 == b5;
+>r5a5 : boolean
+>a5 == b5 : boolean
+>a5 : new <T>(...x: T[]) => T
+>b5 : new (...x: string[]) => string
+
+var r5a6 = a6 == b6;
+>r5a6 : boolean
+>a6 == b6 : boolean
+>a6 : new <T>(x: T, y: T) => T
+>b6 : new (x: string, y: number) => {}
+
+//var r5a7 = a7 == b7;
+
+var r5b1 = b1 == a1;
+>r5b1 : boolean
+>b1 == a1 : boolean
+>b1 : new (x: string) => string
+>a1 : new <T>(x: T) => T
+
+var r5b2 = b2 == a2;
+>r5b2 : boolean
+>b2 == a2 : boolean
+>b2 : new (x: string, y: number) => string
+>a2 : new <T>(x: T) => T
+
+var r5b3 = b3 == a3;
+>r5b3 : boolean
+>b3 == a3 : boolean
+>b3 : new (x: string, y: number) => string
+>a3 : new <T, U>(x: T, y: U) => T
+
+var r5b4 = b4 == a4;
+>r5b4 : boolean
+>b4 == a4 : boolean
+>b4 : new (x?: string) => string
+>a4 : new <T>(x?: T) => T
+
+var r5b5 = b5 == a5;
+>r5b5 : boolean
+>b5 == a5 : boolean
+>b5 : new (...x: string[]) => string
+>a5 : new <T>(...x: T[]) => T
+
+var r5b6 = b6 == a6;
+>r5b6 : boolean
+>b6 == a6 : boolean
+>b6 : new (x: string, y: number) => {}
+>a6 : new <T>(x: T, y: T) => T
+
+//var r5b7 = b7 == a7;
+
+// operator !=
+var r6a1 = a1 != b1;
+>r6a1 : boolean
+>a1 != b1 : boolean
+>a1 : new <T>(x: T) => T
+>b1 : new (x: string) => string
+
+var r6a2 = a2 != b2;
+>r6a2 : boolean
+>a2 != b2 : boolean
+>a2 : new <T>(x: T) => T
+>b2 : new (x: string, y: number) => string
+
+var r6a3 = a3 != b3;
+>r6a3 : boolean
+>a3 != b3 : boolean
+>a3 : new <T, U>(x: T, y: U) => T
+>b3 : new (x: string, y: number) => string
+
+var r6a4 = a4 != b4;
+>r6a4 : boolean
+>a4 != b4 : boolean
+>a4 : new <T>(x?: T) => T
+>b4 : new (x?: string) => string
+
+var r6a5 = a5 != b5;
+>r6a5 : boolean
+>a5 != b5 : boolean
+>a5 : new <T>(...x: T[]) => T
+>b5 : new (...x: string[]) => string
+
+var r6a6 = a6 != b6;
+>r6a6 : boolean
+>a6 != b6 : boolean
+>a6 : new <T>(x: T, y: T) => T
+>b6 : new (x: string, y: number) => {}
+
+//var r6a7 = a7 != b7;
+
+var r6b1 = b1 != a1;
+>r6b1 : boolean
+>b1 != a1 : boolean
+>b1 : new (x: string) => string
+>a1 : new <T>(x: T) => T
+
+var r6b2 = b2 != a2;
+>r6b2 : boolean
+>b2 != a2 : boolean
+>b2 : new (x: string, y: number) => string
+>a2 : new <T>(x: T) => T
+
+var r6b3 = b3 != a3;
+>r6b3 : boolean
+>b3 != a3 : boolean
+>b3 : new (x: string, y: number) => string
+>a3 : new <T, U>(x: T, y: U) => T
+
+var r6b4 = b4 != a4;
+>r6b4 : boolean
+>b4 != a4 : boolean
+>b4 : new (x?: string) => string
+>a4 : new <T>(x?: T) => T
+
+var r6b5 = b5 != a5;
+>r6b5 : boolean
+>b5 != a5 : boolean
+>b5 : new (...x: string[]) => string
+>a5 : new <T>(...x: T[]) => T
+
+var r6b6 = b6 != a6;
+>r6b6 : boolean
+>b6 != a6 : boolean
+>b6 : new (x: string, y: number) => {}
+>a6 : new <T>(x: T, y: T) => T
+
+//var r6b7 = b7 != a7;
+
+// operator ===
+var r7a1 = a1 === b1;
+>r7a1 : boolean
+>a1 === b1 : boolean
+>a1 : new <T>(x: T) => T
+>b1 : new (x: string) => string
+
+var r7a2 = a2 === b2;
+>r7a2 : boolean
+>a2 === b2 : boolean
+>a2 : new <T>(x: T) => T
+>b2 : new (x: string, y: number) => string
+
+var r7a3 = a3 === b3;
+>r7a3 : boolean
+>a3 === b3 : boolean
+>a3 : new <T, U>(x: T, y: U) => T
+>b3 : new (x: string, y: number) => string
+
+var r7a4 = a4 === b4;
+>r7a4 : boolean
+>a4 === b4 : boolean
+>a4 : new <T>(x?: T) => T
+>b4 : new (x?: string) => string
+
+var r7a5 = a5 === b5;
+>r7a5 : boolean
+>a5 === b5 : boolean
+>a5 : new <T>(...x: T[]) => T
+>b5 : new (...x: string[]) => string
+
+var r7a6 = a6 === b6;
+>r7a6 : boolean
+>a6 === b6 : boolean
+>a6 : new <T>(x: T, y: T) => T
+>b6 : new (x: string, y: number) => {}
+
+//var r7a7 = a7 === b7;
+
+var r7b1 = b1 === a1;
+>r7b1 : boolean
+>b1 === a1 : boolean
+>b1 : new (x: string) => string
+>a1 : new <T>(x: T) => T
+
+var r7b2 = b2 === a2;
+>r7b2 : boolean
+>b2 === a2 : boolean
+>b2 : new (x: string, y: number) => string
+>a2 : new <T>(x: T) => T
+
+var r7b3 = b3 === a3;
+>r7b3 : boolean
+>b3 === a3 : boolean
+>b3 : new (x: string, y: number) => string
+>a3 : new <T, U>(x: T, y: U) => T
+
+var r7b4 = b4 === a4;
+>r7b4 : boolean
+>b4 === a4 : boolean
+>b4 : new (x?: string) => string
+>a4 : new <T>(x?: T) => T
+
+var r7b5 = b5 === a5;
+>r7b5 : boolean
+>b5 === a5 : boolean
+>b5 : new (...x: string[]) => string
+>a5 : new <T>(...x: T[]) => T
+
+var r7b6 = b6 === a6;
+>r7b6 : boolean
+>b6 === a6 : boolean
+>b6 : new (x: string, y: number) => {}
+>a6 : new <T>(x: T, y: T) => T
+
+//var r7b7 = b7 === a7;
+
+// operator !==
+var r8a1 = a1 !== b1;
+>r8a1 : boolean
+>a1 !== b1 : boolean
+>a1 : new <T>(x: T) => T
+>b1 : new (x: string) => string
+
+var r8a2 = a2 !== b2;
+>r8a2 : boolean
+>a2 !== b2 : boolean
+>a2 : new <T>(x: T) => T
+>b2 : new (x: string, y: number) => string
+
+var r8a3 = a3 !== b3;
+>r8a3 : boolean
+>a3 !== b3 : boolean
+>a3 : new <T, U>(x: T, y: U) => T
+>b3 : new (x: string, y: number) => string
+
+var r8a4 = a4 !== b4;
+>r8a4 : boolean
+>a4 !== b4 : boolean
+>a4 : new <T>(x?: T) => T
+>b4 : new (x?: string) => string
+
+var r8a5 = a5 !== b5;
+>r8a5 : boolean
+>a5 !== b5 : boolean
+>a5 : new <T>(...x: T[]) => T
+>b5 : new (...x: string[]) => string
+
+var r8a6 = a6 !== b6;
+>r8a6 : boolean
+>a6 !== b6 : boolean
+>a6 : new <T>(x: T, y: T) => T
+>b6 : new (x: string, y: number) => {}
+
+//var r8a7 = a7 !== b7;
+
+var r8b1 = b1 !== a1;
+>r8b1 : boolean
+>b1 !== a1 : boolean
+>b1 : new (x: string) => string
+>a1 : new <T>(x: T) => T
+
+var r8b2 = b2 !== a2;
+>r8b2 : boolean
+>b2 !== a2 : boolean
+>b2 : new (x: string, y: number) => string
+>a2 : new <T>(x: T) => T
+
+var r8b3 = b3 !== a3;
+>r8b3 : boolean
+>b3 !== a3 : boolean
+>b3 : new (x: string, y: number) => string
+>a3 : new <T, U>(x: T, y: U) => T
+
+var r8b4 = b4 !== a4;
+>r8b4 : boolean
+>b4 !== a4 : boolean
+>b4 : new (x?: string) => string
+>a4 : new <T>(x?: T) => T
+
+var r8b5 = b5 !== a5;
+>r8b5 : boolean
+>b5 !== a5 : boolean
+>b5 : new (...x: string[]) => string
+>a5 : new <T>(...x: T[]) => T
+
+var r8b6 = b6 !== a6;
+>r8b6 : boolean
+>b6 !== a6 : boolean
+>b6 : new (x: string, y: number) => {}
+>a6 : new <T>(x: T, y: T) => T
+
+//var r8b7 = b7 !== a7;

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

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'.

tests/baselines/reference/contextualSignatureInstantiation.js

@@ -0,0 +1,50 @@
+//// [contextualSignatureInstantiation.ts]
+// TypeScript Spec, section 4.12.2:
+// If e is an expression of a function type that contains exactly one generic call signature and no other members,
+// and T is a function type with exactly one non - generic call signature and no other members, then any inferences
+// made for type parameters referenced by the parameters of T's call signature are fixed, and e's type is changed
+// to a function type with e's call signature instantiated in the context of T's call signature (section 3.8.5).
+
+declare function foo<T>(cb: (x: number, y: string) => T): T;
+declare function bar<T, U, V>(x: T, y: U, cb: (x: T, y: U) => V): V;
+declare function baz<T, U>(x: T, y: T, cb: (x: T, y: T) => U): U;
+
+declare function g<T>(x: T, y: T): T;
+declare function h<T, U>(x: T, y: U): T[] | U[];
+
+var a: number;
+var a = bar(1, 1, g);      // Should be number
+var a = baz(1, 1, g);      // Should be number
+
+var b: number | string;
+var b = foo(g);            // Should be number | string
+var b = bar(1, "one", g);  // Should be number | string
+var b = bar("one", 1, g);  // Should be number | string
+var b = baz(b, b, g);      // Should be number | string
+
+var d: number[] | string[];
+var d = foo(h);            // Should be number[] | string[]
+var d = bar(1, "one", h);  // Should be number[] | string[]
+var d = bar("one", 1, h);  // Should be number[] | string[]
+var d = baz(d, d, g);      // Should be number[] | string[]
+
+
+//// [contextualSignatureInstantiation.js]
+// TypeScript Spec, section 4.12.2:
+// If e is an expression of a function type that contains exactly one generic call signature and no other members,
+// and T is a function type with exactly one non - generic call signature and no other members, then any inferences
+// made for type parameters referenced by the parameters of T's call signature are fixed, and e's type is changed
+// to a function type with e's call signature instantiated in the context of T's call signature (section 3.8.5).
+var a;
+var a = bar(1, 1, g); // Should be number
+var a = baz(1, 1, g); // Should be number
+var b;
+var b = foo(g); // Should be number | string
+var b = bar(1, "one", g); // Should be number | string
+var b = bar("one", 1, g); // Should be number | string
+var b = baz(b, b, g); // Should be number | string
+var d;
+var d = foo(h); // Should be number[] | string[]
+var d = bar(1, "one", h); // Should be number[] | string[]
+var d = bar("one", 1, h); // Should be number[] | string[]
+var d = baz(d, d, g); // Should be number[] | string[]

tests/baselines/reference/contextualSignatureInstantiation.types

@@ -0,0 +1,142 @@
+=== tests/cases/conformance/types/typeRelationships/typeInference/contextualSignatureInstantiation.ts ===
+// TypeScript Spec, section 4.12.2:
+// If e is an expression of a function type that contains exactly one generic call signature and no other members,
+// and T is a function type with exactly one non - generic call signature and no other members, then any inferences
+// made for type parameters referenced by the parameters of T's call signature are fixed, and e's type is changed
+// to a function type with e's call signature instantiated in the context of T's call signature (section 3.8.5).
+
+declare function foo<T>(cb: (x: number, y: string) => T): T;
+>foo : <T>(cb: (x: number, y: string) => T) => T
+>T : T
+>cb : (x: number, y: string) => T
+>x : number
+>y : string
+>T : T
+>T : T
+
+declare function bar<T, U, V>(x: T, y: U, cb: (x: T, y: U) => V): V;
+>bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
+>T : T
+>U : U
+>V : V
+>x : T
+>T : T
+>y : U
+>U : U
+>cb : (x: T, y: U) => V
+>x : T
+>T : T
+>y : U
+>U : U
+>V : V
+>V : V
+
+declare function baz<T, U>(x: T, y: T, cb: (x: T, y: T) => U): U;
+>baz : <T, U>(x: T, y: T, cb: (x: T, y: T) => U) => U
+>T : T
+>U : U
+>x : T
+>T : T
+>y : T
+>T : T
+>cb : (x: T, y: T) => U
+>x : T
+>T : T
+>y : T
+>T : T
+>U : U
+>U : U
+
+declare function g<T>(x: T, y: T): T;
+>g : <T>(x: T, y: T) => T
+>T : T
+>x : T
+>T : T
+>y : T
+>T : T
+>T : T
+
+declare function h<T, U>(x: T, y: U): T[] | U[];
+>h : <T, U>(x: T, y: U) => T[] | U[]
+>T : T
+>U : U
+>x : T
+>T : T
+>y : U
+>U : U
+>T : T
+>U : U
+
+var a: number;
+>a : number
+
+var a = bar(1, 1, g);      // Should be number
+>a : number
+>bar(1, 1, g) : number
+>bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
+>g : <T>(x: T, y: T) => T
+
+var a = baz(1, 1, g);      // Should be number
+>a : number
+>baz(1, 1, g) : number
+>baz : <T, U>(x: T, y: T, cb: (x: T, y: T) => U) => U
+>g : <T>(x: T, y: T) => T
+
+var b: number | string;
+>b : string | number
+
+var b = foo(g);            // Should be number | string
+>b : string | number
+>foo(g) : string | number
+>foo : <T>(cb: (x: number, y: string) => T) => T
+>g : <T>(x: T, y: T) => T
+
+var b = bar(1, "one", g);  // Should be number | string
+>b : string | number
+>bar(1, "one", g) : string | number
+>bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
+>g : <T>(x: T, y: T) => T
+
+var b = bar("one", 1, g);  // Should be number | string
+>b : string | number
+>bar("one", 1, g) : string | number
+>bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
+>g : <T>(x: T, y: T) => T
+
+var b = baz(b, b, g);      // Should be number | string
+>b : string | number
+>baz(b, b, g) : string | number
+>baz : <T, U>(x: T, y: T, cb: (x: T, y: T) => U) => U
+>b : string | number
+>b : string | number
+>g : <T>(x: T, y: T) => T
+
+var d: number[] | string[];
+>d : string[] | number[]
+
+var d = foo(h);            // Should be number[] | string[]
+>d : string[] | number[]
+>foo(h) : string[] | number[]
+>foo : <T>(cb: (x: number, y: string) => T) => T
+>h : <T, U>(x: T, y: U) => T[] | U[]
+
+var d = bar(1, "one", h);  // Should be number[] | string[]
+>d : string[] | number[]
+>bar(1, "one", h) : string[] | number[]
+>bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
+>h : <T, U>(x: T, y: U) => T[] | U[]
+
+var d = bar("one", 1, h);  // Should be number[] | string[]
+>d : string[] | number[]
+>bar("one", 1, h) : string[] | number[]
+>bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
+>h : <T, U>(x: T, y: U) => T[] | U[]
+
+var d = baz(d, d, g);      // Should be number[] | string[]
+>d : string[] | number[]
+>baz(d, d, g) : string[] | number[]
+>baz : <T, U>(x: T, y: T, cb: (x: T, y: T) => U) => U
+>d : string[] | number[]
+>d : string[] | number[]
+>g : <T>(x: T, y: T) => T
+

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'.

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'.

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
 

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; }'.

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

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':

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':

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

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

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
 

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

tests/baselines/reference/enumIdentifierLiterals.errors.txt

@@ -1,11 +1,10 @@
 tests/cases/compiler/enumIdentifierLiterals.ts(2,5): error TS1151: An enum member cannot have a numeric name.
 tests/cases/compiler/enumIdentifierLiterals.ts(3,5): error TS1151: An enum member cannot have a numeric name.
 tests/cases/compiler/enumIdentifierLiterals.ts(4,5): error TS1151: An enum member cannot have a numeric name.
-tests/cases/compiler/enumIdentifierLiterals.ts(5,5): error TS1151: An enum member cannot have a numeric name.
 tests/cases/compiler/enumIdentifierLiterals.ts(6,5): error TS1151: An enum member cannot have a numeric name.
 
 
-==== tests/cases/compiler/enumIdentifierLiterals.ts (5 errors) ====
+==== tests/cases/compiler/enumIdentifierLiterals.ts (4 errors) ====
     enum Nums {
         1.0,
         ~~~
@@ -17,8 +16,6 @@ tests/cases/compiler/enumIdentifierLiterals.ts(6,5): error TS1151: An enum membe
         ~~~~~~
 !!! error TS1151: An enum member cannot have a numeric name.
         "13e-1",
-        ~~~~~~~
-!!! error TS1151: An enum member cannot have a numeric name.
         0xF00D
         ~~~~~~
 !!! error TS1151: An enum member cannot have a numeric name.

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>>();;){}

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;

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
 }
 

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
     }
 }

tests/baselines/reference/functionTypesLackingReturnTypes.errors.txt

@@ -1,5 +1,5 @@
 tests/cases/compiler/functionTypesLackingReturnTypes.ts(3,17): error TS1005: '=>' expected.
-tests/cases/compiler/functionTypesLackingReturnTypes.ts(7,15): error TS1005: '=>' expected.
+tests/cases/compiler/functionTypesLackingReturnTypes.ts(7,9): error TS2304: Cannot find name 'param'.
 
 
 ==== tests/cases/compiler/functionTypesLackingReturnTypes.ts (2 errors) ====
@@ -12,8 +12,8 @@ tests/cases/compiler/functionTypesLackingReturnTypes.ts(7,15): error TS1005: '=>
     
     // Error (no '=>')
     var g: (param);
-                  ~
-!!! error TS1005: '=>' expected.
+            ~~~~~
+!!! error TS2304: Cannot find name 'param'.
     
     // Okay
     var h: { () }

tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt

@@ -0,0 +1,112 @@
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(58,1): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(67,1): error TS2354: No best common type exists among return expressions.
+
+
+==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts (2 errors) ====
+    // return type of a function with multiple returns is the BCT of each return statement
+    // no errors expected here
+    
+    function f1() {
+        if (true) {
+            return 1;
+        } else {
+            return null;
+        }
+    }
+    
+    function f2() {
+        if (true) {
+            return 1;
+        } else if (false) {
+            return null;
+        } else {
+            return 2;
+        }
+    }
+    
+    function f4() {
+        try {
+            return 1;
+        }
+        catch (e) {
+            return undefined;
+        }
+        finally {
+            return 1;
+        }
+    }
+    
+    function f5() {
+        return 1;
+        return new Object();
+    }
+    
+    function f6<T>(x: T) {
+        if (true) {
+            return x;
+        } else {
+            return null;
+        }
+    }
+    
+    //function f7<T extends U, U>(x: T, y: U) {
+    //    if (true) {
+    //        return x;
+    //    } else {
+    //        return y;
+    //    }
+    //}
+    
+    var a: { x: number; y?: number };
+    var b: { x: number; z?: number };
+    // returns typeof a
+    function f9() {
+    ~~~~~~~~~~~~~~~
+        if (true) {
+    ~~~~~~~~~~~~~~~
+            return a;
+    ~~~~~~~~~~~~~~~~~
+        } else {
+    ~~~~~~~~~~~~
+            return b;
+    ~~~~~~~~~~~~~~~~~
+        }
+    ~~~~~
+    }
+    ~
+!!! error TS2354: No best common type exists among return expressions.
+    
+    // returns typeof b
+    function f10() {
+    ~~~~~~~~~~~~~~~~
+        if (true) {
+    ~~~~~~~~~~~~~~~
+            return b;
+    ~~~~~~~~~~~~~~~~~
+        } else {
+    ~~~~~~~~~~~~
+            return a;
+    ~~~~~~~~~~~~~~~~~
+        }
+    ~~~~~
+    }
+    ~
+!!! error TS2354: No best common type exists among return expressions.
+    
+    // returns number => void
+    function f11() {
+        if (true) {
+            return (x: number) => { }
+        } else {
+            return (x: Object) => { }
+        }
+    }
+    
+    // returns Object => void
+    function f12() {
+        if (true) {
+            return (x: Object) => { }
+        } else {
+            return (x: number) => { }        
+        }
+    }

tests/baselines/reference/functionWithMultipleReturnStatements2.types

@@ -1,146 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts ===
-// return type of a function with multiple returns is the BCT of each return statement
-// no errors expected here
-
-function f1() {
->f1 : () => number
-
-    if (true) {
-        return 1;
-    } else {
-        return null;
-    }
-}
-
-function f2() {
->f2 : () => number
-
-    if (true) {
-        return 1;
-    } else if (false) {
-        return null;
-    } else {
-        return 2;
-    }
-}
-
-function f4() {
->f4 : () => number
-
-    try {
-        return 1;
-    }
-    catch (e) {
->e : any
-
-        return undefined;
->undefined : undefined
-    }
-    finally {
-        return 1;
-    }
-}
-
-function f5() {
->f5 : () => Object
-
-    return 1;
-    return new Object();
->new Object() : Object
->Object : { (): any; (value: any): any; new (value?: any): Object; prototype: Object; getPrototypeOf(o: any): any; getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor; getOwnPropertyNames(o: any): string[]; create(o: any, properties?: PropertyDescriptorMap): any; defineProperty(o: any, p: string, attributes: PropertyDescriptor): any; defineProperties(o: any, properties: PropertyDescriptorMap): any; seal(o: any): any; freeze(o: any): any; preventExtensions(o: any): any; isSealed(o: any): boolean; isFrozen(o: any): boolean; isExtensible(o: any): boolean; keys(o: any): string[]; }
-}
-
-function f6<T>(x: T) {
->f6 : <T>(x: T) => T
->T : T
->x : T
->T : T
-
-    if (true) {
-        return x;
->x : T
-
-    } else {
-        return null;
-    }
-}
-
-//function f7<T extends U, U>(x: T, y: U) {
-//    if (true) {
-//        return x;
-//    } else {
-//        return y;
-//    }
-//}
-
-var a: { x: number; y?: number };
->a : { x: number; y?: number; }
->x : number
->y : number
-
-var b: { x: number; z?: number };
->b : { x: number; z?: number; }
->x : number
->z : number
-
-// returns typeof a
-function f9() {
->f9 : () => { x: number; y?: number; }
-
-    if (true) {
-        return a;
->a : { x: number; y?: number; }
-
-    } else {
-        return b;
->b : { x: number; z?: number; }
-    }
-}
-
-// returns typeof b
-function f10() {
->f10 : () => { x: number; z?: number; }
-
-    if (true) {
-        return b;
->b : { x: number; z?: number; }
-
-    } else {
-        return a;
->a : { x: number; y?: number; }
-    }
-}
-
-// returns number => void
-function f11() {
->f11 : () => (x: number) => void
-
-    if (true) {
-        return (x: number) => { }
->(x: number) => { } : (x: number) => void
->x : number
-
-    } else {
-        return (x: Object) => { }
->(x: Object) => { } : (x: Object) => void
->x : Object
->Object : Object
-    }
-}
-
-// returns Object => void
-function f12() {
->f12 : () => (x: Object) => void
-
-    if (true) {
-        return (x: Object) => { }
->(x: Object) => { } : (x: Object) => void
->x : Object
->Object : Object
-
-    } else {
-        return (x: number) => { }        
->(x: number) => { } : (x: number) => void
->x : number
-    }
-}

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

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)[]
 

tests/baselines/reference/genericCallWithGenericSignatureArguments.errors.txt

@@ -0,0 +1,51 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments.ts(18,10): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments.ts(19,10): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments.ts (2 errors) ====
+    // When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
+    // the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
+    
+    function foo<T>(a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
+    
+    //var r1 = foo((x: number) => 1, (x: string) => ''); // error
+    var r1b = foo((x) => 1, (x) => ''); // {} => {}
+    var r2 = foo((x: Object) => null, (x: string) => ''); // Object => Object
+    var r3 = foo((x: number) => 1, (x: Object) => null); // number => number
+    var r3ii = foo((x: number) => 1, (x: number) => 1); // number => number
+    
+    var a: { x: number; y?: number; };
+    var b: { x: number; z?: number; };
+    
+    var r4 = foo((x: typeof a) => a, (x: typeof b) => b); // typeof a => typeof a
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var r5 = foo((x: typeof b) => b, (x: typeof a) => a); // typeof b => typeof b
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    function other<T>(x: T) {
+        var r6 = foo((a: T) => a, (b: T) => b); // T => T
+        var r6b = foo((a) => a, (b) => b); // {} => {}
+    }
+    
+    function other2<T extends Date>(x: T) {
+        var r7 = foo((a: T) => a, (b: T) => b); // T => T
+        var r7b = foo((a) => a, (b) => b); // {} => {}
+        var r8 = r7(null);
+        // BUG 835518
+        //var r9 = r7(new Date());
+    }
+    
+    
+    function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
+    
+    function other3<T extends RegExp>(x: T) {
+        var r8 = foo2((a: Date) => a, (b: Date) => b); // Date => Date
+    }

tests/baselines/reference/genericCallWithGenericSignatureArguments.types

@@ -1,216 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments.ts ===
-// When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
-// the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
-
-function foo<T>(a: (x: T) => T, b: (x: T) => T) {
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->T : T
->a : (x: T) => T
->x : T
->T : T
->T : T
->b : (x: T) => T
->x : T
->T : T
->T : T
-
-    var r: (x: T) => T;
->r : (x: T) => T
->x : T
->T : T
->T : T
-
-    return r;
->r : (x: T) => T
-}
-
-//var r1 = foo((x: number) => 1, (x: string) => ''); // error
-var r1b = foo((x) => 1, (x) => ''); // {} => {}
->r1b : (x: {}) => {}
->foo((x) => 1, (x) => '') : (x: {}) => {}
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x) => 1 : (x: {}) => number
->x : {}
->(x) => '' : (x: {}) => string
->x : {}
-
-var r2 = foo((x: Object) => null, (x: string) => ''); // Object => Object
->r2 : (x: any) => any
->foo((x: Object) => null, (x: string) => '') : (x: any) => any
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x: Object) => null : (x: Object) => any
->x : Object
->Object : Object
->(x: string) => '' : (x: string) => string
->x : string
-
-var r3 = foo((x: number) => 1, (x: Object) => null); // number => number
->r3 : (x: any) => any
->foo((x: number) => 1, (x: Object) => null) : (x: any) => any
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x: number) => 1 : (x: number) => number
->x : number
->(x: Object) => null : (x: Object) => any
->x : Object
->Object : Object
-
-var r3ii = foo((x: number) => 1, (x: number) => 1); // number => number
->r3ii : (x: number) => number
->foo((x: number) => 1, (x: number) => 1) : (x: number) => number
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x: number) => 1 : (x: number) => number
->x : number
->(x: number) => 1 : (x: number) => number
->x : number
-
-var a: { x: number; y?: number; };
->a : { x: number; y?: number; }
->x : number
->y : number
-
-var b: { x: number; z?: number; };
->b : { x: number; z?: number; }
->x : number
->z : number
-
-var r4 = foo((x: typeof a) => a, (x: typeof b) => b); // typeof a => typeof a
->r4 : (x: { x: number; y?: number; }) => { x: number; y?: number; }
->foo((x: typeof a) => a, (x: typeof b) => b) : (x: { x: number; y?: number; }) => { x: number; y?: number; }
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x: typeof a) => a : (x: { x: number; y?: number; }) => { x: number; y?: number; }
->x : { x: number; y?: number; }
->a : { x: number; y?: number; }
->a : { x: number; y?: number; }
->(x: typeof b) => b : (x: { x: number; z?: number; }) => { x: number; z?: number; }
->x : { x: number; z?: number; }
->b : { x: number; z?: number; }
->b : { x: number; z?: number; }
-
-var r5 = foo((x: typeof b) => b, (x: typeof a) => a); // typeof b => typeof b
->r5 : (x: { x: number; z?: number; }) => { x: number; z?: number; }
->foo((x: typeof b) => b, (x: typeof a) => a) : (x: { x: number; z?: number; }) => { x: number; z?: number; }
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x: typeof b) => b : (x: { x: number; z?: number; }) => { x: number; z?: number; }
->x : { x: number; z?: number; }
->b : { x: number; z?: number; }
->b : { x: number; z?: number; }
->(x: typeof a) => a : (x: { x: number; y?: number; }) => { x: number; y?: number; }
->x : { x: number; y?: number; }
->a : { x: number; y?: number; }
->a : { x: number; y?: number; }
-
-function other<T>(x: T) {
->other : <T>(x: T) => void
->T : T
->x : T
->T : T
-
-    var r6 = foo((a: T) => a, (b: T) => b); // T => T
->r6 : (x: T) => T
->foo((a: T) => a, (b: T) => b) : (x: T) => T
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(a: T) => a : (a: T) => T
->a : T
->T : T
->a : T
->(b: T) => b : (b: T) => T
->b : T
->T : T
->b : T
-
-    var r6b = foo((a) => a, (b) => b); // {} => {}
->r6b : (x: {}) => {}
->foo((a) => a, (b) => b) : (x: {}) => {}
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(a) => a : (a: {}) => {}
->a : {}
->a : {}
->(b) => b : (b: {}) => {}
->b : {}
->b : {}
-}
-
-function other2<T extends Date>(x: T) {
->other2 : <T extends Date>(x: T) => void
->T : T
->Date : Date
->x : T
->T : T
-
-    var r7 = foo((a: T) => a, (b: T) => b); // T => T
->r7 : (x: T) => T
->foo((a: T) => a, (b: T) => b) : (x: T) => T
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(a: T) => a : (a: T) => T
->a : T
->T : T
->a : T
->(b: T) => b : (b: T) => T
->b : T
->T : T
->b : T
-
-    var r7b = foo((a) => a, (b) => b); // {} => {}
->r7b : (x: {}) => {}
->foo((a) => a, (b) => b) : (x: {}) => {}
->foo : <T>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(a) => a : (a: {}) => {}
->a : {}
->a : {}
->(b) => b : (b: {}) => {}
->b : {}
->b : {}
-
-    var r8 = r7(null);
->r8 : T
->r7(null) : T
->r7 : (x: T) => T
-
-    // BUG 835518
-    //var r9 = r7(new Date());
-}
-
-
-function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
->foo2 : <T extends Date>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->T : T
->Date : Date
->a : (x: T) => T
->x : T
->T : T
->T : T
->b : (x: T) => T
->x : T
->T : T
->T : T
-
-    var r: (x: T) => T;
->r : (x: T) => T
->x : T
->T : T
->T : T
-
-    return r;
->r : (x: T) => T
-}
-
-function other3<T extends RegExp>(x: T) {
->other3 : <T extends RegExp>(x: T) => void
->T : T
->RegExp : RegExp
->x : T
->T : T
-
-    var r8 = foo2((a: Date) => a, (b: Date) => b); // Date => Date
->r8 : (x: Date) => Date
->foo2((a: Date) => a, (b: Date) => b) : (x: Date) => Date
->foo2 : <T extends Date>(a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(a: Date) => a : (a: Date) => Date
->a : Date
->Date : Date
->a : Date
->(b: Date) => b : (b: Date) => Date
->b : Date
->Date : Date
->b : Date
-}

tests/baselines/reference/genericCallWithNonSymmetricSubtypes.errors.txt

@@ -0,0 +1,40 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithNonSymmetricSubtypes.ts(12,9): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithNonSymmetricSubtypes.ts(13,10): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithNonSymmetricSubtypes.ts (2 errors) ====
+    // generic type argument inference where inference leads to two candidates that are both supertypes of all candidates
+    // we choose the first candidate so the result is dependent on the order of the arguments provided
+    
+    function foo<T>(x: T, y: T) {
+        var r: T;
+        return r;
+    }
+    
+    var a: { x: number; y?: number; };
+    var b: { x: number; z?: number; };
+    
+    var r = foo(a, b); // { x: number; y?: number; };
+            ~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var r2 = foo(b, a); // { x: number; z?: number; };
+             ~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    var x: { x: number; };
+    var y: { x?: number; };
+    
+    var r3 = foo(a, x); // { x: number; y?: number; };
+    var r4 = foo(x, a); // { x: number; };
+    
+    var r5 = foo(a, y); // { x?: number; };
+    var r5 = foo(y, a); // { x?: number; };
+    
+    var r6 = foo(x, y); // { x?: number; };
+    var r6 = foo(y, x); // { x?: number; };
+    
+    var s1: (x: Object) => string;
+    var s2: (x: string) => string;
+    
+    var r7 = foo(s1, s2); // (x: Object) => string;
+    var r8 = foo(s2, s1); // (x: string) => string;

tests/baselines/reference/genericCallWithNonSymmetricSubtypes.types

@@ -1,117 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithNonSymmetricSubtypes.ts ===
-// generic type argument inference where inference leads to two candidates that are both supertypes of all candidates
-// we choose the first candidate so the result is dependent on the order of the arguments provided
-
-function foo<T>(x: T, y: T) {
->foo : <T>(x: T, y: T) => T
->T : T
->x : T
->T : T
->y : T
->T : T
-
-    var r: T;
->r : T
->T : T
-
-    return r;
->r : T
-}
-
-var a: { x: number; y?: number; };
->a : { x: number; y?: number; }
->x : number
->y : number
-
-var b: { x: number; z?: number; };
->b : { x: number; z?: number; }
->x : number
->z : number
-
-var r = foo(a, b); // { x: number; y?: number; };
->r : { x: number; y?: number; }
->foo(a, b) : { x: number; y?: number; }
->foo : <T>(x: T, y: T) => T
->a : { x: number; y?: number; }
->b : { x: number; z?: number; }
-
-var r2 = foo(b, a); // { x: number; z?: number; };
->r2 : { x: number; z?: number; }
->foo(b, a) : { x: number; z?: number; }
->foo : <T>(x: T, y: T) => T
->b : { x: number; z?: number; }
->a : { x: number; y?: number; }
-
-var x: { x: number; };
->x : { x: number; }
->x : number
-
-var y: { x?: number; };
->y : { x?: number; }
->x : number
-
-var r3 = foo(a, x); // { x: number; y?: number; };
->r3 : { x: number; y?: number; }
->foo(a, x) : { x: number; y?: number; }
->foo : <T>(x: T, y: T) => T
->a : { x: number; y?: number; }
->x : { x: number; }
-
-var r4 = foo(x, a); // { x: number; };
->r4 : { x: number; }
->foo(x, a) : { x: number; }
->foo : <T>(x: T, y: T) => T
->x : { x: number; }
->a : { x: number; y?: number; }
-
-var r5 = foo(a, y); // { x?: number; };
->r5 : { x?: number; }
->foo(a, y) : { x?: number; }
->foo : <T>(x: T, y: T) => T
->a : { x: number; y?: number; }
->y : { x?: number; }
-
-var r5 = foo(y, a); // { x?: number; };
->r5 : { x?: number; }
->foo(y, a) : { x?: number; }
->foo : <T>(x: T, y: T) => T
->y : { x?: number; }
->a : { x: number; y?: number; }
-
-var r6 = foo(x, y); // { x?: number; };
->r6 : { x?: number; }
->foo(x, y) : { x?: number; }
->foo : <T>(x: T, y: T) => T
->x : { x: number; }
->y : { x?: number; }
-
-var r6 = foo(y, x); // { x?: number; };
->r6 : { x?: number; }
->foo(y, x) : { x?: number; }
->foo : <T>(x: T, y: T) => T
->y : { x?: number; }
->x : { x: number; }
-
-var s1: (x: Object) => string;
->s1 : (x: Object) => string
->x : Object
->Object : Object
-
-var s2: (x: string) => string;
->s2 : (x: string) => string
->x : string
-
-var r7 = foo(s1, s2); // (x: Object) => string;
->r7 : (x: Object) => string
->foo(s1, s2) : (x: Object) => string
->foo : <T>(x: T, y: T) => T
->s1 : (x: Object) => string
->s2 : (x: string) => string
-
-var r8 = foo(s2, s1); // (x: string) => string;
->r8 : (x: string) => string
->foo(s2, s1) : (x: string) => string
->foo : <T>(x: T, y: T) => T
->s2 : (x: string) => string
->s1 : (x: Object) => string
-

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

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

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

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'.
         }

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
 }

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>>();

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

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

tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt

@@ -4,12 +4,9 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(90,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(93,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(18,5): error TS2412: Property '2.0' of type 'number' is not assignable to numeric index type 'string'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(20,5): error TS2412: Property '"4.0"' of type 'number' is not assignable to numeric index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(21,5): error TS2412: Property '3.0' of type 'MyNumber' is not assignable to numeric index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(50,5): error TS2412: Property '2.0' of type 'number' is not assignable to numeric index type 'string'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(55,5): error TS2412: Property '"4.0"' of type 'number' is not assignable to numeric index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(68,5): error TS2412: Property '2.0' of type 'number' is not assignable to numeric index type 'string'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(73,5): error TS2412: Property '"4.0"' of type 'number' is not assignable to numeric index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: number]: string | number; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: any; X: string; foo: () => string; }' is not assignable to type '{ [x: number]: string; }':
   Index signatures are incompatible:
     Type 'string | number' is not assignable to type 'string':
@@ -17,7 +14,7 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(88,9): error TS2304: Cannot find name 'Myn'.
 
 
-==== tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts (14 errors) ====
+==== tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts (11 errors) ====
     // String indexer types constrain the types of named properties in their containing type
     
     interface MyNumber extends Number {
@@ -40,8 +37,6 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
 !!! error TS2412: Property '2.0' of type 'number' is not assignable to numeric index type 'string'.
         "3.0": string; // ok
         "4.0": number; // error
-        ~~~~~~~~~~~~~~
-!!! error TS2412: Property '"4.0"' of type 'number' is not assignable to numeric index type 'string'.
         3.0: MyNumber // error
         ~~~~~~~~~~~~~
 !!! error TS2412: Property '3.0' of type 'MyNumber' is not assignable to numeric index type 'string'.
@@ -87,8 +82,6 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
         foo(): string; // ok
         "3.0": string; // ok
         "4.0": number; // error
-        ~~~~~~~~~~~~~~
-!!! error TS2412: Property '"4.0"' of type 'number' is not assignable to numeric index type 'string'.
         f: MyNumber; // error
     }
     
@@ -109,8 +102,6 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
         foo(): string; // ok
         "3.0": string; // ok
         "4.0": number; // error
-        ~~~~~~~~~~~~~~
-!!! error TS2412: Property '"4.0"' of type 'number' is not assignable to numeric index type 'string'.
         f: MyNumber; // error
     }
     

tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt

@@ -1,16 +1,13 @@
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(16,5): error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(17,5): error TS2412: Property '"4.0"' of type 'string' is not assignable to numeric index type 'A'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(25,5): error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(26,5): error TS2412: Property '"4.0"' of type 'string' is not assignable to numeric index type 'A'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(34,5): error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(35,5): error TS2412: Property '"4.0"' of type 'string' is not assignable to numeric index type 'A'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(39,5): error TS2322: Type '{ [x: number]: string | number | A; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }':
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(39,5): error TS2322: Type '{ [x: number]: number | A; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }':
   Index signatures are incompatible:
-    Type 'string | number | A' is not assignable to type 'A':
-      Type 'string' is not assignable to type 'A'.
+    Type 'number | A' is not assignable to type 'A':
+      Type 'number' is not assignable to type 'A'.
 
 
-==== tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts (7 errors) ====
+==== tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts (4 errors) ====
     // String indexer providing a constraint of a user defined type
     
     class A {
@@ -30,8 +27,6 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
         ~~~~~~~~~~~~
 !!! error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
         "4.0": string; // error
-        ~~~~~~~~~~~~~~
-!!! error TS2412: Property '"4.0"' of type 'string' is not assignable to numeric index type 'A'.
     }
     
     interface Foo2 {
@@ -43,8 +38,6 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
         ~~~~~~~~~~~~
 !!! error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
         "4.0": string; // error
-        ~~~~~~~~~~~~~~
-!!! error TS2412: Property '"4.0"' of type 'string' is not assignable to numeric index type 'A'.
     }
     
     var a: {
@@ -56,17 +49,15 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
         ~~~~~~~~~~~~
 !!! error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
         "4.0": string; // error
-        ~~~~~~~~~~~~~~
-!!! error TS2412: Property '"4.0"' of type 'string' is not assignable to numeric index type 'A'.
     };
     
     // error
     var b: { [x: number]: A } = {
         ~
-!!! error TS2322: Type '{ [x: number]: string | number | A; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }':
+!!! error TS2322: Type '{ [x: number]: number | A; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }':
 !!! error TS2322:   Index signatures are incompatible:
-!!! error TS2322:     Type 'string | number | A' is not assignable to type 'A':
-!!! error TS2322:       Type 'string' is not assignable to type 'A'.
+!!! error TS2322:     Type 'number | A' is not assignable to type 'A':
+!!! error TS2322:       Type 'number' is not assignable to type 'A'.
         1.0: new A(), 
         2.0: new B(), 
         "2.5": new B(),

tests/baselines/reference/parenthesizedTypes.js

@@ -0,0 +1,52 @@
+//// [parenthesizedTypes.ts]
+var a: string;
+var a: (string);
+var a: ((string) | string | (((string))));
+var a: ((((((((((((((((((((((((((((((((((((((((string))))))))))))))))))))))))))))))))))))))));
+
+var b: (x: string) => string;
+var b: ((x: (string)) => (string));
+
+var c: string[] | number[];
+var c: (string)[] | (number)[];
+var c: ((string)[]) | ((number)[]);
+
+var d: (((x: string) => string) | ((x: number) => number))[];
+var d: ({ (x: string): string } | { (x: number): number })[];
+var d: Array<((x: string) => string) | ((x: number) => number)>;
+var d: Array<{ (x: string): string } | { (x: number): number }>;
+var d: (Array<{ (x: string): string } | { (x: number): number }>);
+
+var e: typeof a[];
+var e: (typeof a)[];
+
+var f: (string) => string;
+var f: (string: any) => string;
+
+var g: [string, string];
+var g: [(string), string];
+var g: [(string), (((typeof a)))];
+
+
+//// [parenthesizedTypes.js]
+var a;
+var a;
+var a;
+var a;
+var b;
+var b;
+var c;
+var c;
+var c;
+var d;
+var d;
+var d;
+var d;
+var d;
+var e;
+var e;
+var f;
+var f;
+var g;
+var g;
+var g;

tests/baselines/reference/parenthesizedTypes.types

@@ -0,0 +1,84 @@
+=== tests/cases/conformance/types/specifyingTypes/typeLiterals/parenthesizedTypes.ts ===
+var a: string;
+>a : string
+
+var a: (string);
+>a : string
+
+var a: ((string) | string | (((string))));
+>a : string
+
+var a: ((((((((((((((((((((((((((((((((((((((((string))))))))))))))))))))))))))))))))))))))));
+>a : string
+
+var b: (x: string) => string;
+>b : (x: string) => string
+>x : string
+
+var b: ((x: (string)) => (string));
+>b : (x: string) => string
+>x : string
+
+var c: string[] | number[];
+>c : string[] | number[]
+
+var c: (string)[] | (number)[];
+>c : string[] | number[]
+
+var c: ((string)[]) | ((number)[]);
+>c : string[] | number[]
+
+var d: (((x: string) => string) | ((x: number) => number))[];
+>d : (((x: string) => string) | ((x: number) => number))[]
+>x : string
+>x : number
+
+var d: ({ (x: string): string } | { (x: number): number })[];
+>d : (((x: string) => string) | ((x: number) => number))[]
+>x : string
+>x : number
+
+var d: Array<((x: string) => string) | ((x: number) => number)>;
+>d : (((x: string) => string) | ((x: number) => number))[]
+>Array : T[]
+>x : string
+>x : number
+
+var d: Array<{ (x: string): string } | { (x: number): number }>;
+>d : (((x: string) => string) | ((x: number) => number))[]
+>Array : T[]
+>x : string
+>x : number
+
+var d: (Array<{ (x: string): string } | { (x: number): number }>);
+>d : (((x: string) => string) | ((x: number) => number))[]
+>Array : T[]
+>x : string
+>x : number
+
+var e: typeof a[];
+>e : string[]
+>a : string
+
+var e: (typeof a)[];
+>e : string[]
+>a : string
+
+var f: (string) => string;
+>f : (string: any) => string
+>string : any
+
+var f: (string: any) => string;
+>f : (string: any) => string
+>string : any
+
+var g: [string, string];
+>g : [string, string]
+
+var g: [(string), string];
+>g : [string, string]
+
+var g: [(string), (((typeof a)))];
+>g : [string, string]
+>a : string
+

tests/baselines/reference/propertiesAndIndexers2.errors.txt

@@ -0,0 +1,46 @@
+tests/cases/compiler/propertiesAndIndexers2.ts(2,5): error TS2413: Numeric index type 'string' is not assignable to string index type 'number'.
+tests/cases/compiler/propertiesAndIndexers2.ts(8,5): error TS2411: Property 'c' of type 'string' is not assignable to string index type 'number'.
+tests/cases/compiler/propertiesAndIndexers2.ts(9,5): error TS2411: Property '3' of type 'string' is not assignable to string index type 'number'.
+tests/cases/compiler/propertiesAndIndexers2.ts(10,5): error TS2411: Property 'Infinity' of type 'string' is not assignable to string index type 'number'.
+tests/cases/compiler/propertiesAndIndexers2.ts(11,5): error TS2411: Property '"-Infinity"' of type 'string' is not assignable to string index type 'number'.
+tests/cases/compiler/propertiesAndIndexers2.ts(12,5): error TS2411: Property 'NaN' of type 'string' is not assignable to string index type 'number'.
+tests/cases/compiler/propertiesAndIndexers2.ts(13,5): error TS2411: Property '"-NaN"' of type 'string' is not assignable to string index type 'number'.
+tests/cases/compiler/propertiesAndIndexers2.ts(14,5): error TS2411: Property '6' of type '() => string' is not assignable to string index type 'number'.
+tests/cases/compiler/propertiesAndIndexers2.ts(14,5): error TS2412: Property '6' of type '() => string' is not assignable to numeric index type 'string'.
+
+
+==== tests/cases/compiler/propertiesAndIndexers2.ts (9 errors) ====
+    interface A {
+        [n: number]: string;
+        ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2413: Numeric index type 'string' is not assignable to string index type 'number'.
+        [s: string]: number;
+    }
+    
+    // All of these should fail.
+    interface B extends A {
+        c: string;
+        ~~~~~~~~~~
+!!! error TS2411: Property 'c' of type 'string' is not assignable to string index type 'number'.
+        3: string;
+        ~~~~~~~~~~
+!!! error TS2411: Property '3' of type 'string' is not assignable to string index type 'number'.
+        Infinity: string;
+        ~~~~~~~~~~~~~~~~~
+!!! error TS2411: Property 'Infinity' of type 'string' is not assignable to string index type 'number'.
+        "-Infinity": string;
+        ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2411: Property '"-Infinity"' of type 'string' is not assignable to string index type 'number'.
+        NaN: string;
+        ~~~~~~~~~~~~
+!!! error TS2411: Property 'NaN' of type 'string' is not assignable to string index type 'number'.
+        "-NaN": string;
+        ~~~~~~~~~~~~~~~
+!!! error TS2411: Property '"-NaN"' of type 'string' is not assignable to string index type 'number'.
+        6(): string;
+        ~~~~~~~~~~~~
+!!! error TS2411: Property '6' of type '() => string' is not assignable to string index type 'number'.
+        ~~~~~~~~~~~~
+!!! error TS2412: Property '6' of type '() => string' is not assignable to numeric index type 'string'.
+    }
+    

tests/baselines/reference/propertiesAndIndexers2.js

@@ -0,0 +1,19 @@
+//// [propertiesAndIndexers2.ts]
+interface A {
+    [n: number]: string;
+    [s: string]: number;
+}
+
+// All of these should fail.
+interface B extends A {
+    c: string;
+    3: string;
+    Infinity: string;
+    "-Infinity": string;
+    NaN: string;
+    "-NaN": string;
+    6(): string;
+}
+
+
+//// [propertiesAndIndexers2.js]

tests/baselines/reference/propertiesAndIndexersForNumericNames.errors.txt

@@ -0,0 +1,69 @@
+tests/cases/compiler/propertiesAndIndexersForNumericNames.ts(6,5): error TS2412: Property '"1"' of type 'string' is not assignable to numeric index type 'number'.
+tests/cases/compiler/propertiesAndIndexersForNumericNames.ts(7,5): error TS2412: Property '"-1"' of type 'string' is not assignable to numeric index type 'number'.
+tests/cases/compiler/propertiesAndIndexersForNumericNames.ts(8,5): error TS2412: Property '"-2.5"' of type 'string' is not assignable to numeric index type 'number'.
+tests/cases/compiler/propertiesAndIndexersForNumericNames.ts(9,5): error TS2412: Property '"3.141592"' of type 'string' is not assignable to numeric index type 'number'.
+tests/cases/compiler/propertiesAndIndexersForNumericNames.ts(10,5): error TS2412: Property '"1.2e-20"' of type 'string' is not assignable to numeric index type 'number'.
+tests/cases/compiler/propertiesAndIndexersForNumericNames.ts(11,5): error TS2412: Property '"Infinity"' of type 'string' is not assignable to numeric index type 'number'.
+tests/cases/compiler/propertiesAndIndexersForNumericNames.ts(12,5): error TS2412: Property '"-Infinity"' of type 'string' is not assignable to numeric index type 'number'.
+tests/cases/compiler/propertiesAndIndexersForNumericNames.ts(13,5): error TS2412: Property '"NaN"' of type 'string' is not assignable to numeric index type 'number'.
+
+
+==== tests/cases/compiler/propertiesAndIndexersForNumericNames.ts (8 errors) ====
+    class C {
+        [i: number]: number;
+    
+        // These all have numeric names; they should error
+        // because their types are not compatible with the numeric indexer.
+        public "1": string = "number"; // Error
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2412: Property '"1"' of type 'string' is not assignable to numeric index type 'number'.
+        public "-1": string = "negative number"; // Error
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2412: Property '"-1"' of type 'string' is not assignable to numeric index type 'number'.
+        public "-2.5": string = "negative number"; // Error
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2412: Property '"-2.5"' of type 'string' is not assignable to numeric index type 'number'.
+        public "3.141592": string = "pi-sitive number"; // Error
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2412: Property '"3.141592"' of type 'string' is not assignable to numeric index type 'number'.
+        public "1.2e-20": string = "really small number"; // Error
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2412: Property '"1.2e-20"' of type 'string' is not assignable to numeric index type 'number'.
+        public "Infinity": string = "A gillion"; // Error
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2412: Property '"Infinity"' of type 'string' is not assignable to numeric index type 'number'.
+        public "-Infinity": string = "Negative-a-gillion"; // Error
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2412: Property '"-Infinity"' of type 'string' is not assignable to numeric index type 'number'.
+        public "NaN": string = "not a number"; // Error
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2412: Property '"NaN"' of type 'string' is not assignable to numeric index type 'number'.
+        
+        // These all have *partially* numeric names,
+        // but should really be treated as plain string literals.
+        public " 1": string = "leading space"; // No error
+        public "1    ": string = "trailing space"; // No error
+        public "": string = "no nothing"; // No error
+        public "    ": string = "just space"; // No error
+        public "1 0 1": string = "several numbers and spaces"; // No error
+        public "hunter2": string = "not a password"; // No error
+        public "+Infinity": string = "A gillion"; // No error
+        public "+NaN": string = "not a positive number"; // No error
+        public "-NaN": string = "not a negative number"; // No error
+        
+    
+        // These fall into the above category, however, they are "trickier";
+        // these all are *scanned* as numeric literals, but they are not written in
+        // "canonical" numeric representations.
+        public "+1": string = "positive number (for the paranoid)"; // No error
+        public "1e0": string = "just one"; // No error
+        public "-0": string = "just zero"; // No error
+        public "-0e0": string = "just zero"; // No error
+        public "0xF00D": string = "hex food"; // No error
+        public "0xBEEF": string = "hex beef"; // No error
+        public "0123": string = "oct 83"; // No error
+        public "0o123": string = "explicit oct 83"; // No error
+        public "0b101101001010": string = "explicit binary"; // No error
+        public "0.000000000000000000012": string = "should've been in exponential form"; // No error
+    }
+    

tests/baselines/reference/propertiesAndIndexersForNumericNames.js

@@ -0,0 +1,84 @@
+//// [propertiesAndIndexersForNumericNames.ts]
+class C {
+    [i: number]: number;
+
+    // These all have numeric names; they should error
+    // because their types are not compatible with the numeric indexer.
+    public "1": string = "number"; // Error
+    public "-1": string = "negative number"; // Error
+    public "-2.5": string = "negative number"; // Error
+    public "3.141592": string = "pi-sitive number"; // Error
+    public "1.2e-20": string = "really small number"; // Error
+    public "Infinity": string = "A gillion"; // Error
+    public "-Infinity": string = "Negative-a-gillion"; // Error
+    public "NaN": string = "not a number"; // Error
+    
+    // These all have *partially* numeric names,
+    // but should really be treated as plain string literals.
+    public " 1": string = "leading space"; // No error
+    public "1    ": string = "trailing space"; // No error
+    public "": string = "no nothing"; // No error
+    public "    ": string = "just space"; // No error
+    public "1 0 1": string = "several numbers and spaces"; // No error
+    public "hunter2": string = "not a password"; // No error
+    public "+Infinity": string = "A gillion"; // No error
+    public "+NaN": string = "not a positive number"; // No error
+    public "-NaN": string = "not a negative number"; // No error
+    
+
+    // These fall into the above category, however, they are "trickier";
+    // these all are *scanned* as numeric literals, but they are not written in
+    // "canonical" numeric representations.
+    public "+1": string = "positive number (for the paranoid)"; // No error
+    public "1e0": string = "just one"; // No error
+    public "-0": string = "just zero"; // No error
+    public "-0e0": string = "just zero"; // No error
+    public "0xF00D": string = "hex food"; // No error
+    public "0xBEEF": string = "hex beef"; // No error
+    public "0123": string = "oct 83"; // No error
+    public "0o123": string = "explicit oct 83"; // No error
+    public "0b101101001010": string = "explicit binary"; // No error
+    public "0.000000000000000000012": string = "should've been in exponential form"; // No error
+}
+
+
+//// [propertiesAndIndexersForNumericNames.js]
+var C = (function () {
+    function C() {
+        // These all have numeric names; they should error
+        // because their types are not compatible with the numeric indexer.
+        this["1"] = "number"; // Error
+        this["-1"] = "negative number"; // Error
+        this["-2.5"] = "negative number"; // Error
+        this["3.141592"] = "pi-sitive number"; // Error
+        this["1.2e-20"] = "really small number"; // Error
+        this["Infinity"] = "A gillion"; // Error
+        this["-Infinity"] = "Negative-a-gillion"; // Error
+        this["NaN"] = "not a number"; // Error
+        // These all have *partially* numeric names,
+        // but should really be treated as plain string literals.
+        this[" 1"] = "leading space"; // No error
+        this["1    "] = "trailing space"; // No error
+        this[""] = "no nothing"; // No error
+        this["    "] = "just space"; // No error
+        this["1 0 1"] = "several numbers and spaces"; // No error
+        this["hunter2"] = "not a password"; // No error
+        this["+Infinity"] = "A gillion"; // No error
+        this["+NaN"] = "not a positive number"; // No error
+        this["-NaN"] = "not a negative number"; // No error
+        // These fall into the above category, however, they are "trickier";
+        // these all are *scanned* as numeric literals, but they are not written in
+        // "canonical" numeric representations.
+        this["+1"] = "positive number (for the paranoid)"; // No error
+        this["1e0"] = "just one"; // No error
+        this["-0"] = "just zero"; // No error
+        this["-0e0"] = "just zero"; // No error
+        this["0xF00D"] = "hex food"; // No error
+        this["0xBEEF"] = "hex beef"; // No error
+        this["0123"] = "oct 83"; // No error
+        this["0o123"] = "explicit oct 83"; // No error
+        this["0b101101001010"] = "explicit binary"; // No error
+        this["0.000000000000000000012"] = "should've been in exponential form"; // No error
+    }
+    return C;
+})();

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, 

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
 

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
 

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[]
 

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
 

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
 

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[]
 

tests/baselines/reference/subtypingWithObjectMembersOptionality3.types

@@ -69,8 +69,8 @@ var b: { Foo2: Derived; }
 >Derived : Derived
 
 var r = true ? a : b; // ok
->r : { Foo?: Base; }
->true ? a : b : { Foo?: Base; }
+>r : { Foo?: Base; } | { Foo2: Derived; }
+>true ? a : b : { Foo?: Base; } | { Foo2: Derived; }
 >a : { Foo?: Base; }
 >b : { Foo2: Derived; }
 

tests/baselines/reference/subtypingWithObjectMembersOptionality4.types

@@ -69,8 +69,8 @@ var b: { Foo2?: Derived; }
 >Derived : Derived
 
 var r = true ? a : b; // ok
->r : { Foo2?: Derived; }
->true ? a : b : { Foo2?: Derived; }
+>r : { Foo: Base; } | { Foo2?: Derived; }
+>true ? a : b : { Foo: Base; } | { Foo2?: Derived; }
 >a : { Foo: Base; }
 >b : { Foo2?: Derived; }
 

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

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'.
     

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

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]/;

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'.
         }

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; }
 

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
 }

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

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

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
 

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;