From 4de0a05402e5e0b804edc7ec1998bd8ff9f9d1c0 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 7 Jul 2016 11:52:07 -0700 Subject: [PATCH 01/10] Make TemplateStringsArray completely immutable. --- src/lib/es5.d.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 77b960409c2..6f017c8a343 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -513,8 +513,8 @@ interface NumberConstructor { /** An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers. */ declare const Number: NumberConstructor; -interface TemplateStringsArray extends Array { - readonly raw: string[]; +interface TemplateStringsArray extends ReadonlyArray { + readonly raw: ReadonlyArray } interface Math { From 348a4e96893e35ab8794197dc0add2a36bcc28e7 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 8 Jul 2016 17:13:12 -0700 Subject: [PATCH 02/10] Fixed up tests that used 'string[]' instead of 'TemplateStringsArray'. --- ...gedTemplateStringsTypeArgumentInference.ts | 22 +++++++++---------- ...TemplateStringsTypeArgumentInferenceES6.ts | 22 +++++++++---------- ...emplateStringsWithIncompatibleTypedTags.ts | 2 +- ...lateStringsWithIncompatibleTypedTagsES6.ts | 2 +- ...StringsWithManyCallAndMemberExpressions.ts | 2 +- ...ingsWithManyCallAndMemberExpressionsES6.ts | 2 +- ...dTemplateStringsWithOverloadResolution1.ts | 8 +++---- ...plateStringsWithOverloadResolution1_ES6.ts | 8 +++---- ...dTemplateStringsWithOverloadResolution2.ts | 8 +++---- ...plateStringsWithOverloadResolution2_ES6.ts | 8 +++---- .../taggedTemplateStringsWithTypedTags.ts | 2 +- .../taggedTemplateStringsWithTypedTagsES6.ts | 2 +- ...eHelpTaggedTemplatesWithOverloadedTags3.ts | 8 +++---- ...eHelpTaggedTemplatesWithOverloadedTags7.ts | 8 +++---- 14 files changed, 52 insertions(+), 52 deletions(-) diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts index 961544f309a..17f2ea6b848 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts @@ -5,60 +5,60 @@ function noParams(n: T) { } noParams ``; // Generic tag with parameter which does not use type parameter -function noGenericParams(n: string[]) { } +function noGenericParams(n: TemplateStringsArray) { } noGenericParams ``; // Generic tag with multiple type parameters and only one used in parameter type annotation function someGenerics1a(n: T, m: number) { } someGenerics1a `${3}`; -function someGenerics1b(n: string[], m: U) { } +function someGenerics1b(n: TemplateStringsArray, m: U) { } someGenerics1b `${3}`; // Generic tag with argument of function type whose parameter is of type parameter type -function someGenerics2a(strs: string[], n: (x: T) => void) { } +function someGenerics2a(strs: TemplateStringsArray, n: (x: T) => void) { } someGenerics2a `${(n: string) => n}`; -function someGenerics2b(strs: string[], n: (x: T, y: U) => void) { } +function someGenerics2b(strs: TemplateStringsArray, n: (x: T, y: U) => void) { } someGenerics2b `${ (n: string, x: number) => n }`; // Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter -function someGenerics3(strs: string[], producer: () => T) { } +function someGenerics3(strs: TemplateStringsArray, producer: () => T) { } someGenerics3 `${() => ''}`; someGenerics3 `${() => undefined}`; someGenerics3 `${() => 3}`; // 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type -function someGenerics4(strs: string[], n: T, f: (x: U) => void) { } +function someGenerics4(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics4 `${4}${ () => null }`; someGenerics4 `${''}${ () => 3 }`; someGenerics4 `${ null }${ null }`; // 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type -function someGenerics5(strs: string[], n: T, f: (x: U) => void) { } +function someGenerics5(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics5 `${ 4 } ${ () => null }`; someGenerics5 `${ '' }${ () => 3 }`; someGenerics5 `${null}${null}`; // Generic tag with multiple arguments of function types that each have parameters of the same generic type -function someGenerics6(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } +function someGenerics6(strs: TemplateStringsArray, a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`; // Generic tag with multiple arguments of function types that each have parameters of different generic type -function someGenerics7(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } +function someGenerics7(strs: TemplateStringsArray, a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`; // Generic tag with argument of generic function type -function someGenerics8(strs: string[], n: T): T { return n; } +function someGenerics8(strs: TemplateStringsArray, n: T): T { return n; } var x = someGenerics8 `${ someGenerics7 }`; x `${null}${null}${null}`; // Generic tag with multiple parameters of generic type passed arguments with no best common type -function someGenerics9(strs: string[], a: T, b: T, c: T): T { +function someGenerics9(strs: TemplateStringsArray, a: T, b: T, c: T): T { return null; } var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`; diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts index bc9fd75cac9..a0ca1aa67d6 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts @@ -5,60 +5,60 @@ function noParams(n: T) { } noParams ``; // Generic tag with parameter which does not use type parameter -function noGenericParams(n: string[]) { } +function noGenericParams(n: TemplateStringsArray) { } noGenericParams ``; // Generic tag with multiple type parameters and only one used in parameter type annotation function someGenerics1a(n: T, m: number) { } someGenerics1a `${3}`; -function someGenerics1b(n: string[], m: U) { } +function someGenerics1b(n: TemplateStringsArray, m: U) { } someGenerics1b `${3}`; // Generic tag with argument of function type whose parameter is of type parameter type -function someGenerics2a(strs: string[], n: (x: T) => void) { } +function someGenerics2a(strs: TemplateStringsArray, n: (x: T) => void) { } someGenerics2a `${(n: string) => n}`; -function someGenerics2b(strs: string[], n: (x: T, y: U) => void) { } +function someGenerics2b(strs: TemplateStringsArray, n: (x: T, y: U) => void) { } someGenerics2b `${ (n: string, x: number) => n }`; // Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter -function someGenerics3(strs: string[], producer: () => T) { } +function someGenerics3(strs: TemplateStringsArray, producer: () => T) { } someGenerics3 `${() => ''}`; someGenerics3 `${() => undefined}`; someGenerics3 `${() => 3}`; // 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type -function someGenerics4(strs: string[], n: T, f: (x: U) => void) { } +function someGenerics4(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics4 `${4}${ () => null }`; someGenerics4 `${''}${ () => 3 }`; someGenerics4 `${ null }${ null }`; // 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type -function someGenerics5(strs: string[], n: T, f: (x: U) => void) { } +function someGenerics5(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics5 `${ 4 } ${ () => null }`; someGenerics5 `${ '' }${ () => 3 }`; someGenerics5 `${null}${null}`; // Generic tag with multiple arguments of function types that each have parameters of the same generic type -function someGenerics6(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } +function someGenerics6(strs: TemplateStringsArray, a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`; // Generic tag with multiple arguments of function types that each have parameters of different generic type -function someGenerics7(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } +function someGenerics7(strs: TemplateStringsArray, a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`; // Generic tag with argument of generic function type -function someGenerics8(strs: string[], n: T): T { return n; } +function someGenerics8(strs: TemplateStringsArray, n: T): T { return n; } var x = someGenerics8 `${ someGenerics7 }`; x `${null}${null}${null}`; // Generic tag with multiple parameters of generic type passed arguments with no best common type -function someGenerics9(strs: string[], a: T, b: T, c: T): T { +function someGenerics9(strs: TemplateStringsArray, a: T, b: T, c: T): T { return null; } var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`; diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts index 0f5d203d60b..d8be6cbd7c2 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts @@ -1,5 +1,5 @@ interface I { - (stringParts: string[], ...rest: boolean[]): I; + (stringParts: TemplateStringsArray, ...rest: boolean[]): I; g: I; h: I; member: I; diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts index 36dc249f672..dec483c1678 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts @@ -1,6 +1,6 @@ // @target: ES6 interface I { - (stringParts: string[], ...rest: boolean[]): I; + (stringParts: TemplateStringsArray, ...rest: boolean[]): I; g: I; h: I; member: I; diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts index d96196ee26e..f86353e7dda 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts @@ -1,5 +1,5 @@ interface I { - (strs: string[], ...subs: number[]): I; + (strs: TemplateStringsArray, ...subs: number[]): I; member: { new (s: string): { new (n: number): { diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts index d0d6604cfde..914f7ca809f 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts @@ -1,6 +1,6 @@ // @target: ES6 interface I { - (strs: string[], ...subs: number[]): I; + (strs: TemplateStringsArray, ...subs: number[]): I; member: { new (s: string): { new (n: number): { diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts index 5b29beddd48..3743c1a7710 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts @@ -1,7 +1,7 @@ -function foo(strs: string[]): number; -function foo(strs: string[], x: number): string; -function foo(strs: string[], x: number, y: number): boolean; -function foo(strs: string[], x: number, y: string): {}; +function foo(strs: TemplateStringsArray): number; +function foo(strs: TemplateStringsArray, x: number): string; +function foo(strs: TemplateStringsArray, x: number, y: number): boolean; +function foo(strs: TemplateStringsArray, x: number, y: string): {}; function foo(...stuff: any[]): any { return undefined; } diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts index f821d84fbdd..d681c6b98b0 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts @@ -1,8 +1,8 @@ //@target: es6 -function foo(strs: string[]): number; -function foo(strs: string[], x: number): string; -function foo(strs: string[], x: number, y: number): boolean; -function foo(strs: string[], x: number, y: string): {}; +function foo(strs: TemplateStringsArray): number; +function foo(strs: TemplateStringsArray, x: number): string; +function foo(strs: TemplateStringsArray, x: number, y: number): boolean; +function foo(strs: TemplateStringsArray, x: number, y: string): {}; function foo(...stuff: any[]): any { return undefined; } diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts index 0ed9b86128b..98799dd92df 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts @@ -5,8 +5,8 @@ function foo1(...stuff: any[]): any { return undefined; } -var a = foo1 `${1}`; // string -var b = foo1([], 1); // number +var a = foo1 `${1}`; +var b = foo1([], 1); function foo2(strs: string[], x: number): number; function foo2(strs: TemplateStringsArray, x: number): string; @@ -14,5 +14,5 @@ function foo2(...stuff: any[]): any { return undefined; } -var c = foo2 `${1}`; // number -var d = foo2([], 1); // number \ No newline at end of file +var c = foo2 `${1}`; +var d = foo2([], 1); \ No newline at end of file diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts index 6c67de325e2..769c56e47a1 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts @@ -5,8 +5,8 @@ function foo1(...stuff: any[]): any { return undefined; } -var a = foo1 `${1}`; // string -var b = foo1([], 1); // number +var a = foo1 `${1}`; +var b = foo1([], 1); function foo2(strs: string[], x: number): number; function foo2(strs: TemplateStringsArray, x: number): string; @@ -14,5 +14,5 @@ function foo2(...stuff: any[]): any { return undefined; } -var c = foo2 `${1}`; // number -var d = foo2([], 1); // number \ No newline at end of file +var c = foo2 `${1}`; +var d = foo2([], 1); \ No newline at end of file diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts index 9b3852c2ddb..60f97104be3 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts @@ -1,5 +1,5 @@ interface I { - (stringParts: string[], ...rest: number[]): I; + (stringParts: TemplateStringsArray, ...rest: number[]): I; g: I; h: I; member: I; diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTagsES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTagsES6.ts index 0dc10820a98..19fb6a874cc 100644 --- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTagsES6.ts +++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTagsES6.ts @@ -1,6 +1,6 @@ // @target: ES6 interface I { - (stringParts: string[], ...rest: number[]): I; + (stringParts: TemplateStringsArray, ...rest: number[]): I; g: I; h: I; member: I; diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags3.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags3.ts index 3843ed34b16..b919afc7703 100644 --- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags3.ts +++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags3.ts @@ -1,8 +1,8 @@ /// -//// function f(templateStrings: string[], p1_o1: string): number; -//// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string; -//// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean; +//// function f(templateStrings: TemplateStringsArray, p1_o1: string): number; +//// function f(templateStrings: TemplateStringsArray, p1_o2: number, p2_o2: number, p3_o2: number): string; +//// function f(templateStrings: TemplateStringsArray, p1_o3: string, p2_o3: boolean, p3_o3: number): boolean; //// function f(...foo[]: any) { return ""; } //// //// f `${/*1*/ "s/*2*/tring" /*3*/ } ${ @@ -14,7 +14,7 @@ test.markers().forEach(m => { verify.signatureHelpArgumentCountIs(3); verify.currentSignatureParameterCountIs(4); - verify.currentSignatureHelpIs('f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean'); + verify.currentSignatureHelpIs('f(templateStrings: TemplateStringsArray, p1_o3: string, p2_o3: boolean, p3_o3: number): boolean'); verify.currentParameterHelpArgumentNameIs("p1_o3"); verify.currentParameterSpanIs("p1_o3: string"); }); \ No newline at end of file diff --git a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags7.ts b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags7.ts index 9a24aacf86b..5f706b8c0fa 100644 --- a/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags7.ts +++ b/tests/cases/fourslash/signatureHelpTaggedTemplatesWithOverloadedTags7.ts @@ -1,8 +1,8 @@ /// -//// function f(templateStrings: string[], p1_o1: string): number; -//// function f(templateStrings: string[], p1_o2: number, p2_o2: number, p3_o2: number): string; -//// function f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean; +//// function f(templateStrings: TemplateStringsArray, p1_o1: string): number; +//// function f(templateStrings: TemplateStringsArray, p1_o2: number, p2_o2: number, p3_o2: number): string; +//// function f(templateStrings: TemplateStringsArray, p1_o3: string, p2_o3: boolean, p3_o3: number): boolean; //// function f(...foo[]: any) { return ""; } //// //// f `${ } ${/*1*/ fa/*2*/lse /*3*/} @@ -14,7 +14,7 @@ test.markers().forEach(m => { verify.signatureHelpArgumentCountIs(3); verify.currentSignatureParameterCountIs(4); - verify.currentSignatureHelpIs('f(templateStrings: string[], p1_o3: string, p2_o3: boolean, p3_o3: number): boolean'); + verify.currentSignatureHelpIs('f(templateStrings: TemplateStringsArray, p1_o3: string, p2_o3: boolean, p3_o3: number): boolean'); verify.currentParameterHelpArgumentNameIs("p2_o3"); verify.currentParameterSpanIs("p2_o3: boolean"); }); \ No newline at end of file From 0961352facdd87c8454cbee00474541e08255d2d Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 8 Jul 2016 17:50:01 -0700 Subject: [PATCH 03/10] Accepted baselines. --- ...ateStringsTypeArgumentInference.errors.txt | 22 +++++++------- ...gedTemplateStringsTypeArgumentInference.js | 22 +++++++------- ...StringsTypeArgumentInferenceES6.errors.txt | 22 +++++++------- ...TemplateStringsTypeArgumentInferenceES6.js | 22 +++++++------- ...tringsWithIncompatibleTypedTags.errors.txt | 2 +- ...emplateStringsWithIncompatibleTypedTags.js | 2 +- ...ngsWithIncompatibleTypedTagsES6.errors.txt | 2 +- ...lateStringsWithIncompatibleTypedTagsES6.js | 2 +- ...StringsWithManyCallAndMemberExpressions.js | 2 +- ...gsWithManyCallAndMemberExpressions.symbols | 11 +++---- ...ingsWithManyCallAndMemberExpressions.types | 5 ++-- ...ingsWithManyCallAndMemberExpressionsES6.js | 2 +- ...ithManyCallAndMemberExpressionsES6.symbols | 11 +++---- ...sWithManyCallAndMemberExpressionsES6.types | 5 ++-- ...eStringsWithOverloadResolution1.errors.txt | 30 ++++++++++++++----- ...dTemplateStringsWithOverloadResolution1.js | 8 ++--- ...ingsWithOverloadResolution1_ES6.errors.txt | 30 ++++++++++++++----- ...plateStringsWithOverloadResolution1_ES6.js | 8 ++--- ...dTemplateStringsWithOverloadResolution2.js | 16 +++++----- ...lateStringsWithOverloadResolution2.symbols | 8 ++--- ...mplateStringsWithOverloadResolution2.types | 12 ++++---- ...plateStringsWithOverloadResolution2_ES6.js | 16 +++++----- ...StringsWithOverloadResolution2_ES6.symbols | 8 ++--- ...teStringsWithOverloadResolution2_ES6.types | 12 ++++---- .../taggedTemplateStringsWithTypedTags.js | 2 +- ...taggedTemplateStringsWithTypedTags.symbols | 7 +++-- .../taggedTemplateStringsWithTypedTags.types | 5 ++-- .../taggedTemplateStringsWithTypedTagsES6.js | 2 +- ...gedTemplateStringsWithTypedTagsES6.symbols | 7 +++-- ...aggedTemplateStringsWithTypedTagsES6.types | 5 ++-- 30 files changed, 172 insertions(+), 136 deletions(-) diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt index be5c21f1a0b..b345e971ab2 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt @@ -13,60 +13,60 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference noParams ``; // Generic tag with parameter which does not use type parameter - function noGenericParams(n: string[]) { } + function noGenericParams(n: TemplateStringsArray) { } noGenericParams ``; // Generic tag with multiple type parameters and only one used in parameter type annotation function someGenerics1a(n: T, m: number) { } someGenerics1a `${3}`; - function someGenerics1b(n: string[], m: U) { } + function someGenerics1b(n: TemplateStringsArray, m: U) { } someGenerics1b `${3}`; // Generic tag with argument of function type whose parameter is of type parameter type - function someGenerics2a(strs: string[], n: (x: T) => void) { } + function someGenerics2a(strs: TemplateStringsArray, n: (x: T) => void) { } someGenerics2a `${(n: string) => n}`; - function someGenerics2b(strs: string[], n: (x: T, y: U) => void) { } + function someGenerics2b(strs: TemplateStringsArray, n: (x: T, y: U) => void) { } someGenerics2b `${ (n: string, x: number) => n }`; // Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter - function someGenerics3(strs: string[], producer: () => T) { } + function someGenerics3(strs: TemplateStringsArray, producer: () => T) { } someGenerics3 `${() => ''}`; someGenerics3 `${() => undefined}`; someGenerics3 `${() => 3}`; // 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type - function someGenerics4(strs: string[], n: T, f: (x: U) => void) { } + function someGenerics4(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics4 `${4}${ () => null }`; someGenerics4 `${''}${ () => 3 }`; someGenerics4 `${ null }${ null }`; // 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type - function someGenerics5(strs: string[], n: T, f: (x: U) => void) { } + function someGenerics5(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics5 `${ 4 } ${ () => null }`; someGenerics5 `${ '' }${ () => 3 }`; someGenerics5 `${null}${null}`; // Generic tag with multiple arguments of function types that each have parameters of the same generic type - function someGenerics6(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } + function someGenerics6(strs: TemplateStringsArray, a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`; // Generic tag with multiple arguments of function types that each have parameters of different generic type - function someGenerics7(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } + function someGenerics7(strs: TemplateStringsArray, a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`; // Generic tag with argument of generic function type - function someGenerics8(strs: string[], n: T): T { return n; } + function someGenerics8(strs: TemplateStringsArray, n: T): T { return n; } var x = someGenerics8 `${ someGenerics7 }`; x `${null}${null}${null}`; // Generic tag with multiple parameters of generic type passed arguments with no best common type - function someGenerics9(strs: string[], a: T, b: T, c: T): T { + function someGenerics9(strs: TemplateStringsArray, a: T, b: T, c: T): T { return null; } var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js index 1b6e3ab92c8..69dcd284183 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js @@ -6,60 +6,60 @@ function noParams(n: T) { } noParams ``; // Generic tag with parameter which does not use type parameter -function noGenericParams(n: string[]) { } +function noGenericParams(n: TemplateStringsArray) { } noGenericParams ``; // Generic tag with multiple type parameters and only one used in parameter type annotation function someGenerics1a(n: T, m: number) { } someGenerics1a `${3}`; -function someGenerics1b(n: string[], m: U) { } +function someGenerics1b(n: TemplateStringsArray, m: U) { } someGenerics1b `${3}`; // Generic tag with argument of function type whose parameter is of type parameter type -function someGenerics2a(strs: string[], n: (x: T) => void) { } +function someGenerics2a(strs: TemplateStringsArray, n: (x: T) => void) { } someGenerics2a `${(n: string) => n}`; -function someGenerics2b(strs: string[], n: (x: T, y: U) => void) { } +function someGenerics2b(strs: TemplateStringsArray, n: (x: T, y: U) => void) { } someGenerics2b `${ (n: string, x: number) => n }`; // Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter -function someGenerics3(strs: string[], producer: () => T) { } +function someGenerics3(strs: TemplateStringsArray, producer: () => T) { } someGenerics3 `${() => ''}`; someGenerics3 `${() => undefined}`; someGenerics3 `${() => 3}`; // 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type -function someGenerics4(strs: string[], n: T, f: (x: U) => void) { } +function someGenerics4(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics4 `${4}${ () => null }`; someGenerics4 `${''}${ () => 3 }`; someGenerics4 `${ null }${ null }`; // 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type -function someGenerics5(strs: string[], n: T, f: (x: U) => void) { } +function someGenerics5(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics5 `${ 4 } ${ () => null }`; someGenerics5 `${ '' }${ () => 3 }`; someGenerics5 `${null}${null}`; // Generic tag with multiple arguments of function types that each have parameters of the same generic type -function someGenerics6(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } +function someGenerics6(strs: TemplateStringsArray, a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`; // Generic tag with multiple arguments of function types that each have parameters of different generic type -function someGenerics7(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } +function someGenerics7(strs: TemplateStringsArray, a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`; // Generic tag with argument of generic function type -function someGenerics8(strs: string[], n: T): T { return n; } +function someGenerics8(strs: TemplateStringsArray, n: T): T { return n; } var x = someGenerics8 `${ someGenerics7 }`; x `${null}${null}${null}`; // Generic tag with multiple parameters of generic type passed arguments with no best common type -function someGenerics9(strs: string[], a: T, b: T, c: T): T { +function someGenerics9(strs: TemplateStringsArray, a: T, b: T, c: T): T { return null; } var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt index 63d04a42b3b..619e5081a3b 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt @@ -12,60 +12,60 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference noParams ``; // Generic tag with parameter which does not use type parameter - function noGenericParams(n: string[]) { } + function noGenericParams(n: TemplateStringsArray) { } noGenericParams ``; // Generic tag with multiple type parameters and only one used in parameter type annotation function someGenerics1a(n: T, m: number) { } someGenerics1a `${3}`; - function someGenerics1b(n: string[], m: U) { } + function someGenerics1b(n: TemplateStringsArray, m: U) { } someGenerics1b `${3}`; // Generic tag with argument of function type whose parameter is of type parameter type - function someGenerics2a(strs: string[], n: (x: T) => void) { } + function someGenerics2a(strs: TemplateStringsArray, n: (x: T) => void) { } someGenerics2a `${(n: string) => n}`; - function someGenerics2b(strs: string[], n: (x: T, y: U) => void) { } + function someGenerics2b(strs: TemplateStringsArray, n: (x: T, y: U) => void) { } someGenerics2b `${ (n: string, x: number) => n }`; // Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter - function someGenerics3(strs: string[], producer: () => T) { } + function someGenerics3(strs: TemplateStringsArray, producer: () => T) { } someGenerics3 `${() => ''}`; someGenerics3 `${() => undefined}`; someGenerics3 `${() => 3}`; // 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type - function someGenerics4(strs: string[], n: T, f: (x: U) => void) { } + function someGenerics4(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics4 `${4}${ () => null }`; someGenerics4 `${''}${ () => 3 }`; someGenerics4 `${ null }${ null }`; // 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type - function someGenerics5(strs: string[], n: T, f: (x: U) => void) { } + function someGenerics5(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics5 `${ 4 } ${ () => null }`; someGenerics5 `${ '' }${ () => 3 }`; someGenerics5 `${null}${null}`; // Generic tag with multiple arguments of function types that each have parameters of the same generic type - function someGenerics6(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } + function someGenerics6(strs: TemplateStringsArray, a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`; // Generic tag with multiple arguments of function types that each have parameters of different generic type - function someGenerics7(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } + function someGenerics7(strs: TemplateStringsArray, a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`; // Generic tag with argument of generic function type - function someGenerics8(strs: string[], n: T): T { return n; } + function someGenerics8(strs: TemplateStringsArray, n: T): T { return n; } var x = someGenerics8 `${ someGenerics7 }`; x `${null}${null}${null}`; // Generic tag with multiple parameters of generic type passed arguments with no best common type - function someGenerics9(strs: string[], a: T, b: T, c: T): T { + function someGenerics9(strs: TemplateStringsArray, a: T, b: T, c: T): T { return null; } var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js index 2f57882b4b7..3097e40c9ad 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js @@ -5,60 +5,60 @@ function noParams(n: T) { } noParams ``; // Generic tag with parameter which does not use type parameter -function noGenericParams(n: string[]) { } +function noGenericParams(n: TemplateStringsArray) { } noGenericParams ``; // Generic tag with multiple type parameters and only one used in parameter type annotation function someGenerics1a(n: T, m: number) { } someGenerics1a `${3}`; -function someGenerics1b(n: string[], m: U) { } +function someGenerics1b(n: TemplateStringsArray, m: U) { } someGenerics1b `${3}`; // Generic tag with argument of function type whose parameter is of type parameter type -function someGenerics2a(strs: string[], n: (x: T) => void) { } +function someGenerics2a(strs: TemplateStringsArray, n: (x: T) => void) { } someGenerics2a `${(n: string) => n}`; -function someGenerics2b(strs: string[], n: (x: T, y: U) => void) { } +function someGenerics2b(strs: TemplateStringsArray, n: (x: T, y: U) => void) { } someGenerics2b `${ (n: string, x: number) => n }`; // Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter -function someGenerics3(strs: string[], producer: () => T) { } +function someGenerics3(strs: TemplateStringsArray, producer: () => T) { } someGenerics3 `${() => ''}`; someGenerics3 `${() => undefined}`; someGenerics3 `${() => 3}`; // 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type -function someGenerics4(strs: string[], n: T, f: (x: U) => void) { } +function someGenerics4(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics4 `${4}${ () => null }`; someGenerics4 `${''}${ () => 3 }`; someGenerics4 `${ null }${ null }`; // 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type -function someGenerics5(strs: string[], n: T, f: (x: U) => void) { } +function someGenerics5(strs: TemplateStringsArray, n: T, f: (x: U) => void) { } someGenerics5 `${ 4 } ${ () => null }`; someGenerics5 `${ '' }${ () => 3 }`; someGenerics5 `${null}${null}`; // Generic tag with multiple arguments of function types that each have parameters of the same generic type -function someGenerics6(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } +function someGenerics6(strs: TemplateStringsArray, a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { } someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ n => n }${ n => n}${ n => n}`; someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`; // Generic tag with multiple arguments of function types that each have parameters of different generic type -function someGenerics7(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } +function someGenerics7(strs: TemplateStringsArray, a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { } someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${ n => n }${ n => n }${ n => n }`; someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`; // Generic tag with argument of generic function type -function someGenerics8(strs: string[], n: T): T { return n; } +function someGenerics8(strs: TemplateStringsArray, n: T): T { return n; } var x = someGenerics8 `${ someGenerics7 }`; x `${null}${null}${null}`; // Generic tag with multiple parameters of generic type passed arguments with no best common type -function someGenerics9(strs: string[], a: T, b: T, c: T): T { +function someGenerics9(strs: TemplateStringsArray, a: T, b: T, c: T): T { return null; } var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`; diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt index 166769fbbf5..44b30fb535f 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt @@ -8,7 +8,7 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTyped ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts (6 errors) ==== interface I { - (stringParts: string[], ...rest: boolean[]): I; + (stringParts: TemplateStringsArray, ...rest: boolean[]): I; g: I; h: I; member: I; diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.js b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.js index 9d113793228..511928e1342 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.js +++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.js @@ -1,6 +1,6 @@ //// [taggedTemplateStringsWithIncompatibleTypedTags.ts] interface I { - (stringParts: string[], ...rest: boolean[]): I; + (stringParts: TemplateStringsArray, ...rest: boolean[]): I; g: I; h: I; member: I; diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.errors.txt index 89b48b0193c..c2825c19e63 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.errors.txt @@ -8,7 +8,7 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTyped ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts (6 errors) ==== interface I { - (stringParts: string[], ...rest: boolean[]): I; + (stringParts: TemplateStringsArray, ...rest: boolean[]): I; g: I; h: I; member: I; diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js index 8b636356068..99fa7c3d550 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js @@ -1,6 +1,6 @@ //// [taggedTemplateStringsWithIncompatibleTypedTagsES6.ts] interface I { - (stringParts: string[], ...rest: boolean[]): I; + (stringParts: TemplateStringsArray, ...rest: boolean[]): I; g: I; h: I; member: I; diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.js b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.js index 1814816283b..a896a811ffb 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.js +++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.js @@ -1,6 +1,6 @@ //// [taggedTemplateStringsWithManyCallAndMemberExpressions.ts] interface I { - (strs: string[], ...subs: number[]): I; + (strs: TemplateStringsArray, ...subs: number[]): I; member: { new (s: string): { new (n: number): { diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.symbols b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.symbols index 226729907de..c8883fda4fe 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.symbols @@ -2,13 +2,14 @@ interface I { >I : Symbol(I, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 0, 0)) - (strs: string[], ...subs: number[]): I; + (strs: TemplateStringsArray, ...subs: number[]): I; >strs : Symbol(strs, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 5)) ->subs : Symbol(subs, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 20)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) +>subs : Symbol(subs, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 32)) >I : Symbol(I, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 0, 0)) member: { ->member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 43)) +>member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 55)) new (s: string): { >s : Symbol(s, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 3, 13)) @@ -27,8 +28,8 @@ var f: I; var x = new new new f `abc${ 0 }def`.member("hello")(42) === true; >x : Symbol(x, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 12, 3)) ->f `abc${ 0 }def`.member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 43)) +>f `abc${ 0 }def`.member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 55)) >f : Symbol(f, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 10, 3)) ->member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 43)) +>member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressions.ts, 1, 55)) diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.types b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.types index 83a0f2cf9f4..553cda2b2b9 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.types +++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.types @@ -2,8 +2,9 @@ interface I { >I : I - (strs: string[], ...subs: number[]): I; ->strs : string[] + (strs: TemplateStringsArray, ...subs: number[]): I; +>strs : TemplateStringsArray +>TemplateStringsArray : TemplateStringsArray >subs : number[] >I : I diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js index b985860f065..f1acbaa1546 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js @@ -1,6 +1,6 @@ //// [taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts] interface I { - (strs: string[], ...subs: number[]): I; + (strs: TemplateStringsArray, ...subs: number[]): I; member: { new (s: string): { new (n: number): { diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.symbols index 6535e998808..0d163daa640 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.symbols @@ -2,13 +2,14 @@ interface I { >I : Symbol(I, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 0, 0)) - (strs: string[], ...subs: number[]): I; + (strs: TemplateStringsArray, ...subs: number[]): I; >strs : Symbol(strs, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 5)) ->subs : Symbol(subs, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 20)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>subs : Symbol(subs, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 32)) >I : Symbol(I, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 0, 0)) member: { ->member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 43)) +>member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 55)) new (s: string): { >s : Symbol(s, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 3, 13)) @@ -27,8 +28,8 @@ var f: I; var x = new new new f `abc${ 0 }def`.member("hello")(42) === true; >x : Symbol(x, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 12, 3)) ->f `abc${ 0 }def`.member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 43)) +>f `abc${ 0 }def`.member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 55)) >f : Symbol(f, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 10, 3)) ->member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 43)) +>member : Symbol(I.member, Decl(taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts, 1, 55)) diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types index c240b7ced11..f9d7c605f7f 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types +++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types @@ -2,8 +2,9 @@ interface I { >I : I - (strs: string[], ...subs: number[]): I; ->strs : string[] + (strs: TemplateStringsArray, ...subs: number[]): I; +>strs : TemplateStringsArray +>TemplateStringsArray : TemplateStringsArray >subs : number[] >I : I diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.errors.txt index 9e450cbb368..426eef8ce7f 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.errors.txt @@ -1,25 +1,39 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(12,20): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(9,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. + Property 'raw' is missing in type 'undefined[]'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(10,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(11,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(12,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(13,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(14,9): error TS2346: Supplied parameters do not match any signature of call target. tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(19,20): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'. tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(21,9): error TS2346: Supplied parameters do not match any signature of call target. -==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts (4 errors) ==== - function foo(strs: string[]): number; - function foo(strs: string[], x: number): string; - function foo(strs: string[], x: number, y: number): boolean; - function foo(strs: string[], x: number, y: string): {}; +==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts (8 errors) ==== + function foo(strs: TemplateStringsArray): number; + function foo(strs: TemplateStringsArray, x: number): string; + function foo(strs: TemplateStringsArray, x: number, y: number): boolean; + function foo(strs: TemplateStringsArray, x: number, y: string): {}; function foo(...stuff: any[]): any { return undefined; } var a = foo([]); // number + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. +!!! error TS2345: Property 'raw' is missing in type 'undefined[]'. var b = foo([], 1); // string + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. var c = foo([], 1, 2); // boolean + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. var d = foo([], 1, true); // boolean (with error) - ~~~~ -!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'. + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. var e = foo([], 1, "2"); // {} + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. var f = foo([], 1, 2, 3); // any (with error) ~~~~~~~~~~~~~~~~ !!! error TS2346: Supplied parameters do not match any signature of call target. diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.js index 431447df22e..4245b0cb0f4 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.js +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.js @@ -1,8 +1,8 @@ //// [taggedTemplateStringsWithOverloadResolution1.ts] -function foo(strs: string[]): number; -function foo(strs: string[], x: number): string; -function foo(strs: string[], x: number, y: number): boolean; -function foo(strs: string[], x: number, y: string): {}; +function foo(strs: TemplateStringsArray): number; +function foo(strs: TemplateStringsArray, x: number): string; +function foo(strs: TemplateStringsArray, x: number, y: number): boolean; +function foo(strs: TemplateStringsArray, x: number, y: string): {}; function foo(...stuff: any[]): any { return undefined; } diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.errors.txt index 53361f2052d..73adc0c0302 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.errors.txt +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.errors.txt @@ -1,25 +1,39 @@ -tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(12,20): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(9,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. + Property 'raw' is missing in type 'undefined[]'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(10,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(11,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(12,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. +tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(13,13): error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(14,9): error TS2346: Supplied parameters do not match any signature of call target. tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(19,20): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'. tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(21,9): error TS2346: Supplied parameters do not match any signature of call target. -==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts (4 errors) ==== - function foo(strs: string[]): number; - function foo(strs: string[], x: number): string; - function foo(strs: string[], x: number, y: number): boolean; - function foo(strs: string[], x: number, y: string): {}; +==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts (8 errors) ==== + function foo(strs: TemplateStringsArray): number; + function foo(strs: TemplateStringsArray, x: number): string; + function foo(strs: TemplateStringsArray, x: number, y: number): boolean; + function foo(strs: TemplateStringsArray, x: number, y: string): {}; function foo(...stuff: any[]): any { return undefined; } var a = foo([]); // number + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. +!!! error TS2345: Property 'raw' is missing in type 'undefined[]'. var b = foo([], 1); // string + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. var c = foo([], 1, 2); // boolean + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. var d = foo([], 1, true); // boolean (with error) - ~~~~ -!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'. + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. var e = foo([], 1, "2"); // {} + ~~ +!!! error TS2345: Argument of type 'undefined[]' is not assignable to parameter of type 'TemplateStringsArray'. var f = foo([], 1, 2, 3); // any (with error) ~~~~~~~~~~~~~~~~ !!! error TS2346: Supplied parameters do not match any signature of call target. diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.js index bd121933b32..b62671d33ac 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.js @@ -1,8 +1,8 @@ //// [taggedTemplateStringsWithOverloadResolution1_ES6.ts] -function foo(strs: string[]): number; -function foo(strs: string[], x: number): string; -function foo(strs: string[], x: number, y: number): boolean; -function foo(strs: string[], x: number, y: string): {}; +function foo(strs: TemplateStringsArray): number; +function foo(strs: TemplateStringsArray, x: number): string; +function foo(strs: TemplateStringsArray, x: number, y: number): boolean; +function foo(strs: TemplateStringsArray, x: number, y: string): {}; function foo(...stuff: any[]): any { return undefined; } diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js index f12008f9581..c16bfa5454f 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.js @@ -6,8 +6,8 @@ function foo1(...stuff: any[]): any { return undefined; } -var a = foo1 `${1}`; // string -var b = foo1([], 1); // number +var a = foo1 `${1}`; +var b = foo1([], 1); function foo2(strs: string[], x: number): number; function foo2(strs: TemplateStringsArray, x: number): string; @@ -15,8 +15,8 @@ function foo2(...stuff: any[]): any { return undefined; } -var c = foo2 `${1}`; // number -var d = foo2([], 1); // number +var c = foo2 `${1}`; +var d = foo2([], 1); //// [taggedTemplateStringsWithOverloadResolution2.js] function foo1() { @@ -26,8 +26,8 @@ function foo1() { } return undefined; } -var a = (_a = ["", ""], _a.raw = ["", ""], foo1(_a, 1)); // string -var b = foo1([], 1); // number +var a = (_a = ["", ""], _a.raw = ["", ""], foo1(_a, 1)); +var b = foo1([], 1); function foo2() { var stuff = []; for (var _i = 0; _i < arguments.length; _i++) { @@ -35,6 +35,6 @@ function foo2() { } return undefined; } -var c = (_b = ["", ""], _b.raw = ["", ""], foo2(_b, 1)); // number -var d = foo2([], 1); // number +var c = (_b = ["", ""], _b.raw = ["", ""], foo2(_b, 1)); +var d = foo2([], 1); var _a, _b; diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols index 52b8f3ab6f0..241c43c4d78 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols @@ -19,11 +19,11 @@ function foo1(...stuff: any[]): any { >undefined : Symbol(undefined) } -var a = foo1 `${1}`; // string +var a = foo1 `${1}`; >a : Symbol(a, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 7, 3)) >foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) -var b = foo1([], 1); // number +var b = foo1([], 1); >b : Symbol(b, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 3)) >foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49)) @@ -46,11 +46,11 @@ function foo2(...stuff: any[]): any { >undefined : Symbol(undefined) } -var c = foo2 `${1}`; // number +var c = foo2 `${1}`; >c : Symbol(c, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 16, 3)) >foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) -var d = foo2([], 1); // number +var d = foo2([], 1); >d : Symbol(d, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 17, 3)) >foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61)) diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types index 77353e9b3ce..3c35974ddec 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.types @@ -19,14 +19,14 @@ function foo1(...stuff: any[]): any { >undefined : undefined } -var a = foo1 `${1}`; // string +var a = foo1 `${1}`; >a : string >foo1 `${1}` : string >foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; } >`${1}` : string >1 : number -var b = foo1([], 1); // number +var b = foo1([], 1); >b : number >foo1([], 1) : number >foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; } @@ -52,14 +52,14 @@ function foo2(...stuff: any[]): any { >undefined : undefined } -var c = foo2 `${1}`; // number ->c : number ->foo2 `${1}` : number +var c = foo2 `${1}`; +>c : string +>foo2 `${1}` : string >foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; } >`${1}` : string >1 : number -var d = foo2([], 1); // number +var d = foo2([], 1); >d : number >foo2([], 1) : number >foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; } diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.js index f208a63354d..502fa4552a3 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.js @@ -5,8 +5,8 @@ function foo1(...stuff: any[]): any { return undefined; } -var a = foo1 `${1}`; // string -var b = foo1([], 1); // number +var a = foo1 `${1}`; +var b = foo1([], 1); function foo2(strs: string[], x: number): number; function foo2(strs: TemplateStringsArray, x: number): string; @@ -14,17 +14,17 @@ function foo2(...stuff: any[]): any { return undefined; } -var c = foo2 `${1}`; // number -var d = foo2([], 1); // number +var c = foo2 `${1}`; +var d = foo2([], 1); //// [taggedTemplateStringsWithOverloadResolution2_ES6.js] function foo1(...stuff) { return undefined; } -var a = foo1 `${1}`; // string -var b = foo1([], 1); // number +var a = foo1 `${1}`; +var b = foo1([], 1); function foo2(...stuff) { return undefined; } -var c = foo2 `${1}`; // number -var d = foo2([], 1); // number +var c = foo2 `${1}`; +var d = foo2([], 1); diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols index cadfa135202..9cc79f2596f 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols @@ -18,11 +18,11 @@ function foo1(...stuff: any[]): any { >undefined : Symbol(undefined) } -var a = foo1 `${1}`; // string +var a = foo1 `${1}`; >a : Symbol(a, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 6, 3)) >foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 1, 49)) -var b = foo1([], 1); // number +var b = foo1([], 1); >b : Symbol(b, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 7, 3)) >foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 1, 49)) @@ -45,11 +45,11 @@ function foo2(...stuff: any[]): any { >undefined : Symbol(undefined) } -var c = foo2 `${1}`; // number +var c = foo2 `${1}`; >c : Symbol(c, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 15, 3)) >foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 61)) -var d = foo2([], 1); // number +var d = foo2([], 1); >d : Symbol(d, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 16, 3)) >foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 61)) diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.types b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.types index 306bf38cac4..7faeec19c4a 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.types +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.types @@ -18,14 +18,14 @@ function foo1(...stuff: any[]): any { >undefined : undefined } -var a = foo1 `${1}`; // string +var a = foo1 `${1}`; >a : string >foo1 `${1}` : string >foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; } >`${1}` : string >1 : number -var b = foo1([], 1); // number +var b = foo1([], 1); >b : number >foo1([], 1) : number >foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; } @@ -51,14 +51,14 @@ function foo2(...stuff: any[]): any { >undefined : undefined } -var c = foo2 `${1}`; // number ->c : number ->foo2 `${1}` : number +var c = foo2 `${1}`; +>c : string +>foo2 `${1}` : string >foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; } >`${1}` : string >1 : number -var d = foo2([], 1); // number +var d = foo2([], 1); >d : number >foo2([], 1) : number >foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; } diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.js b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.js index fcc2cda86dc..d011c3048a7 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.js @@ -1,6 +1,6 @@ //// [taggedTemplateStringsWithTypedTags.ts] interface I { - (stringParts: string[], ...rest: number[]): I; + (stringParts: TemplateStringsArray, ...rest: number[]): I; g: I; h: I; member: I; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.symbols b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.symbols index d3f85d8375a..cd28177f587 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.symbols @@ -2,13 +2,14 @@ interface I { >I : Symbol(I, Decl(taggedTemplateStringsWithTypedTags.ts, 0, 0)) - (stringParts: string[], ...rest: number[]): I; + (stringParts: TemplateStringsArray, ...rest: number[]): I; >stringParts : Symbol(stringParts, Decl(taggedTemplateStringsWithTypedTags.ts, 1, 5)) ->rest : Symbol(rest, Decl(taggedTemplateStringsWithTypedTags.ts, 1, 27)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) +>rest : Symbol(rest, Decl(taggedTemplateStringsWithTypedTags.ts, 1, 39)) >I : Symbol(I, Decl(taggedTemplateStringsWithTypedTags.ts, 0, 0)) g: I; ->g : Symbol(I.g, Decl(taggedTemplateStringsWithTypedTags.ts, 1, 50)) +>g : Symbol(I.g, Decl(taggedTemplateStringsWithTypedTags.ts, 1, 62)) >I : Symbol(I, Decl(taggedTemplateStringsWithTypedTags.ts, 0, 0)) h: I; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.types b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.types index 2c992a2d233..c7c521154c7 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.types +++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.types @@ -2,8 +2,9 @@ interface I { >I : I - (stringParts: string[], ...rest: number[]): I; ->stringParts : string[] + (stringParts: TemplateStringsArray, ...rest: number[]): I; +>stringParts : TemplateStringsArray +>TemplateStringsArray : TemplateStringsArray >rest : number[] >I : I diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.js b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.js index 9eefc46ec30..35a616f05f4 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.js +++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.js @@ -1,6 +1,6 @@ //// [taggedTemplateStringsWithTypedTagsES6.ts] interface I { - (stringParts: string[], ...rest: number[]): I; + (stringParts: TemplateStringsArray, ...rest: number[]): I; g: I; h: I; member: I; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.symbols index f0b088bd6f6..f7f9c62d492 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.symbols @@ -2,13 +2,14 @@ interface I { >I : Symbol(I, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 0, 0)) - (stringParts: string[], ...rest: number[]): I; + (stringParts: TemplateStringsArray, ...rest: number[]): I; >stringParts : Symbol(stringParts, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 1, 5)) ->rest : Symbol(rest, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 1, 27)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>rest : Symbol(rest, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 1, 39)) >I : Symbol(I, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 0, 0)) g: I; ->g : Symbol(I.g, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 1, 50)) +>g : Symbol(I.g, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 1, 62)) >I : Symbol(I, Decl(taggedTemplateStringsWithTypedTagsES6.ts, 0, 0)) h: I; diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types index 4bda0f3fbb0..bf45144c329 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types +++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types @@ -2,8 +2,9 @@ interface I { >I : I - (stringParts: string[], ...rest: number[]): I; ->stringParts : string[] + (stringParts: TemplateStringsArray, ...rest: number[]): I; +>stringParts : TemplateStringsArray +>TemplateStringsArray : TemplateStringsArray >rest : number[] >I : I From 5efbf61c951c22eba2ea7630fbdd5bb67c70d336 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 13 Jul 2016 11:42:59 -0700 Subject: [PATCH 04/10] Skip `this` in emitter in 2 more places --- src/compiler/emitter.ts | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 2d5acb3b486..6e1a2a39c10 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -4571,14 +4571,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge function emitRestParameter(node: FunctionLikeDeclaration) { if (languageVersion < ScriptTarget.ES6 && hasDeclaredRestParameter(node)) { - const restIndex = node.parameters.length - 1; - const restParam = node.parameters[restIndex]; + const restParam = node.parameters[node.parameters.length - 1]; // A rest parameter cannot have a binding pattern, so let's just ignore it if it does. if (isBindingPattern(restParam.name)) { return; } + const skipThisCount = node.parameters.length && (node.parameters[0].name).text === "this" ? 1 : 0; + const restIndex = node.parameters.length - 1 - skipThisCount; const tempName = createTempVariable(TempFlags._i).text; writeLine(); emitLeadingComments(restParam); @@ -6155,10 +6156,11 @@ const _super = (function (geti, seti) { if (valueDeclaration) { const parameters = valueDeclaration.parameters; + const skipThisCount = parameters.length && (parameters[0].name).text === "this" ? 1 : 0; const parameterCount = parameters.length; - if (parameterCount > 0) { - for (let i = 0; i < parameterCount; i++) { - if (i > 0) { + if (parameterCount > skipThisCount) { + for (let i = skipThisCount; i < parameterCount; i++) { + if (i > skipThisCount) { write(", "); } From 2cc040c66629d29f470a9ef9914dab7a4ec245f5 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 13 Jul 2016 11:43:28 -0700 Subject: [PATCH 05/10] Test that emitter skips `this` with rest parameter Also test that it's skipped when emitting decorator metadata --- .../emitDecoratorMetadata_restArgs.js | 2 +- .../emitDecoratorMetadata_restArgs.symbols | 5 ++-- .../emitDecoratorMetadata_restArgs.types | 5 ++-- .../emitSkipsThisWithRestParameter.js | 18 ++++++++++++ .../emitSkipsThisWithRestParameter.symbols | 25 ++++++++++++++++ .../emitSkipsThisWithRestParameter.types | 29 +++++++++++++++++++ .../emitDecoratorMetadata_restArgs.ts | 2 +- .../emitSkipsThisWithRestParameter.ts | 5 ++++ 8 files changed, 85 insertions(+), 6 deletions(-) create mode 100644 tests/baselines/reference/emitSkipsThisWithRestParameter.js create mode 100644 tests/baselines/reference/emitSkipsThisWithRestParameter.symbols create mode 100644 tests/baselines/reference/emitSkipsThisWithRestParameter.types create mode 100644 tests/cases/compiler/emitSkipsThisWithRestParameter.ts diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.js b/tests/baselines/reference/emitDecoratorMetadata_restArgs.js index 35350c54e0a..6ca7e40d413 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.js +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.js @@ -14,7 +14,7 @@ class A { class B { constructor(...args: number[]) {} @MyMethodDecorator - method(...args: string[]) {} + method(this: this, ...args: string[]) {} } diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols b/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols index b665b778f86..29ccb8b2711 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols @@ -37,8 +37,9 @@ class B { @MyMethodDecorator >MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13)) - method(...args: string[]) {} + method(this: this, ...args: string[]) {} >method : Symbol(B.method, Decl(emitDecoratorMetadata_restArgs.ts, 13, 37)) ->args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 15, 11)) +>this : Symbol(this, Decl(emitDecoratorMetadata_restArgs.ts, 15, 11)) +>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 15, 22)) } diff --git a/tests/baselines/reference/emitDecoratorMetadata_restArgs.types b/tests/baselines/reference/emitDecoratorMetadata_restArgs.types index 4820d3a7d8d..e08261e4503 100644 --- a/tests/baselines/reference/emitDecoratorMetadata_restArgs.types +++ b/tests/baselines/reference/emitDecoratorMetadata_restArgs.types @@ -37,8 +37,9 @@ class B { @MyMethodDecorator >MyMethodDecorator : (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor) => TypedPropertyDescriptor | void - method(...args: string[]) {} ->method : (...args: string[]) => void + method(this: this, ...args: string[]) {} +>method : (this: this, ...args: string[]) => void +>this : this >args : string[] } diff --git a/tests/baselines/reference/emitSkipsThisWithRestParameter.js b/tests/baselines/reference/emitSkipsThisWithRestParameter.js new file mode 100644 index 00000000000..d1e99f9409d --- /dev/null +++ b/tests/baselines/reference/emitSkipsThisWithRestParameter.js @@ -0,0 +1,18 @@ +//// [emitSkipsThisWithRestParameter.ts] +function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any { + return function(this: any, ...args: any[]) { + return fn.apply(this, [ this ].concat(args)); + }; +} + + +//// [emitSkipsThisWithRestParameter.js] +function rebase(fn) { + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } + return fn.apply(this, [this].concat(args)); + }; +} diff --git a/tests/baselines/reference/emitSkipsThisWithRestParameter.symbols b/tests/baselines/reference/emitSkipsThisWithRestParameter.symbols new file mode 100644 index 00000000000..4f1e2bc1aec --- /dev/null +++ b/tests/baselines/reference/emitSkipsThisWithRestParameter.symbols @@ -0,0 +1,25 @@ +=== tests/cases/compiler/emitSkipsThisWithRestParameter.ts === +function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any { +>rebase : Symbol(rebase, Decl(emitSkipsThisWithRestParameter.ts, 0, 0)) +>fn : Symbol(fn, Decl(emitSkipsThisWithRestParameter.ts, 0, 16)) +>base : Symbol(base, Decl(emitSkipsThisWithRestParameter.ts, 0, 21)) +>args : Symbol(args, Decl(emitSkipsThisWithRestParameter.ts, 0, 31)) +>args : Symbol(args, Decl(emitSkipsThisWithRestParameter.ts, 0, 58)) + + return function(this: any, ...args: any[]) { +>this : Symbol(this, Decl(emitSkipsThisWithRestParameter.ts, 1, 20)) +>args : Symbol(args, Decl(emitSkipsThisWithRestParameter.ts, 1, 30)) + + return fn.apply(this, [ this ].concat(args)); +>fn.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) +>fn : Symbol(fn, Decl(emitSkipsThisWithRestParameter.ts, 0, 16)) +>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) +>this : Symbol(this, Decl(emitSkipsThisWithRestParameter.ts, 1, 20)) +>[ this ].concat : Symbol(Array.concat, Decl(lib.d.ts, --, --)) +>this : Symbol(this, Decl(emitSkipsThisWithRestParameter.ts, 1, 20)) +>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --)) +>args : Symbol(args, Decl(emitSkipsThisWithRestParameter.ts, 1, 30)) + + }; +} + diff --git a/tests/baselines/reference/emitSkipsThisWithRestParameter.types b/tests/baselines/reference/emitSkipsThisWithRestParameter.types new file mode 100644 index 00000000000..97276fa117d --- /dev/null +++ b/tests/baselines/reference/emitSkipsThisWithRestParameter.types @@ -0,0 +1,29 @@ +=== tests/cases/compiler/emitSkipsThisWithRestParameter.ts === +function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any { +>rebase : (fn: (base: any, ...args: any[]) => any) => (...args: any[]) => any +>fn : (base: any, ...args: any[]) => any +>base : any +>args : any[] +>args : any[] + + return function(this: any, ...args: any[]) { +>function(this: any, ...args: any[]) { return fn.apply(this, [ this ].concat(args)); } : (this: any, ...args: any[]) => any +>this : any +>args : any[] + + return fn.apply(this, [ this ].concat(args)); +>fn.apply(this, [ this ].concat(args)) : any +>fn.apply : (this: Function, thisArg: any, argArray?: any) => any +>fn : (base: any, ...args: any[]) => any +>apply : (this: Function, thisArg: any, argArray?: any) => any +>this : any +>[ this ].concat(args) : any[] +>[ this ].concat : (...items: any[]) => any[] +>[ this ] : any[] +>this : any +>concat : (...items: any[]) => any[] +>args : any[] + + }; +} + diff --git a/tests/cases/compiler/emitDecoratorMetadata_restArgs.ts b/tests/cases/compiler/emitDecoratorMetadata_restArgs.ts index 6b0741e2205..f58e9b704d4 100644 --- a/tests/cases/compiler/emitDecoratorMetadata_restArgs.ts +++ b/tests/cases/compiler/emitDecoratorMetadata_restArgs.ts @@ -16,5 +16,5 @@ class A { class B { constructor(...args: number[]) {} @MyMethodDecorator - method(...args: string[]) {} + method(this: this, ...args: string[]) {} } diff --git a/tests/cases/compiler/emitSkipsThisWithRestParameter.ts b/tests/cases/compiler/emitSkipsThisWithRestParameter.ts new file mode 100644 index 00000000000..09411a28cd2 --- /dev/null +++ b/tests/cases/compiler/emitSkipsThisWithRestParameter.ts @@ -0,0 +1,5 @@ +function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any { + return function(this: any, ...args: any[]) { + return fn.apply(this, [ this ].concat(args)); + }; +} From ebb09069283fa8a6ba792a06c75cb3a5421f4190 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders Date: Wed, 13 Jul 2016 13:06:10 -0700 Subject: [PATCH 06/10] Use originalKeywordKind to detect this parameters --- src/compiler/emitter.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 6e1a2a39c10..bdf50a2c4da 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -4578,7 +4578,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge return; } - const skipThisCount = node.parameters.length && (node.parameters[0].name).text === "this" ? 1 : 0; + const skipThisCount = node.parameters.length && (node.parameters[0].name).originalKeywordKind === SyntaxKind.ThisKeyword ? 1 : 0; const restIndex = node.parameters.length - 1 - skipThisCount; const tempName = createTempVariable(TempFlags._i).text; writeLine(); @@ -4727,7 +4727,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge write("("); if (node) { const parameters = node.parameters; - const skipCount = node.parameters.length && (node.parameters[0].name).text === "this" ? 1 : 0; + const skipCount = node.parameters.length && (node.parameters[0].name).originalKeywordKind === SyntaxKind.ThisKeyword ? 1 : 0; const omitCount = languageVersion < ScriptTarget.ES6 && hasDeclaredRestParameter(node) ? 1 : 0; emitList(parameters, skipCount, parameters.length - omitCount - skipCount, /*multiLine*/ false, /*trailingComma*/ false); } @@ -6156,7 +6156,7 @@ const _super = (function (geti, seti) { if (valueDeclaration) { const parameters = valueDeclaration.parameters; - const skipThisCount = parameters.length && (parameters[0].name).text === "this" ? 1 : 0; + const skipThisCount = parameters.length && (parameters[0].name).originalKeywordKind === SyntaxKind.ThisKeyword ? 1 : 0; const parameterCount = parameters.length; if (parameterCount > skipThisCount) { for (let i = skipThisCount; i < parameterCount; i++) { From 2a26beb9d8933f66b4e8bc23c1ee89b50c7a2aff Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Tue, 19 Jul 2016 15:10:29 -0700 Subject: [PATCH 07/10] Add performance framework from transforms branch (#9536) * Port performance tools from transforms branch * Use friendlier names, add compiler option to print all recorded measures * Always print total time * + -> .getTime --- Jakefile.js | 2 + src/compiler/binder.ts | 6 +- src/compiler/checker.ts | 6 +- src/compiler/commandLineParser.ts | 4 ++ src/compiler/core.ts | 2 + src/compiler/parser.ts | 6 +- src/compiler/performance.ts | 107 ++++++++++++++++++++++++++++++ src/compiler/program.ts | 21 +++--- src/compiler/sourcemap.ts | 4 ++ src/compiler/tsc.ts | 41 +++++++----- src/compiler/tsconfig.json | 1 + src/compiler/types.ts | 1 + 12 files changed, 159 insertions(+), 42 deletions(-) create mode 100644 src/compiler/performance.ts diff --git a/Jakefile.js b/Jakefile.js index eee9fe1370e..1c22305cd86 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -34,6 +34,7 @@ if (process.env.path !== undefined) { var compilerSources = [ "core.ts", + "performance.ts", "sys.ts", "types.ts", "scanner.ts", @@ -54,6 +55,7 @@ var compilerSources = [ var servicesSources = [ "core.ts", + "performance.ts", "sys.ts", "types.ts", "scanner.ts", diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index b7852a64d04..6059cd1f86a 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -3,8 +3,6 @@ /* @internal */ namespace ts { - export let bindTime = 0; - export const enum ModuleInstanceState { NonInstantiated = 0, Instantiated = 1, @@ -91,9 +89,9 @@ namespace ts { const binder = createBinder(); export function bindSourceFile(file: SourceFile, options: CompilerOptions) { - const start = new Date().getTime(); + const start = performance.mark(); binder(file, options); - bindTime += new Date().getTime() - start; + performance.measure("Bind", start); } function createBinder(): (file: SourceFile, options: CompilerOptions) => void { diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d68502dc8e8..d769cc4e3fc 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -15,8 +15,6 @@ namespace ts { return node.id; } - export let checkTime = 0; - export function getSymbolId(symbol: Symbol): number { if (!symbol.id) { symbol.id = nextSymbolId; @@ -17026,11 +17024,11 @@ namespace ts { } function checkSourceFile(node: SourceFile) { - const start = new Date().getTime(); + const start = performance.mark(); checkSourceFileWorker(node); - checkTime += new Date().getTime() - start; + performance.measure("Check", start); } // Fully type check a source file and collect the relevant diagnostics. diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index f11854a6858..b82cf6a094d 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -27,6 +27,10 @@ namespace ts { name: "diagnostics", type: "boolean", }, + { + name: "extendedDiagnostics", + type: "boolean", + }, { name: "emitBOM", type: "boolean" diff --git a/src/compiler/core.ts b/src/compiler/core.ts index bffd3179e83..926ee38a795 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -1,4 +1,6 @@ /// +/// + /* @internal */ namespace ts { diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 2eae2c4025e..774cea60e09 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2,8 +2,6 @@ /// namespace ts { - /* @internal */ export let parseTime = 0; - let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node; let TokenConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node; let IdentifierConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node; @@ -421,10 +419,10 @@ namespace ts { } export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes = false, scriptKind?: ScriptKind): SourceFile { - const start = new Date().getTime(); + const start = performance.mark(); const result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind); - parseTime += new Date().getTime() - start; + performance.measure("Parse", start); return result; } diff --git a/src/compiler/performance.ts b/src/compiler/performance.ts new file mode 100644 index 00000000000..f40b191a1a5 --- /dev/null +++ b/src/compiler/performance.ts @@ -0,0 +1,107 @@ +/*@internal*/ +namespace ts { + /** Performance measurements for the compiler. */ + export namespace performance { + declare const onProfilerEvent: { (markName: string): void; profiler: boolean; }; + declare const performance: { now?(): number } | undefined; + let profilerEvent: (markName: string) => void; + let markInternal: () => number; + let counters: Map; + let measures: Map; + + /** + * Emit a performance event if ts-profiler is connected. This is primarily used + * to generate heap snapshots. + * + * @param eventName A name for the event. + */ + export function emit(eventName: string) { + if (profilerEvent) { + profilerEvent(eventName); + } + } + + /** + * Increments a counter with the specified name. + * + * @param counterName The name of the counter. + */ + export function increment(counterName: string) { + if (counters) { + counters[counterName] = (getProperty(counters, counterName) || 0) + 1; + } + } + + /** + * Gets the value of the counter with the specified name. + * + * @param counterName The name of the counter. + */ + export function getCount(counterName: string) { + return counters && getProperty(counters, counterName) || 0; + } + + /** + * Marks the start of a performance measurement. + */ + export function mark() { + return measures ? markInternal() : 0; + } + + /** + * Adds a performance measurement with the specified name. + * + * @param measureName The name of the performance measurement. + * @param marker The timestamp of the starting mark. + */ + export function measure(measureName: string, marker: number) { + if (measures) { + measures[measureName] = (getProperty(measures, measureName) || 0) + (Date.now() - marker); + } + } + + /** + * Iterate over each measure, performing some action + * + * @param cb The action to perform for each measure + */ + export function forEachMeasure(cb: (measureName: string, duration: number) => void) { + return forEachKey(measures, key => cb(key, measures[key])); + } + + /** + * Gets the total duration of all measurements with the supplied name. + * + * @param measureName The name of the measure whose durations should be accumulated. + */ + export function getDuration(measureName: string) { + return measures && getProperty(measures, measureName) || 0; + } + + /** Enables (and resets) performance measurements for the compiler. */ + export function enable() { + counters = { }; + measures = { + "I/O Read": 0, + "I/O Write": 0, + "Program": 0, + "Parse": 0, + "Bind": 0, + "Check": 0, + "Emit": 0, + }; + + profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true + ? onProfilerEvent + : undefined; + markInternal = performance && performance.now ? performance.now : Date.now ? Date.now : () => new Date().getTime(); + } + + /** Disables (and clears) performance measurements for the compiler. */ + export function disable() { + counters = undefined; + measures = undefined; + profilerEvent = undefined; + } + } +} \ No newline at end of file diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 206311e2f18..988714be2ab 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -3,11 +3,6 @@ /// namespace ts { - /* @internal */ export let programTime = 0; - /* @internal */ export let emitTime = 0; - /* @internal */ export let ioReadTime = 0; - /* @internal */ export let ioWriteTime = 0; - /** The version of the TypeScript compiler release */ export const version = "2.1.0"; @@ -865,9 +860,9 @@ namespace ts { function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile { let text: string; try { - const start = new Date().getTime(); + const start = performance.mark(); text = sys.readFile(fileName, options.charset); - ioReadTime += new Date().getTime() - start; + performance.measure("I/O Read", start); } catch (e) { if (onError) { @@ -934,7 +929,7 @@ namespace ts { function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) { try { - const start = new Date().getTime(); + const start = performance.mark(); ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName))); if (isWatchSet(options) && sys.createHash && sys.getModifiedTime) { @@ -944,7 +939,7 @@ namespace ts { sys.writeFile(fileName, data, writeByteOrderMark); } - ioWriteTime += new Date().getTime() - start; + performance.measure("I/O Write", start); } catch (e) { if (onError) { @@ -1121,7 +1116,7 @@ namespace ts { // Track source files that are source files found by searching under node_modules, as these shouldn't be compiled. const sourceFilesFoundSearchingNodeModules: Map = {}; - const start = new Date().getTime(); + const start = performance.mark(); host = host || createCompilerHost(options); @@ -1220,7 +1215,7 @@ namespace ts { verifyCompilerOptions(); - programTime += new Date().getTime() - start; + performance.measure("Program", start); return program; @@ -1463,14 +1458,14 @@ namespace ts { // checked is to not pass the file to getEmitResolver. const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile); - const start = new Date().getTime(); + const start = performance.mark(); const emitResult = emitFiles( emitResolver, getEmitHost(writeFileCallback), sourceFile); - emitTime += new Date().getTime() - start; + performance.measure("Emit", start); return emitResult; } diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts index cf7c3d1eaae..2d8c36a3d02 100644 --- a/src/compiler/sourcemap.ts +++ b/src/compiler/sourcemap.ts @@ -240,6 +240,8 @@ namespace ts { return; } + const start = performance.mark(); + const sourceLinePos = getLineAndCharacterOfPosition(currentSourceFile, pos); // Convert the location to be one-based. @@ -279,6 +281,8 @@ namespace ts { } updateLastEncodedAndRecordedSpans(); + + performance.measure("Source Map", start); } function getStartPos(range: TextRange) { diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index 242d24caf3c..10538d0c009 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -550,12 +550,8 @@ namespace ts { } function compile(fileNames: string[], compilerOptions: CompilerOptions, compilerHost: CompilerHost) { - ioReadTime = 0; - ioWriteTime = 0; - programTime = 0; - bindTime = 0; - checkTime = 0; - emitTime = 0; + const hasDiagnostics = compilerOptions.diagnostics || compilerOptions.extendedDiagnostics; + if (hasDiagnostics) performance.enable(); const program = createProgram(fileNames, compilerOptions, compilerHost); const exitStatus = compileProgram(); @@ -566,7 +562,7 @@ namespace ts { }); } - if (compilerOptions.diagnostics) { + if (hasDiagnostics) { const memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1; reportCountStatistic("Files", program.getSourceFiles().length); reportCountStatistic("Lines", countLines(program)); @@ -579,17 +575,28 @@ namespace ts { reportStatisticalValue("Memory used", Math.round(memoryUsed / 1000) + "K"); } - // Individual component times. - // Note: To match the behavior of previous versions of the compiler, the reported parse time includes - // I/O read time and processing time for triple-slash references and module imports, and the reported - // emit time includes I/O write time. We preserve this behavior so we can accurately compare times. - reportTimeStatistic("I/O read", ioReadTime); - reportTimeStatistic("I/O write", ioWriteTime); - reportTimeStatistic("Parse time", programTime); - reportTimeStatistic("Bind time", bindTime); - reportTimeStatistic("Check time", checkTime); - reportTimeStatistic("Emit time", emitTime); + const programTime = performance.getDuration("Program"); + const bindTime = performance.getDuration("Bind"); + const checkTime = performance.getDuration("Check"); + const emitTime = performance.getDuration("Emit"); + if (compilerOptions.extendedDiagnostics) { + performance.forEachMeasure((name, duration) => reportTimeStatistic(`${name} time`, duration)); + } + else { + // Individual component times. + // Note: To match the behavior of previous versions of the compiler, the reported parse time includes + // I/O read time and processing time for triple-slash references and module imports, and the reported + // emit time includes I/O write time. We preserve this behavior so we can accurately compare times. + reportTimeStatistic("I/O read", performance.getDuration("I/O Read")); + reportTimeStatistic("I/O write", performance.getDuration("I/O Write")); + reportTimeStatistic("Parse time", programTime); + reportTimeStatistic("Bind time", bindTime); + reportTimeStatistic("Check time", checkTime); + reportTimeStatistic("Emit time", emitTime); + } reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime); + + performance.disable(); } return { program, exitStatus }; diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json index 827a9b81c4d..cc9bfddcece 100644 --- a/src/compiler/tsconfig.json +++ b/src/compiler/tsconfig.json @@ -12,6 +12,7 @@ }, "files": [ "core.ts", + "performance.ts", "sys.ts", "types.ts", "scanner.ts", diff --git a/src/compiler/types.ts b/src/compiler/types.ts index d0df5e86550..dc332b24567 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2539,6 +2539,7 @@ namespace ts { declaration?: boolean; declarationDir?: string; /* @internal */ diagnostics?: boolean; + /* @internal */ extendedDiagnostics?: boolean; disableSizeLimit?: boolean; emitBOM?: boolean; emitDecoratorMetadata?: boolean; From 80db0f2f166d0a3547319fce789c31604e8fc83b Mon Sep 17 00:00:00 2001 From: Yui Date: Tue, 19 Jul 2016 15:16:27 -0700 Subject: [PATCH 08/10] [Release-2.0] Fix 9782: do not report blocked-scope-used-before-declaration error in ambient context (#9789) (#9830) * Do not report block-scoped-used-before-declaration in ambient context * Add tests and baselines --- src/compiler/checker.ts | 2 +- .../noUsedBeforeDefinedErrorInAmbientContext1.symbols | 9 +++++++++ .../noUsedBeforeDefinedErrorInAmbientContext1.types | 9 +++++++++ .../noUsedBeforeDefinedErrorInAmbientContext1.ts | 4 ++++ 4 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols create mode 100644 tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types create mode 100644 tests/cases/compiler/noUsedBeforeDefinedErrorInAmbientContext1.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d769cc4e3fc..1cebd469388 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -974,7 +974,7 @@ namespace ts { Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined"); - if (!isBlockScopedNameDeclaredBeforeUse(getAncestor(declaration, SyntaxKind.VariableDeclaration), errorLocation)) { + if (!isInAmbientContext(declaration) && !isBlockScopedNameDeclaredBeforeUse(getAncestor(declaration, SyntaxKind.VariableDeclaration), errorLocation)) { error(errorLocation, Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationNameToString(declaration.name)); } } diff --git a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols new file mode 100644 index 00000000000..690a19ef18f --- /dev/null +++ b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/test.d.ts === + +declare var S: typeof A; // no error +>S : Symbol(S, Decl(test.d.ts, 1, 11)) +>A : Symbol(A, Decl(test.d.ts, 2, 13)) + +declare const A: number; +>A : Symbol(A, Decl(test.d.ts, 2, 13)) + diff --git a/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types new file mode 100644 index 00000000000..dfacda30915 --- /dev/null +++ b/tests/baselines/reference/noUsedBeforeDefinedErrorInAmbientContext1.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/test.d.ts === + +declare var S: typeof A; // no error +>S : number +>A : number + +declare const A: number; +>A : number + diff --git a/tests/cases/compiler/noUsedBeforeDefinedErrorInAmbientContext1.ts b/tests/cases/compiler/noUsedBeforeDefinedErrorInAmbientContext1.ts new file mode 100644 index 00000000000..834356e88b4 --- /dev/null +++ b/tests/cases/compiler/noUsedBeforeDefinedErrorInAmbientContext1.ts @@ -0,0 +1,4 @@ +// @filename: test.d.ts + +declare var S: typeof A; // no error +declare const A: number; \ No newline at end of file From 729464dc23ba896b4a77ec9b3d8acd1cc1907fc9 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 20 Jul 2016 15:42:29 -0700 Subject: [PATCH 09/10] Integrate feedback from @mihailik to performance framework (#9845) * Integrate feedback from @mihailik * Rons feedback, explicitly include in new tsconfigs --- src/compiler/performance.ts | 202 ++++++++++++++++++------------------ src/harness/tsconfig.json | 1 + src/services/services.ts | 38 +++---- src/services/shims.ts | 6 +- src/services/tsconfig.json | 1 + 5 files changed, 126 insertions(+), 122 deletions(-) diff --git a/src/compiler/performance.ts b/src/compiler/performance.ts index f40b191a1a5..63f929c0a26 100644 --- a/src/compiler/performance.ts +++ b/src/compiler/performance.ts @@ -1,107 +1,109 @@ /*@internal*/ namespace ts { + declare const performance: { now?(): number } | undefined; + /** Gets a timestamp with (at least) ms resolution */ + export const timestamp = typeof performance !== "undefined" && performance.now ? performance.now : Date.now ? Date.now : () => +(new Date()); +} + +/*@internal*/ +namespace ts.performance { /** Performance measurements for the compiler. */ - export namespace performance { - declare const onProfilerEvent: { (markName: string): void; profiler: boolean; }; - declare const performance: { now?(): number } | undefined; - let profilerEvent: (markName: string) => void; - let markInternal: () => number; - let counters: Map; - let measures: Map; + declare const onProfilerEvent: { (markName: string): void; profiler: boolean; }; + let profilerEvent: (markName: string) => void; + let counters: Map; + let measures: Map; - /** - * Emit a performance event if ts-profiler is connected. This is primarily used - * to generate heap snapshots. - * - * @param eventName A name for the event. - */ - export function emit(eventName: string) { - if (profilerEvent) { - profilerEvent(eventName); - } - } - - /** - * Increments a counter with the specified name. - * - * @param counterName The name of the counter. - */ - export function increment(counterName: string) { - if (counters) { - counters[counterName] = (getProperty(counters, counterName) || 0) + 1; - } - } - - /** - * Gets the value of the counter with the specified name. - * - * @param counterName The name of the counter. - */ - export function getCount(counterName: string) { - return counters && getProperty(counters, counterName) || 0; - } - - /** - * Marks the start of a performance measurement. - */ - export function mark() { - return measures ? markInternal() : 0; - } - - /** - * Adds a performance measurement with the specified name. - * - * @param measureName The name of the performance measurement. - * @param marker The timestamp of the starting mark. - */ - export function measure(measureName: string, marker: number) { - if (measures) { - measures[measureName] = (getProperty(measures, measureName) || 0) + (Date.now() - marker); - } - } - - /** - * Iterate over each measure, performing some action - * - * @param cb The action to perform for each measure - */ - export function forEachMeasure(cb: (measureName: string, duration: number) => void) { - return forEachKey(measures, key => cb(key, measures[key])); - } - - /** - * Gets the total duration of all measurements with the supplied name. - * - * @param measureName The name of the measure whose durations should be accumulated. - */ - export function getDuration(measureName: string) { - return measures && getProperty(measures, measureName) || 0; - } - - /** Enables (and resets) performance measurements for the compiler. */ - export function enable() { - counters = { }; - measures = { - "I/O Read": 0, - "I/O Write": 0, - "Program": 0, - "Parse": 0, - "Bind": 0, - "Check": 0, - "Emit": 0, - }; - - profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true - ? onProfilerEvent - : undefined; - markInternal = performance && performance.now ? performance.now : Date.now ? Date.now : () => new Date().getTime(); - } - - /** Disables (and clears) performance measurements for the compiler. */ - export function disable() { - counters = undefined; - measures = undefined; - profilerEvent = undefined; + /** + * Emit a performance event if ts-profiler is connected. This is primarily used + * to generate heap snapshots. + * + * @param eventName A name for the event. + */ + export function emit(eventName: string) { + if (profilerEvent) { + profilerEvent(eventName); } } + + /** + * Increments a counter with the specified name. + * + * @param counterName The name of the counter. + */ + export function increment(counterName: string) { + if (counters) { + counters[counterName] = (getProperty(counters, counterName) || 0) + 1; + } + } + + /** + * Gets the value of the counter with the specified name. + * + * @param counterName The name of the counter. + */ + export function getCount(counterName: string) { + return counters && getProperty(counters, counterName) || 0; + } + + /** + * Marks the start of a performance measurement. + */ + export function mark() { + return measures ? timestamp() : 0; + } + + /** + * Adds a performance measurement with the specified name. + * + * @param measureName The name of the performance measurement. + * @param marker The timestamp of the starting mark. + */ + export function measure(measureName: string, marker: number) { + if (measures) { + measures[measureName] = (getProperty(measures, measureName) || 0) + (timestamp() - marker); + } + } + + /** + * Iterate over each measure, performing some action + * + * @param cb The action to perform for each measure + */ + export function forEachMeasure(cb: (measureName: string, duration: number) => void) { + return forEachKey(measures, key => cb(key, measures[key])); + } + + /** + * Gets the total duration of all measurements with the supplied name. + * + * @param measureName The name of the measure whose durations should be accumulated. + */ + export function getDuration(measureName: string) { + return measures && getProperty(measures, measureName) || 0; + } + + /** Enables (and resets) performance measurements for the compiler. */ + export function enable() { + counters = { }; + measures = { + "I/O Read": 0, + "I/O Write": 0, + "Program": 0, + "Parse": 0, + "Bind": 0, + "Check": 0, + "Emit": 0, + }; + + profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true + ? onProfilerEvent + : undefined; + } + + /** Disables (and clears) performance measurements for the compiler. */ + export function disable() { + counters = undefined; + measures = undefined; + profilerEvent = undefined; + } } \ No newline at end of file diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json index 5853bee3274..3b9025c27c3 100644 --- a/src/harness/tsconfig.json +++ b/src/harness/tsconfig.json @@ -14,6 +14,7 @@ }, "files": [ "../compiler/core.ts", + "../compiler/performance.ts", "../compiler/sys.ts", "../compiler/types.ts", "../compiler/scanner.ts", diff --git a/src/services/services.ts b/src/services/services.ts index d9e025cf8fd..226d18f77dc 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -434,7 +434,7 @@ namespace ts { } } IdentifierObject.prototype.kind = SyntaxKind.Identifier; - + class SymbolObject implements Symbol { flags: SymbolFlags; name: string; @@ -3349,14 +3349,14 @@ namespace ts { let isJsDocTagName = false; - let start = new Date().getTime(); + let start = timestamp(); const currentToken = getTokenAtPosition(sourceFile, position); - log("getCompletionData: Get current token: " + (new Date().getTime() - start)); + log("getCompletionData: Get current token: " + (timestamp() - start)); - start = new Date().getTime(); + start = timestamp(); // Completion not allowed inside comments, bail out if this is the case const insideComment = isInsideComment(sourceFile, currentToken, position); - log("getCompletionData: Is inside comment: " + (new Date().getTime() - start)); + log("getCompletionData: Is inside comment: " + (timestamp() - start)); if (insideComment) { // The current position is next to the '@' sign, when no tag name being provided yet. @@ -3399,9 +3399,9 @@ namespace ts { } } - start = new Date().getTime(); + start = timestamp(); const previousToken = findPrecedingToken(position, sourceFile); - log("getCompletionData: Get previous token 1: " + (new Date().getTime() - start)); + log("getCompletionData: Get previous token 1: " + (timestamp() - start)); // The decision to provide completion depends on the contextToken, which is determined through the previousToken. // Note: 'previousToken' (and thus 'contextToken') can be undefined if we are the beginning of the file @@ -3410,9 +3410,9 @@ namespace ts { // Check if the caret is at the end of an identifier; this is a partial identifier that we want to complete: e.g. a.toS| // Skip this partial identifier and adjust the contextToken to the token that precedes it. if (contextToken && position <= contextToken.end && isWord(contextToken.kind)) { - const start = new Date().getTime(); + const start = timestamp(); contextToken = findPrecedingToken(contextToken.getFullStart(), sourceFile); - log("getCompletionData: Get previous token 2: " + (new Date().getTime() - start)); + log("getCompletionData: Get previous token 2: " + (timestamp() - start)); } // Find the node where completion is requested on. @@ -3459,7 +3459,7 @@ namespace ts { } } - const semanticStart = new Date().getTime(); + const semanticStart = timestamp(); let isMemberCompletion: boolean; let isNewIdentifierLocation: boolean; let symbols: Symbol[] = []; @@ -3497,7 +3497,7 @@ namespace ts { } } - log("getCompletionData: Semantic work: " + (new Date().getTime() - semanticStart)); + log("getCompletionData: Semantic work: " + (timestamp() - semanticStart)); return { symbols, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot: (isRightOfDot || isRightOfOpenTag), isJsDocTagName }; @@ -3641,12 +3641,12 @@ namespace ts { } function isCompletionListBlocker(contextToken: Node): boolean { - const start = new Date().getTime(); + const start = timestamp(); const result = isInStringOrRegularExpressionOrTemplateLiteral(contextToken) || isSolelyIdentifierDefinitionLocation(contextToken) || isDotOfNumericLiteral(contextToken) || isInJsxText(contextToken); - log("getCompletionsAtPosition: isCompletionListBlocker: " + (new Date().getTime() - start)); + log("getCompletionsAtPosition: isCompletionListBlocker: " + (timestamp() - start)); return result; } @@ -4299,7 +4299,7 @@ namespace ts { } function getCompletionEntriesFromSymbols(symbols: Symbol[], entries: CompletionEntry[], location: Node, performCharacterChecks: boolean): Map { - const start = new Date().getTime(); + const start = timestamp(); const uniqueNames: Map = {}; if (symbols) { for (const symbol of symbols) { @@ -4314,7 +4314,7 @@ namespace ts { } } - log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (new Date().getTime() - start)); + log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (timestamp() - start)); return uniqueNames; } @@ -7735,14 +7735,14 @@ namespace ts { } function getIndentationAtPosition(fileName: string, position: number, editorOptions: EditorOptions) { - let start = new Date().getTime(); + let start = timestamp(); const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - log("getIndentationAtPosition: getCurrentSourceFile: " + (new Date().getTime() - start)); + log("getIndentationAtPosition: getCurrentSourceFile: " + (timestamp() - start)); - start = new Date().getTime(); + start = timestamp(); const result = formatting.SmartIndenter.getIndentation(position, sourceFile, editorOptions); - log("getIndentationAtPosition: computeIndentation : " + (new Date().getTime() - start)); + log("getIndentationAtPosition: computeIndentation : " + (timestamp() - start)); return result; } diff --git a/src/services/shims.ts b/src/services/shims.ts index e85bf537d30..271d6f2d6e2 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -423,7 +423,7 @@ namespace ts { } public isCancellationRequested(): boolean { - const time = Date.now(); + const time = timestamp(); const duration = Math.abs(time - this.lastCancellationCheckTime); if (duration > 10) { // Check no more than once every 10 ms. @@ -498,13 +498,13 @@ namespace ts { let start: number; if (logPerformance) { logger.log(actionDescription); - start = Date.now(); + start = timestamp(); } const result = action(); if (logPerformance) { - const end = Date.now(); + const end = timestamp(); logger.log(`${actionDescription} completed in ${end - start} msec`); if (typeof result === "string") { let str = result; diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json index 86efd254937..cfeb7c2fcd5 100644 --- a/src/services/tsconfig.json +++ b/src/services/tsconfig.json @@ -13,6 +13,7 @@ }, "files": [ "../compiler/core.ts", + "../compiler/performance.ts", "../compiler/sys.ts", "../compiler/types.ts", "../compiler/scanner.ts", From 1b07fbb2228e00c4dbfb1250333ab5c963707875 Mon Sep 17 00:00:00 2001 From: Herrington Darkholme Date: Thu, 21 Jul 2016 10:01:12 +0800 Subject: [PATCH 10/10] Fix #9843. IScriptSnapshot can return undefined --- src/services/services.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/services/services.ts b/src/services/services.ts index 226d18f77dc..3124c78bd15 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -94,7 +94,7 @@ namespace ts { * change range cannot be determined. However, in that case, incremental parsing will * not happen and the entire document will be re - parsed. */ - getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange; + getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined; /** Releases all resources held by this script snapshot */ dispose?(): void;