mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-02-05 08:11:30 -06:00
Merge branch 'master' into optionalPropertySubtyping
Conflicts: tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
This commit is contained in:
Anders Hejlsberg
commit
ff20df7a4a
2
Jakefile
2
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);
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -1,2 +0,0 @@
|
||||
# TypeScript Language Specification
|
||||
|
||||
103
doc/spec.md
103
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.
|
||||
|
||||
  *Type:*
|
||||
   *PrimaryOrUnionType*
|
||||
   *FunctionType*
|
||||
   *ConstructorType*
|
||||
|
||||
  *PrimaryOrUnionType:*
|
||||
   *PrimaryType*
|
||||
   *UnionType*
|
||||
|
||||
  *PrimaryType:*
|
||||
   *ParenthesizedType*
|
||||
   *PredefinedType*
|
||||
   *TypeReference*
|
||||
   *ObjectType*
|
||||
   *ArrayType*
|
||||
   *TupleType*
|
||||
   *UnionType*
|
||||
   *FunctionType*
|
||||
   *ConstructorType*
|
||||
   *TypeQuery*
|
||||
|
||||
  *ParenthesizedType:*
|
||||
   `(` *Type* `)`
|
||||
|
||||
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.
|
||||
|
||||
  *ArrayType:*
|
||||
   *ElementType* *[no LineTerminator here]* `[` `]`
|
||||
|
||||
  *ElementType:*
|
||||
   *PredefinedType*
|
||||
   *TypeReference*
|
||||
   *ObjectType*
|
||||
   *ArrayType*
|
||||
   *TupleType*
|
||||
   *TypeQuery*
|
||||
   *PrimaryType* *[no LineTerminator here]* `[` `]`
|
||||
|
||||
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<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<T>' notation
|
||||
Alternatively, array types can be written using the 'Array<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.
|
||||
|
||||
  *UnionType:*
|
||||
   *ElementType* `|` *UnionOrElementType*
|
||||
|
||||
  *UnionOrElementType:*
|
||||
   *UnionType*
|
||||
   *ElementType*
|
||||
   *PrimaryOrUnionType* `|` *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
|
||||
   *Type*
|
||||
|
||||
  *Type:*
|
||||
   *PrimaryOrUnionType*
|
||||
   *FunctionType*
|
||||
   *ConstructorType*
|
||||
|
||||
  *PrimaryOrUnionType:*
|
||||
   *PrimaryType*
|
||||
   *UnionType*
|
||||
|
||||
  *PrimaryType:*
|
||||
   *ParenthesizedType*
|
||||
   *PredefinedType*
|
||||
   *TypeReference*
|
||||
   *ObjectType*
|
||||
   *ArrayType*
|
||||
   *TupleType*
|
||||
   *UnionType*
|
||||
   *FunctionType*
|
||||
   *ConstructorType*
|
||||
   *TypeQuery*
|
||||
|
||||
  *ParenthesizedType:*
|
||||
   `(` *Type* `)`
|
||||
|
||||
  *PredefinedType:*
|
||||
   `any`
|
||||
   `number`
|
||||
@ -5216,15 +5225,7 @@ This appendix contains a summary of the grammar found in the main document. As d
|
||||
   *MethodSignature*
|
||||
|
||||
  *ArrayType:*
|
||||
   *ElementType* *[no LineTerminator here]* `[` `]`
|
||||
|
||||
  *ElementType:*
|
||||
   *PredefinedType*
|
||||
   *TypeReference*
|
||||
   *ObjectType*
|
||||
   *ArrayType*
|
||||
   *TupleType*
|
||||
   *TypeQuery*
|
||||
   *PrimaryType* *[no LineTerminator here]* `[` `]`
|
||||
|
||||
  *TupleType:*
|
||||
   `[` *TupleElementTypes* `]`
|
||||
@ -5237,11 +5238,7 @@ This appendix contains a summary of the grammar found in the main document. As d
|
||||
   *Type*
|
||||
|
||||
  *UnionType:*
|
||||
   *ElementType* `|` *UnionOrElementType*
|
||||
|
||||
  *UnionOrElementType:*
|
||||
   *UnionType*
|
||||
   *ElementType*
|
||||
   *PrimaryOrUnionType* `|` *PrimaryType*
|
||||
|
||||
  *FunctionType:*
|
||||
   *TypeParameters<sub>opt</sub>* `(` *ParameterList<sub>opt</sub>* `)` `=>` *Type*
|
||||
|
||||
@ -1077,18 +1077,19 @@ module ts {
|
||||
return writeSymbolName(symbol);
|
||||
}
|
||||
|
||||
function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, typeStack?: Type[]) {
|
||||
return writeType(type, flags | TypeFormatFlags.WriteArrowStyleSignature);
|
||||
function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, typeStack?: Type[]) {
|
||||
var globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike;
|
||||
return writeType(type, globalFlags);
|
||||
|
||||
function writeType(type: Type, flags: TypeFormatFlags) {
|
||||
// Write undefined/null type as any
|
||||
if (type.flags & TypeFlags.Intrinsic) {
|
||||
// Special handling for unknown / resolving types, they should show up as any and not unknown or __resolving
|
||||
writer.writeKeyword(!(flags & TypeFormatFlags.WriteOwnNameForAnyLike) &&
|
||||
writer.writeKeyword(!(globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike) &&
|
||||
(type.flags & TypeFlags.Any) ? "any" : (<IntrinsicType>type).intrinsicName);
|
||||
}
|
||||
else if (type.flags & TypeFlags.Reference) {
|
||||
writeTypeReference(<TypeReference>type);
|
||||
writeTypeReference(<TypeReference>type, flags);
|
||||
}
|
||||
else if (type.flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) {
|
||||
buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type);
|
||||
@ -1097,7 +1098,7 @@ module ts {
|
||||
writeTupleType(<TupleType>type);
|
||||
}
|
||||
else if (type.flags & TypeFlags.Union) {
|
||||
writeUnionType(<UnionType>type);
|
||||
writeUnionType(<UnionType>type, flags);
|
||||
}
|
||||
else if (type.flags & TypeFlags.Anonymous) {
|
||||
writeAnonymousType(<ObjectType>type, flags);
|
||||
@ -1125,17 +1126,13 @@ module ts {
|
||||
writePunctuation(writer, union ? SyntaxKind.BarToken : SyntaxKind.CommaToken);
|
||||
writeSpace(writer);
|
||||
}
|
||||
// Don't output function type literals in unions because '() => string | () => number' would be parsed
|
||||
// as a function type that returns a union type. Instead output '{ (): string; } | { (): number; }'.
|
||||
writeType(types[i], union ? flags & ~TypeFormatFlags.WriteArrowStyleSignature : flags | TypeFormatFlags.WriteArrowStyleSignature);
|
||||
writeType(types[i], union ? TypeFormatFlags.InElementType : TypeFormatFlags.None);
|
||||
}
|
||||
}
|
||||
|
||||
function writeTypeReference(type: TypeReference) {
|
||||
if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType) && !(type.typeArguments[0].flags & TypeFlags.Union)) {
|
||||
// If we are writing array element type the arrow style signatures are not allowed as
|
||||
// we need to surround it by curlies, e.g. { (): T; }[]; as () => T[] would mean something different
|
||||
writeType(type.typeArguments[0], flags & ~TypeFormatFlags.WriteArrowStyleSignature);
|
||||
function writeTypeReference(type: TypeReference, flags: TypeFormatFlags) {
|
||||
if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
|
||||
writeType(type.typeArguments[0], TypeFormatFlags.InElementType);
|
||||
writePunctuation(writer, SyntaxKind.OpenBracketToken);
|
||||
writePunctuation(writer, SyntaxKind.CloseBracketToken);
|
||||
}
|
||||
@ -1153,8 +1150,14 @@ module ts {
|
||||
writePunctuation(writer, SyntaxKind.CloseBracketToken);
|
||||
}
|
||||
|
||||
function writeUnionType(type: UnionType) {
|
||||
function writeUnionType(type: UnionType, flags: TypeFormatFlags) {
|
||||
if (flags & TypeFormatFlags.InElementType) {
|
||||
writePunctuation(writer, SyntaxKind.OpenParenToken);
|
||||
}
|
||||
writeTypeList(type.types, /*union*/ true);
|
||||
if (flags & TypeFormatFlags.InElementType) {
|
||||
writePunctuation(writer, SyntaxKind.CloseParenToken);
|
||||
}
|
||||
}
|
||||
|
||||
function writeAnonymousType(type: ObjectType, flags: TypeFormatFlags) {
|
||||
@ -1212,17 +1215,27 @@ module ts {
|
||||
return;
|
||||
}
|
||||
|
||||
if (flags & TypeFormatFlags.WriteArrowStyleSignature) {
|
||||
if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
|
||||
buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, flags, typeStack);
|
||||
return;
|
||||
if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
|
||||
if (flags & TypeFormatFlags.InElementType) {
|
||||
writePunctuation(writer, SyntaxKind.OpenParenToken);
|
||||
}
|
||||
if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
|
||||
writeKeyword(writer, SyntaxKind.NewKeyword);
|
||||
writeSpace(writer);
|
||||
buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, flags, typeStack);
|
||||
return;
|
||||
buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | TypeFormatFlags.WriteArrowStyleSignature , typeStack);
|
||||
if (flags & TypeFormatFlags.InElementType) {
|
||||
writePunctuation(writer, SyntaxKind.CloseParenToken);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
|
||||
if (flags & TypeFormatFlags.InElementType) {
|
||||
writePunctuation(writer, SyntaxKind.OpenParenToken);
|
||||
}
|
||||
writeKeyword(writer, SyntaxKind.NewKeyword);
|
||||
writeSpace(writer);
|
||||
buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | TypeFormatFlags.WriteArrowStyleSignature, typeStack);
|
||||
if (flags & TypeFormatFlags.InElementType) {
|
||||
writePunctuation(writer, SyntaxKind.CloseParenToken);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1230,7 +1243,7 @@ module ts {
|
||||
writer.writeLine();
|
||||
writer.increaseIndent();
|
||||
for (var i = 0; i < resolved.callSignatures.length; i++) {
|
||||
buildSignatureDisplay(resolved.callSignatures[i], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
|
||||
buildSignatureDisplay(resolved.callSignatures[i], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
|
||||
writePunctuation(writer, SyntaxKind.SemicolonToken);
|
||||
writer.writeLine();
|
||||
}
|
||||
@ -1238,7 +1251,7 @@ module ts {
|
||||
writeKeyword(writer, SyntaxKind.NewKeyword);
|
||||
writeSpace(writer);
|
||||
|
||||
buildSignatureDisplay(resolved.constructSignatures[i], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
|
||||
buildSignatureDisplay(resolved.constructSignatures[i], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
|
||||
writePunctuation(writer, SyntaxKind.SemicolonToken);
|
||||
writer.writeLine();
|
||||
}
|
||||
@ -1252,7 +1265,7 @@ module ts {
|
||||
writePunctuation(writer, SyntaxKind.CloseBracketToken);
|
||||
writePunctuation(writer, SyntaxKind.ColonToken);
|
||||
writeSpace(writer);
|
||||
writeType(resolved.stringIndexType, flags | TypeFormatFlags.WriteArrowStyleSignature);
|
||||
writeType(resolved.stringIndexType, TypeFormatFlags.None);
|
||||
writePunctuation(writer, SyntaxKind.SemicolonToken);
|
||||
writer.writeLine();
|
||||
}
|
||||
@ -1266,7 +1279,7 @@ module ts {
|
||||
writePunctuation(writer, SyntaxKind.CloseBracketToken);
|
||||
writePunctuation(writer, SyntaxKind.ColonToken);
|
||||
writeSpace(writer);
|
||||
writeType(resolved.numberIndexType, flags | TypeFormatFlags.WriteArrowStyleSignature);
|
||||
writeType(resolved.numberIndexType, TypeFormatFlags.None);
|
||||
writePunctuation(writer, SyntaxKind.SemicolonToken);
|
||||
writer.writeLine();
|
||||
}
|
||||
@ -1280,7 +1293,7 @@ module ts {
|
||||
if (isOptionalProperty(p)) {
|
||||
writePunctuation(writer, SyntaxKind.QuestionToken);
|
||||
}
|
||||
buildSignatureDisplay(signatures[j], writer, enclosingDeclaration, flags & ~TypeFormatFlags.WriteArrowStyleSignature, typeStack);
|
||||
buildSignatureDisplay(signatures[j], writer, enclosingDeclaration, globalFlagsToPass, typeStack);
|
||||
writePunctuation(writer, SyntaxKind.SemicolonToken);
|
||||
writer.writeLine();
|
||||
}
|
||||
@ -1292,7 +1305,7 @@ module ts {
|
||||
}
|
||||
writePunctuation(writer, SyntaxKind.ColonToken);
|
||||
writeSpace(writer);
|
||||
writeType(t, flags | TypeFormatFlags.WriteArrowStyleSignature);
|
||||
writeType(t, TypeFormatFlags.None);
|
||||
writePunctuation(writer, SyntaxKind.SemicolonToken);
|
||||
writer.writeLine();
|
||||
}
|
||||
@ -1335,7 +1348,7 @@ module ts {
|
||||
writePunctuation(writer, SyntaxKind.CommaToken);
|
||||
writeSpace(writer);
|
||||
}
|
||||
buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, TypeFormatFlags.WriteArrowStyleSignature);
|
||||
buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, TypeFormatFlags.None);
|
||||
}
|
||||
writePunctuation(writer, SyntaxKind.GreaterThanToken);
|
||||
}
|
||||
@ -2831,6 +2844,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
|
||||
@ -7476,6 +7491,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:
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
@ -703,6 +708,7 @@ module ts {
|
||||
WriteArrowStyleSignature = 0x00000008, // Write arrow style signature
|
||||
WriteOwnNameForAnyLike = 0x00000010, // Write symbol's own name instead of 'any' for any like types (eg. unknown, __resolving__ etc)
|
||||
WriteTypeArgumentsOfSignature = 0x00000020, // Write the type arguments instead of type parameters of the signature
|
||||
InElementType = 0x00000040, // Writing an array or union element type
|
||||
}
|
||||
|
||||
export enum SymbolFormatFlags {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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)[]
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -17,27 +17,27 @@ var c: { x: number; a?: number };
|
||||
>a : number
|
||||
|
||||
var as = [a, b]; // { x: number; y?: number };[]
|
||||
>as : Array<{ x: number; y?: number; } | { x: number; z?: number; }>
|
||||
>[a, b] : Array<{ x: number; y?: number; } | { x: number; z?: 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 : Array<{ x: number; y?: number; } | { x: number; z?: number; }>
|
||||
>[b, a] : Array<{ x: number; y?: number; } | { x: number; z?: 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 : Array<{ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: number; }>
|
||||
>[a, b, c] : Array<{ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: 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 : Array<{ (a: { x: number; y?: number; }): number; } | { (b: { x: number; z?: number; }): number; }>
|
||||
>[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : Array<{ (a: { x: number; y?: number; }): number; } | { (b: { x: number; z?: 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 : Array<{ (b: { x: number; z?: number; }): number; } | { (a: { x: number; y?: number; }): number; }>
|
||||
>[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : Array<{ (b: { x: number; z?: number; }): number; } | { (a: { x: number; y?: 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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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>
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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]; // {}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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'.
|
||||
@ -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'.
|
||||
@ -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'.
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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; }'.
|
||||
@ -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
|
||||
|
||||
@ -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':
|
||||
|
||||
@ -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':
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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>>();;){}
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
|
||||
@ -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
|
||||
}
|
||||
}
|
||||
|
||||
@ -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: { () }
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -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
|
||||
|
||||
@ -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)[]
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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'.
|
||||
}
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
@ -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>>();
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
52
tests/baselines/reference/parenthesizedTypes.js
Normal file
52
tests/baselines/reference/parenthesizedTypes.js
Normal file
@ -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;
|
||||
84
tests/baselines/reference/parenthesizedTypes.types
Normal file
84
tests/baselines/reference/parenthesizedTypes.types
Normal file
@ -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
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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[]
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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[]
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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'.
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -219,7 +219,7 @@ throw [];
|
||||
>[] : undefined[]
|
||||
|
||||
throw ['a', ['b']];
|
||||
>['a', ['b']] : Array<string | string[]>
|
||||
>['a', ['b']] : (string | string[])[]
|
||||
>['b'] : string[]
|
||||
|
||||
throw /[a-z]/;
|
||||
|
||||
@ -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'.
|
||||
}
|
||||
|
||||
@ -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; }
|
||||
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -107,7 +107,7 @@ var n2: {
|
||||
(): void;
|
||||
}
|
||||
var n4: {
|
||||
>n4 : { (): void; }[]
|
||||
>n4 : (() => void)[]
|
||||
|
||||
(): void;
|
||||
}[];
|
||||
|
||||
@ -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)))];
|
||||
@ -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}[]');
|
||||
|
||||
@ -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');
|
||||
|
||||
@ -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');
|
||||
|
||||
@ -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');
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user