Merge branch 'master' into sigHelp

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,7 +291,6 @@ 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;
     console.log(cmd);

doc/header.md

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

doc/spec.md

@@ -1155,8 +1155,8 @@ For purposes of property access (section [4.10](#4.10)) and function calls ([4.1
 When used as a contextual type (section [4.19](#4.19)), a union type *U* has those members that are present in any of its constituent types, with types that are unions of the respective members in the constituent types. Specifically:
 
 * Let *S* be the set of types in *U* that has a property *P*. If *S* is not empty, *U* has a property *P* of a union type of the types of *P* from each type in *S*.
-* Let *S* be the set of types in *U* that have call signatures. If *S* is not empty and the sets of call signatures of the types in *S* are identical ignoring return types,* U* has the same set of call signatures, but with return types that are unions of the return types of the respective call signatures from each type in *S*.
-* Let *S* be the set of types in *U* that have construct signatures. If *S* is not empty and the sets of construct signatures of the types in *S* are identical ignoring return types,* U* has the same set of construct signatures, but with return types that are unions of the return types of the respective construct signatures from each type in *S*.
+* Let *S* be the set of types in *U* that have call signatures. If *S* is not empty and the sets of call signatures of the types in *S* are identical ignoring return types, *U* has the same set of call signatures, but with return types that are unions of the return types of the respective call signatures from each type in *S*.
+* Let *S* be the set of types in *U* that have construct signatures. If *S* is not empty and the sets of construct signatures of the types in *S* are identical ignoring return types, *U* has the same set of construct signatures, but with return types that are unions of the return types of the respective construct signatures from each type in *S*.
 * Let *S* be the set of types in *U* that has a string index signature. If *S* is not empty, *U* has a string index signature of a union type of the types of the string index signatures from each type in *S*.
 * Let *S* be the set of types in *U* that has a numeric index signature. If *S* is not empty, *U* has a numeric index signature of a union type of the types of the numeric index signatures from each type in *S*.
 
@@ -1349,16 +1349,33 @@ class G<T> {               // Introduce type parameter T
 Types are specified either by referencing their keyword or name, or by writing object type literals, array type literals, tuple type literals, function type literals, constructor type literals, or type queries.
 
 &emsp;&emsp;*Type:*  
+&emsp;&emsp;&emsp;*PrimaryOrUnionType*  
+&emsp;&emsp;&emsp;*FunctionType*  
+&emsp;&emsp;&emsp;*ConstructorType*
+
+&emsp;&emsp;*PrimaryOrUnionType:*  
+&emsp;&emsp;&emsp;*PrimaryType*  
+&emsp;&emsp;&emsp;*UnionType*
+
+&emsp;&emsp;*PrimaryType:*  
+&emsp;&emsp;&emsp;*ParenthesizedType*  
 &emsp;&emsp;&emsp;*PredefinedType*  
 &emsp;&emsp;&emsp;*TypeReference*  
 &emsp;&emsp;&emsp;*ObjectType*  
 &emsp;&emsp;&emsp;*ArrayType*  
 &emsp;&emsp;&emsp;*TupleType*  
-&emsp;&emsp;&emsp;*UnionType*  
-&emsp;&emsp;&emsp;*FunctionType*  
-&emsp;&emsp;&emsp;*ConstructorType*  
 &emsp;&emsp;&emsp;*TypeQuery*
 
+&emsp;&emsp;*ParenthesizedType:*  
+&emsp;&emsp;&emsp;`(`&emsp;*Type*&emsp;`)`
+
+Parentheses are required around union, function, or constructor types when they are used as array element types, and parentheses are required around function or constructor types in union types. For example:
+
+```TypeScript
+(string | number)[]  
+((x: string) => string) | (x: number) => number)
+```
+
 The different forms of type notations are described in the following sections.
 
 ### <a name="3.6.1"/>3.6.1 Predefined Types
@@ -1461,36 +1478,24 @@ The members of an object type literal are specified as a combination of property
 An array type literal is written as an element type followed by an open and close square bracket.
 
 &emsp;&emsp;*ArrayType:*  
-&emsp;&emsp;&emsp;*ElementType*&emsp;*[no LineTerminator here]*&emsp;`[`&emsp;`]`
-
-&emsp;&emsp;*ElementType:*  
-&emsp;&emsp;&emsp;*PredefinedType*  
-&emsp;&emsp;&emsp;*TypeReference*  
-&emsp;&emsp;&emsp;*ObjectType*  
-&emsp;&emsp;&emsp;*ArrayType*  
-&emsp;&emsp;&emsp;*TupleType*  
-&emsp;&emsp;&emsp;*TypeQuery*
+&emsp;&emsp;&emsp;*PrimaryType*&emsp;*[no LineTerminator here]*&emsp;`[`&emsp;`]`
 
 An array type literal references an array type (section [3.3.2](#3.3.2)) with the given element type. An array type literal is simply shorthand notation for a reference to the generic interface type 'Array' in the global module with the element type as a type argument.
 
-In order to avoid grammar ambiguities, array type literals permit only a restricted set of notations for the element type. Specifically, an *ArrayType* cannot start with a *UnionType*, *FunctionType* or *ConstructorType*. To use one of those forms for the element type, an array type must be written using the 'Array&lt;T>' notation. For example, the type
+When union, function, or constructor types are used as array element types they must be enclosed in parentheses. For example:
 
 ```TypeScript
-() => string[]
+(string | number)[]  
+(() => string))[]
 ```
 
-denotes a function returning a string array, not an array of functions returning string. The latter can be expressed using 'Array&lt;T>' notation
+Alternatively, array types can be written using the 'Array&lt;T>' notation. For example, the types above are equivalent to
 
 ```TypeScript
+Array<string | number>  
 Array<() => string>
 ```
 
-or by writing the element type as an object type literal
-
-```TypeScript
-{ (): string }[]
-```
-
 ### <a name="3.6.5"/>3.6.5 Tuple Type Literals
 
 A tuple type literal is written as a sequence of element types, separated by commas and enclosed in square brackets.
@@ -1512,28 +1517,22 @@ A tuple type literal references a tuple type (section [3.3.3](#3.3.3)).
 A union type literal is written as a sequence of types separated by vertical bars.
 
 &emsp;&emsp;*UnionType:*  
-&emsp;&emsp;&emsp;*ElementType*&emsp;`|`&emsp;*UnionOrElementType*
-
-&emsp;&emsp;*UnionOrElementType:*  
-&emsp;&emsp;&emsp;*UnionType*  
-&emsp;&emsp;&emsp;*ElementType*
+&emsp;&emsp;&emsp;*PrimaryOrUnionType*&emsp;`|`&emsp;*PrimaryType*
 
 A union typle literal references a union type (section [3.3.4](#3.3.4)).
 
-In order to avoid grammar ambiguities, union type literals permit only a restricted set of notations for the element types. Specifically, an element of a *UnionType* cannot be written as a *FunctionType* or *ConstructorType*. To include function or constructor types in a union type the function or constructor types must be written as object type literals. For example
+When function or constructor types are included in union types they must be enclosed in parentheses. For example:
 
 ```TypeScript
-() => string | () => number
+((x: string) => string) | ((x: number) => number)
 ```
 
-denotes a function whose return value is either a string or a function returning number, whereas
+Alternatively, function or constructor types in union types can be written using object literals:
 
 ```TypeScript
-{ (): string } | { (): number }
+{ (x: string): string } | { (x: number): number }
 ```
 
-denotes either a function returning string or a function returning number.
-
 ### <a name="3.6.7"/>3.6.7 Function Type Literals
 
 A function type literal specifies the type parameters, regular parameters, and return type of a call signature.
@@ -2221,8 +2220,8 @@ The resulting type an array literal expression is determined as follows:
 The rules above mean that an array literal is always of an array type, unless it is contextually typed by a type with numerically named properties (such as a tuple type). For example
 
 ```TypeScript
-var a = [1, 2];                          // Array<number>  
-var b = ["hello", true];                 // Array<string | boolean>  
+var a = [1, 2];                          // number[]  
+var b = ["hello", true];                 // (string | boolean)[]  
 var c: [number, string] = [3, "three"];  // [number, string]
 ```
 
@@ -5170,16 +5169,26 @@ This appendix contains a summary of the grammar found in the main document. As d
 &emsp;&emsp;&emsp;*Type*
 
 &emsp;&emsp;*Type:*  
+&emsp;&emsp;&emsp;*PrimaryOrUnionType*  
+&emsp;&emsp;&emsp;*FunctionType*  
+&emsp;&emsp;&emsp;*ConstructorType*
+
+&emsp;&emsp;*PrimaryOrUnionType:*  
+&emsp;&emsp;&emsp;*PrimaryType*  
+&emsp;&emsp;&emsp;*UnionType*
+
+&emsp;&emsp;*PrimaryType:*  
+&emsp;&emsp;&emsp;*ParenthesizedType*  
 &emsp;&emsp;&emsp;*PredefinedType*  
 &emsp;&emsp;&emsp;*TypeReference*  
 &emsp;&emsp;&emsp;*ObjectType*  
 &emsp;&emsp;&emsp;*ArrayType*  
 &emsp;&emsp;&emsp;*TupleType*  
-&emsp;&emsp;&emsp;*UnionType*  
-&emsp;&emsp;&emsp;*FunctionType*  
-&emsp;&emsp;&emsp;*ConstructorType*  
 &emsp;&emsp;&emsp;*TypeQuery*
 
+&emsp;&emsp;*ParenthesizedType:*  
+&emsp;&emsp;&emsp;`(`&emsp;*Type*&emsp;`)`
+
 &emsp;&emsp;*PredefinedType:*  
 &emsp;&emsp;&emsp;`any`  
 &emsp;&emsp;&emsp;`number`  
@@ -5216,15 +5225,7 @@ This appendix contains a summary of the grammar found in the main document. As d
 &emsp;&emsp;&emsp;*MethodSignature*
 
 &emsp;&emsp;*ArrayType:*  
-&emsp;&emsp;&emsp;*ElementType*&emsp;*[no LineTerminator here]*&emsp;`[`&emsp;`]`
-
-&emsp;&emsp;*ElementType:*  
-&emsp;&emsp;&emsp;*PredefinedType*  
-&emsp;&emsp;&emsp;*TypeReference*  
-&emsp;&emsp;&emsp;*ObjectType*  
-&emsp;&emsp;&emsp;*ArrayType*  
-&emsp;&emsp;&emsp;*TupleType*  
-&emsp;&emsp;&emsp;*TypeQuery*
+&emsp;&emsp;&emsp;*PrimaryType*&emsp;*[no LineTerminator here]*&emsp;`[`&emsp;`]`
 
 &emsp;&emsp;*TupleType:*  
 &emsp;&emsp;&emsp;`[`&emsp;*TupleElementTypes*&emsp;`]`
@@ -5237,11 +5238,7 @@ This appendix contains a summary of the grammar found in the main document. As d
 &emsp;&emsp;&emsp;*Type*
 
 &emsp;&emsp;*UnionType:*  
-&emsp;&emsp;&emsp;*ElementType*&emsp;`|`&emsp;*UnionOrElementType*
-
-&emsp;&emsp;*UnionOrElementType:*  
-&emsp;&emsp;&emsp;*UnionType*  
-&emsp;&emsp;&emsp;*ElementType*
+&emsp;&emsp;&emsp;*PrimaryOrUnionType*&emsp;`|`&emsp;*PrimaryType*
 
 &emsp;&emsp;*FunctionType:*  
 &emsp;&emsp;&emsp;*TypeParameters<sub>opt</sub>*&emsp;`(`&emsp;*ParameterList<sub>opt</sub>*&emsp;`)`&emsp;`=>`&emsp;*Type*

src/compiler/checker.ts

@@ -1087,18 +1087,19 @@ module ts {
                 return appendParentTypeArgumentsAndSymbolName(symbol);
             }
 
-            function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, typeStack?: Type[]) {
-                return writeType(type, flags | TypeFormatFlags.WriteArrowStyleSignature);
+            function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, typeStack?: Type[]) {
+                var globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike;
+                return writeType(type, globalFlags);
 
                 function writeType(type: Type, flags: TypeFormatFlags) {
                     // Write undefined/null type as any
                     if (type.flags & TypeFlags.Intrinsic) {
                         // Special handling for unknown / resolving types, they should show up as any and not unknown or __resolving
-                        writer.writeKeyword(!(flags & TypeFormatFlags.WriteOwnNameForAnyLike) &&
+                        writer.writeKeyword(!(globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike) &&
                             (type.flags & TypeFlags.Any) ? "any" : (<IntrinsicType>type).intrinsicName);
                     }
                     else if (type.flags & TypeFlags.Reference) {
-                        writeTypeReference(<TypeReference>type);
+                        writeTypeReference(<TypeReference>type, flags);
                     }
                     else if (type.flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) {
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type);
@@ -1107,7 +1108,7 @@ module ts {
                         writeTupleType(<TupleType>type);
                     }
                     else if (type.flags & TypeFlags.Union) {
-                        writeUnionType(<UnionType>type);
+                        writeUnionType(<UnionType>type, flags);
                     }
                     else if (type.flags & TypeFlags.Anonymous) {
                         writeAnonymousType(<ObjectType>type, flags);
@@ -1135,17 +1136,13 @@ module ts {
                             writePunctuation(writer, union ? SyntaxKind.BarToken : SyntaxKind.CommaToken);
                             writeSpace(writer);
                         }
-                        // Don't output function type literals in unions because '() => string | () => number' would be parsed
-                        // as a function type that returns a union type. Instead output '{ (): string; } | { (): number; }'.
-                        writeType(types[i], union ? flags & ~TypeFormatFlags.WriteArrowStyleSignature : flags | TypeFormatFlags.WriteArrowStyleSignature);
+                        writeType(types[i], union ? TypeFormatFlags.InElementType : TypeFormatFlags.None);
                     }
                 }
 
-                function writeTypeReference(type: TypeReference) {
-                    if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType) && !(type.typeArguments[0].flags & TypeFlags.Union)) {
-                        // If we are writing array element type the arrow style signatures are not allowed as 
-                        // we need to surround it by curlies, e.g. { (): T; }[]; as () => T[] would mean something different
-                        writeType(type.typeArguments[0], flags & ~TypeFormatFlags.WriteArrowStyleSignature);
+                function writeTypeReference(type: TypeReference, flags: TypeFormatFlags) {
+                    if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
+                        writeType(type.typeArguments[0], TypeFormatFlags.InElementType);
                         writePunctuation(writer, SyntaxKind.OpenBracketToken);
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                     }
@@ -1163,8 +1160,14 @@ module ts {
                     writePunctuation(writer, SyntaxKind.CloseBracketToken);
                 }
 
-                function writeUnionType(type: UnionType) {
+                function writeUnionType(type: UnionType, flags: TypeFormatFlags) {
+                    if (flags & TypeFormatFlags.InElementType) {
+                        writePunctuation(writer, SyntaxKind.OpenParenToken);
+                    }
                     writeTypeList(type.types, /*union*/ true);
+                    if (flags & TypeFormatFlags.InElementType) {
+                        writePunctuation(writer, SyntaxKind.CloseParenToken);
+                    }
                 }
 
                 function writeAnonymousType(type: ObjectType, flags: TypeFormatFlags) {
@@ -1222,17 +1225,27 @@ module ts {
                             return;
                         }
 
-                        if (flags & TypeFormatFlags.WriteArrowStyleSignature) {
-                            if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
-                                buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, flags, typeStack);
-                                return;
+                        if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
+                            if (flags & TypeFormatFlags.InElementType) {
+                                writePunctuation(writer, SyntaxKind.OpenParenToken);
                             }
-                            if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
-                                writeKeyword(writer, SyntaxKind.NewKeyword);
-                                writeSpace(writer);
-                                buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, flags, typeStack);
-                                return;
+                            buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | TypeFormatFlags.WriteArrowStyleSignature , typeStack);
+                            if (flags & TypeFormatFlags.InElementType) {
+                                writePunctuation(writer, SyntaxKind.CloseParenToken);
                             }
+                            return;
+                        }
+                        if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
+                            if (flags & TypeFormatFlags.InElementType) {
+                                writePunctuation(writer, SyntaxKind.OpenParenToken);
+                            }
+                            writeKeyword(writer, SyntaxKind.NewKeyword);
+                            writeSpace(writer);
+                            buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | TypeFormatFlags.WriteArrowStyleSignature, typeStack);
+                            if (flags & TypeFormatFlags.InElementType) {
+                                writePunctuation(writer, SyntaxKind.CloseParenToken);
+                            }
+                            return;
                         }
                     }
 
@@ -1240,7 +1253,7 @@ module ts {
                     writer.writeLine();
                     writer.increaseIndent();
                     for (var i = 0; i < resolved.callSignatures.length; i++) {
-                        buildSignatureDisplay(resolved.callSignatures[i], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
+                        buildSignatureDisplay(resolved.callSignatures[i], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
@@ -1248,7 +1261,7 @@ module ts {
                         writeKeyword(writer, SyntaxKind.NewKeyword);
                         writeSpace(writer);
 
-                        buildSignatureDisplay(resolved.constructSignatures[i], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
+                        buildSignatureDisplay(resolved.constructSignatures[i], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
@@ -1262,7 +1275,7 @@ module ts {
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                         writePunctuation(writer, SyntaxKind.ColonToken);
                         writeSpace(writer);
-                        writeType(resolved.stringIndexType, flags | TypeFormatFlags.WriteArrowStyleSignature);
+                        writeType(resolved.stringIndexType, TypeFormatFlags.None);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
@@ -1276,7 +1289,7 @@ module ts {
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                         writePunctuation(writer, SyntaxKind.ColonToken);
                         writeSpace(writer);
-                        writeType(resolved.numberIndexType, flags | TypeFormatFlags.WriteArrowStyleSignature);
+                        writeType(resolved.numberIndexType, TypeFormatFlags.None);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
@@ -1290,7 +1303,7 @@ module ts {
                                 if (isOptionalProperty(p)) {
                                     writePunctuation(writer, SyntaxKind.QuestionToken);
                                 }
-                                buildSignatureDisplay(signatures[j], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
+                                buildSignatureDisplay(signatures[j], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
                                 writePunctuation(writer, SyntaxKind.SemicolonToken);
                                 writer.writeLine();
                             }
@@ -1302,7 +1315,7 @@ module ts {
                             }
                             writePunctuation(writer, SyntaxKind.ColonToken);
                             writeSpace(writer);
-                            writeType(t, flags | TypeFormatFlags.WriteArrowStyleSignature);
+                            writeType(t, TypeFormatFlags.None);
                             writePunctuation(writer, SyntaxKind.SemicolonToken);
                             writer.writeLine();
                         }
@@ -1366,7 +1379,7 @@ module ts {
                             writePunctuation(writer, SyntaxKind.CommaToken);
                             writeSpace(writer);
                         }
-                        buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, TypeFormatFlags.WriteArrowStyleSignature);
+                        buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, TypeFormatFlags.None);
                     }
                     writePunctuation(writer, SyntaxKind.GreaterThanToken);
                 }
@@ -2855,6 +2868,8 @@ module ts {
                     return getTypeFromTupleTypeNode(<TupleTypeNode>node);
                 case SyntaxKind.UnionType:
                     return getTypeFromUnionTypeNode(<UnionTypeNode>node);
+                case SyntaxKind.ParenType:
+                    return getTypeFromTypeNode((<ParenTypeNode>node).type);
                 case SyntaxKind.TypeLiteral:
                     return getTypeFromTypeLiteralNode(<TypeLiteralNode>node);
                 // This function assumes that an identifier or qualified name is a type expression
@@ -3381,7 +3396,7 @@ module ts {
                     var sourceProp = getPropertyOfApparentType(<ApparentType>source, targetProp.name);
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
-                            if (!isOptionalProperty(targetProp)) {
+                            if (relation === subtypeRelation || !isOptionalProperty(targetProp)) {
                                 if (reportErrors) {
                                     reportError(Diagnostics.Property_0_is_missing_in_type_1, symbolToString(targetProp), typeToString(source));
                                 }
@@ -3670,10 +3685,6 @@ module ts {
             return forEach(types, t => isSupertypeOfEach(t, types) ? t : undefined);
         }
 
-        function getBestCommonType(types: Type[], contextualType: Type): Type {
-            return contextualType && isSupertypeOfEach(contextualType, types) ? contextualType : getUnionType(types);
-        }
-
         function isTypeOfObjectLiteral(type: Type): boolean {
             return (type.flags & TypeFlags.Anonymous) && type.symbol && (type.symbol.flags & SymbolFlags.ObjectLiteral) ? true : false;
         }
@@ -3782,11 +3793,12 @@ module ts {
             }
         }
 
-        function createInferenceContext(typeParameters: TypeParameter[]): InferenceContext {
+        function createInferenceContext(typeParameters: TypeParameter[], inferUnionTypes: boolean): InferenceContext {
             var inferences: Type[][] = [];
             for (var i = 0; i < typeParameters.length; i++) inferences.push([]);
             return {
                 typeParameters: typeParameters,
+                inferUnionTypes: inferUnionTypes,
                 inferenceCount: 0,
                 inferences: inferences,
                 inferredTypes: new Array(typeParameters.length),
@@ -3933,10 +3945,9 @@ module ts {
             if (!result) {
                 var inferences = context.inferences[index];
                 if (inferences.length) {
-                    // Find type that is supertype of all others
-                    var supertype = getCommonSupertype(inferences);
-                    // Infer widened supertype, or the undefined type for no common supertype
-                    var inferredType = supertype ? getWidenedType(supertype) : undefinedType;
+                    // Infer widened union or supertype, or the undefined type for no common supertype
+                    var unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences);
+                    var inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : undefinedType;
                 }
                 else {
                     // Infer the empty object type when no inferences were made
@@ -5000,7 +5011,7 @@ module ts {
 
         // Instantiate a generic signature in the context of a non-generic signature (section 3.8.5 in TypeScript spec)
         function instantiateSignatureInContextOf(signature: Signature, contextualSignature: Signature, contextualMapper: TypeMapper): Signature {
-            var context = createInferenceContext(signature.typeParameters);
+            var context = createInferenceContext(signature.typeParameters, /*inferUnionTypes*/ true);
             forEachMatchingParameterType(contextualSignature, signature, (source, target) => {
                 // Type parameters from outer context referenced by source type are fixed by instantiation of the source type
                 inferTypes(context, instantiateType(source, contextualMapper), target);
@@ -5010,7 +5021,7 @@ module ts {
 
         function inferTypeArguments(signature: Signature, args: Expression[], excludeArgument?: boolean[]): Type[] {
             var typeParameters = signature.typeParameters;
-            var context = createInferenceContext(typeParameters);
+            var context = createInferenceContext(typeParameters, /*inferUnionTypes*/ false);
             var mapper = createInferenceMapper(context);
             // First infer from arguments that are not context sensitive
             for (var i = 0; i < args.length; i++) {
@@ -5760,7 +5771,7 @@ module ts {
                 case SyntaxKind.GreaterThanToken:
                 case SyntaxKind.LessThanEqualsToken:
                 case SyntaxKind.GreaterThanEqualsToken:
-                    if (!isTypeSubtypeOf(leftType, rightType) && !isTypeSubtypeOf(rightType, leftType)) {
+                    if (!isTypeAssignableTo(leftType, rightType) && !isTypeAssignableTo(rightType, leftType)) {
                         reportOperatorError();
                     }
                     return booleanType;
@@ -7504,6 +7515,8 @@ module ts {
                     return checkTupleType(<TupleTypeNode>node);
                 case SyntaxKind.UnionType:
                     return checkUnionType(<UnionTypeNode>node);
+                case SyntaxKind.ParenType:
+                    return checkSourceElement((<ParenTypeNode>node).type);
                 case SyntaxKind.FunctionDeclaration:
                     return checkFunctionDeclaration(<FunctionDeclaration>node);
                 case SyntaxKind.Block:

src/compiler/emitter.ts

@@ -2868,7 +2868,7 @@ module ts {
                         }
                         return {
                             diagnosticMessage: diagnosticMessage,
-                            errorNode: node.parameters[0],
+                            errorNode: <Node>node.parameters[0],
                             typeName: node.name
                         };
                     }
@@ -2889,7 +2889,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:
@@ -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;
         }

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,
@@ -342,6 +343,10 @@ module ts {
         types: NodeArray<TypeNode>;
     }
 
+    export interface ParenTypeNode extends TypeNode {
+        type: TypeNode;
+    }
+
     export interface StringLiteralTypeNode extends TypeNode {
         text: string;
     }
@@ -707,6 +712,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 {
@@ -1014,6 +1020,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

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

tests/baselines/reference/vardecl.types

@@ -107,7 +107,7 @@ var n2: {
     (): void;
 }
 var n4: {
->n4 : { (): void; }[]
+>n4 : (() => void)[]
 
     (): void;
 }[];

tests/cases/conformance/types/specifyingTypes/typeLiterals/parenthesizedTypes.ts

@@ -0,0 +1,27 @@
+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)))];

tests/cases/conformance/types/typeRelationships/typeInference/contextualSignatureInstantiation.ts

@@ -0,0 +1,28 @@
+// 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[]

tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts

@@ -28,7 +28,7 @@ goTo.marker('2');
 verify.quickInfoIs('(var) c1: {\n    name: string;\n    age: number;\n}[]');
 
 goTo.marker('3');
-verify.quickInfoIs('(var) c2: Array<{\n\
+verify.quickInfoIs('(var) c2: ({\n\
     name: string;\n\
     age: number;\n\
     address: string;\n\
@@ -36,7 +36,7 @@ verify.quickInfoIs('(var) c2: Array<{\n\
     name: string;\n\
     age: number;\n\
     dob: Date;\n\
-}>');
+})[]');
 
 goTo.marker('4');
 verify.quickInfoIs('(var) c2a: {\n    name: string;\n    age: number;\n}[]');

tests/cases/fourslash/contextualTyping.ts

@@ -242,7 +242,7 @@ verify.quickInfoIs("(var) c3t9: number[][]");
 goTo.marker('23');
 verify.quickInfoIs("(var) c3t10: IFoo[]");
 goTo.marker('24');
-verify.quickInfoIs("(var) c3t11: {\n    (n: number, s: string): string;\n}[]");
+verify.quickInfoIs("(var) c3t11: ((n: number, s: string) => string)[]");
 goTo.marker('25');
 verify.quickInfoIs("(parameter) n: number");
 goTo.marker('26');
@@ -314,7 +314,7 @@ verify.quickInfoIs("(property) t9: number[][]");
 goTo.marker('59');
 verify.quickInfoIs("(property) t10: IFoo[]");
 goTo.marker('60');
-verify.quickInfoIs("(property) t11: {\n    (n: number, s: string): string;\n}[]");
+verify.quickInfoIs("(property) t11: ((n: number, s: string) => string)[]");
 goTo.marker('61');
 verify.quickInfoIs("(parameter) n: number");
 goTo.marker('62');
@@ -374,7 +374,7 @@ verify.quickInfoIs("(var) c12t9: number[][]");
 goTo.marker('89');
 verify.quickInfoIs("(var) c12t10: IFoo[]");
 goTo.marker('90');
-verify.quickInfoIs("(var) c12t11: {\n    (n: number, s: string): string;\n}[]");
+verify.quickInfoIs("(var) c12t11: ((n: number, s: string) => string)[]");
 goTo.marker('91');
 verify.quickInfoIs("(parameter) n: number");
 goTo.marker('92');

tests/cases/fourslash/genericTypeArgumentInference1.ts

@@ -20,7 +20,7 @@
 goTo.marker('1');
 verify.quickInfoIs('(var) r: string | number | boolean');
 goTo.marker('11');
-verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: Array<string | number | boolean>, iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
+verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: (string | number | boolean)[], iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
 
 goTo.marker('2');
 verify.quickInfoIs('(var) r2: boolean');

tests/cases/fourslash/genericTypeArgumentInference2.ts

@@ -20,7 +20,7 @@
 goTo.marker('1');
 verify.quickInfoIs('(var) r: string | number | boolean');
 goTo.marker('11');
-verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: Array<string | number | boolean>, iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
+verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: (string | number | boolean)[], iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
 
 goTo.marker('2');
 verify.quickInfoIs('(var) r2: boolean');