Accept new baselines

2025-11-18 17:21:48 +00:00 · 2017-07-16 17:05:27 -10:00
parent 8a69ad89c0
commit 5093f93677
56 changed files with 355 additions and 355 deletions
@@ -26,11 +26,11 @@ class Board {

        return this.ships.every(function (val) { return val.isSunk; });
 >this.ships.every(function (val) { return val.isSunk; }) : boolean
->this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
+>this.ships.every : (this: readonly, callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
 >this.ships : Ship[]
 >this : this
 >ships : Ship[]
->every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
 >function (val) { return val.isSunk; } : (val: Ship) => boolean
 >val : Ship
 >val.isSunk : boolean
@@ -4,9 +4,9 @@ var paired: any[];

 paired.reduce(function (a1, a2) {
 >paired.reduce(function (a1, a2) {    return a1.concat({});} , []) : any
->paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired.reduce : { (this: readonly, callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >paired : any[]
->reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >function (a1, a2) {    return a1.concat({});} : (a1: any, a2: any) => any
 >a1 : any
 >a2 : any
@@ -23,9 +23,9 @@ paired.reduce(function (a1, a2) {

 paired.reduce((b1, b2) => {
 >paired.reduce((b1, b2) => {    return b1.concat({});} , []) : any
->paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired.reduce : { (this: readonly, callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >paired : any[]
->reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >(b1, b2) => {    return b1.concat({});} : (b1: any, b2: any) => any
 >b1 : any
 >b2 : any
@@ -42,9 +42,9 @@ paired.reduce((b1, b2) => {

 paired.reduce((b3, b4) => b3.concat({}), []);
 >paired.reduce((b3, b4) => b3.concat({}), []) : any
->paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired.reduce : { (this: readonly, callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >paired : any[]
->reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >(b3, b4) => b3.concat({}) : (b3: any, b4: any) => any
 >b3 : any
 >b4 : any
@@ -57,9 +57,9 @@ paired.reduce((b3, b4) => b3.concat({}), []);

 paired.map((c1) => c1.count);
 >paired.map((c1) => c1.count) : any[]
->paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>paired.map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >paired : any[]
->map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >(c1) => c1.count : (c1: any) => any
 >c1 : any
 >c1.count : any
@@ -68,9 +68,9 @@ paired.map((c1) => c1.count);

 paired.map(function (c2) { return c2.count; });
 >paired.map(function (c2) { return c2.count; }) : any[]
->paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>paired.map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >paired : any[]
->map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >function (c2) { return c2.count; } : (c2: any) => any
 >c2 : any
 >c2.count : any
@@ -42,12 +42,12 @@ function myFunction(myType: MyType) {

        [1, 2, 3].forEach(function(j) { use(x); })
 >[1, 2, 3].forEach(function(j) { use(x); }) : void
->[1, 2, 3].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>[1, 2, 3].forEach : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
->forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
 >function(j) { use(x); } : (j: number) => void
 >j : number
 >use(x) : any
@@ -5,17 +5,17 @@ var a: string[] = [];

 a.concat("hello", 'world');
 >a.concat("hello", 'world') : string[]
->a.concat : { (...items: string[][]): string[]; (...items: (string | string[])[]): string[]; }
+>a.concat : { (this: readonly, ...items: string[][]): string[]; (this: readonly, ...items: (string | string[])[]): string[]; }
 >a : string[]
->concat : { (...items: string[][]): string[]; (...items: (string | string[])[]): string[]; }
+>concat : { (this: readonly, ...items: string[][]): string[]; (this: readonly, ...items: (string | string[])[]): string[]; }
 >"hello" : "hello"
 >'world' : "world"

 a.concat('Hello');
 >a.concat('Hello') : string[]
->a.concat : { (...items: string[][]): string[]; (...items: (string | string[])[]): string[]; }
+>a.concat : { (this: readonly, ...items: string[][]): string[]; (this: readonly, ...items: (string | string[])[]): string[]; }
 >a : string[]
->concat : { (...items: string[][]): string[]; (...items: (string | string[])[]): string[]; }
+>concat : { (this: readonly, ...items: string[][]): string[]; (this: readonly, ...items: (string | string[])[]): string[]; }
 >'Hello' : "Hello"

 var b = new Array<string>();
@@ -25,8 +25,8 @@ var b = new Array<string>();

 b.concat('hello');
 >b.concat('hello') : string[]
->b.concat : { (...items: string[][]): string[]; (...items: (string | string[])[]): string[]; }
+>b.concat : { (this: readonly, ...items: string[][]): string[]; (this: readonly, ...items: (string | string[])[]): string[]; }
 >b : string[]
->concat : { (...items: string[][]): string[]; (...items: (string | string[])[]): string[]; }
+>concat : { (this: readonly, ...items: string[][]): string[]; (this: readonly, ...items: (string | string[])[]): string[]; }
 >'hello' : "hello"

@@ -2,11 +2,11 @@
 var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >x : any[]
 >[].concat([{ a: 1 }], [{ a: 2 }])          .map(b => b.a) : any[]
->[].concat([{ a: 1 }], [{ a: 2 }])          .map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>[].concat([{ a: 1 }], [{ a: 2 }])          .map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
->[].concat : { (...items: any[][]): any[]; (...items: any[]): any[]; }
+>[].concat : { (this: readonly, ...items: any[][]): any[]; (this: readonly, ...items: any[]): any[]; }
 >[] : undefined[]
->concat : { (...items: any[][]): any[]; (...items: any[]): any[]; }
+>concat : { (this: readonly, ...items: any[][]): any[]; (this: readonly, ...items: any[]): any[]; }
 >[{ a: 1 }] : { a: number; }[]
 >{ a: 1 } : { a: number; }
 >a : number
@@ -17,7 +17,7 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >2 : 2

          .map(b => b.a);
->map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >b => b.a : (b: any) => any
 >b : any
 >b.a : any
@@ -22,9 +22,9 @@ var foo = [

 foo.filter(x => x.name); //should accepted all possible types not only boolean! 
 >foo.filter(x => x.name) : { name: string; }[]
->foo.filter : { <S extends { name: string; }>(callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg?: any): { name: string; }[]; }
+>foo.filter : { <S extends { name: string; }>(this: readonly, callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg?: any): { name: string; }[]; }
 >foo : { name: string; }[]
->filter : { <S extends { name: string; }>(callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg?: any): { name: string; }[]; }
+>filter : { <S extends { name: string; }>(this: readonly, callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: { name: string; }, index: number, array: { name: string; }[]) => any, thisArg?: any): { name: string; }[]; }
 >x => x.name : (x: { name: string; }) => string
 >x : { name: string; }
 >x.name : string
@@ -1,12 +1,12 @@
 tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(13,1): error TS2322: Type 'A[]' is not assignable to type 'ReadonlyArray<B>'.
  Types of property 'concat' are incompatible.
-    Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+    Type '{ (this: readonly, ...items: A[][]): A[]; (this: readonly, ...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
      Type 'A[]' is not assignable to type 'B[]'.
        Type 'A' is not assignable to type 'B'.
          Property 'b' is missing in type 'A'.
 tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is not assignable to type 'ReadonlyArray<B>'.
  Types of property 'concat' are incompatible.
-    Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+    Type '{ (this: readonly, ...items: A[][]): A[]; (this: readonly, ...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
      Type 'A[]' is not assignable to type 'B[]'.


@@ -27,7 +27,7 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T
    ~~~
 !!! error TS2322: Type 'A[]' is not assignable to type 'ReadonlyArray<B>'.
 !!! error TS2322:   Types of property 'concat' are incompatible.
-!!! error TS2322:     Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+!!! error TS2322:     Type '{ (this: readonly, ...items: A[][]): A[]; (this: readonly, ...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
 !!! error TS2322:       Type 'A[]' is not assignable to type 'B[]'.
 !!! error TS2322:         Type 'A' is not assignable to type 'B'.
 !!! error TS2322:           Property 'b' is missing in type 'A'.
@@ -39,6 +39,6 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T
    ~~~
 !!! error TS2322: Type 'C<A>' is not assignable to type 'ReadonlyArray<B>'.
 !!! error TS2322:   Types of property 'concat' are incompatible.
-!!! error TS2322:     Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+!!! error TS2322:     Type '{ (this: readonly, ...items: A[][]): A[]; (this: readonly, ...items: (A | A[])[]): A[]; }' is not assignable to type '{ (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
 !!! error TS2322:       Type 'A[]' is not assignable to type 'B[]'.
    
@@ -3,7 +3,7 @@

 (''.match(/ /) || []).map(s => s.toLowerCase());
 >(''.match(/ /) || []).map(s => s.toLowerCase()) : string[]
->(''.match(/ /) || []).map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>(''.match(/ /) || []).map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >(''.match(/ /) || []) : RegExpMatchArray
 >''.match(/ /) || [] : RegExpMatchArray
 >''.match(/ /) : RegExpMatchArray | null
@@ -12,7 +12,7 @@
 >match : (regexp: string | RegExp) => RegExpMatchArray | null
 >/ / : RegExp
 >[] : never[]
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >s => s.toLowerCase() : (s: string) => string
 >s : string
 >s.toLowerCase() : string
@@ -42,9 +42,9 @@ function f1() {
    let z = y.map(s => s.toLowerCase());
 >z : string[]
 >y.map(s => s.toLowerCase()) : string[]
->y.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>y.map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >y : RegExpMatchArray
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >s => s.toLowerCase() : (s: string) => string
 >s : string
 >s.toLowerCase() : string
@@ -74,9 +74,9 @@ function f2() {
    let z = y.map(s => s.toLowerCase());
 >z : string[]
 >y.map(s => s.toLowerCase()) : string[]
->y.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>y.map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >y : RegExpMatchArray
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >s => s.toLowerCase() : (s: string) => string
 >s : string
 >s.toLowerCase() : string
@@ -13,9 +13,9 @@ class A {

        x.forEach((v) => {
 >x.forEach((v) => {            switch(v) {                case "test": use(this);            }        }) : void
->x.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>x.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >x : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >(v) => {            switch(v) {                case "test": use(this);            }        } : (v: string) => void
 >v : string

@@ -41,9 +41,9 @@ for (let i = 0; i < 3; i++) {
 }
 arr.forEach(C => console.log(C.y()));
 >arr.forEach(C => console.log(C.y())) : void
->arr.forEach : (callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
+>arr.forEach : (this: readonly, callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
 >arr : { y(): number; }[]
->forEach : (callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
 >C => console.log(C.y()) : (C: { y(): number; }) => any
 >C : { y(): number; }
 >console.log(C.y()) : any
@@ -41,9 +41,9 @@ for (let i = 0; i < 3; i++) {
 }
 arr.forEach(C => console.log(C.y()));
 >arr.forEach(C => console.log(C.y())) : void
->arr.forEach : (callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
+>arr.forEach : (this: readonly, callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
 >arr : { y(): number; }[]
->forEach : (callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: { y(): number; }, index: number, array: { y(): number; }[]) => void, thisArg?: any) => void
 >C => console.log(C.y()) : (C: { y(): number; }) => any
 >C : { y(): number; }
 >console.log(C.y()) : any
@@ -5,12 +5,12 @@ function f (m: string) {

    [1, 2, 3].map(i => {
 >[1, 2, 3].map(i => {        return true? { [m]: i } : { [m]: i + 1 }    }) : { [x: string]: number; }[]
->[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>[1, 2, 3].map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >i => {        return true? { [m]: i } : { [m]: i + 1 }    } : (i: number) => { [x: string]: number; }
 >i : number

@@ -5,9 +5,9 @@ var s: string[];

 s.map(// do something
 >s.map(// do something    function () { }) : void[]
->s.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>s.map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >s : string[]
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]

    function () { });
 >function () { } : () => void
@@ -15,9 +15,9 @@ fa = fa.concat([0]);
 >fa = fa.concat([0]) : number[]
 >fa : number[]
 >fa.concat([0]) : number[]
->fa.concat : { (...items: number[][]): number[]; (...items: (number | number[])[]): number[]; }
+>fa.concat : { (this: readonly, ...items: number[][]): number[]; (this: readonly, ...items: (number | number[])[]): number[]; }
 >fa : number[]
->concat : { (...items: number[][]): number[]; (...items: (number | number[])[]): number[]; }
+>concat : { (this: readonly, ...items: number[][]): number[]; (this: readonly, ...items: (number | number[])[]): number[]; }
 >[0] : number[]
 >0 : 0

@@ -25,9 +25,9 @@ fa = fa.concat(0);
 >fa = fa.concat(0) : number[]
 >fa : number[]
 >fa.concat(0) : number[]
->fa.concat : { (...items: number[][]): number[]; (...items: (number | number[])[]): number[]; }
+>fa.concat : { (this: readonly, ...items: number[][]): number[]; (this: readonly, ...items: (number | number[])[]): number[]; }
 >fa : number[]
->concat : { (...items: number[][]): number[]; (...items: (number | number[])[]): number[]; }
+>concat : { (this: readonly, ...items: number[][]): number[]; (this: readonly, ...items: (number | number[])[]): number[]; }
 >0 : 0


@@ -10,9 +10,9 @@ ijs = ijs.concat([[3, 4], [5, 6]]);
 >ijs = ijs.concat([[3, 4], [5, 6]]) : [number, number][]
 >ijs : [number, number][]
 >ijs.concat([[3, 4], [5, 6]]) : [number, number][]
->ijs.concat : { (...items: [number, number][][]): [number, number][]; (...items: ([number, number] | [number, number][])[]): [number, number][]; }
+>ijs.concat : { (this: readonly, ...items: [number, number][][]): [number, number][]; (this: readonly, ...items: ([number, number] | [number, number][])[]): [number, number][]; }
 >ijs : [number, number][]
->concat : { (...items: [number, number][][]): [number, number][]; (...items: ([number, number] | [number, number][])[]): [number, number][]; }
+>concat : { (this: readonly, ...items: [number, number][][]): [number, number][]; (this: readonly, ...items: ([number, number] | [number, number][])[]): [number, number][]; }
 >[[3, 4], [5, 6]] : [number, number][]
 >[3, 4] : [number, number]
 >3 : 3
@@ -13,9 +13,9 @@ function map<T, U>(items: T[], f: (x: T) => U): U[]{

    return items.map(f);
 >items.map(f) : U[]
->items.map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
+>items.map : <U>(this: readonly, callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
 >items : T[]
->map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
 >f : (x: T) => U
 }

@@ -54,9 +54,9 @@ var v1: number[];
 var v1 = xs.map(identity);      // Error if not number[]
 >v1 : number[]
 >xs.map(identity) : number[]
->xs.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>xs.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >xs : number[]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >identity : <T>(x: T) => T

 var v1 = map(xs, identity);     // Error if not number[]
@@ -72,9 +72,9 @@ var v2: number[][];
 var v2 = xs.map(singleton);     // Error if not number[][]
 >v2 : number[][]
 >xs.map(singleton) : number[][]
->xs.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>xs.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >xs : number[]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >singleton : <T>(x: T) => T[]

 var v2 = map(xs, singleton);    // Error if not number[][]
@@ -105,9 +105,9 @@
 >(...numbers) => numbers.every(n => n > 0) : (...numbers: number[]) => boolean
 >numbers : number[]
 >numbers.every(n => n > 0) : boolean
->numbers.every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>numbers.every : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >numbers : number[]
->every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >n => n > 0 : (n: number) => boolean
 >n : number
 >n > 0 : boolean
@@ -123,9 +123,9 @@
 >(...mixed) => mixed.every(n => !!n) : (...mixed: (string | number)[]) => boolean
 >mixed : (string | number)[]
 >mixed.every(n => !!n) : boolean
->mixed.every : (callbackfn: (value: string | number, index: number, array: (string | number)[]) => boolean, thisArg?: any) => boolean
+>mixed.every : (this: readonly, callbackfn: (value: string | number, index: number, array: (string | number)[]) => boolean, thisArg?: any) => boolean
 >mixed : (string | number)[]
->every : (callbackfn: (value: string | number, index: number, array: (string | number)[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: string | number, index: number, array: (string | number)[]) => boolean, thisArg?: any) => boolean
 >n => !!n : (n: string | number) => boolean
 >n : string | number
 >!!n : boolean
@@ -141,9 +141,9 @@
 >(...noNumbers) => noNumbers.some(n => n > 0) : (...noNumbers: any[]) => boolean
 >noNumbers : any[]
 >noNumbers.some(n => n > 0) : boolean
->noNumbers.some : (callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any) => boolean
+>noNumbers.some : (this: readonly, callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any) => boolean
 >noNumbers : any[]
->some : (callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any) => boolean
 >n => n > 0 : (n: any) => boolean
 >n : any
 >n > 0 : boolean
@@ -160,9 +160,9 @@
 >first : number
 >[] : undefined[]
 >rest.map(n => n > 0) : boolean[]
->rest.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>rest.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >rest : number[]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >n => n > 0 : (n: number) => boolean
 >n : number
 >n > 0 : boolean
@@ -4,12 +4,12 @@

 [{ x: 1 }].map(
 >[{ x: 1 }].map(  ({ x }) => x) : number[]
->[{ x: 1 }].map : <U>(callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]
+>[{ x: 1 }].map : <U>(this: readonly, callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]
 >[{ x: 1 }] : { x: number; }[]
 >{ x: 1 } : { x: number; }
 >x : number
 >1 : 1
->map : <U>(callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]

  ({ x }) => x
 >({ x }) => x : ({ x }: { x: number; }) => number
@@ -34,8 +34,8 @@ const helper = function<T>(t: T[]) {
 >helper(t.slice(1)) : void
 >helper : <T>(t: T[]) => void
 >t.slice(1) : T[]
->t.slice : (start?: number | undefined, end?: number | undefined) => T[]
+>t.slice : (this: readonly, start?: number | undefined, end?: number | undefined) => T[]
 >t : T[]
->slice : (start?: number | undefined, end?: number | undefined) => T[]
+>slice : (this: readonly, start?: number | undefined, end?: number | undefined) => T[]
 >1 : 1
 }
@@ -34,9 +34,9 @@ export class ConstructorWithRestParamters {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }
 }
@@ -124,9 +124,9 @@ class GlobalConstructorWithRestParamters {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }
 }
@@ -25,9 +25,9 @@ export function fooWithRestParameters(a: string, ...rests: string[]) {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
 }

@@ -123,9 +123,9 @@ function nonExportedFooWithRestParameters(a: string, ...rests: string[]) {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
 }

@@ -172,9 +172,9 @@ function globalfooWithRestParameters(a: string, ...rests: string[]) {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
 }
 function globalfooWithOverloads(a: string): string;
@@ -28,9 +28,9 @@ export class c1 {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }

@@ -77,9 +77,9 @@ export class c1 {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }
    private privateFooWithOverloads(a: string): string;
@@ -125,9 +125,9 @@ export class c1 {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }
    static staticFooWithOverloads(a: string): string;
@@ -173,9 +173,9 @@ export class c1 {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }
    private static privateStaticFooWithOverloads(a: string): string;
@@ -255,9 +255,9 @@ class c2 {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }

@@ -304,9 +304,9 @@ class c2 {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }
    private privateFooWithOverloads(a: string): string;
@@ -352,9 +352,9 @@ class c2 {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }
    static staticFooWithOverloads(a: string): string;
@@ -400,9 +400,9 @@ class c2 {
 >a + rests.join("") : string
 >a : string
 >rests.join("") : string
->rests.join : (separator?: string) => string
+>rests.join : (this: readonly, separator?: string) => string
 >rests : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >"" : ""
    }
    private static privateStaticFooWithOverloads(a: string): string;
@@ -44,14 +44,14 @@ export async function runSampleWorks<A, B, C, D, E>(
 >bluebird : typeof bluebird
 >all : bluebird<any>[]
 >[a, b, c, d, e].filter(el => !!el) : bluebird<A>[]
->[a, b, c, d, e].filter : { <S extends bluebird<A>>(callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
+>[a, b, c, d, e].filter : { <S extends bluebird<A>>(this: readonly, callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
 >[a, b, c, d, e] : bluebird<A>[]
 >a : bluebird<A>
 >b : bluebird<B>
 >c : bluebird<C>
 >d : bluebird<D>
 >e : bluebird<E>
->filter : { <S extends bluebird<A>>(callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
+>filter : { <S extends bluebird<A>>(this: readonly, callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
 >el => !!el : (el: bluebird<A>) => boolean
 >el : bluebird<A>
 >!!el : boolean
@@ -129,14 +129,14 @@ export async function runSampleBreaks<A, B, C, D, E>(
 >bluebird : typeof bluebird
 >all : bluebird<any>[]
 >[a, b, c, d, e].filter(el => !!el) : bluebird<A>[]
->[a, b, c, d, e].filter : { <S extends bluebird<A>>(callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
+>[a, b, c, d, e].filter : { <S extends bluebird<A>>(this: readonly, callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
 >[a, b, c, d, e] : bluebird<A>[]
 >a : bluebird<A>
 >b : bluebird<B>
 >c : bluebird<C>
 >d : bluebird<D>
 >e : bluebird<E>
->filter : { <S extends bluebird<A>>(callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
+>filter : { <S extends bluebird<A>>(this: readonly, callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: bluebird<A>, index: number, array: bluebird<A>[]) => any, thisArg?: any): bluebird<A>[]; }
 >el => !!el : (el: bluebird<A>) => boolean
 >el : bluebird<A>
 >!!el : boolean
@@ -4,7 +4,7 @@ interface Array<T> {
 >T : T

    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T,
->reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
 >callbackfn : (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T
 >previousValue : T
 >T : T
@@ -21,7 +21,7 @@ interface Array<T> {
 >T : T

    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U,
->reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
 >U : U
 >callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
 >previousValue : U
@@ -45,9 +45,9 @@ var a: Array<string>;
 var r5 = a.reduce((x, y) => x + y);
 >r5 : string
 >a.reduce((x, y) => x + y) : string
->a.reduce : { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
+>a.reduce : { (this: readonly, callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
 >a : string[]
->reduce : { (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue?: string): string; <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U; }
 >(x, y) => x + y : (x: string, y: string) => string
 >x : string
 >y : string
@@ -18,10 +18,10 @@ function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any
 >apply : (this: Function, thisArg: any, argArray?: any) => any
 >this : any
 >[ this ].concat(args) : any[]
->[ this ].concat : { (...items: any[][]): any[]; (...items: any[]): any[]; }
+>[ this ].concat : { (this: readonly, ...items: any[][]): any[]; (this: readonly, ...items: any[]): any[]; }
 >[ this ] : any[]
 >this : any
->concat : { (...items: any[][]): any[]; (...items: any[]): any[]; }
+>concat : { (this: readonly, ...items: any[][]): any[]; (this: readonly, ...items: any[]): any[]; }
 >args : any[]

    };
@@ -25,9 +25,9 @@ var enumValue = MyEnumType.foo;
 var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same type
 >x : boolean[]
 >_arr.map(o => MyEnumType[o.key] === enumValue) : boolean[]
->_arr.map : <U>(callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
+>_arr.map : <U>(this: readonly, callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
 >_arr : { key: string; }[]
->map : <U>(callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
 >o => MyEnumType[o.key] === enumValue : (o: { key: string; }) => boolean
 >o : { key: string; }
 >MyEnumType[o.key] === enumValue : boolean
@@ -14,12 +14,12 @@ interface String{
 var lengths = ["a", "b", "c"].map(x => x.length);
 >lengths : number[]
 >["a", "b", "c"].map(x => x.length) : number[]
->["a", "b", "c"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>["a", "b", "c"].map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b", "c"] : string[]
 >"a" : "a"
 >"b" : "b"
 >"c" : "c"
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >x => x.length : (x: string) => number
 >x : string
 >x.length : number
@@ -230,9 +230,9 @@ const arrayMap = <T, U>(f: (x: T) => U) => (a: T[]) => a.map(f);
 >a : T[]
 >T : T
 >a.map(f) : U[]
->a.map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
+>a.map : <U>(this: readonly, callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
 >a : T[]
->map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
 >f : (x: T) => U

 const arrayFilter = <T>(f: (x: T) => boolean) => (a: T[]) => a.filter(f);
@@ -246,9 +246,9 @@ const arrayFilter = <T>(f: (x: T) => boolean) => (a: T[]) => a.filter(f);
 >a : T[]
 >T : T
 >a.filter(f) : T[]
->a.filter : { <S extends T>(callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): T[]; }
+>a.filter : { <S extends T>(this: readonly, callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): T[]; }
 >a : T[]
->filter : { <S extends T>(callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): T[]; }
+>filter : { <S extends T>(this: readonly, callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): T[]; }
 >f : (x: T) => boolean

 const f20: (a: string[]) => number[] = arrayMap(x => x.length);
@@ -4,9 +4,9 @@ var b: number[];

 b.reduce<number>((c, d) => c + d, 0); // should not error on '+'
 >b.reduce<number>((c, d) => c + d, 0) : number
->b.reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>b.reduce : { (this: readonly, callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >b : number[]
->reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >(c, d) => c + d : (c: number, d: number) => number
 >c : number
 >d : number
@@ -1,12 +1,12 @@
 === tests/cases/compiler/genericInference1.ts ===
 ['a', 'b', 'c'].map(x => x.length);
 >['a', 'b', 'c'].map(x => x.length) : number[]
->['a', 'b', 'c'].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>['a', 'b', 'c'].map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >['a', 'b', 'c'] : string[]
 >'a' : "a"
 >'b' : "b"
 >'c' : "c"
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >x => x.length : (x: string) => number
 >x : string
 >x.length : number
@@ -34,9 +34,9 @@ interface Document {
 var elements = names.map(function (name) {
 >elements : HTMLElement[]
 >names.map(function (name) {    return document.getElementById(name);}) : HTMLElement[]
->names.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>names.map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >names : string[]
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >function (name) {    return document.getElementById(name);} : (name: string) => HTMLElement
 >name : string

@@ -53,9 +53,9 @@ var elements = names.map(function (name) {
 var xxx = elements.filter(function (e) {
 >xxx : HTMLElement[]
 >elements.filter(function (e) {    return !e.isDisabled;}) : HTMLElement[]
->elements.filter : { <S extends HTMLElement>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg?: any): HTMLElement[]; }
+>elements.filter : { <S extends HTMLElement>(this: readonly, callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg?: any): HTMLElement[]; }
 >elements : HTMLElement[]
->filter : { <S extends HTMLElement>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg?: any): HTMLElement[]; }
+>filter : { <S extends HTMLElement>(this: readonly, callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => any, thisArg?: any): HTMLElement[]; }
 >function (e) {    return !e.isDisabled;} : (e: HTMLElement) => boolean
 >e : HTMLElement

@@ -70,9 +70,9 @@ var xxx = elements.filter(function (e) {
 var widths:number[] = elements.map(function (e) { // should not error
 >widths : number[]
 >elements.map(function (e) { // should not error    return e.clientWidth;}) : number[]
->elements.map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
+>elements.map : <U>(this: readonly, callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
 >elements : HTMLElement[]
->map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
 >function (e) { // should not error    return e.clientWidth;} : (e: HTMLElement) => number
 >e : HTMLElement

@@ -120,11 +120,11 @@ foo(wrap(s => s.length));
 let a1 = ["a", "b"].map(s => s.length);
 >a1 : number[]
 >["a", "b"].map(s => s.length) : number[]
->["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>["a", "b"].map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >s => s.length : (s: string) => number
 >s : string
 >s.length : number
@@ -134,11 +134,11 @@ let a1 = ["a", "b"].map(s => s.length);
 let a2 = ["a", "b"].map(wrap(s => s.length));
 >a2 : number[]
 >["a", "b"].map(wrap(s => s.length)) : number[]
->["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>["a", "b"].map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >wrap(s => s.length) : Mapper<string, number>
 >wrap : <T, U>(cb: Mapper<T, U>) => Mapper<T, U>
 >s => s.length : (s: string) => number
@@ -150,11 +150,11 @@ let a2 = ["a", "b"].map(wrap(s => s.length));
 let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
 >a3 : number[][]
 >["a", "b"].map(wrap(arrayize(s => s.length))) : number[][]
->["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>["a", "b"].map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >wrap(arrayize(s => s.length)) : Mapper<string, number[]>
 >wrap : <T, U>(cb: Mapper<T, U>) => Mapper<T, U>
 >arrayize(s => s.length) : Mapper<string, number[]>
@@ -168,11 +168,11 @@ let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
 let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
 >a4 : boolean[]
 >["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10))) : boolean[]
->["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>["a", "b"].map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >combine(wrap(s => s.length), wrap(n => n > 10)) : (x: string) => boolean
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
 >wrap(s => s.length) : Mapper<string, number>
@@ -193,11 +193,11 @@ let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
 let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
 >a5 : number[]
 >["a", "b"].map(combine(identity, wrap(s => s.length))) : number[]
->["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>["a", "b"].map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >combine(identity, wrap(s => s.length)) : (x: string) => number
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
 >identity : <T>(x: T) => T
@@ -212,11 +212,11 @@ let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
 let a6 = ["a", "b"].map(combine(wrap(s => s.length), identity));
 >a6 : number[]
 >["a", "b"].map(combine(wrap(s => s.length), identity)) : number[]
->["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>["a", "b"].map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >["a", "b"] : string[]
 >"a" : "a"
 >"b" : "b"
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >combine(wrap(s => s.length), identity) : (x: string) => number
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
 >wrap(s => s.length) : Mapper<string, number>
@@ -279,11 +279,11 @@ class SetOf<A> {

      this._store.forEach((a, i) => fn(a, i));
 >this._store.forEach((a, i) => fn(a, i)) : void
->this._store.forEach : (callbackfn: (value: A, index: number, array: A[]) => void, thisArg?: any) => void
+>this._store.forEach : (this: readonly, callbackfn: (value: A, index: number, array: A[]) => void, thisArg?: any) => void
 >this._store : A[]
 >this : this
 >_store : A[]
->forEach : (callbackfn: (value: A, index: number, array: A[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: A, index: number, array: A[]) => void, thisArg?: any) => void
 >(a, i) => fn(a, i) : (a: A, i: number) => void
 >a : A
 >i : number
@@ -358,9 +358,9 @@ function compose<T>(...fns: ((x: T) => T)[]): (x: T) => T {
 >x : T
 >T : T
 >fns.reduce((prev, fn) => fn(prev), x) : T
->fns.reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue?: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
+>fns.reduce : { (this: readonly, callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue?: (x: T) => T): (x: T) => T; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
 >fns : ((x: T) => T)[]
->reduce : { (callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue?: (x: T) => T): (x: T) => T; <U>(callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: (x: T) => T, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => (x: T) => T, initialValue?: (x: T) => T): (x: T) => T; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: (x: T) => T, currentIndex: number, array: ((x: T) => T)[]) => U, initialValue: U): U; }
 >(prev, fn) => fn(prev) : (prev: T, fn: (x: T) => T) => T
 >prev : T
 >fn : (x: T) => T
@@ -84,9 +84,9 @@ export class BrokenClass {
 >Promise : PromiseConstructor
 >all : { <TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; <T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; <T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; <T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; <T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<[T1, T2, T3, T4, T5, T6]>; <T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>; <T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>; <T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<[T1, T2, T3]>; <T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<[T1, T2]>; <T>(values: (T | PromiseLike<T>)[]): Promise<T[]>; }
 >result.map(populateItems) : Promise<{}>[]
->result.map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
+>result.map : <U>(this: readonly, callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
 >result : MyModule.MyModel[]
->map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
 >populateItems : (order: any) => Promise<{}>

      .then((orders: Array<MyModule.MyModel>) => {
@@ -13,12 +13,12 @@ var x = [1, 2, 3].map(identity)[0];
 >x : number
 >[1, 2, 3].map(identity)[0] : number
 >[1, 2, 3].map(identity) : number[]
->[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>[1, 2, 3].map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >identity : <A>(a: A) => A
 >0 : 0

@@ -35,9 +35,9 @@ var array: symbol[];

 array.concat([...new SymbolIterator]);
 >array.concat([...new SymbolIterator]) : symbol[]
->array.concat : { (...items: symbol[][]): symbol[]; (...items: (symbol | symbol[])[]): symbol[]; }
+>array.concat : { (this: readonly, ...items: symbol[][]): symbol[]; (this: readonly, ...items: (symbol | symbol[])[]): symbol[]; }
 >array : symbol[]
->concat : { (...items: symbol[][]): symbol[]; (...items: (symbol | symbol[])[]): symbol[]; }
+>concat : { (this: readonly, ...items: symbol[][]): symbol[]; (this: readonly, ...items: (symbol | symbol[])[]): symbol[]; }
 >[...new SymbolIterator] : symbol[]
 >...new SymbolIterator : symbol
 >new SymbolIterator : SymbolIterator
@@ -522,9 +522,9 @@ function pluck<T, K extends keyof T>(array: T[], key: K) {

    return array.map(x => x[key]);
 >array.map(x => x[key]) : T[K][]
->array.map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
+>array.map : <U>(this: readonly, callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
 >array : T[]
->map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
 >x => x[key] : (x: T) => T[K]
 >x : T
 >x[key] : T[K]
@@ -2,28 +2,28 @@
 // Array.prototype.slice can have zero, one, or two arguments
 Array.prototype.slice();
 >Array.prototype.slice() : any[]
->Array.prototype.slice : (start?: number, end?: number) => any[]
+>Array.prototype.slice : (this: readonly, start?: number, end?: number) => any[]
 >Array.prototype : any[]
 >Array : ArrayConstructor
 >prototype : any[]
->slice : (start?: number, end?: number) => any[]
+>slice : (this: readonly, start?: number, end?: number) => any[]

 Array.prototype.slice(0);
 >Array.prototype.slice(0) : any[]
->Array.prototype.slice : (start?: number, end?: number) => any[]
+>Array.prototype.slice : (this: readonly, start?: number, end?: number) => any[]
 >Array.prototype : any[]
 >Array : ArrayConstructor
 >prototype : any[]
->slice : (start?: number, end?: number) => any[]
+>slice : (this: readonly, start?: number, end?: number) => any[]
 >0 : 0

 Array.prototype.slice(0, 1);
 >Array.prototype.slice(0, 1) : any[]
->Array.prototype.slice : (start?: number, end?: number) => any[]
+>Array.prototype.slice : (this: readonly, start?: number, end?: number) => any[]
 >Array.prototype : any[]
 >Array : ArrayConstructor
 >prototype : any[]
->slice : (start?: number, end?: number) => any[]
+>slice : (this: readonly, start?: number, end?: number) => any[]
 >0 : 0
 >1 : 1

@@ -6,22 +6,22 @@ var regExpExecArrayValue: RegExpExecArray;

 regExpExecArrayValue.slice();
 >regExpExecArrayValue.slice() : string[]
->regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
+>regExpExecArrayValue.slice : (this: readonly, start?: number, end?: number) => string[]
 >regExpExecArrayValue : RegExpExecArray
->slice : (start?: number, end?: number) => string[]
+>slice : (this: readonly, start?: number, end?: number) => string[]

 regExpExecArrayValue.slice(0);
 >regExpExecArrayValue.slice(0) : string[]
->regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
+>regExpExecArrayValue.slice : (this: readonly, start?: number, end?: number) => string[]
 >regExpExecArrayValue : RegExpExecArray
->slice : (start?: number, end?: number) => string[]
+>slice : (this: readonly, start?: number, end?: number) => string[]
 >0 : 0

 regExpExecArrayValue.slice(0,1);
 >regExpExecArrayValue.slice(0,1) : string[]
->regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
+>regExpExecArrayValue.slice : (this: readonly, start?: number, end?: number) => string[]
 >regExpExecArrayValue : RegExpExecArray
->slice : (start?: number, end?: number) => string[]
+>slice : (this: readonly, start?: number, end?: number) => string[]
 >0 : 0
 >1 : 1

@@ -781,9 +781,9 @@ function append<T>(a: T[], x: T): T[] {
    let result = a.slice();
 >result : T[]
 >a.slice() : T[]
->a.slice : (start?: number, end?: number) => T[]
+>a.slice : (this: readonly, start?: number, end?: number) => T[]
 >a : T[]
->slice : (start?: number, end?: number) => T[]
+>slice : (this: readonly, start?: number, end?: number) => T[]

    result.push(x);
 >result.push(x) : number
@@ -2,13 +2,13 @@
 export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n);
 >mapOnLooseArrayLiteral : number[]
 >[1, 2, 3, 4].map(n => n * n) : number[]
->[1, 2, 3, 4].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>[1, 2, 3, 4].map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >[1, 2, 3, 4] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
 >4 : 4
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >n => n * n : (n: number) => number
 >n : number
 >n * n : number
@@ -25,9 +25,9 @@ let numTuple: [number] = [1];
 export let a = numTuple.map(x => x * x);
 >a : number[]
 >numTuple.map(x => x * x) : number[]
->numTuple.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>numTuple.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numTuple : [number]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >x => x * x : (x: number) => number
 >x : number
 >x * x : number
@@ -57,9 +57,9 @@ let numStr: [number, string] = [    100, "hello"];
 export let b = numNum.map(n => n * n);
 >b : number[]
 >numNum.map(n => n * n) : number[]
->numNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>numNum.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNum : [number, number]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >n => n * n : (n: number) => number
 >n : number
 >n * n : number
@@ -69,9 +69,9 @@ export let b = numNum.map(n => n * n);
 export let c = strStr.map(s => s.charCodeAt(0));
 >c : number[]
 >strStr.map(s => s.charCodeAt(0)) : number[]
->strStr.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>strStr.map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >strStr : [string, string]
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >s => s.charCodeAt(0) : (s: string) => number
 >s : string
 >s.charCodeAt(0) : number
@@ -83,9 +83,9 @@ export let c = strStr.map(s => s.charCodeAt(0));
 export let d = numStr.map(x => x);
 >d : (string | number)[]
 >numStr.map(x => x) : (string | number)[]
->numStr.map : <U>(callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[]
+>numStr.map : <U>(this: readonly, callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[]
 >numStr : [number, string]
->map : <U>(callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[]
 >x => x : (x: string | number) => string | number
 >x : string | number
 >x : string | number
@@ -102,9 +102,9 @@ let numNumNum: [number, number, number] = [1, 2, 3];
 export let e = numNumNum.map(n => n * n);
 >e : number[]
 >numNumNum.map(n => n * n) : number[]
->numNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>numNumNum.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNumNum : [number, number, number]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >n => n * n : (n: number) => number
 >n : number
 >n * n : number
@@ -124,9 +124,9 @@ let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4];
 export let f = numNumNumNum.map(n => n * n);
 >f : number[]
 >numNumNumNum.map(n => n * n) : number[]
->numNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>numNumNumNum.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNumNumNum : [number, number, number, number]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >n => n * n : (n: number) => number
 >n : number
 >n * n : number
@@ -147,9 +147,9 @@ let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5];
 export let g = numNumNumNumNum.map(n => n * n);
 >g : number[]
 >numNumNumNumNum.map(n => n * n) : number[]
->numNumNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>numNumNumNumNum.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNumNumNumNum : [number, number, number, number, number]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >n => n * n : (n: number) => number
 >n : number
 >n * n : number
@@ -172,9 +172,9 @@ let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2
 export let h = numNumNumNumNum.map(n => n * n);
 >h : number[]
 >numNumNumNumNum.map(n => n * n) : number[]
->numNumNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>numNumNumNumNum.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >numNumNumNumNum : [number, number, number, number, number]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >n => n * n : (n: number) => number
 >n : number
 >n * n : number
@@ -9,9 +9,9 @@ export function increment(point: Point) {

  return point.map(d => d + 1);
 >point.map(d => d + 1) : number[]
->point.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>point.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >point : [number, number]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >d => d + 1 : (d: number) => number
 >d : number
 >d + 1 : number
@@ -12,12 +12,12 @@ module M {
   public foo() { [1,2,3].map((x) => { return this.n * x; })}
 >foo : () => void
 >[1,2,3].map((x) => { return this.n * x; }) : number[]
->[1,2,3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>[1,2,3].map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >[1,2,3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >(x) => { return this.n * x; } : (x: number) => number
 >x : number
 >this.n * x : number
@@ -7,9 +7,9 @@ var regexMatchList = ['', ''];

 regexMatchList.forEach(match => ''.replace(match, ''));
 >regexMatchList.forEach(match => ''.replace(match, '')) : void
->regexMatchList.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>regexMatchList.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >regexMatchList : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >match => ''.replace(match, '') : (match: string) => string
 >match : string
 >''.replace(match, '') : string
@@ -36,9 +36,9 @@ for ({ x: xx, ...rrestOff } of array ) {
 for (const norest of array.map(a => ({ ...a, x: 'a string' }))) {
 >norest : { x: string; y: string; }
 >array.map(a => ({ ...a, x: 'a string' })) : { x: string; y: string; }[]
->array.map : <U>(callbackfn: (value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg?: any) => U[]
+>array.map : <U>(this: readonly, callbackfn: (value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg?: any) => U[]
 >array : { x: number; y: string; }[]
->map : <U>(callbackfn: (value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg?: any) => U[]
 >a => ({ ...a, x: 'a string' }) : (a: { x: number; y: string; }) => { x: string; y: string; }
 >a : { x: number; y: string; }
 >({ ...a, x: 'a string' }) : { x: string; y: string; }
@@ -14,11 +14,11 @@ module M1 {
        return Array.prototype.reduce.apply(ar, e ? [f, e] : [f]);
 >Array.prototype.reduce.apply(ar, e ? [f, e] : [f]) : any
 >Array.prototype.reduce.apply : (this: Function, thisArg: any, argArray?: any) => any
->Array.prototype.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>Array.prototype.reduce : { (this: readonly, callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >Array.prototype : any[]
 >Array : ArrayConstructor
 >prototype : any[]
->reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>reduce : { (this: readonly, callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(this: readonly, callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >apply : (this: Function, thisArg: any, argArray?: any) => any
 >ar : any
 >e ? [f, e] : [f] : any[]
@@ -1,14 +1,14 @@
 === tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts ===
 [].map(() => [].map(p => ({ X: p })));
 >[].map(() => [].map(p => ({ X: p }))) : { X: any; }[][]
->[].map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>[].map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >[] : undefined[]
->map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >() => [].map(p => ({ X: p })) : () => { X: any; }[]
 >[].map(p => ({ X: p })) : { X: any; }[]
->[].map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>[].map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >[] : undefined[]
->map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >p => ({ X: p }) : (p: any) => { X: any; }
 >p : any
 >({ X: p }) : { X: any; }
@@ -25,9 +25,9 @@ function foo() {

    series2.map(seriesExtent);
 >series2.map(seriesExtent) : any[]
->series2.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>series2.map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >series2 : number[]
->map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >seriesExtent : (series: any) => any

    return null;
@@ -38,11 +38,11 @@ function foo() {
 var keyExtent2: any[] = series.data.map(function (d: string) { return d; });
 >keyExtent2 : any[]
 >series.data.map(function (d: string) { return d; }) : string[]
->series.data.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>series.data.map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >series.data : string[]
 >series : Series
 >data : string[]
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >function (d: string) { return d; } : (d: string) => string
 >d : string
 >d : string
@@ -39,9 +39,9 @@ class ListWrapper2 {
 >T : T
 >T : T
 >array.slice(0) : T[]
->array.slice : (start?: number, end?: number) => T[]
+>array.slice : (this: readonly, start?: number, end?: number) => T[]
 >array : T[]
->slice : (start?: number, end?: number) => T[]
+>slice : (this: readonly, start?: number, end?: number) => T[]
 >0 : 0

  static reversed<T>(dit: typeof ListWrapper2, array: T[]): T[] {
@@ -168,9 +168,9 @@ class ListWrapper {
 >T : T
 >T : T
 >array.slice(0) : T[]
->array.slice : (start?: number, end?: number) => T[]
+>array.slice : (this: readonly, start?: number, end?: number) => T[]
 >array : T[]
->slice : (start?: number, end?: number) => T[]
+>slice : (this: readonly, start?: number, end?: number) => T[]
 >0 : 0

  static forEachWithIndex<T>(dit: typeof ListWrapper, array: T[], fn: (t: T, n: number) => void) {
@@ -267,9 +267,9 @@ class ListWrapper {

    return array.indexOf(value, startIndex);
 >array.indexOf(value, startIndex) : number
->array.indexOf : (searchElement: T, fromIndex?: number) => number
+>array.indexOf : (this: readonly, searchElement: T, fromIndex?: number) => number
 >array : T[]
->indexOf : (searchElement: T, fromIndex?: number) => number
+>indexOf : (this: readonly, searchElement: T, fromIndex?: number) => number
 >value : T
 >startIndex : number
  }
@@ -284,9 +284,9 @@ class ListWrapper {
 >T : T
 >list.indexOf(el) !== -1 : boolean
 >list.indexOf(el) : number
->list.indexOf : (searchElement: T, fromIndex?: number) => number
+>list.indexOf : (this: readonly, searchElement: T, fromIndex?: number) => number
 >list : T[]
->indexOf : (searchElement: T, fromIndex?: number) => number
+>indexOf : (this: readonly, searchElement: T, fromIndex?: number) => number
 >el : T
 >-1 : -1
 >1 : 1
@@ -348,9 +348,9 @@ class ListWrapper {
 >a : any[]
 >b : any[]
 >a.concat(b) : any[]
->a.concat : { (...items: any[][]): any[]; (...items: any[]): any[]; }
+>a.concat : { (this: readonly, ...items: any[][]): any[]; (this: readonly, ...items: any[]): any[]; }
 >a : any[]
->concat : { (...items: any[][]): any[]; (...items: any[]): any[]; }
+>concat : { (this: readonly, ...items: any[][]): any[]; (this: readonly, ...items: any[]): any[]; }
 >b : any[]

  static insert<T>(dit: typeof ListWrapper, list: T[], index: number, value: T) { list.splice(index, 0, value); }
@@ -422,9 +422,9 @@ class ListWrapper {
      var index = list.indexOf(items[i]);
 >index : number
 >list.indexOf(items[i]) : number
->list.indexOf : (searchElement: T, fromIndex?: number) => number
+>list.indexOf : (this: readonly, searchElement: T, fromIndex?: number) => number
 >list : T[]
->indexOf : (searchElement: T, fromIndex?: number) => number
+>indexOf : (this: readonly, searchElement: T, fromIndex?: number) => number
 >items[i] : T
 >items : T[]
 >i : number
@@ -451,9 +451,9 @@ class ListWrapper {
    var index = list.indexOf(el);
 >index : number
 >list.indexOf(el) : number
->list.indexOf : (searchElement: T, fromIndex?: number) => number
+>list.indexOf : (this: readonly, searchElement: T, fromIndex?: number) => number
 >list : T[]
->indexOf : (searchElement: T, fromIndex?: number) => number
+>indexOf : (this: readonly, searchElement: T, fromIndex?: number) => number
 >el : T

    if (index > -1) {
@@ -581,9 +581,9 @@ class ListWrapper {

    return l.slice(from, to === null ? undefined : to);
 >l.slice(from, to === null ? undefined : to) : T[]
->l.slice : (start?: number, end?: number) => T[]
+>l.slice : (this: readonly, start?: number, end?: number) => T[]
 >l : T[]
->slice : (start?: number, end?: number) => T[]
+>slice : (this: readonly, start?: number, end?: number) => T[]
 >from : number
 >to === null ? undefined : to : number
 >to === null : boolean
@@ -650,9 +650,9 @@ class ListWrapper {
 >l : T[]
 >T : T
 >l.toString() : string
->l.toString : () => string
+>l.toString : (this: readonly) => string
 >l : T[]
->toString : () => string
+>toString : (this: readonly) => string

  static toJSON<T>(dit: typeof ListWrapper, l: T[]): string { return JSON.stringify(l); }
 >toJSON : <T>(dit: typeof ListWrapper, l: T[]) => string
@@ -19,10 +19,10 @@ foo(function(x) { x });

 [1].forEach(function(v,i,a) { v });
 >[1].forEach(function(v,i,a) { v }) : void
->[1].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>[1].forEach : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
 >[1] : number[]
 >1 : 1
->forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
 >function(v,i,a) { v } : (v: number, i: number, a: number[]) => void
 >v : number
 >i : number
@@ -31,10 +31,10 @@ foo(function(x) { x });

 ["hello"].every(function(v,i,a) {return true;});
 >["hello"].every(function(v,i,a) {return true;}) : boolean
->["hello"].every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>["hello"].every : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >["hello"] : string[]
 >"hello" : "hello"
->every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >function(v,i,a) {return true;} : (v: string, i: number, a: string[]) => true
 >v : string
 >i : number
@@ -43,10 +43,10 @@ foo(function(x) { x });

 [1].every(function(v,i,a) {return true;});
 >[1].every(function(v,i,a) {return true;}) : boolean
->[1].every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>[1].every : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >[1] : number[]
 >1 : 1
->every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >function(v,i,a) {return true;} : (v: number, i: number, a: number[]) => true
 >v : number
 >i : number
@@ -55,10 +55,10 @@ foo(function(x) { x });

 [1].every(function(v,i,a) {return true;});
 >[1].every(function(v,i,a) {return true;}) : boolean
->[1].every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>[1].every : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >[1] : number[]
 >1 : 1
->every : (callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: number, index: number, array: number[]) => boolean, thisArg?: any) => boolean
 >function(v,i,a) {return true;} : (v: number, i: number, a: number[]) => true
 >v : number
 >i : number
@@ -67,10 +67,10 @@ foo(function(x) { x });

 ["s"].every(function(v,i,a) {return true;});
 >["s"].every(function(v,i,a) {return true;}) : boolean
->["s"].every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>["s"].every : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >["s"] : string[]
 >"s" : "s"
->every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >function(v,i,a) {return true;} : (v: string, i: number, a: string[]) => true
 >v : string
 >i : number
@@ -79,10 +79,10 @@ foo(function(x) { x });

 ["s"].forEach(function(v,i,a) { v });
 >["s"].forEach(function(v,i,a) { v }) : void
->["s"].forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>["s"].forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >["s"] : string[]
 >"s" : "s"
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >function(v,i,a) { v } : (v: string, i: number, a: string[]) => void
 >v : string
 >i : number
@@ -10,9 +10,9 @@ function suggest(){
 					
 	TypeScriptKeywords.forEach(function(keyword) {						
 >TypeScriptKeywords.forEach(function(keyword) {								result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any	}) : void
->TypeScriptKeywords.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>TypeScriptKeywords.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >TypeScriptKeywords : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >function(keyword) {								result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any	} : (keyword: string) => void
 >keyword : string

@@ -24,9 +24,9 @@ class A {
        }
        options.forEach(function (item) {
 >options.forEach(function (item) {            this.options.push(item);        }, this) : void
->options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >function (item) {            this.options.push(item);        } : (item: string) => void
 >item : string

@@ -57,9 +57,9 @@ class A {

        options.forEach(function () {
 >options.forEach(function () {            undefinedArr.push(this);        }) : void
->options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >function () {            undefinedArr.push(this);        } : () => void

            undefinedArr.push(this);
@@ -72,9 +72,9 @@ class A {
        }); // case1
        options.forEach(function () {
 >options.forEach(function () {            undefinedArr.push(this);        }, undefined) : void
->options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >function () {            undefinedArr.push(this);        } : () => void

            undefinedArr.push(this);
@@ -89,9 +89,9 @@ class A {

        options.forEach(function () {
 >options.forEach(function () {            undefinedArr.push(this);        }, null) : void
->options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >function () {            undefinedArr.push(this);        } : () => void

            undefinedArr.push(this);
@@ -216,9 +216,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
@@ -237,9 +237,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >options : string[]
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: string, index: number) => any
 >val : string
 >index : number
@@ -265,9 +265,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >options : string[]
->some : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
@@ -286,9 +286,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : string[]
->options.filter : { <S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
+>options.filter : { <S extends string>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
 >options : string[]
->filter : { <S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
+>filter : { <S extends string>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
@@ -307,9 +307,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >options : string[]
->every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
@@ -441,9 +441,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >options : string[]
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
@@ -462,9 +462,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >options : string[]
->map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: string, index: number) => any
 >val : string
 >index : number
@@ -490,9 +490,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >options : string[]
->some : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
@@ -511,9 +511,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : string[]
->options.filter : { <S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
+>options.filter : { <S extends string>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
 >options : string[]
->filter : { <S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
+>filter : { <S extends string>(this: readonly, callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
@@ -532,9 +532,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >options : string[]
->every : (callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: string, index: number) => boolean
 >val : string
 >index : number
@@ -613,9 +613,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => void, thisArg?: any) => void
 >options : Int8Array[]
->forEach : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
@@ -634,9 +634,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => U, thisArg?: any) => U[]
 >options : Int8Array[]
->map : <U>(callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Int8Array, index: number) => any
 >val : Int8Array
 >index : number
@@ -662,9 +662,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
 >options : Int8Array[]
->some : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
@@ -683,9 +683,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Int8Array[]
->options.filter : { <S extends Int8Array>(callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => any, thisArg?: any): Int8Array[]; }
+>options.filter : { <S extends Int8Array>(this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => any, thisArg?: any): Int8Array[]; }
 >options : Int8Array[]
->filter : { <S extends Int8Array>(callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => any, thisArg?: any): Int8Array[]; }
+>filter : { <S extends Int8Array>(this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => any, thisArg?: any): Int8Array[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
@@ -704,9 +704,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
 >options : Int8Array[]
->every : (callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Int8Array, index: number, array: Int8Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Int8Array, index: number) => boolean
 >val : Int8Array
 >index : number
@@ -785,9 +785,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg?: any) => void
 >options : Uint8Array[]
->forEach : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
@@ -806,9 +806,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg?: any) => U[]
 >options : Uint8Array[]
->map : <U>(callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Uint8Array, index: number) => any
 >val : Uint8Array
 >index : number
@@ -834,9 +834,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint8Array[]
->some : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
@@ -855,9 +855,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint8Array[]
->options.filter : { <S extends Uint8Array>(callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg?: any): Uint8Array[]; }
+>options.filter : { <S extends Uint8Array>(this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg?: any): Uint8Array[]; }
 >options : Uint8Array[]
->filter : { <S extends Uint8Array>(callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg?: any): Uint8Array[]; }
+>filter : { <S extends Uint8Array>(this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => any, thisArg?: any): Uint8Array[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
@@ -876,9 +876,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint8Array[]
->every : (callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Uint8Array, index: number, array: Uint8Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Uint8Array, index: number) => boolean
 >val : Uint8Array
 >index : number
@@ -957,9 +957,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => void, thisArg?: any) => void
 >options : Float32Array[]
->forEach : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
@@ -978,9 +978,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => U, thisArg?: any) => U[]
 >options : Float32Array[]
->map : <U>(callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Float32Array, index: number) => any
 >val : Float32Array
 >index : number
@@ -1006,9 +1006,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
 >options : Float32Array[]
->some : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
@@ -1027,9 +1027,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Float32Array[]
->options.filter : { <S extends Float32Array>(callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => any, thisArg?: any): Float32Array[]; }
+>options.filter : { <S extends Float32Array>(this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => any, thisArg?: any): Float32Array[]; }
 >options : Float32Array[]
->filter : { <S extends Float32Array>(callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => any, thisArg?: any): Float32Array[]; }
+>filter : { <S extends Float32Array>(this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => any, thisArg?: any): Float32Array[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
@@ -1048,9 +1048,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
 >options : Float32Array[]
->every : (callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Float32Array, index: number, array: Float32Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Float32Array, index: number) => boolean
 >val : Float32Array
 >index : number
@@ -1129,9 +1129,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg?: any) => void
 >options : Uint8ClampedArray[]
->forEach : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
@@ -1150,9 +1150,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg?: any) => U[]
 >options : Uint8ClampedArray[]
->map : <U>(callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Uint8ClampedArray, index: number) => any
 >val : Uint8ClampedArray
 >index : number
@@ -1178,9 +1178,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
 >options : Uint8ClampedArray[]
->some : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
@@ -1199,9 +1199,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint8ClampedArray[]
->options.filter : { <S extends Uint8ClampedArray>(callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg?: any): Uint8ClampedArray[]; }
+>options.filter : { <S extends Uint8ClampedArray>(this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg?: any): Uint8ClampedArray[]; }
 >options : Uint8ClampedArray[]
->filter : { <S extends Uint8ClampedArray>(callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg?: any): Uint8ClampedArray[]; }
+>filter : { <S extends Uint8ClampedArray>(this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => any, thisArg?: any): Uint8ClampedArray[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
@@ -1220,9 +1220,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
 >options : Uint8ClampedArray[]
->every : (callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Uint8ClampedArray, index: number, array: Uint8ClampedArray[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Uint8ClampedArray, index: number) => boolean
 >val : Uint8ClampedArray
 >index : number
@@ -1301,9 +1301,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => void, thisArg?: any) => void
 >options : Int16Array[]
->forEach : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
@@ -1322,9 +1322,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => U, thisArg?: any) => U[]
 >options : Int16Array[]
->map : <U>(callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Int16Array, index: number) => any
 >val : Int16Array
 >index : number
@@ -1350,9 +1350,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
 >options : Int16Array[]
->some : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
@@ -1371,9 +1371,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Int16Array[]
->options.filter : { <S extends Int16Array>(callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => any, thisArg?: any): Int16Array[]; }
+>options.filter : { <S extends Int16Array>(this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => any, thisArg?: any): Int16Array[]; }
 >options : Int16Array[]
->filter : { <S extends Int16Array>(callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => any, thisArg?: any): Int16Array[]; }
+>filter : { <S extends Int16Array>(this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => any, thisArg?: any): Int16Array[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
@@ -1392,9 +1392,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
 >options : Int16Array[]
->every : (callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Int16Array, index: number, array: Int16Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Int16Array, index: number) => boolean
 >val : Int16Array
 >index : number
@@ -1473,9 +1473,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg?: any) => void
 >options : Uint16Array[]
->forEach : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
@@ -1494,9 +1494,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg?: any) => U[]
 >options : Uint16Array[]
->map : <U>(callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Uint16Array, index: number) => any
 >val : Uint16Array
 >index : number
@@ -1522,9 +1522,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint16Array[]
->some : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
@@ -1543,9 +1543,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint16Array[]
->options.filter : { <S extends Uint16Array>(callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg?: any): Uint16Array[]; }
+>options.filter : { <S extends Uint16Array>(this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg?: any): Uint16Array[]; }
 >options : Uint16Array[]
->filter : { <S extends Uint16Array>(callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg?: any): Uint16Array[]; }
+>filter : { <S extends Uint16Array>(this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => any, thisArg?: any): Uint16Array[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
@@ -1564,9 +1564,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint16Array[]
->every : (callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Uint16Array, index: number, array: Uint16Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Uint16Array, index: number) => boolean
 >val : Uint16Array
 >index : number
@@ -1645,9 +1645,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg?: any) => void
 >options : Uint32Array[]
->forEach : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
@@ -1666,9 +1666,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg?: any) => U[]
 >options : Uint32Array[]
->map : <U>(callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Uint32Array, index: number) => any
 >val : Uint32Array
 >index : number
@@ -1694,9 +1694,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint32Array[]
->some : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
@@ -1715,9 +1715,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Uint32Array[]
->options.filter : { <S extends Uint32Array>(callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg?: any): Uint32Array[]; }
+>options.filter : { <S extends Uint32Array>(this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg?: any): Uint32Array[]; }
 >options : Uint32Array[]
->filter : { <S extends Uint32Array>(callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg?: any): Uint32Array[]; }
+>filter : { <S extends Uint32Array>(this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => any, thisArg?: any): Uint32Array[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
@@ -1736,9 +1736,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
 >options : Uint32Array[]
->every : (callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Uint32Array, index: number, array: Uint32Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Uint32Array, index: number) => boolean
 >val : Uint32Array
 >index : number
@@ -1817,9 +1817,9 @@ class A {

        options.forEach(function (val, index) {
 >options.forEach(function (val, index) {            return val === this.options[index];        }, thisObject) : void
->options.forEach : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => void, thisArg?: any) => void
+>options.forEach : (this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => void, thisArg?: any) => void
 >options : Float64Array[]
->forEach : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => void, thisArg?: any) => void
+>forEach : (this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => void, thisArg?: any) => void
 >function (val, index) {            return val === this.options[index];        } : (val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
@@ -1838,9 +1838,9 @@ class A {

        options.map(function (val, index) {
 >options.map(function (val, index) {            if (val === this.options[index])                return this.options[index];        }, thisObject) : any[]
->options.map : <U>(callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => U, thisArg?: any) => U[]
+>options.map : <U>(this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => U, thisArg?: any) => U[]
 >options : Float64Array[]
->map : <U>(callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => U, thisArg?: any) => U[]
 >function (val, index) {            if (val === this.options[index])                return this.options[index];        } : (val: Float64Array, index: number) => any
 >val : Float64Array
 >index : number
@@ -1866,9 +1866,9 @@ class A {

        options.some(function (val, index) {
 >options.some(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.some : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
+>options.some : (this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
 >options : Float64Array[]
->some : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
+>some : (this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
@@ -1887,9 +1887,9 @@ class A {

        options.filter(function (val, index) {
 >options.filter(function (val, index) {            return val === this.options[index];        }, thisObject) : Float64Array[]
->options.filter : { <S extends Float64Array>(callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => any, thisArg?: any): Float64Array[]; }
+>options.filter : { <S extends Float64Array>(this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => any, thisArg?: any): Float64Array[]; }
 >options : Float64Array[]
->filter : { <S extends Float64Array>(callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => any, thisArg?: any): Float64Array[]; }
+>filter : { <S extends Float64Array>(this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => value is S, thisArg?: any): S[]; (this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => any, thisArg?: any): Float64Array[]; }
 >function (val, index) {            return val === this.options[index];        } : (val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
@@ -1908,9 +1908,9 @@ class A {

        options.every(function (val, index) {
 >options.every(function (val, index) {            return val === this.options[index];        }, thisObject) : boolean
->options.every : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
+>options.every : (this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
 >options : Float64Array[]
->every : (callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
+>every : (this: readonly, callbackfn: (value: Float64Array, index: number, array: Float64Array[]) => boolean, thisArg?: any) => boolean
 >function (val, index) {            return val === this.options[index];        } : (val: Float64Array, index: number) => boolean
 >val : Float64Array
 >index : number
@@ -4,7 +4,7 @@ interface Array<T> {
 >T : T

    slice(): this;
->slice : { (start?: number, end?: number): T[]; (): this; }
+>slice : { (this: readonly, start?: number, end?: number): T[]; (): this; }
 }

 let t: [number, string] = [42, "hello"];
@@ -16,24 +16,24 @@ let t: [number, string] = [42, "hello"];
 let a = t.slice();
 >a : [number, string]
 >t.slice() : [number, string]
->t.slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
+>t.slice : { (this: readonly, start?: number, end?: number): (string | number)[]; (): [number, string]; }
 >t : [number, string]
->slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
+>slice : { (this: readonly, start?: number, end?: number): (string | number)[]; (): [number, string]; }

 let b = t.slice(1);
 >b : (string | number)[]
 >t.slice(1) : (string | number)[]
->t.slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
+>t.slice : { (this: readonly, start?: number, end?: number): (string | number)[]; (): [number, string]; }
 >t : [number, string]
->slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
+>slice : { (this: readonly, start?: number, end?: number): (string | number)[]; (): [number, string]; }
 >1 : 1

 let c = t.slice(0, 1);
 >c : (string | number)[]
 >t.slice(0, 1) : (string | number)[]
->t.slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
+>t.slice : { (this: readonly, start?: number, end?: number): (string | number)[]; (): [number, string]; }
 >t : [number, string]
->slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
+>slice : { (this: readonly, start?: number, end?: number): (string | number)[]; (): [number, string]; }
 >0 : 0
 >1 : 1

@@ -63,9 +63,9 @@ function TodoList({ todos }: TodoListProps) {

        {...todos.map(todo => <Todo key={todo.id} todo={todo.todo}/>)}
 >todos.map(todo => <Todo key={todo.id} todo={todo.todo}/>) : JSX.Element[]
->todos.map : <U>(callbackfn: (value: TodoProp, index: number, array: TodoProp[]) => U, thisArg?: any) => U[]
+>todos.map : <U>(this: readonly, callbackfn: (value: TodoProp, index: number, array: TodoProp[]) => U, thisArg?: any) => U[]
 >todos : TodoProp[]
->map : <U>(callbackfn: (value: TodoProp, index: number, array: TodoProp[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: TodoProp, index: number, array: TodoProp[]) => U, thisArg?: any) => U[]
 >todo => <Todo key={todo.id} todo={todo.todo}/> : (todo: TodoProp) => JSX.Element
 >todo : TodoProp
 ><Todo key={todo.id} todo={todo.todo}/> : JSX.Element
@@ -16,9 +16,9 @@ var nodes: TreeNode[];

 nodes.map(n => n.name);
 >nodes.map(n => n.name) : string[]
->nodes.map : <U>(callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[]
+>nodes.map : <U>(this: readonly, callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[]
 >nodes : TreeNode[]
->map : <U>(callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[]
 >n => n.name : (n: TreeNode) => string
 >n : TreeNode
 >n.name : string
@@ -27,9 +27,9 @@ var nodes: TreeNodeMiddleman[];

 nodes.map(n => n.name);
 >nodes.map(n => n.name) : string[]
->nodes.map : <U>(callbackfn: (value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg?: any) => U[]
+>nodes.map : <U>(this: readonly, callbackfn: (value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg?: any) => U[]
 >nodes : TreeNodeMiddleman[]
->map : <U>(callbackfn: (value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg?: any) => U[]
+>map : <U>(this: readonly, callbackfn: (value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg?: any) => U[]
 >n => n.name : (n: TreeNodeMiddleman) => string
 >n : TreeNodeMiddleman
 >n.name : string
@@ -27,9 +27,9 @@ class D {
 >"string" : "string"
 >data : string
 >data.join(" ") : string
->data.join : (separator?: string) => string
+>data.join : (this: readonly, separator?: string) => string
 >data : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >" " : " "
    }

@@ -48,11 +48,11 @@ class D {
 >this : this
 >data : string
 >this.data.join(" ") : string
->this.data.join : (separator?: string) => string
+>this.data.join : (this: readonly, separator?: string) => string
 >this.data : string[]
 >this : this
 >data : string[]
->join : (separator?: string) => string
+>join : (this: readonly, separator?: string) => string
 >" " : " "
    }
 }