From 85d589431c5469117a1f0caece44c48bbdefcf38 Mon Sep 17 00:00:00 2001 From: Torben Fitschen Date: Fri, 9 Sep 2016 11:07:23 +0200 Subject: [PATCH 01/21] Added detection for case sensitive file systems --- src/compiler/sys.ts | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts index 437cf8e05ec..171f4439103 100644 --- a/src/compiler/sys.ts +++ b/src/compiler/sys.ts @@ -311,9 +311,19 @@ namespace ts { return parseInt(process.version.charAt(1)) >= 4; } + function isFileSystemCaseSensitive(): boolean { + // win32\win64 are case insensitive platforms + if (platform === "win32" || platform === "win64") { + return false; + } + + const upperCaseFilename = _path.basename(__filename).toUpperCase(); + + return !fileExists(_path.join(_path.dirname(__filename), upperCaseFilename)); + } + const platform: string = _os.platform(); - // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive - const useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin"; + const useCaseSensitiveFileNames = isFileSystemCaseSensitive(); function readFile(fileName: string, encoding?: string): string { if (!fileExists(fileName)) { From 8c70109d1855f9e60217f4a2068f07ba87474c6b Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 28 Sep 2016 09:52:08 -0700 Subject: [PATCH 02/21] Turn 3 type flags into properties 1. Instantiated (only modifies anonymous types) 2. ObjectLiteralWithComputedProperties (only modifies [resolved] object types) 3. ThisType (only modifies type parameters) This is needed for object spread and rest, which will each need a type flag. There are 4-5 other likely targets for removal, and I may remove those later. --- src/compiler/checker.ts | 44 +++++++++++++++++++++-------------------- src/compiler/types.ts | 20 ++++++++++--------- 2 files changed, 34 insertions(+), 30 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 61cf701eb95..e7fd07045ec 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2164,7 +2164,7 @@ namespace ts { ? "any" : (type).intrinsicName); } - else if (type.flags & TypeFlags.ThisType) { + else if (type.flags & TypeFlags.TypeParameter && (type as TypeParameter).isThisType) { if (inObjectTypeLiteral) { writer.reportInaccessibleThisError(); } @@ -3155,9 +3155,9 @@ namespace ts { } // Return the type implied by an object binding pattern - function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): Type { + function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): ResolvedType { const members = createMap(); - let hasComputedProperties = false; + let hasComputedProperties: boolean; forEach(pattern.elements, e => { const name = e.propertyName || e.name; if (isComputedNonLiteralName(name)) { @@ -3177,9 +3177,7 @@ namespace ts { if (includePatternInType) { result.pattern = pattern; } - if (hasComputedProperties) { - result.flags |= TypeFlags.ObjectLiteralPatternWithComputedProperties; - } + result.inObjectLiteralPatternWithComputedProperties = hasComputedProperties; return result; } @@ -3765,7 +3763,8 @@ namespace ts { (type).instantiations[getTypeListId(type.typeParameters)] = type; (type).target = type; (type).typeArguments = type.typeParameters; - type.thisType = createType(TypeFlags.TypeParameter | TypeFlags.ThisType); + type.thisType = createType(TypeFlags.TypeParameter); + type.thisType.isThisType = true; type.thisType.symbol = symbol; type.thisType.constraint = type; } @@ -4414,7 +4413,7 @@ namespace ts { * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the * type itself. Note that the apparent type of a union type is the union type itself. */ - function getApparentType(type: Type): Type { + function getApparentType(type: Type): ObjectType { if (type.flags & TypeFlags.TypeParameter) { type = getApparentTypeOfTypeParameter(type); } @@ -4967,7 +4966,7 @@ namespace ts { function hasConstraintReferenceTo(type: Type, target: TypeParameter): boolean { let checked: Type[]; - while (type && !(type.flags & TypeFlags.ThisType) && type.flags & TypeFlags.TypeParameter && !contains(checked, type)) { + while (type && type.flags & TypeFlags.TypeParameter && !((type as TypeParameter).isThisType) && !contains(checked, type)) { if (type === target) { return true; } @@ -5330,7 +5329,8 @@ namespace ts { type.instantiations[getTypeListId(type.typeParameters)] = type; type.target = type; type.typeArguments = type.typeParameters; - type.thisType = createType(TypeFlags.TypeParameter | TypeFlags.ThisType); + type.thisType = createType(TypeFlags.TypeParameter); + type.thisType.isThisType = true; type.thisType.constraint = type; type.declaredProperties = properties; type.declaredCallSignatures = emptyArray; @@ -5920,7 +5920,8 @@ namespace ts { mapper.instantiations = []; } // Mark the anonymous type as instantiated such that our infinite instantiation detection logic can recognize it - const result = createObjectType(TypeFlags.Anonymous | TypeFlags.Instantiated, type.symbol); + const result = createObjectType(TypeFlags.Anonymous, type.symbol); + result.isInstantiated = true; result.target = type; result.mapper = mapper; result.aliasSymbol = type.aliasSymbol; @@ -5992,7 +5993,7 @@ namespace ts { // instantiation. return type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) && - (type.flags & TypeFlags.Instantiated || isSymbolInScopeOfMappedTypeParameter(type.symbol, mapper)) ? + ((type as AnonymousType).isInstantiated || isSymbolInScopeOfMappedTypeParameter(type.symbol, mapper)) ? instantiateAnonymousType(type, mapper) : type; } if (type.flags & TypeFlags.Reference) { @@ -6646,7 +6647,7 @@ namespace ts { } function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean { - if (!(target.flags & TypeFlags.ObjectLiteralPatternWithComputedProperties) && maybeTypeOfKind(target, TypeFlags.ObjectType)) { + if (maybeTypeOfKind(target, TypeFlags.ObjectType) && !(target as ObjectType).inObjectLiteralPatternWithComputedProperties) { for (const prop of getPropertiesOfObjectType(source)) { if (!isKnownProperty(target, prop.name)) { if (reportErrors) { @@ -7140,12 +7141,12 @@ namespace ts { // some level beyond that. function isDeeplyNestedGeneric(type: Type, stack: Type[], depth: number): boolean { // We track type references (created by createTypeReference) and instantiated types (created by instantiateType) - if (type.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && depth >= 5) { + if ((type.flags & TypeFlags.Reference || type.flags & TypeFlags.Anonymous && (type as AnonymousType).isInstantiated) && depth >= 5) { const symbol = type.symbol; let count = 0; for (let i = 0; i < depth; i++) { const t = stack[i]; - if (t.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && t.symbol === symbol) { + if ((t.flags & TypeFlags.Reference || t.flags & TypeFlags.Anonymous && (t as AnonymousType).isInstantiated) && t.symbol === symbol) { count++; if (count >= 5) return true; } @@ -9937,7 +9938,7 @@ namespace ts { // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily // be "pushed" onto a node using the contextualType property. - function getApparentTypeOfContextualType(node: Expression): Type { + function getApparentTypeOfContextualType(node: Expression): ObjectType { const type = getContextualType(node); return type && getApparentType(type); } @@ -10271,7 +10272,7 @@ namespace ts { const contextualTypeHasPattern = contextualType && contextualType.pattern && (contextualType.pattern.kind === SyntaxKind.ObjectBindingPattern || contextualType.pattern.kind === SyntaxKind.ObjectLiteralExpression); let typeFlags: TypeFlags = 0; - let patternWithComputedProperties = false; + let patternWithComputedProperties: boolean | undefined; let hasComputedStringProperty = false; let hasComputedNumberProperty = false; @@ -10306,7 +10307,7 @@ namespace ts { patternWithComputedProperties = true; } } - else if (contextualTypeHasPattern && !(contextualType.flags & TypeFlags.ObjectLiteralPatternWithComputedProperties)) { + else if (contextualTypeHasPattern && !contextualType.inObjectLiteralPatternWithComputedProperties) { // If object literal is contextually typed by the implied type of a binding pattern, and if the // binding pattern specifies a default value for the property, make the property optional. const impliedProp = getPropertyOfType(contextualType, member.name); @@ -10371,7 +10372,8 @@ namespace ts { const numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, propertiesArray, IndexKind.Number) : undefined; const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo); const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshLiteral; - result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags) | (patternWithComputedProperties ? TypeFlags.ObjectLiteralPatternWithComputedProperties : 0); + result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags); + result.inObjectLiteralPatternWithComputedProperties = patternWithComputedProperties; if (inDestructuringPattern) { result.pattern = node; } @@ -10941,7 +10943,7 @@ namespace ts { return true; } // An instance property must be accessed through an instance of the enclosing class - if (type.flags & TypeFlags.ThisType) { + if (type.flags & TypeFlags.TypeParameter && (type as TypeParameter).isThisType) { // get the original type -- represented as the type constraint of the 'this' type type = getConstraintOfTypeParameter(type); } @@ -10991,7 +10993,7 @@ namespace ts { const prop = getPropertyOfType(apparentType, right.text); if (!prop) { if (right.text && !checkAndReportErrorForExtendingInterface(node)) { - reportNonexistentProperty(right, type.flags & TypeFlags.ThisType ? apparentType : type); + reportNonexistentProperty(right, type.flags & TypeFlags.TypeParameter && (type as TypeParameter).isThisType ? apparentType : type); } return unknownType; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index ab48ae543c2..a9529659b3e 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2382,19 +2382,16 @@ namespace ts { Union = 1 << 19, // Union (T | U) Intersection = 1 << 20, // Intersection (T & U) Anonymous = 1 << 21, // Anonymous - Instantiated = 1 << 22, // Instantiated anonymous type /* @internal */ - ObjectLiteral = 1 << 23, // Originates in an object literal + ObjectLiteral = 1 << 22, // Originates in an object literal /* @internal */ - FreshLiteral = 1 << 24, // Fresh literal type + FreshLiteral = 1 << 23, // Fresh literal type /* @internal */ - ContainsWideningType = 1 << 25, // Type is or contains undefined or null widening type + ContainsWideningType = 1 << 24, // Type is or contains undefined or null widening type /* @internal */ - ContainsObjectLiteral = 1 << 26, // Type is or contains object literal type + ContainsObjectLiteral = 1 << 25, // Type is or contains object literal type /* @internal */ - ContainsAnyFunctionType = 1 << 27, // Type is or contains object literal type - ThisType = 1 << 28, // This type - ObjectLiteralPatternWithComputedProperties = 1 << 29, // Object literal type implied by binding pattern has computed properties + ContainsAnyFunctionType = 1 << 26, // Type is or contains object literal type /* @internal */ Nullable = Undefined | Null, @@ -2463,7 +2460,9 @@ namespace ts { } // Object types (TypeFlags.ObjectType) - export interface ObjectType extends Type { } + export interface ObjectType extends Type { + inObjectLiteralPatternWithComputedProperties?: boolean; + } // Class and interface types (TypeFlags.Class and TypeFlags.Interface) export interface InterfaceType extends ObjectType { @@ -2519,6 +2518,7 @@ namespace ts { /* @internal */ // An instantiated anonymous type has a target and a mapper export interface AnonymousType extends ObjectType { + isInstantiated?: boolean; target?: AnonymousType; // Instantiation target mapper?: TypeMapper; // Instantiation mapper } @@ -2558,6 +2558,8 @@ namespace ts { mapper?: TypeMapper; // Instantiation mapper /* @internal */ resolvedApparentType: Type; + /* @internal */ + isThisType?: boolean; } export const enum SignatureKind { From 04b1c26120e190765f1ecdf0bf1df83d212ddf3f Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 28 Sep 2016 10:58:20 -0700 Subject: [PATCH 03/21] Added test. --- tests/cases/compiler/mapOnTupleTypes01.ts | 45 +++++++++++++++++++++++ tests/cases/compiler/mapOnTupleTypes02.ts | 9 +++++ 2 files changed, 54 insertions(+) create mode 100644 tests/cases/compiler/mapOnTupleTypes01.ts create mode 100644 tests/cases/compiler/mapOnTupleTypes02.ts diff --git a/tests/cases/compiler/mapOnTupleTypes01.ts b/tests/cases/compiler/mapOnTupleTypes01.ts new file mode 100644 index 00000000000..0a6ee2bda6a --- /dev/null +++ b/tests/cases/compiler/mapOnTupleTypes01.ts @@ -0,0 +1,45 @@ +// @declaration: true +// @noImplicitAny: true +// @strictNullChecks: true + +export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); + +// Length 1 + +let numTuple: [number] = [1]; +export let a = numTuple.map(x => x * x); + +// Length 2 + +let numNum: [number, number] = [ 100, 100]; +let strStr: [string, string] = ["hello", "hello"]; +let numStr: [number, string] = [ 100, "hello"]; + +export let b = numNum.map(n => n * n); +export let c = strStr.map(s => s.charCodeAt(0)); +export let d = numStr.map(x => x); + +// Length 3 + +let numNumNum: [number, number, number] = [1, 2, 3]; + +export let e = numNumNum.map(n => n * n); + +// Length 4 + +let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; + +export let f = numNumNumNum.map(n => n * n); + +// Length 5 + +let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; + +export let g = numNumNumNumNum.map(n => n * n); + + +// Length 6 + +let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6]; + +export let h = numNumNumNumNum.map(n => n * n); \ No newline at end of file diff --git a/tests/cases/compiler/mapOnTupleTypes02.ts b/tests/cases/compiler/mapOnTupleTypes02.ts new file mode 100644 index 00000000000..e4c30fa0e8f --- /dev/null +++ b/tests/cases/compiler/mapOnTupleTypes02.ts @@ -0,0 +1,9 @@ +// @declaration: true +// @noImplicitAny: true +// @strictNullChecks: true + +export type Point = [number, number]; + +export function increment(point: Point) { + return point.map(d => d + 1); +} \ No newline at end of file From d1416de4c7f769350e2b2154ffa1b587234766ee Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 29 Sep 2016 00:40:50 -0700 Subject: [PATCH 04/21] Accepted baselines. --- .../baselines/reference/mapOnTupleTypes01.js | 81 ++++++++ .../reference/mapOnTupleTypes01.symbols | 119 +++++++++++ .../reference/mapOnTupleTypes01.types | 184 ++++++++++++++++++ .../baselines/reference/mapOnTupleTypes02.js | 19 ++ .../reference/mapOnTupleTypes02.symbols | 17 ++ .../reference/mapOnTupleTypes02.types | 21 ++ 6 files changed, 441 insertions(+) create mode 100644 tests/baselines/reference/mapOnTupleTypes01.js create mode 100644 tests/baselines/reference/mapOnTupleTypes01.symbols create mode 100644 tests/baselines/reference/mapOnTupleTypes01.types create mode 100644 tests/baselines/reference/mapOnTupleTypes02.js create mode 100644 tests/baselines/reference/mapOnTupleTypes02.symbols create mode 100644 tests/baselines/reference/mapOnTupleTypes02.types diff --git a/tests/baselines/reference/mapOnTupleTypes01.js b/tests/baselines/reference/mapOnTupleTypes01.js new file mode 100644 index 00000000000..6c51cf3e6a3 --- /dev/null +++ b/tests/baselines/reference/mapOnTupleTypes01.js @@ -0,0 +1,81 @@ +//// [mapOnTupleTypes01.ts] + +export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); + +// Length 1 + +let numTuple: [number] = [1]; +export let a = numTuple.map(x => x * x); + +// Length 2 + +let numNum: [number, number] = [ 100, 100]; +let strStr: [string, string] = ["hello", "hello"]; +let numStr: [number, string] = [ 100, "hello"]; + +export let b = numNum.map(n => n * n); +export let c = strStr.map(s => s.charCodeAt(0)); +export let d = numStr.map(x => x); + +// Length 3 + +let numNumNum: [number, number, number] = [1, 2, 3]; + +export let e = numNumNum.map(n => n * n); + +// Length 4 + +let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; + +export let f = numNumNumNum.map(n => n * n); + +// Length 5 + +let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; + +export let g = numNumNumNumNum.map(n => n * n); + + +// Length 6 + +let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6]; + +export let h = numNumNumNumNum.map(n => n * n); + +//// [mapOnTupleTypes01.js] +"use strict"; +exports.mapOnLooseArrayLiteral = [1, 2, 3, 4].map(function (n) { return n * n; }); +// Length 1 +var numTuple = [1]; +exports.a = numTuple.map(function (x) { return x * x; }); +// Length 2 +var numNum = [100, 100]; +var strStr = ["hello", "hello"]; +var numStr = [100, "hello"]; +exports.b = numNum.map(function (n) { return n * n; }); +exports.c = strStr.map(function (s) { return s.charCodeAt(0); }); +exports.d = numStr.map(function (x) { return x; }); +// Length 3 +var numNumNum = [1, 2, 3]; +exports.e = numNumNum.map(function (n) { return n * n; }); +// Length 4 +var numNumNumNum = [1, 2, 3, 4]; +exports.f = numNumNumNum.map(function (n) { return n * n; }); +// Length 5 +var numNumNumNumNum = [1, 2, 3, 4, 5]; +exports.g = numNumNumNumNum.map(function (n) { return n * n; }); +// Length 6 +var numNumNumNumNumNum = [1, 2, 3, 4, 5, 6]; +exports.h = numNumNumNumNum.map(function (n) { return n * n; }); + + +//// [mapOnTupleTypes01.d.ts] +export declare let mapOnLooseArrayLiteral: number[]; +export declare let a: number[]; +export declare let b: number[]; +export declare let c: number[]; +export declare let d: (string | number)[]; +export declare let e: number[]; +export declare let f: number[]; +export declare let g: number[]; +export declare let h: number[]; diff --git a/tests/baselines/reference/mapOnTupleTypes01.symbols b/tests/baselines/reference/mapOnTupleTypes01.symbols new file mode 100644 index 00000000000..1c735fc06cf --- /dev/null +++ b/tests/baselines/reference/mapOnTupleTypes01.symbols @@ -0,0 +1,119 @@ +=== tests/cases/compiler/mapOnTupleTypes01.ts === + +export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); +>mapOnLooseArrayLiteral : Symbol(mapOnLooseArrayLiteral, Decl(mapOnTupleTypes01.ts, 1, 10)) +>[1, 2, 3, 4].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) + +// Length 1 + +let numTuple: [number] = [1]; +>numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3)) + +export let a = numTuple.map(x => x * x); +>a : Symbol(a, Decl(mapOnTupleTypes01.ts, 6, 10)) +>numTuple.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) + +// Length 2 + +let numNum: [number, number] = [ 100, 100]; +>numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3)) + +let strStr: [string, string] = ["hello", "hello"]; +>strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3)) + +let numStr: [number, string] = [ 100, "hello"]; +>numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3)) + +export let b = numNum.map(n => n * n); +>b : Symbol(b, Decl(mapOnTupleTypes01.ts, 14, 10)) +>numNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) + +export let c = strStr.map(s => s.charCodeAt(0)); +>c : Symbol(c, Decl(mapOnTupleTypes01.ts, 15, 10)) +>strStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26)) +>s.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) +>s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26)) +>charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) + +export let d = numStr.map(x => x); +>d : Symbol(d, Decl(mapOnTupleTypes01.ts, 16, 10)) +>numStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26)) +>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26)) + +// Length 3 + +let numNumNum: [number, number, number] = [1, 2, 3]; +>numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3)) + +export let e = numNumNum.map(n => n * n); +>e : Symbol(e, Decl(mapOnTupleTypes01.ts, 22, 10)) +>numNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) + +// Length 4 + +let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; +>numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3)) + +export let f = numNumNumNum.map(n => n * n); +>f : Symbol(f, Decl(mapOnTupleTypes01.ts, 28, 10)) +>numNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) + +// Length 5 + +let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) + +export let g = numNumNumNumNum.map(n => n * n); +>g : Symbol(g, Decl(mapOnTupleTypes01.ts, 34, 10)) +>numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) + + +// Length 6 + +let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6]; +>numNumNumNumNumNum : Symbol(numNumNumNumNumNum, Decl(mapOnTupleTypes01.ts, 39, 3)) + +export let h = numNumNumNumNum.map(n => n * n); +>h : Symbol(h, Decl(mapOnTupleTypes01.ts, 41, 10)) +>numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) +>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) + diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types new file mode 100644 index 00000000000..b97b9570fa1 --- /dev/null +++ b/tests/baselines/reference/mapOnTupleTypes01.types @@ -0,0 +1,184 @@ +=== tests/cases/compiler/mapOnTupleTypes01.ts === + +export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); +>mapOnLooseArrayLiteral : number[] +>[1, 2, 3, 4].map(n => n * n) : number[] +>[1, 2, 3, 4].map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>[1, 2, 3, 4] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>4 : 4 +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>n => n * n : (n: number) => number +>n : number +>n * n : number +>n : number +>n : number + +// Length 1 + +let numTuple: [number] = [1]; +>numTuple : [number] +>[1] : [number] +>1 : 1 + +export let a = numTuple.map(x => x * x); +>a : number[] +>numTuple.map(x => x * x) : number[] +>numTuple.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>numTuple : [number] +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>x => x * x : (x: number) => number +>x : number +>x * x : number +>x : number +>x : number + +// Length 2 + +let numNum: [number, number] = [ 100, 100]; +>numNum : [number, number] +>[ 100, 100] : [number, number] +>100 : 100 +>100 : 100 + +let strStr: [string, string] = ["hello", "hello"]; +>strStr : [string, string] +>["hello", "hello"] : [string, string] +>"hello" : "hello" +>"hello" : "hello" + +let numStr: [number, string] = [ 100, "hello"]; +>numStr : [number, string] +>[ 100, "hello"] : [number, string] +>100 : 100 +>"hello" : "hello" + +export let b = numNum.map(n => n * n); +>b : number[] +>numNum.map(n => n * n) : number[] +>numNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>numNum : [number, number] +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>n => n * n : (n: number) => number +>n : number +>n * n : number +>n : number +>n : number + +export let c = strStr.map(s => s.charCodeAt(0)); +>c : number[] +>strStr.map(s => s.charCodeAt(0)) : number[] +>strStr.map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>strStr : [string, string] +>map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>s => s.charCodeAt(0) : (s: string) => number +>s : string +>s.charCodeAt(0) : number +>s.charCodeAt : (index: number) => number +>s : string +>charCodeAt : (index: number) => number +>0 : 0 + +export let d = numStr.map(x => x); +>d : (string | number)[] +>numStr.map(x => x) : (string | number)[] +>numStr.map : (callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[] +>numStr : [number, string] +>map : (callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[] +>x => x : (x: string | number) => string | number +>x : string | number +>x : string | number + +// Length 3 + +let numNumNum: [number, number, number] = [1, 2, 3]; +>numNumNum : [number, number, number] +>[1, 2, 3] : [number, number, number] +>1 : 1 +>2 : 2 +>3 : 3 + +export let e = numNumNum.map(n => n * n); +>e : number[] +>numNumNum.map(n => n * n) : number[] +>numNumNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>numNumNum : [number, number, number] +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>n => n * n : (n: number) => number +>n : number +>n * n : number +>n : number +>n : number + +// Length 4 + +let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; +>numNumNumNum : [number, number, number, number] +>[1, 2, 3, 4] : [number, number, number, number] +>1 : 1 +>2 : 2 +>3 : 3 +>4 : 4 + +export let f = numNumNumNum.map(n => n * n); +>f : number[] +>numNumNumNum.map(n => n * n) : number[] +>numNumNumNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>numNumNumNum : [number, number, number, number] +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>n => n * n : (n: number) => number +>n : number +>n * n : number +>n : number +>n : number + +// Length 5 + +let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; +>numNumNumNumNum : [number, number, number, number, number] +>[1, 2, 3, 4, 5] : [number, number, number, number, number] +>1 : 1 +>2 : 2 +>3 : 3 +>4 : 4 +>5 : 5 + +export let g = numNumNumNumNum.map(n => n * n); +>g : number[] +>numNumNumNumNum.map(n => n * n) : number[] +>numNumNumNumNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>numNumNumNumNum : [number, number, number, number, number] +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>n => n * n : (n: number) => number +>n : number +>n * n : number +>n : number +>n : number + + +// Length 6 + +let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6]; +>numNumNumNumNumNum : [number, number, number, number, number, number] +>[1, 2, 3, 4, 5, 6] : [number, number, number, number, number, number] +>1 : 1 +>2 : 2 +>3 : 3 +>4 : 4 +>5 : 5 +>6 : 6 + +export let h = numNumNumNumNum.map(n => n * n); +>h : number[] +>numNumNumNumNum.map(n => n * n) : number[] +>numNumNumNumNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>numNumNumNumNum : [number, number, number, number, number] +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>n => n * n : (n: number) => number +>n : number +>n * n : number +>n : number +>n : number + diff --git a/tests/baselines/reference/mapOnTupleTypes02.js b/tests/baselines/reference/mapOnTupleTypes02.js new file mode 100644 index 00000000000..0f5f59f3285 --- /dev/null +++ b/tests/baselines/reference/mapOnTupleTypes02.js @@ -0,0 +1,19 @@ +//// [mapOnTupleTypes02.ts] + +export type Point = [number, number]; + +export function increment(point: Point) { + return point.map(d => d + 1); +} + +//// [mapOnTupleTypes02.js] +"use strict"; +function increment(point) { + return point.map(function (d) { return d + 1; }); +} +exports.increment = increment; + + +//// [mapOnTupleTypes02.d.ts] +export declare type Point = [number, number]; +export declare function increment(point: Point): number[]; diff --git a/tests/baselines/reference/mapOnTupleTypes02.symbols b/tests/baselines/reference/mapOnTupleTypes02.symbols new file mode 100644 index 00000000000..e0f1ca79f61 --- /dev/null +++ b/tests/baselines/reference/mapOnTupleTypes02.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/mapOnTupleTypes02.ts === + +export type Point = [number, number]; +>Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0)) + +export function increment(point: Point) { +>increment : Symbol(increment, Decl(mapOnTupleTypes02.ts, 1, 37)) +>point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26)) +>Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0)) + + return point.map(d => d + 1); +>point.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19)) +>d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19)) +} diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types new file mode 100644 index 00000000000..bb261f3093a --- /dev/null +++ b/tests/baselines/reference/mapOnTupleTypes02.types @@ -0,0 +1,21 @@ +=== tests/cases/compiler/mapOnTupleTypes02.ts === + +export type Point = [number, number]; +>Point : [number, number] + +export function increment(point: Point) { +>increment : (point: [number, number]) => number[] +>point : [number, number] +>Point : [number, number] + + return point.map(d => d + 1); +>point.map(d => d + 1) : number[] +>point.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>point : [number, number] +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>d => d + 1 : (d: number) => number +>d : number +>d + 1 : number +>d : number +>1 : 1 +} From 7f3db5cf187c602a84dfb608f9ead0a72e554f65 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 29 Sep 2016 00:41:06 -0700 Subject: [PATCH 05/21] Added overloads for 'map' on tuple types. --- src/lib/es5.d.ts | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index ce719668acf..ccff01a8722 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1200,6 +1200,30 @@ interface Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; + /** + * Calls a defined callback function on each element of an array, and returns an array that contains the results. + * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + map(this: [T, T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U, U]; + /** + * Calls a defined callback function on each element of an array, and returns an array that contains the results. + * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + map(this: [T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U]; + /** + * Calls a defined callback function on each element of an array, and returns an array that contains the results. + * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + map(this: [T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U]; + /** + * Calls a defined callback function on each element of an array, and returns an array that contains the results. + * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + map(this: [T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U]; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. From bc028a3cf0664e145031960f16043fb797dbd9b4 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 29 Sep 2016 10:30:41 -0700 Subject: [PATCH 06/21] Remove TypeFlags.ObjectLiteral, not Instantiated --- src/compiler/checker.ts | 55 ++++++++++++++++++++++++----------------- src/compiler/types.ts | 13 +++++----- 2 files changed, 40 insertions(+), 28 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e7fd07045ec..5c38b9477ed 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1618,9 +1618,12 @@ namespace ts { return type; } - function createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo): ResolvedType { - return setObjectTypeMembers(createObjectType(TypeFlags.Anonymous, symbol), - members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); + function createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo, isObjectLiteral?: boolean): ResolvedType { + const t = createObjectType(TypeFlags.Anonymous, symbol); + if (isObjectLiteral) { + t.isObjectLiteral = true; + } + return setObjectTypeMembers(t, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); } function forEachSymbolTableInScope(enclosingDeclaration: Node, callback: (symbolTable: SymbolTable) => T): T { @@ -3177,7 +3180,9 @@ namespace ts { if (includePatternInType) { result.pattern = pattern; } - result.inObjectLiteralPatternWithComputedProperties = hasComputedProperties; + if (hasComputedProperties) { + result.inObjectLiteralPatternWithComputedProperties = hasComputedProperties; + } return result; } @@ -4413,7 +4418,7 @@ namespace ts { * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the * type itself. Note that the apparent type of a union type is the union type itself. */ - function getApparentType(type: Type): ObjectType { + function getApparentType(type: Type): Type { if (type.flags & TypeFlags.TypeParameter) { type = getApparentTypeOfTypeParameter(type); } @@ -5920,8 +5925,7 @@ namespace ts { mapper.instantiations = []; } // Mark the anonymous type as instantiated such that our infinite instantiation detection logic can recognize it - const result = createObjectType(TypeFlags.Anonymous, type.symbol); - result.isInstantiated = true; + const result = createObjectType(TypeFlags.Anonymous | TypeFlags.Instantiated, type.symbol); result.target = type; result.mapper = mapper; result.aliasSymbol = type.aliasSymbol; @@ -5993,7 +5997,7 @@ namespace ts { // instantiation. return type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) && - ((type as AnonymousType).isInstantiated || isSymbolInScopeOfMappedTypeParameter(type.symbol, mapper)) ? + (type.flags & TypeFlags.Instantiated || isSymbolInScopeOfMappedTypeParameter(type.symbol, mapper)) ? instantiateAnonymousType(type, mapper) : type; } if (type.flags & TypeFlags.Reference) { @@ -6473,7 +6477,7 @@ namespace ts { if (isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined)) return Ternary.True; - if (source.flags & TypeFlags.ObjectLiteral && source.flags & TypeFlags.FreshLiteral) { + if (source.flags & TypeFlags.ObjectType && (source as ObjectType).isObjectLiteral && source.flags & TypeFlags.FreshLiteral) { if (hasExcessProperties(source, target, reportErrors)) { if (reportErrors) { reportRelationError(headMessage, source, target); @@ -6647,7 +6651,8 @@ namespace ts { } function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean { - if (maybeTypeOfKind(target, TypeFlags.ObjectType) && !(target as ObjectType).inObjectLiteralPatternWithComputedProperties) { + if (maybeTypeOfKind(target, TypeFlags.ObjectType) && + (!(target.flags & TypeFlags.ObjectType) || !(target as ObjectType).inObjectLiteralPatternWithComputedProperties)) { for (const prop of getPropertiesOfObjectType(source)) { if (!isKnownProperty(target, prop.name)) { if (reportErrors) { @@ -6841,7 +6846,7 @@ namespace ts { } let result = Ternary.True; const properties = getPropertiesOfObjectType(target); - const requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectLiteral); + const requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectType && (source as ObjectType).isObjectLiteral); for (const targetProp of properties) { const sourceProp = getPropertyOfType(source, targetProp.name); @@ -7141,12 +7146,12 @@ namespace ts { // some level beyond that. function isDeeplyNestedGeneric(type: Type, stack: Type[], depth: number): boolean { // We track type references (created by createTypeReference) and instantiated types (created by instantiateType) - if ((type.flags & TypeFlags.Reference || type.flags & TypeFlags.Anonymous && (type as AnonymousType).isInstantiated) && depth >= 5) { + if (type.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && depth >= 5) { const symbol = type.symbol; let count = 0; for (let i = 0; i < depth; i++) { const t = stack[i]; - if ((t.flags & TypeFlags.Reference || t.flags & TypeFlags.Anonymous && (t as AnonymousType).isInstantiated) && t.symbol === symbol) { + if (t.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && t.symbol === symbol) { count++; if (count >= 5) return true; } @@ -7480,7 +7485,7 @@ namespace ts { * Leave signatures alone since they are not subject to the check. */ function getRegularTypeOfObjectLiteral(type: Type): Type { - if (!(type.flags & TypeFlags.ObjectLiteral && type.flags & TypeFlags.FreshLiteral)) { + if (!(type.flags & TypeFlags.ObjectType && (type as ObjectType).isObjectLiteral && type.flags & TypeFlags.FreshLiteral)) { return type; } const regularType = (type).regularType; @@ -7495,7 +7500,8 @@ namespace ts { resolved.callSignatures, resolved.constructSignatures, resolved.stringIndexInfo, - resolved.numberIndexInfo); + resolved.numberIndexInfo, + resolved.isObjectLiteral); regularNew.flags = resolved.flags & ~TypeFlags.FreshLiteral; (type).regularType = regularNew; return regularNew; @@ -7510,7 +7516,8 @@ namespace ts { const numberIndexInfo = getIndexInfoOfType(type, IndexKind.Number); return createAnonymousType(type.symbol, members, emptyArray, emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), - numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly)); + numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly), + (type as ObjectType).isObjectLiteral); } function getWidenedConstituentType(type: Type): Type { @@ -7522,7 +7529,8 @@ namespace ts { if (type.flags & TypeFlags.Nullable) { return anyType; } - if (type.flags & TypeFlags.ObjectLiteral) { + // if (type.flags & TypeFlags.ObjectLiteral) { + if (type.flags & TypeFlags.ObjectType && (type as ObjectType).isObjectLiteral) { return getWidenedTypeOfObjectLiteral(type); } if (type.flags & TypeFlags.Union) { @@ -7562,7 +7570,7 @@ namespace ts { } } } - if (type.flags & TypeFlags.ObjectLiteral) { + if (type.flags & TypeFlags.ObjectType && (type as ObjectType).isObjectLiteral) { for (const p of getPropertiesOfObjectType(type)) { const t = getTypeOfSymbol(p); if (t.flags & TypeFlags.ContainsWideningType) { @@ -9938,7 +9946,7 @@ namespace ts { // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily // be "pushed" onto a node using the contextualType property. - function getApparentTypeOfContextualType(node: Expression): ObjectType { + function getApparentTypeOfContextualType(node: Expression): Type { const type = getContextualType(node); return type && getApparentType(type); } @@ -10307,7 +10315,8 @@ namespace ts { patternWithComputedProperties = true; } } - else if (contextualTypeHasPattern && !contextualType.inObjectLiteralPatternWithComputedProperties) { + else if (contextualTypeHasPattern && + !(contextualType.flags & TypeFlags.ObjectType && (contextualType as ObjectType).inObjectLiteralPatternWithComputedProperties)) { // If object literal is contextually typed by the implied type of a binding pattern, and if the // binding pattern specifies a default value for the property, make the property optional. const impliedProp = getPropertyOfType(contextualType, member.name); @@ -10370,10 +10379,12 @@ namespace ts { const stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, propertiesArray, IndexKind.String) : undefined; const numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, propertiesArray, IndexKind.Number) : undefined; - const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo); + const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo, /*isObjectLiteral*/ true); const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshLiteral; result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags); - result.inObjectLiteralPatternWithComputedProperties = patternWithComputedProperties; + if (patternWithComputedProperties) { + result.inObjectLiteralPatternWithComputedProperties = patternWithComputedProperties; + } if (inDestructuringPattern) { result.pattern = node; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index a9529659b3e..7b4f8dced69 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2382,16 +2382,17 @@ namespace ts { Union = 1 << 19, // Union (T | U) Intersection = 1 << 20, // Intersection (T & U) Anonymous = 1 << 21, // Anonymous + Instantiated = 1 << 22, // Instantiated anonymous type /* @internal */ - ObjectLiteral = 1 << 22, // Originates in an object literal + ObjectLiteral = 1 << 23, // Originates in an object literal /* @internal */ - FreshLiteral = 1 << 23, // Fresh literal type + FreshLiteral = 1 << 24, // Fresh literal type /* @internal */ - ContainsWideningType = 1 << 24, // Type is or contains undefined or null widening type + ContainsWideningType = 1 << 25, // Type is or contains undefined or null widening type /* @internal */ - ContainsObjectLiteral = 1 << 25, // Type is or contains object literal type + ContainsObjectLiteral = 1 << 26, // Type is or contains object literal type /* @internal */ - ContainsAnyFunctionType = 1 << 26, // Type is or contains object literal type + ContainsAnyFunctionType = 1 << 27, // Type is or contains object literal type /* @internal */ Nullable = Undefined | Null, @@ -2461,6 +2462,7 @@ namespace ts { // Object types (TypeFlags.ObjectType) export interface ObjectType extends Type { + isObjectLiteral?: boolean; inObjectLiteralPatternWithComputedProperties?: boolean; } @@ -2518,7 +2520,6 @@ namespace ts { /* @internal */ // An instantiated anonymous type has a target and a mapper export interface AnonymousType extends ObjectType { - isInstantiated?: boolean; target?: AnonymousType; // Instantiation target mapper?: TypeMapper; // Instantiation mapper } From d0607a9db7716ece6c84f8f38c0c65646fb466a2 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 29 Sep 2016 10:39:31 -0700 Subject: [PATCH 07/21] Accepted baselines. --- .../anyInferenceAnonymousFunctions.symbols | 8 +-- .../anyInferenceAnonymousFunctions.types | 8 +-- .../reference/arrayConcatMap.symbols | 4 +- .../baselines/reference/arrayConcatMap.types | 4 +- .../reference/bestChoiceType.symbols | 12 ++-- .../baselines/reference/bestChoiceType.types | 12 ++-- .../reference/commentInMethodCall.symbols | 4 +- .../reference/commentInMethodCall.types | 4 +- .../contextualSignatureInstantiation3.symbols | 12 ++-- .../contextualSignatureInstantiation3.types | 12 ++-- .../reference/contextuallyTypedIife.symbols | 4 +- .../reference/contextuallyTypedIife.types | 4 +- ...controlFlowDestructuringParameters.symbols | 4 +- .../controlFlowDestructuringParameters.types | 4 +- tests/baselines/reference/enumIndexer.symbols | 4 +- tests/baselines/reference/enumIndexer.types | 4 +- .../baselines/reference/genericArray1.symbols | 4 +- tests/baselines/reference/genericArray1.types | 4 +- .../reference/genericInference1.symbols | 4 +- .../reference/genericInference1.types | 4 +- .../genericMethodOverspecialization.symbols | 8 +-- .../genericMethodOverspecialization.types | 8 +-- .../implementArrayInterface.errors.txt | 47 ++++++++++++++ .../reference/inferenceLimit.symbols | 4 +- .../baselines/reference/inferenceLimit.types | 4 +- ...inferentialTypingWithFunctionType2.symbols | 4 +- .../inferentialTypingWithFunctionType2.types | 4 +- .../baselines/reference/mapOnTupleTypes01.js | 14 ++-- .../reference/mapOnTupleTypes01.symbols | 36 +++++------ .../reference/mapOnTupleTypes01.types | 64 +++++++++---------- .../baselines/reference/mapOnTupleTypes02.js | 2 +- .../reference/mapOnTupleTypes02.symbols | 4 +- .../reference/mapOnTupleTypes02.types | 8 +-- tests/baselines/reference/nestedSelf.symbols | 4 +- tests/baselines/reference/nestedSelf.types | 4 +- ...arameterReferencedInObjectLiteral1.symbols | 8 +-- ...nParameterReferencedInObjectLiteral1.types | 8 +-- ...alizationsShouldNotAffectEachOther.symbols | 8 +-- ...cializationsShouldNotAffectEachOther.types | 8 +-- ...ReferencedTypeAliasToTypeLiteral01.symbols | 4 +- ...lyReferencedTypeAliasToTypeLiteral01.types | 4 +- ...ReferencedTypeAliasToTypeLiteral02.symbols | 4 +- ...lyReferencedTypeAliasToTypeLiteral02.types | 4 +- 43 files changed, 215 insertions(+), 168 deletions(-) create mode 100644 tests/baselines/reference/implementArrayInterface.errors.txt diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols index c1b5df88fb0..ff576a36423 100644 --- a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols +++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols @@ -35,16 +35,16 @@ paired.reduce((b3, b4) => b3.concat({}), []); >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15)) paired.map((c1) => c1.count); ->paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12)) >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12)) paired.map(function (c2) { return c2.count; }); ->paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21)) >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21)) diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.types b/tests/baselines/reference/anyInferenceAnonymousFunctions.types index 8dc7fdcb90f..1f3bb78f958 100644 --- a/tests/baselines/reference/anyInferenceAnonymousFunctions.types +++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.types @@ -57,9 +57,9 @@ paired.reduce((b3, b4) => b3.concat({}), []); paired.map((c1) => c1.count); >paired.map((c1) => c1.count) : any[] ->paired.map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>paired.map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >paired : any[] ->map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >(c1) => c1.count : (c1: any) => any >c1 : any >c1.count : any @@ -68,9 +68,9 @@ paired.map((c1) => c1.count); paired.map(function (c2) { return c2.count; }); >paired.map(function (c2) { return c2.count; }) : any[] ->paired.map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>paired.map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >paired : any[] ->map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >function (c2) { return c2.count; } : (c2: any) => any >c2 : any >c2.count : any diff --git a/tests/baselines/reference/arrayConcatMap.symbols b/tests/baselines/reference/arrayConcatMap.symbols index 5ef9d811723..c3df6bed533 100644 --- a/tests/baselines/reference/arrayConcatMap.symbols +++ b/tests/baselines/reference/arrayConcatMap.symbols @@ -1,14 +1,14 @@ === tests/cases/compiler/arrayConcatMap.ts === var x = [].concat([{ a: 1 }], [{ a: 2 }]) >x : Symbol(x, Decl(arrayConcatMap.ts, 0, 3)) ->[].concat([{ a: 1 }], [{ a: 2 }]) .map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>[].concat([{ a: 1 }], [{ a: 2 }]) .map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >[].concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 20)) >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 32)) .map(b => b.a); ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15)) >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15)) diff --git a/tests/baselines/reference/arrayConcatMap.types b/tests/baselines/reference/arrayConcatMap.types index 89289e58d4e..10e0a74c16d 100644 --- a/tests/baselines/reference/arrayConcatMap.types +++ b/tests/baselines/reference/arrayConcatMap.types @@ -2,7 +2,7 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }]) >x : any[] >[].concat([{ a: 1 }], [{ a: 2 }]) .map(b => b.a) : any[] ->[].concat([{ a: 1 }], [{ a: 2 }]) .map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>[].concat([{ a: 1 }], [{ a: 2 }]) .map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >[].concat([{ a: 1 }], [{ a: 2 }]) : any[] >[].concat : { (...items: any[][]): any[]; (...items: any[]): any[]; } >[] : undefined[] @@ -17,7 +17,7 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }]) >2 : 2 .map(b => b.a); ->map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >b => b.a : (b: any) => any >b : any >b.a : any diff --git a/tests/baselines/reference/bestChoiceType.symbols b/tests/baselines/reference/bestChoiceType.symbols index 25f7de2eeda..737ba35b520 100644 --- a/tests/baselines/reference/bestChoiceType.symbols +++ b/tests/baselines/reference/bestChoiceType.symbols @@ -3,10 +3,10 @@ // Repro from #10041 (''.match(/ /) || []).map(s => s.toLowerCase()); ->(''.match(/ /) || []).map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>(''.match(/ /) || []).map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >''.match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(bestChoiceType.ts, 3, 26)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(bestChoiceType.ts, 3, 26)) @@ -28,9 +28,9 @@ function f1() { let z = y.map(s => s.toLowerCase()); >z : Symbol(z, Decl(bestChoiceType.ts, 10, 7)) ->y.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>y.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(bestChoiceType.ts, 9, 7)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(bestChoiceType.ts, 10, 18)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(bestChoiceType.ts, 10, 18)) @@ -52,9 +52,9 @@ function f2() { let z = y.map(s => s.toLowerCase()); >z : Symbol(z, Decl(bestChoiceType.ts, 16, 7)) ->y.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>y.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(bestChoiceType.ts, 15, 7)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(bestChoiceType.ts, 16, 18)) >s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(bestChoiceType.ts, 16, 18)) diff --git a/tests/baselines/reference/bestChoiceType.types b/tests/baselines/reference/bestChoiceType.types index b1b4d419756..07b61fc9f84 100644 --- a/tests/baselines/reference/bestChoiceType.types +++ b/tests/baselines/reference/bestChoiceType.types @@ -4,7 +4,7 @@ (''.match(/ /) || []).map(s => s.toLowerCase()); >(''.match(/ /) || []).map(s => s.toLowerCase()) : string[] ->(''.match(/ /) || []).map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>(''.match(/ /) || []).map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >(''.match(/ /) || []) : RegExpMatchArray >''.match(/ /) || [] : RegExpMatchArray >''.match(/ /) : RegExpMatchArray | null @@ -13,7 +13,7 @@ >match : { (regexp: string): RegExpMatchArray | null; (regexp: RegExp): RegExpMatchArray | null; } >/ / : RegExp >[] : never[] ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >s => s.toLowerCase() : (s: string) => string >s : string >s.toLowerCase() : string @@ -43,9 +43,9 @@ function f1() { let z = y.map(s => s.toLowerCase()); >z : string[] >y.map(s => s.toLowerCase()) : string[] ->y.map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>y.map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >y : RegExpMatchArray ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >s => s.toLowerCase() : (s: string) => string >s : string >s.toLowerCase() : string @@ -75,9 +75,9 @@ function f2() { let z = y.map(s => s.toLowerCase()); >z : string[] >y.map(s => s.toLowerCase()) : string[] ->y.map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>y.map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >y : RegExpMatchArray ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >s => s.toLowerCase() : (s: string) => string >s : string >s.toLowerCase() : string diff --git a/tests/baselines/reference/commentInMethodCall.symbols b/tests/baselines/reference/commentInMethodCall.symbols index 9db0719cf89..1ef762da871 100644 --- a/tests/baselines/reference/commentInMethodCall.symbols +++ b/tests/baselines/reference/commentInMethodCall.symbols @@ -4,9 +4,9 @@ var s: string[]; >s : Symbol(s, Decl(commentInMethodCall.ts, 1, 3)) s.map(// do something ->s.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>s.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(commentInMethodCall.ts, 1, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function () { }); diff --git a/tests/baselines/reference/commentInMethodCall.types b/tests/baselines/reference/commentInMethodCall.types index e9543a8c6f2..a97b0319777 100644 --- a/tests/baselines/reference/commentInMethodCall.types +++ b/tests/baselines/reference/commentInMethodCall.types @@ -5,9 +5,9 @@ var s: string[]; s.map(// do something >s.map(// do something function () { }) : void[] ->s.map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>s.map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >s : string[] ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } function () { }); >function () { } : () => void diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.symbols b/tests/baselines/reference/contextualSignatureInstantiation3.symbols index 6d480a7aef4..50dac0b5d67 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation3.symbols +++ b/tests/baselines/reference/contextualSignatureInstantiation3.symbols @@ -12,9 +12,9 @@ function map(items: T[], f: (x: T) => U): U[]{ >U : Symbol(U, Decl(contextualSignatureInstantiation3.ts, 0, 15)) return items.map(f); ->items.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>items.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >items : Symbol(items, Decl(contextualSignatureInstantiation3.ts, 0, 19)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >f : Symbol(f, Decl(contextualSignatureInstantiation3.ts, 0, 30)) } @@ -47,9 +47,9 @@ var v1: number[]; var v1 = xs.map(identity); // Error if not number[] >v1 : Symbol(v1, Decl(contextualSignatureInstantiation3.ts, 15, 3), Decl(contextualSignatureInstantiation3.ts, 16, 3), Decl(contextualSignatureInstantiation3.ts, 17, 3)) ->xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >xs : Symbol(xs, Decl(contextualSignatureInstantiation3.ts, 12, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >identity : Symbol(identity, Decl(contextualSignatureInstantiation3.ts, 2, 1)) var v1 = map(xs, identity); // Error if not number[] @@ -63,9 +63,9 @@ var v2: number[][]; var v2 = xs.map(singleton); // Error if not number[][] >v2 : Symbol(v2, Decl(contextualSignatureInstantiation3.ts, 19, 3), Decl(contextualSignatureInstantiation3.ts, 20, 3), Decl(contextualSignatureInstantiation3.ts, 21, 3)) ->xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >xs : Symbol(xs, Decl(contextualSignatureInstantiation3.ts, 12, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >singleton : Symbol(singleton, Decl(contextualSignatureInstantiation3.ts, 6, 1)) var v2 = map(xs, singleton); // Error if not number[][] diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.types b/tests/baselines/reference/contextualSignatureInstantiation3.types index 945a4374ad1..409c685215d 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation3.types +++ b/tests/baselines/reference/contextualSignatureInstantiation3.types @@ -13,9 +13,9 @@ function map(items: T[], f: (x: T) => U): U[]{ return items.map(f); >items.map(f) : U[] ->items.map : (callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[] +>items.map : { (this: [T, T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U]; (this: [T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U]; (this: [T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; } >items : T[] ->map : (callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[] +>map : { (this: [T, T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U]; (this: [T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U]; (this: [T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; } >f : (x: T) => U } @@ -54,9 +54,9 @@ var v1: number[]; var v1 = xs.map(identity); // Error if not number[] >v1 : number[] >xs.map(identity) : number[] ->xs.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>xs.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >xs : number[] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >identity : (x: T) => T var v1 = map(xs, identity); // Error if not number[] @@ -72,9 +72,9 @@ var v2: number[][]; var v2 = xs.map(singleton); // Error if not number[][] >v2 : number[][] >xs.map(singleton) : number[][] ->xs.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>xs.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >xs : number[] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >singleton : (x: T) => T[] var v2 = map(xs, singleton); // Error if not number[][] diff --git a/tests/baselines/reference/contextuallyTypedIife.symbols b/tests/baselines/reference/contextuallyTypedIife.symbols index 824ce6031ce..4512b4db8a2 100644 --- a/tests/baselines/reference/contextuallyTypedIife.symbols +++ b/tests/baselines/reference/contextuallyTypedIife.symbols @@ -73,9 +73,9 @@ >first : Symbol(first, Decl(contextuallyTypedIife.ts, 20, 2)) >rest : Symbol(rest, Decl(contextuallyTypedIife.ts, 20, 8)) >first : Symbol(first, Decl(contextuallyTypedIife.ts, 20, 2)) ->rest.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>rest.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >rest : Symbol(rest, Decl(contextuallyTypedIife.ts, 20, 8)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(contextuallyTypedIife.ts, 20, 43)) >n : Symbol(n, Decl(contextuallyTypedIife.ts, 20, 43)) diff --git a/tests/baselines/reference/contextuallyTypedIife.types b/tests/baselines/reference/contextuallyTypedIife.types index ca0f7f2a508..e6f41265e9a 100644 --- a/tests/baselines/reference/contextuallyTypedIife.types +++ b/tests/baselines/reference/contextuallyTypedIife.types @@ -160,9 +160,9 @@ >first : number >[] : undefined[] >rest.map(n => n > 0) : boolean[] ->rest.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>rest.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >rest : number[] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >n => n > 0 : (n: number) => boolean >n : number >n > 0 : boolean diff --git a/tests/baselines/reference/controlFlowDestructuringParameters.symbols b/tests/baselines/reference/controlFlowDestructuringParameters.symbols index 668d346b929..58d2edfc12c 100644 --- a/tests/baselines/reference/controlFlowDestructuringParameters.symbols +++ b/tests/baselines/reference/controlFlowDestructuringParameters.symbols @@ -3,9 +3,9 @@ [{ x: 1 }].map( ->[{ x: 1 }].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>[{ x: 1 }].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(controlFlowDestructuringParameters.ts, 3, 2)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ({ x }) => x >x : Symbol(x, Decl(controlFlowDestructuringParameters.ts, 4, 4)) diff --git a/tests/baselines/reference/controlFlowDestructuringParameters.types b/tests/baselines/reference/controlFlowDestructuringParameters.types index d0729e6d7d5..c38a8fb1aa4 100644 --- a/tests/baselines/reference/controlFlowDestructuringParameters.types +++ b/tests/baselines/reference/controlFlowDestructuringParameters.types @@ -4,12 +4,12 @@ [{ x: 1 }].map( >[{ x: 1 }].map( ({ x }) => x) : number[] ->[{ x: 1 }].map : (callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[] +>[{ x: 1 }].map : { (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): [U, U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): U[]; } >[{ x: 1 }] : { x: number; }[] >{ x: 1 } : { x: number; } >x : number >1 : 1 ->map : (callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[] +>map : { (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }, { x: number; }], callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): [U, U, U, U]; (this: [{ x: number; }, { x: number; }, { x: number; }], callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): [U, U, U]; (this: [{ x: number; }, { x: number; }], callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any): U[]; } ({ x }) => x >({ x }) => x : ({x}: { x: number; }) => number diff --git a/tests/baselines/reference/enumIndexer.symbols b/tests/baselines/reference/enumIndexer.symbols index 59191a73276..79baee66498 100644 --- a/tests/baselines/reference/enumIndexer.symbols +++ b/tests/baselines/reference/enumIndexer.symbols @@ -19,9 +19,9 @@ var enumValue = MyEnumType.foo; var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same type >x : Symbol(x, Decl(enumIndexer.ts, 5, 3)) ->_arr.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>_arr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >_arr : Symbol(_arr, Decl(enumIndexer.ts, 3, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >o : Symbol(o, Decl(enumIndexer.ts, 5, 17)) >MyEnumType : Symbol(MyEnumType, Decl(enumIndexer.ts, 0, 0)) >o.key : Symbol(key, Decl(enumIndexer.ts, 3, 13)) diff --git a/tests/baselines/reference/enumIndexer.types b/tests/baselines/reference/enumIndexer.types index 6c6e50822b5..3abd7eaaa4c 100644 --- a/tests/baselines/reference/enumIndexer.types +++ b/tests/baselines/reference/enumIndexer.types @@ -25,9 +25,9 @@ var enumValue = MyEnumType.foo; var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same type >x : boolean[] >_arr.map(o => MyEnumType[o.key] === enumValue) : boolean[] ->_arr.map : (callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[] +>_arr.map : { (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): [U, U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): U[]; } >_arr : { key: string; }[] ->map : (callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[] +>map : { (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }, { key: string; }], callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): [U, U, U, U]; (this: [{ key: string; }, { key: string; }, { key: string; }], callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): [U, U, U]; (this: [{ key: string; }, { key: string; }], callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any): U[]; } >o => MyEnumType[o.key] === enumValue : (o: { key: string; }) => boolean >o : { key: string; } >MyEnumType[o.key] === enumValue : boolean diff --git a/tests/baselines/reference/genericArray1.symbols b/tests/baselines/reference/genericArray1.symbols index b73872b8d55..a96b487f1d7 100644 --- a/tests/baselines/reference/genericArray1.symbols +++ b/tests/baselines/reference/genericArray1.symbols @@ -13,8 +13,8 @@ interface String{ var lengths = ["a", "b", "c"].map(x => x.length); >lengths : Symbol(lengths, Decl(genericArray1.ts, 12, 3)) ->["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericArray1.ts, 12, 34)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericArray1.ts, 12, 34)) diff --git a/tests/baselines/reference/genericArray1.types b/tests/baselines/reference/genericArray1.types index baa2ec8a9cf..68d691a96e3 100644 --- a/tests/baselines/reference/genericArray1.types +++ b/tests/baselines/reference/genericArray1.types @@ -14,12 +14,12 @@ interface String{ var lengths = ["a", "b", "c"].map(x => x.length); >lengths : number[] >["a", "b", "c"].map(x => x.length) : number[] ->["a", "b", "c"].map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>["a", "b", "c"].map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >["a", "b", "c"] : string[] >"a" : "a" >"b" : "b" >"c" : "c" ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >x => x.length : (x: string) => number >x : string >x.length : number diff --git a/tests/baselines/reference/genericInference1.symbols b/tests/baselines/reference/genericInference1.symbols index 8beecf27254..7fc39ac556f 100644 --- a/tests/baselines/reference/genericInference1.symbols +++ b/tests/baselines/reference/genericInference1.symbols @@ -1,7 +1,7 @@ === tests/cases/compiler/genericInference1.ts === ['a', 'b', 'c'].map(x => x.length); ->['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericInference1.ts, 0, 20)) >x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericInference1.ts, 0, 20)) diff --git a/tests/baselines/reference/genericInference1.types b/tests/baselines/reference/genericInference1.types index 30b7279ebc0..ddf8d762000 100644 --- a/tests/baselines/reference/genericInference1.types +++ b/tests/baselines/reference/genericInference1.types @@ -1,12 +1,12 @@ === tests/cases/compiler/genericInference1.ts === ['a', 'b', 'c'].map(x => x.length); >['a', 'b', 'c'].map(x => x.length) : number[] ->['a', 'b', 'c'].map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>['a', 'b', 'c'].map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >['a', 'b', 'c'] : string[] >'a' : "a" >'b' : "b" >'c' : "c" ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >x => x.length : (x: string) => number >x : string >x.length : number diff --git a/tests/baselines/reference/genericMethodOverspecialization.symbols b/tests/baselines/reference/genericMethodOverspecialization.symbols index 329ca2de675..5fd2a0479e6 100644 --- a/tests/baselines/reference/genericMethodOverspecialization.symbols +++ b/tests/baselines/reference/genericMethodOverspecialization.symbols @@ -27,9 +27,9 @@ interface Document { var elements = names.map(function (name) { >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3)) ->names.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>names.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >names : Symbol(names, Decl(genericMethodOverspecialization.ts, 0, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(genericMethodOverspecialization.ts, 12, 35)) return document.getElementById(name); @@ -57,9 +57,9 @@ var xxx = elements.filter(function (e) { var widths:number[] = elements.map(function (e) { // should not error >widths : Symbol(widths, Decl(genericMethodOverspecialization.ts, 21, 3)) ->elements.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>elements.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 21, 45)) return e.clientWidth; diff --git a/tests/baselines/reference/genericMethodOverspecialization.types b/tests/baselines/reference/genericMethodOverspecialization.types index 268943a9723..0f90bd34e2e 100644 --- a/tests/baselines/reference/genericMethodOverspecialization.types +++ b/tests/baselines/reference/genericMethodOverspecialization.types @@ -34,9 +34,9 @@ interface Document { var elements = names.map(function (name) { >elements : HTMLElement[] >names.map(function (name) { return document.getElementById(name);}) : HTMLElement[] ->names.map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>names.map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >names : string[] ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >function (name) { return document.getElementById(name);} : (name: string) => HTMLElement >name : string @@ -70,9 +70,9 @@ var xxx = elements.filter(function (e) { var widths:number[] = elements.map(function (e) { // should not error >widths : number[] >elements.map(function (e) { // should not error return e.clientWidth;}) : number[] ->elements.map : (callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[] +>elements.map : { (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): [U, U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): U[]; } >elements : HTMLElement[] ->map : (callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[] +>map : { (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement, HTMLElement], callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): [U, U, U, U]; (this: [HTMLElement, HTMLElement, HTMLElement], callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): [U, U, U]; (this: [HTMLElement, HTMLElement], callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any): U[]; } >function (e) { // should not error return e.clientWidth;} : (e: HTMLElement) => number >e : HTMLElement diff --git a/tests/baselines/reference/implementArrayInterface.errors.txt b/tests/baselines/reference/implementArrayInterface.errors.txt new file mode 100644 index 00000000000..08c438ebaf3 --- /dev/null +++ b/tests/baselines/reference/implementArrayInterface.errors.txt @@ -0,0 +1,47 @@ +tests/cases/compiler/implementArrayInterface.ts(1,15): error TS2420: Class 'MyArray' incorrectly implements interface 'T[]'. + Types of property 'map' are incompatible. + Type '(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ (this: [T, T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U]; (this: [T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U]; (this: [T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; }'. + Type 'any[]' is not assignable to type '[any, any, any, any, any]'. + Property '0' is missing in type 'any[]'. + + +==== tests/cases/compiler/implementArrayInterface.ts (1 errors) ==== + declare class MyArray implements Array { + ~~~~~~~ +!!! error TS2420: Class 'MyArray' incorrectly implements interface 'T[]'. +!!! error TS2420: Types of property 'map' are incompatible. +!!! error TS2420: Type '(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]' is not assignable to type '{ (this: [T, T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U]; (this: [T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U]; (this: [T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; }'. +!!! error TS2420: Type 'any[]' is not assignable to type '[any, any, any, any, any]'. +!!! error TS2420: Property '0' is missing in type 'any[]'. + toString(): string; + toLocaleString(): string; + concat(...items: U[]): T[]; + concat(...items: T[]): T[]; + join(separator?: string): string; + pop(): T; + push(...items: T[]): number; + reverse(): T[]; + shift(): T; + slice(start?: number, end?: number): T[]; + sort(compareFn?: (a: T, b: T) => number): this; + splice(start: number): T[]; + splice(start: number, deleteCount: number, ...items: T[]): T[]; + unshift(...items: T[]): number; + + indexOf(searchElement: T, fromIndex?: number): number; + lastIndexOf(searchElement: T, fromIndex?: number): number; + every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean; + some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean; + forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; + map(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; + filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[]; + reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; + reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; + reduceRight(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; + + length: number; + + [n: number]: T; + } + \ No newline at end of file diff --git a/tests/baselines/reference/inferenceLimit.symbols b/tests/baselines/reference/inferenceLimit.symbols index 4601de27b51..721e7af7560 100644 --- a/tests/baselines/reference/inferenceLimit.symbols +++ b/tests/baselines/reference/inferenceLimit.symbols @@ -64,9 +64,9 @@ export class BrokenClass { >Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) >Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) >all : Symbol(PromiseConstructor.all, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) ->result.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>result.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >result : Symbol(result, Decl(file1.ts, 10, 7)) ->map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >populateItems : Symbol(populateItems, Decl(file1.ts, 12, 7)) .then((orders: Array) => { diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types index 3801388f343..c123e21802e 100644 --- a/tests/baselines/reference/inferenceLimit.types +++ b/tests/baselines/reference/inferenceLimit.types @@ -84,9 +84,9 @@ export class BrokenClass { >Promise : PromiseConstructor >all : { (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike, T7 | PromiseLike, T8 | PromiseLike, T9 | PromiseLike, T10 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike, T7 | PromiseLike, T8 | PromiseLike, T9 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike, T7 | PromiseLike, T8 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike, T7 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike, T6 | PromiseLike]): Promise<[T1, T2, T3, T4, T5, T6]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike, T5 | PromiseLike]): Promise<[T1, T2, T3, T4, T5]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike, T4 | PromiseLike]): Promise<[T1, T2, T3, T4]>; (values: [T1 | PromiseLike, T2 | PromiseLike, T3 | PromiseLike]): Promise<[T1, T2, T3]>; (values: [T1 | PromiseLike, T2 | PromiseLike]): Promise<[T1, T2]>; (values: (T | PromiseLike)[]): Promise; (values: Iterable>): Promise; } >result.map(populateItems) : Promise<{}>[] ->result.map : (callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[] +>result.map : { (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): U[]; } >result : MyModule.MyModel[] ->map : (callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[] +>map : { (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): [U, U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel, MyModule.MyModel], callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): [U, U, U]; (this: [MyModule.MyModel, MyModule.MyModel], callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any): U[]; } >populateItems : (order: any) => Promise<{}> .then((orders: Array) => { diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols b/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols index c6ac17b0ccb..56d2c2dc87f 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols +++ b/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols @@ -11,7 +11,7 @@ function identity(a: A): A { } var x = [1, 2, 3].map(identity)[0]; >x : Symbol(x, Decl(inferentialTypingWithFunctionType2.ts, 3, 3)) ->[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >identity : Symbol(identity, Decl(inferentialTypingWithFunctionType2.ts, 0, 0)) diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.types b/tests/baselines/reference/inferentialTypingWithFunctionType2.types index 2c4bb2542fb..b9208409fe0 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionType2.types +++ b/tests/baselines/reference/inferentialTypingWithFunctionType2.types @@ -13,12 +13,12 @@ var x = [1, 2, 3].map(identity)[0]; >x : number >[1, 2, 3].map(identity)[0] : number >[1, 2, 3].map(identity) : number[] ->[1, 2, 3].map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>[1, 2, 3].map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >[1, 2, 3] : number[] >1 : 1 >2 : 2 >3 : 3 ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >identity : (a: A) => A >0 : 0 diff --git a/tests/baselines/reference/mapOnTupleTypes01.js b/tests/baselines/reference/mapOnTupleTypes01.js index 6c51cf3e6a3..cb1de5fdc61 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.js +++ b/tests/baselines/reference/mapOnTupleTypes01.js @@ -72,10 +72,10 @@ exports.h = numNumNumNumNum.map(function (n) { return n * n; }); //// [mapOnTupleTypes01.d.ts] export declare let mapOnLooseArrayLiteral: number[]; export declare let a: number[]; -export declare let b: number[]; -export declare let c: number[]; -export declare let d: (string | number)[]; -export declare let e: number[]; -export declare let f: number[]; -export declare let g: number[]; -export declare let h: number[]; +export declare let b: [number, number]; +export declare let c: [number, number]; +export declare let d: [string | number, string | number]; +export declare let e: [number, number, number]; +export declare let f: [number, number, number, number]; +export declare let g: [number, number, number, number, number]; +export declare let h: [number, number, number, number, number]; diff --git a/tests/baselines/reference/mapOnTupleTypes01.symbols b/tests/baselines/reference/mapOnTupleTypes01.symbols index 1c735fc06cf..1dbfca4a4c3 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.symbols +++ b/tests/baselines/reference/mapOnTupleTypes01.symbols @@ -2,8 +2,8 @@ export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); >mapOnLooseArrayLiteral : Symbol(mapOnLooseArrayLiteral, Decl(mapOnTupleTypes01.ts, 1, 10)) ->[1, 2, 3, 4].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>[1, 2, 3, 4].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53)) @@ -15,9 +15,9 @@ let numTuple: [number] = [1]; export let a = numTuple.map(x => x * x); >a : Symbol(a, Decl(mapOnTupleTypes01.ts, 6, 10)) ->numTuple.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numTuple.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28)) @@ -35,18 +35,18 @@ let numStr: [number, string] = [ 100, "hello"]; export let b = numNum.map(n => n * n); >b : Symbol(b, Decl(mapOnTupleTypes01.ts, 14, 10)) ->numNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26)) export let c = strStr.map(s => s.charCodeAt(0)); >c : Symbol(c, Decl(mapOnTupleTypes01.ts, 15, 10)) ->strStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>strStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26)) >s.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26)) @@ -54,9 +54,9 @@ export let c = strStr.map(s => s.charCodeAt(0)); export let d = numStr.map(x => x); >d : Symbol(d, Decl(mapOnTupleTypes01.ts, 16, 10)) ->numStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26)) >x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26)) @@ -67,9 +67,9 @@ let numNumNum: [number, number, number] = [1, 2, 3]; export let e = numNumNum.map(n => n * n); >e : Symbol(e, Decl(mapOnTupleTypes01.ts, 22, 10)) ->numNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29)) @@ -81,9 +81,9 @@ let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; export let f = numNumNumNum.map(n => n * n); >f : Symbol(f, Decl(mapOnTupleTypes01.ts, 28, 10)) ->numNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32)) @@ -95,9 +95,9 @@ let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; export let g = numNumNumNumNum.map(n => n * n); >g : Symbol(g, Decl(mapOnTupleTypes01.ts, 34, 10)) ->numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35)) @@ -110,9 +110,9 @@ let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2 export let h = numNumNumNumNum.map(n => n * n); >h : Symbol(h, Decl(mapOnTupleTypes01.ts, 41, 10)) ->numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) >n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35)) diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types index b97b9570fa1..0a01ecfa380 100644 --- a/tests/baselines/reference/mapOnTupleTypes01.types +++ b/tests/baselines/reference/mapOnTupleTypes01.types @@ -3,13 +3,13 @@ export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n); >mapOnLooseArrayLiteral : number[] >[1, 2, 3, 4].map(n => n * n) : number[] ->[1, 2, 3, 4].map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>[1, 2, 3, 4].map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >[1, 2, 3, 4] : number[] >1 : 1 >2 : 2 >3 : 3 >4 : 4 ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >n => n * n : (n: number) => number >n : number >n * n : number @@ -26,9 +26,9 @@ let numTuple: [number] = [1]; export let a = numTuple.map(x => x * x); >a : number[] >numTuple.map(x => x * x) : number[] ->numTuple.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>numTuple.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >numTuple : [number] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >x => x * x : (x: number) => number >x : number >x * x : number @@ -56,11 +56,11 @@ let numStr: [number, string] = [ 100, "hello"]; >"hello" : "hello" export let b = numNum.map(n => n * n); ->b : number[] ->numNum.map(n => n * n) : number[] ->numNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>b : [number, number] +>numNum.map(n => n * n) : [number, number] +>numNum.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >numNum : [number, number] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >n => n * n : (n: number) => number >n : number >n * n : number @@ -68,11 +68,11 @@ export let b = numNum.map(n => n * n); >n : number export let c = strStr.map(s => s.charCodeAt(0)); ->c : number[] ->strStr.map(s => s.charCodeAt(0)) : number[] ->strStr.map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>c : [number, number] +>strStr.map(s => s.charCodeAt(0)) : [number, number] +>strStr.map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >strStr : [string, string] ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >s => s.charCodeAt(0) : (s: string) => number >s : string >s.charCodeAt(0) : number @@ -82,11 +82,11 @@ export let c = strStr.map(s => s.charCodeAt(0)); >0 : 0 export let d = numStr.map(x => x); ->d : (string | number)[] ->numStr.map(x => x) : (string | number)[] ->numStr.map : (callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[] +>d : [string | number, string | number] +>numStr.map(x => x) : [string | number, string | number] +>numStr.map : { (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): [U, U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): [U, U, U]; (this: [string | number, string | number], callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): U[]; } >numStr : [number, string] ->map : (callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[] +>map : { (this: [string | number, string | number, string | number, string | number, string | number], callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string | number, string | number, string | number, string | number], callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): [U, U, U, U]; (this: [string | number, string | number, string | number], callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): [U, U, U]; (this: [string | number, string | number], callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any): U[]; } >x => x : (x: string | number) => string | number >x : string | number >x : string | number @@ -101,11 +101,11 @@ let numNumNum: [number, number, number] = [1, 2, 3]; >3 : 3 export let e = numNumNum.map(n => n * n); ->e : number[] ->numNumNum.map(n => n * n) : number[] ->numNumNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>e : [number, number, number] +>numNumNum.map(n => n * n) : [number, number, number] +>numNumNum.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >numNumNum : [number, number, number] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >n => n * n : (n: number) => number >n : number >n * n : number @@ -123,11 +123,11 @@ let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4]; >4 : 4 export let f = numNumNumNum.map(n => n * n); ->f : number[] ->numNumNumNum.map(n => n * n) : number[] ->numNumNumNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>f : [number, number, number, number] +>numNumNumNum.map(n => n * n) : [number, number, number, number] +>numNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >numNumNumNum : [number, number, number, number] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >n => n * n : (n: number) => number >n : number >n * n : number @@ -146,11 +146,11 @@ let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5]; >5 : 5 export let g = numNumNumNumNum.map(n => n * n); ->g : number[] ->numNumNumNumNum.map(n => n * n) : number[] ->numNumNumNumNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>g : [number, number, number, number, number] +>numNumNumNumNum.map(n => n * n) : [number, number, number, number, number] +>numNumNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >numNumNumNumNum : [number, number, number, number, number] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >n => n * n : (n: number) => number >n : number >n * n : number @@ -171,11 +171,11 @@ let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2 >6 : 6 export let h = numNumNumNumNum.map(n => n * n); ->h : number[] ->numNumNumNumNum.map(n => n * n) : number[] ->numNumNumNumNum.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>h : [number, number, number, number, number] +>numNumNumNumNum.map(n => n * n) : [number, number, number, number, number] +>numNumNumNumNum.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >numNumNumNumNum : [number, number, number, number, number] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >n => n * n : (n: number) => number >n : number >n * n : number diff --git a/tests/baselines/reference/mapOnTupleTypes02.js b/tests/baselines/reference/mapOnTupleTypes02.js index 0f5f59f3285..97ffc9510db 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.js +++ b/tests/baselines/reference/mapOnTupleTypes02.js @@ -16,4 +16,4 @@ exports.increment = increment; //// [mapOnTupleTypes02.d.ts] export declare type Point = [number, number]; -export declare function increment(point: Point): number[]; +export declare function increment(point: Point): [number, number]; diff --git a/tests/baselines/reference/mapOnTupleTypes02.symbols b/tests/baselines/reference/mapOnTupleTypes02.symbols index e0f1ca79f61..da27a13d4f6 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.symbols +++ b/tests/baselines/reference/mapOnTupleTypes02.symbols @@ -9,9 +9,9 @@ export function increment(point: Point) { >Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0)) return point.map(d => d + 1); ->point.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>point.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19)) >d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19)) } diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types index bb261f3093a..3803e3c319e 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.types +++ b/tests/baselines/reference/mapOnTupleTypes02.types @@ -4,15 +4,15 @@ export type Point = [number, number]; >Point : [number, number] export function increment(point: Point) { ->increment : (point: [number, number]) => number[] +>increment : (point: [number, number]) => [number, number] >point : [number, number] >Point : [number, number] return point.map(d => d + 1); ->point.map(d => d + 1) : number[] ->point.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>point.map(d => d + 1) : [number, number] +>point.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >point : [number, number] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >d => d + 1 : (d: number) => number >d : number >d + 1 : number diff --git a/tests/baselines/reference/nestedSelf.symbols b/tests/baselines/reference/nestedSelf.symbols index 50bdd9981e2..b9a9e91d36d 100644 --- a/tests/baselines/reference/nestedSelf.symbols +++ b/tests/baselines/reference/nestedSelf.symbols @@ -10,8 +10,8 @@ module M { public foo() { [1,2,3].map((x) => { return this.n * x; })} >foo : Symbol(C.foo, Decl(nestedSelf.ts, 2, 17)) ->[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(nestedSelf.ts, 3, 31)) >this.n : Symbol(C.n, Decl(nestedSelf.ts, 1, 17)) >this : Symbol(C, Decl(nestedSelf.ts, 0, 10)) diff --git a/tests/baselines/reference/nestedSelf.types b/tests/baselines/reference/nestedSelf.types index 9fb4b0bd65d..1ec95a8d24a 100644 --- a/tests/baselines/reference/nestedSelf.types +++ b/tests/baselines/reference/nestedSelf.types @@ -12,12 +12,12 @@ module M { public foo() { [1,2,3].map((x) => { return this.n * x; })} >foo : () => void >[1,2,3].map((x) => { return this.n * x; }) : number[] ->[1,2,3].map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>[1,2,3].map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >[1,2,3] : number[] >1 : 1 >2 : 2 >3 : 3 ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >(x) => { return this.n * x; } : (x: number) => number >x : number >this.n * x : number diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols index 49528257830..23a1df25653 100644 --- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols +++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols @@ -1,9 +1,9 @@ === tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts === [].map(() => [].map(p => ({ X: p }))); ->[].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) ->[].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>[].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>[].map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20)) >X : Symbol(X, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 27)) >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20)) diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types index 417a51ac4b8..ff1640909d9 100644 --- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types +++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types @@ -1,14 +1,14 @@ === tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts === [].map(() => [].map(p => ({ X: p }))); >[].map(() => [].map(p => ({ X: p }))) : { X: any; }[][] ->[].map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>[].map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >[] : undefined[] ->map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >() => [].map(p => ({ X: p })) : () => { X: any; }[] >[].map(p => ({ X: p })) : { X: any; }[] ->[].map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>[].map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >[] : undefined[] ->map : (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[] +>map : { (this: [any, any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [any, any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U, U]; (this: [any, any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U, U]; (this: [any, any], callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[]; } >p => ({ X: p }) : (p: any) => { X: any; } >p : any >({ X: p }) : { X: any; } diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols index 5c93a74fe51..7d5a6d979b3 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols @@ -23,9 +23,9 @@ function foo() { >series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7)) series2.map(seriesExtent); ->series2.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>series2.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7)) return null; @@ -34,11 +34,11 @@ function foo() { var keyExtent2: any[] = series.data.map(function (d: string) { return d; }); >keyExtent2 : Symbol(keyExtent2, Decl(specializationsShouldNotAffectEachOther.ts, 19, 3)) ->series.data.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>series.data.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >series.data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19)) >series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 5, 3)) >data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50)) >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50)) diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types index f666fd8fe21..aa14eca0508 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types @@ -26,9 +26,9 @@ function foo() { series2.map(seriesExtent); >series2.map(seriesExtent) : any[] ->series2.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>series2.map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >series2 : number[] ->map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>map : { (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U]; (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U]; (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; } >seriesExtent : (series: any) => any return null; @@ -39,11 +39,11 @@ function foo() { var keyExtent2: any[] = series.data.map(function (d: string) { return d; }); >keyExtent2 : any[] >series.data.map(function (d: string) { return d; }) : string[] ->series.data.map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>series.data.map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >series.data : string[] >series : Series >data : string[] ->map : (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[] +>map : { (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U]; (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U]; (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[]; } >function (d: string) { return d; } : (d: string) => string >d : string >d : string diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols index b73bd8882d2..766c75e2c13 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols +++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols @@ -15,9 +15,9 @@ var nodes: TreeNode[]; >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 0)) nodes.map(n => n.name); ->nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 5, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10)) >n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17)) >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10)) diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types index 5269bd9b518..045b5e65da3 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types +++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types @@ -16,9 +16,9 @@ var nodes: TreeNode[]; nodes.map(n => n.name); >nodes.map(n => n.name) : string[] ->nodes.map : (callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[] +>nodes.map : { (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): [U, U, U]; (this: [TreeNode, TreeNode], callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): U[]; } >nodes : TreeNode[] ->map : (callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[] +>map : { (this: [TreeNode, TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode, TreeNode], callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): [U, U, U, U]; (this: [TreeNode, TreeNode, TreeNode], callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): [U, U, U]; (this: [TreeNode, TreeNode], callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any): U[]; } >n => n.name : (n: TreeNode) => string >n : TreeNode >n.name : string diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols index 7cec46cb4b6..62e2b398827 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols +++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols @@ -26,9 +26,9 @@ var nodes: TreeNodeMiddleman[]; >TreeNodeMiddleman : Symbol(TreeNodeMiddleman, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 3, 1)) nodes.map(n => n.name); ->nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 10, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10)) >n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26)) >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10)) diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types index fec665f3f61..6e3997c2d1f 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types +++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types @@ -27,9 +27,9 @@ var nodes: TreeNodeMiddleman[]; nodes.map(n => n.name); >nodes.map(n => n.name) : string[] ->nodes.map : (callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any) => U[] +>nodes.map : { (this: [{ name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }], callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [{ name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }], callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): [U, U, U, U]; (this: [{ name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }], callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): [U, U, U]; (this: [{ name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }], callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): U[]; } >nodes : { name: string; parent: TreeNode; }[] ->map : (callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any) => U[] +>map : { (this: [{ name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }], callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): [U, U, U, U, U]; (this: [{ name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }], callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): [U, U, U, U]; (this: [{ name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }], callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): [U, U, U]; (this: [{ name: string; parent: TreeNode; }, { name: string; parent: TreeNode; }], callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): [U, U]; (callbackfn: (value: { name: string; parent: TreeNode; }, index: number, array: { name: string; parent: TreeNode; }[]) => U, thisArg?: any): U[]; } >n => n.name : (n: { name: string; parent: TreeNode; }) => string >n : { name: string; parent: TreeNode; } >n.name : string From 561168c01cdc3b43edb0a5394ba0b3bc55980e5f Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 29 Sep 2016 10:46:54 -0700 Subject: [PATCH 08/21] Make isObjectLiteral required --- src/compiler/checker.ts | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 5c38b9477ed..3c73bccb049 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -134,16 +134,16 @@ namespace ts { const neverType = createIntrinsicType(TypeFlags.Never, "never"); const silentNeverType = createIntrinsicType(TypeFlags.Never, "never"); - const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); - const emptyGenericType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); + const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined, undefined); + const emptyGenericType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined, undefined); emptyGenericType.instantiations = createMap(); - const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); + const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined, undefined); // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated // in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes. anyFunctionType.flags |= TypeFlags.ContainsAnyFunctionType; - const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); + const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined, undefined); const anySignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false); const unknownSignature = createSignature(undefined, undefined, undefined, emptyArray, unknownType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false); @@ -1618,7 +1618,7 @@ namespace ts { return type; } - function createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo, isObjectLiteral?: boolean): ResolvedType { + function createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo, isObjectLiteral: boolean): ResolvedType { const t = createObjectType(TypeFlags.Anonymous, symbol); if (isObjectLiteral) { t.isObjectLiteral = true; @@ -3176,7 +3176,7 @@ namespace ts { symbol.bindingElement = e; members[symbol.name] = symbol; }); - const result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined); + const result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined, undefined); if (includePatternInType) { result.pattern = pattern; } @@ -12492,7 +12492,7 @@ namespace ts { function getInferredClassType(symbol: Symbol) { const links = getSymbolLinks(symbol); if (!links.inferredClassType) { - links.inferredClassType = createAnonymousType(symbol, symbol.members, emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined); + links.inferredClassType = createAnonymousType(symbol, symbol.members, emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined, /*isObjectLiteral*/ undefined); } return links.inferredClassType; } From 9e1b5300c4693091783b2d82fe44aeb1e5f021b8 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Thu, 29 Sep 2016 11:26:58 -0700 Subject: [PATCH 09/21] Put TypeFlags.ObjectLiteral back --- src/compiler/checker.ts | 40 +++++++++++++++++----------------------- src/compiler/types.ts | 1 - 2 files changed, 17 insertions(+), 24 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3c73bccb049..7a2ec512e5a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -134,16 +134,16 @@ namespace ts { const neverType = createIntrinsicType(TypeFlags.Never, "never"); const silentNeverType = createIntrinsicType(TypeFlags.Never, "never"); - const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined, undefined); - const emptyGenericType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined, undefined); + const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); + const emptyGenericType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); emptyGenericType.instantiations = createMap(); - const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined, undefined); + const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated // in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes. anyFunctionType.flags |= TypeFlags.ContainsAnyFunctionType; - const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined, undefined); + const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); const anySignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false); const unknownSignature = createSignature(undefined, undefined, undefined, emptyArray, unknownType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false); @@ -1618,12 +1618,9 @@ namespace ts { return type; } - function createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo, isObjectLiteral: boolean): ResolvedType { - const t = createObjectType(TypeFlags.Anonymous, symbol); - if (isObjectLiteral) { - t.isObjectLiteral = true; - } - return setObjectTypeMembers(t, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); + function createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo): ResolvedType { + return setObjectTypeMembers(createObjectType(TypeFlags.Anonymous, symbol), + members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); } function forEachSymbolTableInScope(enclosingDeclaration: Node, callback: (symbolTable: SymbolTable) => T): T { @@ -3176,7 +3173,7 @@ namespace ts { symbol.bindingElement = e; members[symbol.name] = symbol; }); - const result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined, undefined); + const result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined); if (includePatternInType) { result.pattern = pattern; } @@ -6477,7 +6474,7 @@ namespace ts { if (isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined)) return Ternary.True; - if (source.flags & TypeFlags.ObjectType && (source as ObjectType).isObjectLiteral && source.flags & TypeFlags.FreshLiteral) { + if (source.flags & TypeFlags.ObjectLiteral && source.flags & TypeFlags.FreshLiteral) { if (hasExcessProperties(source, target, reportErrors)) { if (reportErrors) { reportRelationError(headMessage, source, target); @@ -6846,7 +6843,7 @@ namespace ts { } let result = Ternary.True; const properties = getPropertiesOfObjectType(target); - const requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectType && (source as ObjectType).isObjectLiteral); + const requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectLiteral); for (const targetProp of properties) { const sourceProp = getPropertyOfType(source, targetProp.name); @@ -7485,7 +7482,7 @@ namespace ts { * Leave signatures alone since they are not subject to the check. */ function getRegularTypeOfObjectLiteral(type: Type): Type { - if (!(type.flags & TypeFlags.ObjectType && (type as ObjectType).isObjectLiteral && type.flags & TypeFlags.FreshLiteral)) { + if (!(type.flags & TypeFlags.ObjectLiteral && type.flags & TypeFlags.FreshLiteral)) { return type; } const regularType = (type).regularType; @@ -7500,8 +7497,7 @@ namespace ts { resolved.callSignatures, resolved.constructSignatures, resolved.stringIndexInfo, - resolved.numberIndexInfo, - resolved.isObjectLiteral); + resolved.numberIndexInfo); regularNew.flags = resolved.flags & ~TypeFlags.FreshLiteral; (type).regularType = regularNew; return regularNew; @@ -7516,8 +7512,7 @@ namespace ts { const numberIndexInfo = getIndexInfoOfType(type, IndexKind.Number); return createAnonymousType(type.symbol, members, emptyArray, emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), - numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly), - (type as ObjectType).isObjectLiteral); + numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly)); } function getWidenedConstituentType(type: Type): Type { @@ -7529,8 +7524,7 @@ namespace ts { if (type.flags & TypeFlags.Nullable) { return anyType; } - // if (type.flags & TypeFlags.ObjectLiteral) { - if (type.flags & TypeFlags.ObjectType && (type as ObjectType).isObjectLiteral) { + if (type.flags & TypeFlags.ObjectLiteral) { return getWidenedTypeOfObjectLiteral(type); } if (type.flags & TypeFlags.Union) { @@ -7570,7 +7564,7 @@ namespace ts { } } } - if (type.flags & TypeFlags.ObjectType && (type as ObjectType).isObjectLiteral) { + if (type.flags & TypeFlags.ObjectLiteral) { for (const p of getPropertiesOfObjectType(type)) { const t = getTypeOfSymbol(p); if (t.flags & TypeFlags.ContainsWideningType) { @@ -10379,7 +10373,7 @@ namespace ts { const stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, propertiesArray, IndexKind.String) : undefined; const numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, propertiesArray, IndexKind.Number) : undefined; - const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo, /*isObjectLiteral*/ true); + const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo); const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshLiteral; result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags); if (patternWithComputedProperties) { @@ -12492,7 +12486,7 @@ namespace ts { function getInferredClassType(symbol: Symbol) { const links = getSymbolLinks(symbol); if (!links.inferredClassType) { - links.inferredClassType = createAnonymousType(symbol, symbol.members, emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined, /*isObjectLiteral*/ undefined); + links.inferredClassType = createAnonymousType(symbol, symbol.members, emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined); } return links.inferredClassType; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 7b4f8dced69..d5afd486d65 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2462,7 +2462,6 @@ namespace ts { // Object types (TypeFlags.ObjectType) export interface ObjectType extends Type { - isObjectLiteral?: boolean; inObjectLiteralPatternWithComputedProperties?: boolean; } From e4e11021985fcc9e7f86b02f9949cb829f7c9d4b Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 29 Sep 2016 15:24:23 -0700 Subject: [PATCH 10/21] Fixed fourslash test. --- tests/cases/fourslash/completionEntryForUnionMethod.ts | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/cases/fourslash/completionEntryForUnionMethod.ts b/tests/cases/fourslash/completionEntryForUnionMethod.ts index f8b5b42f2a5..dd0e034cd2d 100644 --- a/tests/cases/fourslash/completionEntryForUnionMethod.ts +++ b/tests/cases/fourslash/completionEntryForUnionMethod.ts @@ -5,6 +5,7 @@ goTo.marker(); verify.quickInfoIs( - "(property) map: ((callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | ((callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[])", - "Calls a defined callback function on each element of an array, and returns an array that contains the results."); -verify.completionListContains('map', "(property) map: ((callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | ((callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[])"); \ No newline at end of file + "(property) map: {\n (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U];\n (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U];\n (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U];\n (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U];\n (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[];\n} | {\n (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U];\n (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U];\n (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U];\n (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U];\n (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[];\n}", + "Calls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results.\nCalls a defined callback function on each element of an array, and returns an array that contains the results."); + +verify.completionListContains('map', "(property) map: {\n (this: [string, string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U, U];\n (this: [string, string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U, U];\n (this: [string, string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U, U];\n (this: [string, string], callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): [U, U];\n (callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[];\n} | {\n (this: [number, number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U, U];\n (this: [number, number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U, U];\n (this: [number, number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U, U];\n (this: [number, number], callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): [U, U];\n (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[];\n}"); From a747a4da81c11f03a14f5cdbc16ef5511cb4f359 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Fri, 30 Sep 2016 17:29:24 -0700 Subject: [PATCH 11/21] Fix crash with nested generators --- src/compiler/transformers/generators.ts | 3 + .../transformNestedGeneratorsWithTry.js | 99 +++++++++++++++++++ .../transformNestedGeneratorsWithTry.symbols | 47 +++++++++ .../transformNestedGeneratorsWithTry.types | 52 ++++++++++ .../transformNestedGeneratorsWithTry.ts | 23 +++++ 5 files changed, 224 insertions(+) create mode 100644 tests/baselines/reference/transformNestedGeneratorsWithTry.js create mode 100644 tests/baselines/reference/transformNestedGeneratorsWithTry.symbols create mode 100644 tests/baselines/reference/transformNestedGeneratorsWithTry.types create mode 100644 tests/cases/compiler/transformNestedGeneratorsWithTry.ts diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index 6fe3187bee1..f3a47f037ca 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -552,6 +552,7 @@ namespace ts { const savedBlocks = blocks; const savedBlockOffsets = blockOffsets; const savedBlockActions = blockActions; + const savedBlockStack = blockStack; const savedLabelOffsets = labelOffsets; const savedLabelExpressions = labelExpressions; const savedNextLabelId = nextLabelId; @@ -566,6 +567,7 @@ namespace ts { blocks = undefined; blockOffsets = undefined; blockActions = undefined; + blockStack = undefined; labelOffsets = undefined; labelExpressions = undefined; nextLabelId = 1; @@ -591,6 +593,7 @@ namespace ts { blocks = savedBlocks; blockOffsets = savedBlockOffsets; blockActions = savedBlockActions; + blockStack = savedBlockStack; labelOffsets = savedLabelOffsets; labelExpressions = savedLabelExpressions; nextLabelId = savedNextLabelId; diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.js b/tests/baselines/reference/transformNestedGeneratorsWithTry.js new file mode 100644 index 00000000000..55dc8bb6558 --- /dev/null +++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.js @@ -0,0 +1,99 @@ +//// [tests/cases/compiler/transformNestedGeneratorsWithTry.ts] //// + +//// [main.ts] +import * as Bluebird from 'bluebird'; +async function a(): Bluebird { + try { + const b = async function b(): Bluebird { + try { + await Bluebird.resolve(); // -- remove this and it compiles + } catch (error) { } + }; + + await b(); // -- or remove this and it compiles + } catch (error) { } +} + +//// [bluebird.d.ts] +declare module "bluebird" { + type Bluebird = Promise; + const Bluebird: typeof Promise; + export = Bluebird; +} + +//// [main.js] +"use strict"; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments)).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t; + return { next: verb(0), "throw": verb(1), "return": verb(2) }; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [0, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var Bluebird = require("bluebird"); +function a() { + return __awaiter(this, void 0, Bluebird, function () { + var b, error_1; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, 2, , 3]); + b = function b() { + return __awaiter(this, void 0, Bluebird, function () { + var error_2; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, 2, , 3]); + return [4 /*yield*/, Bluebird.resolve()]; + case 1: + _a.sent(); // -- remove this and it compiles + return [3 /*break*/, 3]; + case 2: + error_2 = _a.sent(); + return [3 /*break*/, 3]; + case 3: return [2 /*return*/]; + } + }); + }); + }; + return [4 /*yield*/, b()]; + case 1: + _a.sent(); // -- or remove this and it compiles + return [3 /*break*/, 3]; + case 2: + error_1 = _a.sent(); + return [3 /*break*/, 3]; + case 3: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols new file mode 100644 index 00000000000..4713b682ff3 --- /dev/null +++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols @@ -0,0 +1,47 @@ +=== tests/cases/compiler/main.ts === +import * as Bluebird from 'bluebird'; +>Bluebird : Symbol(Bluebird, Decl(main.ts, 0, 6)) + +async function a(): Bluebird { +>a : Symbol(a, Decl(main.ts, 0, 37)) +>Bluebird : Symbol(Bluebird, Decl(main.ts, 0, 6)) + + try { + const b = async function b(): Bluebird { +>b : Symbol(b, Decl(main.ts, 3, 9)) +>b : Symbol(b, Decl(main.ts, 3, 13)) +>Bluebird : Symbol(Bluebird, Decl(main.ts, 0, 6)) + + try { + await Bluebird.resolve(); // -- remove this and it compiles +>Bluebird.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Bluebird : Symbol(Bluebird, Decl(main.ts, 0, 6)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + } catch (error) { } +>error : Symbol(error, Decl(main.ts, 6, 15)) + + }; + + await b(); // -- or remove this and it compiles +>b : Symbol(b, Decl(main.ts, 3, 9)) + + } catch (error) { } +>error : Symbol(error, Decl(main.ts, 10, 11)) +} + +=== tests/cases/compiler/bluebird.d.ts === +declare module "bluebird" { + type Bluebird = Promise; +>Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9)) +>T : Symbol(T, Decl(bluebird.d.ts, 1, 18)) +>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(bluebird.d.ts, 1, 18)) + + const Bluebird: typeof Promise; +>Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9)) +>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) + + export = Bluebird; +>Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9)) +} diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.types b/tests/baselines/reference/transformNestedGeneratorsWithTry.types new file mode 100644 index 00000000000..25198b98adf --- /dev/null +++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.types @@ -0,0 +1,52 @@ +=== tests/cases/compiler/main.ts === +import * as Bluebird from 'bluebird'; +>Bluebird : PromiseConstructor + +async function a(): Bluebird { +>a : () => Promise +>Bluebird : Promise + + try { + const b = async function b(): Bluebird { +>b : () => Promise +>async function b(): Bluebird { try { await Bluebird.resolve(); // -- remove this and it compiles } catch (error) { } } : () => Promise +>b : () => Promise +>Bluebird : Promise + + try { + await Bluebird.resolve(); // -- remove this and it compiles +>await Bluebird.resolve() : void +>Bluebird.resolve() : Promise +>Bluebird.resolve : { (value: T | PromiseLike): Promise; (): Promise; } +>Bluebird : PromiseConstructor +>resolve : { (value: T | PromiseLike): Promise; (): Promise; } + + } catch (error) { } +>error : any + + }; + + await b(); // -- or remove this and it compiles +>await b() : void +>b() : Promise +>b : () => Promise + + } catch (error) { } +>error : any +} + +=== tests/cases/compiler/bluebird.d.ts === +declare module "bluebird" { + type Bluebird = Promise; +>Bluebird : Promise +>T : T +>Promise : Promise +>T : T + + const Bluebird: typeof Promise; +>Bluebird : PromiseConstructor +>Promise : PromiseConstructor + + export = Bluebird; +>Bluebird : Promise +} diff --git a/tests/cases/compiler/transformNestedGeneratorsWithTry.ts b/tests/cases/compiler/transformNestedGeneratorsWithTry.ts new file mode 100644 index 00000000000..7d57c17c7a3 --- /dev/null +++ b/tests/cases/compiler/transformNestedGeneratorsWithTry.ts @@ -0,0 +1,23 @@ +// @target: ES5 +// @lib: es5,es6 +// @filename: main.ts +// https://github.com/Microsoft/TypeScript/issues/11177 +import * as Bluebird from 'bluebird'; +async function a(): Bluebird { + try { + const b = async function b(): Bluebird { + try { + await Bluebird.resolve(); // -- remove this and it compiles + } catch (error) { } + }; + + await b(); // -- or remove this and it compiles + } catch (error) { } +} + +// @filename: bluebird.d.ts +declare module "bluebird" { + type Bluebird = Promise; + const Bluebird: typeof Promise; + export = Bluebird; +} \ No newline at end of file From f293bf5cb448e7e10782823f4bfd24b1e81d1cd7 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Sat, 1 Oct 2016 15:31:24 -0700 Subject: [PATCH 12/21] Updated baselines --- .../transformNestedGeneratorsWithTry.js | 2 ++ .../transformNestedGeneratorsWithTry.symbols | 21 ++++++++++--------- .../transformNestedGeneratorsWithTry.types | 1 + 3 files changed, 14 insertions(+), 10 deletions(-) diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.js b/tests/baselines/reference/transformNestedGeneratorsWithTry.js index 55dc8bb6558..4ad1b2b7e88 100644 --- a/tests/baselines/reference/transformNestedGeneratorsWithTry.js +++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.js @@ -1,6 +1,7 @@ //// [tests/cases/compiler/transformNestedGeneratorsWithTry.ts] //// //// [main.ts] +// https://github.com/Microsoft/TypeScript/issues/11177 import * as Bluebird from 'bluebird'; async function a(): Bluebird { try { @@ -58,6 +59,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) { if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; } }; +// https://github.com/Microsoft/TypeScript/issues/11177 var Bluebird = require("bluebird"); function a() { return __awaiter(this, void 0, Bluebird, function () { diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols index 4713b682ff3..e966202c277 100644 --- a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols +++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols @@ -1,33 +1,34 @@ === tests/cases/compiler/main.ts === +// https://github.com/Microsoft/TypeScript/issues/11177 import * as Bluebird from 'bluebird'; ->Bluebird : Symbol(Bluebird, Decl(main.ts, 0, 6)) +>Bluebird : Symbol(Bluebird, Decl(main.ts, 1, 6)) async function a(): Bluebird { ->a : Symbol(a, Decl(main.ts, 0, 37)) ->Bluebird : Symbol(Bluebird, Decl(main.ts, 0, 6)) +>a : Symbol(a, Decl(main.ts, 1, 37)) +>Bluebird : Symbol(Bluebird, Decl(main.ts, 1, 6)) try { const b = async function b(): Bluebird { ->b : Symbol(b, Decl(main.ts, 3, 9)) ->b : Symbol(b, Decl(main.ts, 3, 13)) ->Bluebird : Symbol(Bluebird, Decl(main.ts, 0, 6)) +>b : Symbol(b, Decl(main.ts, 4, 9)) +>b : Symbol(b, Decl(main.ts, 4, 13)) +>Bluebird : Symbol(Bluebird, Decl(main.ts, 1, 6)) try { await Bluebird.resolve(); // -- remove this and it compiles >Bluebird.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) ->Bluebird : Symbol(Bluebird, Decl(main.ts, 0, 6)) +>Bluebird : Symbol(Bluebird, Decl(main.ts, 1, 6)) >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } catch (error) { } ->error : Symbol(error, Decl(main.ts, 6, 15)) +>error : Symbol(error, Decl(main.ts, 7, 15)) }; await b(); // -- or remove this and it compiles ->b : Symbol(b, Decl(main.ts, 3, 9)) +>b : Symbol(b, Decl(main.ts, 4, 9)) } catch (error) { } ->error : Symbol(error, Decl(main.ts, 10, 11)) +>error : Symbol(error, Decl(main.ts, 11, 11)) } === tests/cases/compiler/bluebird.d.ts === diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.types b/tests/baselines/reference/transformNestedGeneratorsWithTry.types index 25198b98adf..3e4ef3f0852 100644 --- a/tests/baselines/reference/transformNestedGeneratorsWithTry.types +++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.types @@ -1,4 +1,5 @@ === tests/cases/compiler/main.ts === +// https://github.com/Microsoft/TypeScript/issues/11177 import * as Bluebird from 'bluebird'; >Bluebird : PromiseConstructor From fcb4c2ba0f1ab659e6ee4f80df0d36801f35d486 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 3 Oct 2016 08:32:37 -0700 Subject: [PATCH 13/21] Use a `for-of` loop for a dense array instead of iterating over keys and then indexing --- src/compiler/transformers/es6.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/compiler/transformers/es6.ts b/src/compiler/transformers/es6.ts index e3ee1dd4c3a..7fb0594a6cc 100644 --- a/src/compiler/transformers/es6.ts +++ b/src/compiler/transformers/es6.ts @@ -2308,8 +2308,7 @@ namespace ts { extraVariableDeclarations = []; } // hoist collected variable declarations - for (const name in currentState.hoistedLocalVariables) { - const identifier = currentState.hoistedLocalVariables[name]; + for (const identifier of currentState.hoistedLocalVariables) { extraVariableDeclarations.push(createVariableDeclaration(identifier)); } } From 4900c074f58567f715840cd8ef0637f314a3c166 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Mon, 3 Oct 2016 10:05:48 -0700 Subject: [PATCH 14/21] Fix capitalization of lsHost --- src/server/tsconfig.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/server/tsconfig.json b/src/server/tsconfig.json index 9e65eb2b8bc..7eb8c28f383 100644 --- a/src/server/tsconfig.json +++ b/src/server/tsconfig.json @@ -18,7 +18,7 @@ "utilities.ts", "scriptVersionCache.ts", "scriptInfo.ts", - "lshost.ts", + "lsHost.ts", "typingsCache.ts", "project.ts", "editorServices.ts", From 5cdbe773c6a89075cceb966474b6d6dba6869cf8 Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Mon, 3 Oct 2016 14:42:06 -0700 Subject: [PATCH 15/21] guard against cases when current file name is already in uppercase --- src/compiler/sys.ts | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts index ed89b9d1611..2d4fcd241aa 100644 --- a/src/compiler/sys.ts +++ b/src/compiler/sys.ts @@ -316,10 +316,9 @@ namespace ts { if (platform === "win32" || platform === "win64") { return false; } - - const upperCaseFilename = _path.basename(__filename).toUpperCase(); - - return !fileExists(_path.join(_path.dirname(__filename), upperCaseFilename)); + // convert current file name to upper case / lower case and check if file exists + // (guards against cases when name is already all uppercase or lowercase) + return !fileExists(__filename.toUpperCase()) || !fileExists(__filename.toLowerCase()); } const platform: string = _os.platform(); From 84e319e226670a571b07f19368fcf5c5ac564cf2 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Mon, 3 Oct 2016 15:54:41 -0700 Subject: [PATCH 16/21] Minor style cleanup --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 7a2ec512e5a..07a81967661 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3157,7 +3157,7 @@ namespace ts { // Return the type implied by an object binding pattern function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): ResolvedType { const members = createMap(); - let hasComputedProperties: boolean; + let hasComputedProperties = false; forEach(pattern.elements, e => { const name = e.propertyName || e.name; if (isComputedNonLiteralName(name)) { @@ -10274,7 +10274,7 @@ namespace ts { const contextualTypeHasPattern = contextualType && contextualType.pattern && (contextualType.pattern.kind === SyntaxKind.ObjectBindingPattern || contextualType.pattern.kind === SyntaxKind.ObjectLiteralExpression); let typeFlags: TypeFlags = 0; - let patternWithComputedProperties: boolean | undefined; + let patternWithComputedProperties = false; let hasComputedStringProperty = false; let hasComputedNumberProperty = false; From 663ee44e62ecb885453db36dec542a335a449488 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Mon, 3 Oct 2016 16:01:08 -0700 Subject: [PATCH 17/21] Rename isObjectLiteralPatternWithComputedProperties --- src/compiler/checker.ts | 8 ++++---- src/compiler/types.ts | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 34a850ea152..e7b9b011fbc 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3179,7 +3179,7 @@ namespace ts { result.pattern = pattern; } if (hasComputedProperties) { - result.inObjectLiteralPatternWithComputedProperties = hasComputedProperties; + result.isObjectLiteralPatternWithComputedProperties = hasComputedProperties; } return result; } @@ -6650,7 +6650,7 @@ namespace ts { function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean { if (maybeTypeOfKind(target, TypeFlags.ObjectType) && - (!(target.flags & TypeFlags.ObjectType) || !(target as ObjectType).inObjectLiteralPatternWithComputedProperties)) { + (!(target.flags & TypeFlags.ObjectType) || !(target as ObjectType).isObjectLiteralPatternWithComputedProperties)) { for (const prop of getPropertiesOfObjectType(source)) { if (!isKnownProperty(target, prop.name)) { if (reportErrors) { @@ -10311,7 +10311,7 @@ namespace ts { } } else if (contextualTypeHasPattern && - !(contextualType.flags & TypeFlags.ObjectType && (contextualType as ObjectType).inObjectLiteralPatternWithComputedProperties)) { + !(contextualType.flags & TypeFlags.ObjectType && (contextualType as ObjectType).isObjectLiteralPatternWithComputedProperties)) { // If object literal is contextually typed by the implied type of a binding pattern, and if the // binding pattern specifies a default value for the property, make the property optional. const impliedProp = getPropertyOfType(contextualType, member.name); @@ -10378,7 +10378,7 @@ namespace ts { const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshLiteral; result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags); if (patternWithComputedProperties) { - result.inObjectLiteralPatternWithComputedProperties = patternWithComputedProperties; + result.isObjectLiteralPatternWithComputedProperties = patternWithComputedProperties; } if (inDestructuringPattern) { result.pattern = node; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 0f7eb00131b..4a4a25fd627 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2462,7 +2462,7 @@ namespace ts { // Object types (TypeFlags.ObjectType) export interface ObjectType extends Type { - inObjectLiteralPatternWithComputedProperties?: boolean; + isObjectLiteralPatternWithComputedProperties?: boolean; } // Class and interface types (TypeFlags.Class and TypeFlags.Interface) From 45af47a12fab2264a2ed4a0f71e90141d0782eaf Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Mon, 3 Oct 2016 16:06:06 -0700 Subject: [PATCH 18/21] getTypeFromObjectBindingPattern just returns Type again --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e7b9b011fbc..a9e46bf1188 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3156,7 +3156,7 @@ namespace ts { } // Return the type implied by an object binding pattern - function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): ResolvedType { + function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): Type { const members = createMap(); let hasComputedProperties = false; forEach(pattern.elements, e => { From f8526960873a5000347f73c536e663de3e651a6d Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Mon, 3 Oct 2016 16:10:16 -0700 Subject: [PATCH 19/21] Just assign true inside an if where a boolean was just checked --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index a9e46bf1188..422f2a70dcc 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3179,7 +3179,7 @@ namespace ts { result.pattern = pattern; } if (hasComputedProperties) { - result.isObjectLiteralPatternWithComputedProperties = hasComputedProperties; + result.isObjectLiteralPatternWithComputedProperties = true; } return result; } @@ -10378,7 +10378,7 @@ namespace ts { const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshLiteral; result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags); if (patternWithComputedProperties) { - result.isObjectLiteralPatternWithComputedProperties = patternWithComputedProperties; + result.isObjectLiteralPatternWithComputedProperties = true; } if (inDestructuringPattern) { result.pattern = node; From 860dd237083836c2a870c83c0c6d09deb16bdb82 Mon Sep 17 00:00:00 2001 From: Andy Hanson Date: Tue, 4 Oct 2016 09:04:23 -0700 Subject: [PATCH 20/21] Lint whitespace around "=" --- src/harness/harness.ts | 2 +- tslint.json | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 114326872f6..c6b6b460fca 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -925,7 +925,7 @@ namespace Harness { export const defaultLibFileName = "lib.d.ts"; export const es2015DefaultLibFileName = "lib.es2015.d.ts"; - const libFileNameSourceFileMap= ts.createMap({ + const libFileNameSourceFileMap = ts.createMap({ [defaultLibFileName]: createSourceFileAndAssertInvariants(defaultLibFileName, IO.readFile(libFolder + "lib.es5.d.ts"), /*languageVersion*/ ts.ScriptTarget.Latest) }); diff --git a/tslint.json b/tslint.json index f058eab3dd6..81990190ddb 100644 --- a/tslint.json +++ b/tslint.json @@ -20,10 +20,11 @@ "semicolon": true, "whitespace": [true, "check-branch", + "check-decl", "check-operator", + "check-module", "check-separator", - "check-type", - "check-module" + "check-type" ], "typedef-whitespace": [true, { "call-signature": "nospace", From 93b8df7c5d02cf217f34b2982bb6674d0259e75e Mon Sep 17 00:00:00 2001 From: Vladimir Matveev Date: Tue, 4 Oct 2016 12:11:59 -0700 Subject: [PATCH 21/21] Addresses #11348: Could the tsserver add process.noAsar = true; (#11351) (#11360) --- src/server/server.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/server/server.ts b/src/server/server.ts index 23e6b7f0de9..d59100bb57c 100644 --- a/src/server/server.ts +++ b/src/server/server.ts @@ -523,6 +523,8 @@ namespace ts.server { process.on("uncaughtException", function (err: Error) { ioSession.logError(err, "unknown"); }); + // See https://github.com/Microsoft/TypeScript/issues/11348 + (process as any).noAsar = true; // Start listening ioSession.listen(); } \ No newline at end of file