Port TemplateStringsArray immutability to release-2.0

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<string> {
-    readonly raw: string[];
+interface TemplateStringsArray extends ReadonlyArray<string> {
+    readonly raw: ReadonlyArray<string>
 }
 
 interface Math {

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<T>(n: string[]) { }
+    function noGenericParams<T>(n: TemplateStringsArray) { }
     noGenericParams ``;
 
     // Generic tag with multiple type parameters and only one used in parameter type annotation
     function someGenerics1a<T, U>(n: T, m: number) { }
     someGenerics1a `${3}`;
 
-    function someGenerics1b<T, U>(n: string[], m: U) { }
+    function someGenerics1b<T, U>(n: TemplateStringsArray, m: U) { }
     someGenerics1b `${3}`;
 
     // Generic tag with argument of function type whose parameter is of type parameter type
-    function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+    function someGenerics2a<T>(strs: TemplateStringsArray, n: (x: T) => void) { }
     someGenerics2a `${(n: string) => n}`;
 
-    function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+    function someGenerics2b<T, U>(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<T>(strs: string[], producer: () => T) { }
+    function someGenerics3<T>(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<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+    function someGenerics4<T, U>(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<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+    function someGenerics5<U, T>(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<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+    function someGenerics6<A>(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<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+    function someGenerics7<A, B, C>(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<T>(strs: string[], n: T): T { return n; }
+    function someGenerics8<T>(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<T>(strs: string[], a: T, b: T, c: T): T {
+    function someGenerics9<T>(strs: TemplateStringsArray, a: T, b: T, c: T): T {
         return null;
     }
     var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;

tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.js

@@ -6,60 +6,60 @@ function noParams<T>(n: T) { }
 noParams ``;
 
 // Generic tag with parameter which does not use type parameter
-function noGenericParams<T>(n: string[]) { }
+function noGenericParams<T>(n: TemplateStringsArray) { }
 noGenericParams ``;
 
 // Generic tag with multiple type parameters and only one used in parameter type annotation
 function someGenerics1a<T, U>(n: T, m: number) { }
 someGenerics1a `${3}`;
 
-function someGenerics1b<T, U>(n: string[], m: U) { }
+function someGenerics1b<T, U>(n: TemplateStringsArray, m: U) { }
 someGenerics1b `${3}`;
 
 // Generic tag with argument of function type whose parameter is of type parameter type
-function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+function someGenerics2a<T>(strs: TemplateStringsArray, n: (x: T) => void) { }
 someGenerics2a `${(n: string) => n}`;
 
-function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+function someGenerics2b<T, U>(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<T>(strs: string[], producer: () => T) { }
+function someGenerics3<T>(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<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+function someGenerics4<T, U>(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<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+function someGenerics5<U, T>(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<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+function someGenerics6<A>(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<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+function someGenerics7<A, B, C>(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<T>(strs: string[], n: T): T { return n; }
+function someGenerics8<T>(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<T>(strs: string[], a: T, b: T, c: T): T {
+function someGenerics9<T>(strs: TemplateStringsArray, a: T, b: T, c: T): T {
     return null;
 }
 var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;

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<T>(n: string[]) { }
+    function noGenericParams<T>(n: TemplateStringsArray) { }
     noGenericParams ``;
 
     // Generic tag with multiple type parameters and only one used in parameter type annotation
     function someGenerics1a<T, U>(n: T, m: number) { }
     someGenerics1a `${3}`;
 
-    function someGenerics1b<T, U>(n: string[], m: U) { }
+    function someGenerics1b<T, U>(n: TemplateStringsArray, m: U) { }
     someGenerics1b `${3}`;
 
     // Generic tag with argument of function type whose parameter is of type parameter type
-    function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+    function someGenerics2a<T>(strs: TemplateStringsArray, n: (x: T) => void) { }
     someGenerics2a `${(n: string) => n}`;
 
-    function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+    function someGenerics2b<T, U>(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<T>(strs: string[], producer: () => T) { }
+    function someGenerics3<T>(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<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+    function someGenerics4<T, U>(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<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+    function someGenerics5<U, T>(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<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+    function someGenerics6<A>(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<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+    function someGenerics7<A, B, C>(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<T>(strs: string[], n: T): T { return n; }
+    function someGenerics8<T>(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<T>(strs: string[], a: T, b: T, c: T): T {
+    function someGenerics9<T>(strs: TemplateStringsArray, a: T, b: T, c: T): T {
         return null;
     }
     var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;

tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js

@@ -5,60 +5,60 @@ function noParams<T>(n: T) { }
 noParams ``;
 
 // Generic tag with parameter which does not use type parameter
-function noGenericParams<T>(n: string[]) { }
+function noGenericParams<T>(n: TemplateStringsArray) { }
 noGenericParams ``;
 
 // Generic tag with multiple type parameters and only one used in parameter type annotation
 function someGenerics1a<T, U>(n: T, m: number) { }
 someGenerics1a `${3}`;
 
-function someGenerics1b<T, U>(n: string[], m: U) { }
+function someGenerics1b<T, U>(n: TemplateStringsArray, m: U) { }
 someGenerics1b `${3}`;
 
 // Generic tag with argument of function type whose parameter is of type parameter type
-function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+function someGenerics2a<T>(strs: TemplateStringsArray, n: (x: T) => void) { }
 someGenerics2a `${(n: string) => n}`;
 
-function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+function someGenerics2b<T, U>(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<T>(strs: string[], producer: () => T) { }
+function someGenerics3<T>(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<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+function someGenerics4<T, U>(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<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+function someGenerics5<U, T>(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<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+function someGenerics6<A>(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<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+function someGenerics7<A, B, C>(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<T>(strs: string[], n: T): T { return n; }
+function someGenerics8<T>(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<T>(strs: string[], a: T, b: T, c: T): T {
+function someGenerics9<T>(strs: TemplateStringsArray, a: T, b: T, c: T): T {
     return null;
 }
 var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;

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;

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;

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;

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;

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): {

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

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