diff --git a/tests/baselines/reference/mapOnTupleTypes01.js b/tests/baselines/reference/mapOnTupleTypes01.js
new file mode 100644
index 00000000000..6c51cf3e6a3
--- /dev/null
+++ b/tests/baselines/reference/mapOnTupleTypes01.js
@@ -0,0 +1,81 @@
+//// [mapOnTupleTypes01.ts]
+
+export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n);
+
+// Length 1
+
+let numTuple: [number] = [1];
+export let a = numTuple.map(x => x * x);
+
+// Length 2
+
+let numNum: [number, number] = [    100,     100];
+let strStr: [string, string] = ["hello", "hello"];
+let numStr: [number, string] = [    100, "hello"];
+
+export let b = numNum.map(n => n * n);
+export let c = strStr.map(s => s.charCodeAt(0));
+export let d = numStr.map(x => x);
+
+// Length 3
+
+let numNumNum: [number, number, number] = [1, 2, 3];
+
+export let e = numNumNum.map(n => n * n);
+
+// Length 4
+
+let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4];
+
+export let f = numNumNumNum.map(n => n * n);
+
+// Length 5
+
+let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5];
+
+export let g = numNumNumNumNum.map(n => n * n);
+
+
+// Length 6
+
+let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6];
+
+export let h = numNumNumNumNum.map(n => n * n);
+
+//// [mapOnTupleTypes01.js]
+"use strict";
+exports.mapOnLooseArrayLiteral = [1, 2, 3, 4].map(function (n) { return n * n; });
+// Length 1
+var numTuple = [1];
+exports.a = numTuple.map(function (x) { return x * x; });
+// Length 2
+var numNum = [100, 100];
+var strStr = ["hello", "hello"];
+var numStr = [100, "hello"];
+exports.b = numNum.map(function (n) { return n * n; });
+exports.c = strStr.map(function (s) { return s.charCodeAt(0); });
+exports.d = numStr.map(function (x) { return x; });
+// Length 3
+var numNumNum = [1, 2, 3];
+exports.e = numNumNum.map(function (n) { return n * n; });
+// Length 4
+var numNumNumNum = [1, 2, 3, 4];
+exports.f = numNumNumNum.map(function (n) { return n * n; });
+// Length 5
+var numNumNumNumNum = [1, 2, 3, 4, 5];
+exports.g = numNumNumNumNum.map(function (n) { return n * n; });
+// Length 6
+var numNumNumNumNumNum = [1, 2, 3, 4, 5, 6];
+exports.h = numNumNumNumNum.map(function (n) { return n * n; });
+
+
+//// [mapOnTupleTypes01.d.ts]
+export declare let mapOnLooseArrayLiteral: number[];
+export declare let a: number[];
+export declare let b: number[];
+export declare let c: number[];
+export declare let d: (string | number)[];
+export declare let e: number[];
+export declare let f: number[];
+export declare let g: number[];
+export declare let h: number[];
diff --git a/tests/baselines/reference/mapOnTupleTypes01.symbols b/tests/baselines/reference/mapOnTupleTypes01.symbols
new file mode 100644
index 00000000000..1c735fc06cf
--- /dev/null
+++ b/tests/baselines/reference/mapOnTupleTypes01.symbols
@@ -0,0 +1,119 @@
+=== tests/cases/compiler/mapOnTupleTypes01.ts ===
+
+export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n);
+>mapOnLooseArrayLiteral : Symbol(mapOnLooseArrayLiteral, Decl(mapOnTupleTypes01.ts, 1, 10))
+>[1, 2, 3, 4].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 1, 53))
+
+// Length 1
+
+let numTuple: [number] = [1];
+>numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3))
+
+export let a = numTuple.map(x => x * x);
+>a : Symbol(a, Decl(mapOnTupleTypes01.ts, 6, 10))
+>numTuple.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>numTuple : Symbol(numTuple, Decl(mapOnTupleTypes01.ts, 5, 3))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28))
+>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28))
+>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 6, 28))
+
+// Length 2
+
+let numNum: [number, number] = [    100,     100];
+>numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3))
+
+let strStr: [string, string] = ["hello", "hello"];
+>strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3))
+
+let numStr: [number, string] = [    100, "hello"];
+>numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3))
+
+export let b = numNum.map(n => n * n);
+>b : Symbol(b, Decl(mapOnTupleTypes01.ts, 14, 10))
+>numNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>numNum : Symbol(numNum, Decl(mapOnTupleTypes01.ts, 10, 3))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 14, 26))
+
+export let c = strStr.map(s => s.charCodeAt(0));
+>c : Symbol(c, Decl(mapOnTupleTypes01.ts, 15, 10))
+>strStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>strStr : Symbol(strStr, Decl(mapOnTupleTypes01.ts, 11, 3))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26))
+>s.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --))
+>s : Symbol(s, Decl(mapOnTupleTypes01.ts, 15, 26))
+>charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --))
+
+export let d = numStr.map(x => x);
+>d : Symbol(d, Decl(mapOnTupleTypes01.ts, 16, 10))
+>numStr.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>numStr : Symbol(numStr, Decl(mapOnTupleTypes01.ts, 12, 3))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26))
+>x : Symbol(x, Decl(mapOnTupleTypes01.ts, 16, 26))
+
+// Length 3
+
+let numNumNum: [number, number, number] = [1, 2, 3];
+>numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3))
+
+export let e = numNumNum.map(n => n * n);
+>e : Symbol(e, Decl(mapOnTupleTypes01.ts, 22, 10))
+>numNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>numNumNum : Symbol(numNumNum, Decl(mapOnTupleTypes01.ts, 20, 3))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 22, 29))
+
+// Length 4
+
+let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4];
+>numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3))
+
+export let f = numNumNumNum.map(n => n * n);
+>f : Symbol(f, Decl(mapOnTupleTypes01.ts, 28, 10))
+>numNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>numNumNumNum : Symbol(numNumNumNum, Decl(mapOnTupleTypes01.ts, 26, 3))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 28, 32))
+
+// Length 5
+
+let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5];
+>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3))
+
+export let g = numNumNumNumNum.map(n => n * n);
+>g : Symbol(g, Decl(mapOnTupleTypes01.ts, 34, 10))
+>numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 34, 35))
+
+
+// Length 6
+
+let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6];
+>numNumNumNumNumNum : Symbol(numNumNumNumNumNum, Decl(mapOnTupleTypes01.ts, 39, 3))
+
+export let h = numNumNumNumNum.map(n => n * n);
+>h : Symbol(h, Decl(mapOnTupleTypes01.ts, 41, 10))
+>numNumNumNumNum.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>numNumNumNumNum : Symbol(numNumNumNumNum, Decl(mapOnTupleTypes01.ts, 32, 3))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35))
+>n : Symbol(n, Decl(mapOnTupleTypes01.ts, 41, 35))
+
diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types
new file mode 100644
index 00000000000..b97b9570fa1
--- /dev/null
+++ b/tests/baselines/reference/mapOnTupleTypes01.types
@@ -0,0 +1,184 @@
+=== tests/cases/compiler/mapOnTupleTypes01.ts ===
+
+export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n);
+>mapOnLooseArrayLiteral : number[]
+>[1, 2, 3, 4].map(n => n * n) : number[]
+>[1, 2, 3, 4].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>[1, 2, 3, 4] : number[]
+>1 : 1
+>2 : 2
+>3 : 3
+>4 : 4
+>map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
+>n => n * n : (n: number) => number
+>n : number
+>n * n : number
+>n : number
+>n : number
+
+// Length 1
+
+let numTuple: [number] = [1];
+>numTuple : [number]
+>[1] : [number]
+>1 : 1
+
+export let a = numTuple.map(x => x * x);
+>a : number[]
+>numTuple.map(x => x * x) : number[]
+>numTuple.map : <U>(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[]
+>x => x * x : (x: number) => number
+>x : number
+>x * x : number
+>x : number
+>x : number
+
+// Length 2
+
+let numNum: [number, number] = [    100,     100];
+>numNum : [number, number]
+>[    100,     100] : [number, number]
+>100 : 100
+>100 : 100
+
+let strStr: [string, string] = ["hello", "hello"];
+>strStr : [string, string]
+>["hello", "hello"] : [string, string]
+>"hello" : "hello"
+>"hello" : "hello"
+
+let numStr: [number, string] = [    100, "hello"];
+>numStr : [number, string]
+>[    100, "hello"] : [number, string]
+>100 : 100
+>"hello" : "hello"
+
+export let b = numNum.map(n => n * n);
+>b : number[]
+>numNum.map(n => n * n) : number[]
+>numNum.map : <U>(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[]
+>n => n * n : (n: number) => number
+>n : number
+>n * n : number
+>n : number
+>n : number
+
+export let c = strStr.map(s => s.charCodeAt(0));
+>c : number[]
+>strStr.map(s => s.charCodeAt(0)) : number[]
+>strStr.map : <U>(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[]
+>s => s.charCodeAt(0) : (s: string) => number
+>s : string
+>s.charCodeAt(0) : number
+>s.charCodeAt : (index: number) => number
+>s : string
+>charCodeAt : (index: number) => number
+>0 : 0
+
+export let d = numStr.map(x => x);
+>d : (string | number)[]
+>numStr.map(x => x) : (string | number)[]
+>numStr.map : <U>(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[]
+>x => x : (x: string | number) => string | number
+>x : string | number
+>x : string | number
+
+// Length 3
+
+let numNumNum: [number, number, number] = [1, 2, 3];
+>numNumNum : [number, number, number]
+>[1, 2, 3] : [number, number, number]
+>1 : 1
+>2 : 2
+>3 : 3
+
+export let e = numNumNum.map(n => n * n);
+>e : number[]
+>numNumNum.map(n => n * n) : number[]
+>numNumNum.map : <U>(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[]
+>n => n * n : (n: number) => number
+>n : number
+>n * n : number
+>n : number
+>n : number
+
+// Length 4
+
+let numNumNumNum: [number, number, number, number] = [1, 2, 3, 4];
+>numNumNumNum : [number, number, number, number]
+>[1, 2, 3, 4] : [number, number, number, number]
+>1 : 1
+>2 : 2
+>3 : 3
+>4 : 4
+
+export let f = numNumNumNum.map(n => n * n);
+>f : number[]
+>numNumNumNum.map(n => n * n) : number[]
+>numNumNumNum.map : <U>(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[]
+>n => n * n : (n: number) => number
+>n : number
+>n * n : number
+>n : number
+>n : number
+
+// Length 5
+
+let numNumNumNumNum: [number, number, number, number, number] = [1, 2, 3, 4, 5];
+>numNumNumNumNum : [number, number, number, number, number]
+>[1, 2, 3, 4, 5] : [number, number, number, number, number]
+>1 : 1
+>2 : 2
+>3 : 3
+>4 : 4
+>5 : 5
+
+export let g = numNumNumNumNum.map(n => n * n);
+>g : number[]
+>numNumNumNumNum.map(n => n * n) : number[]
+>numNumNumNumNum.map : <U>(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[]
+>n => n * n : (n: number) => number
+>n : number
+>n * n : number
+>n : number
+>n : number
+
+
+// Length 6
+
+let numNumNumNumNumNum: [number, number, number, number, number, number] = [1, 2, 3, 4, 5, 6];
+>numNumNumNumNumNum : [number, number, number, number, number, number]
+>[1, 2, 3, 4, 5, 6] : [number, number, number, number, number, number]
+>1 : 1
+>2 : 2
+>3 : 3
+>4 : 4
+>5 : 5
+>6 : 6
+
+export let h = numNumNumNumNum.map(n => n * n);
+>h : number[]
+>numNumNumNumNum.map(n => n * n) : number[]
+>numNumNumNumNum.map : <U>(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[]
+>n => n * n : (n: number) => number
+>n : number
+>n * n : number
+>n : number
+>n : number
+
diff --git a/tests/baselines/reference/mapOnTupleTypes02.js b/tests/baselines/reference/mapOnTupleTypes02.js
new file mode 100644
index 00000000000..0f5f59f3285
--- /dev/null
+++ b/tests/baselines/reference/mapOnTupleTypes02.js
@@ -0,0 +1,19 @@
+//// [mapOnTupleTypes02.ts]
+
+export type Point = [number, number];
+
+export function increment(point: Point) {
+  return point.map(d => d + 1);
+}
+
+//// [mapOnTupleTypes02.js]
+"use strict";
+function increment(point) {
+    return point.map(function (d) { return d + 1; });
+}
+exports.increment = increment;
+
+
+//// [mapOnTupleTypes02.d.ts]
+export declare type Point = [number, number];
+export declare function increment(point: Point): number[];
diff --git a/tests/baselines/reference/mapOnTupleTypes02.symbols b/tests/baselines/reference/mapOnTupleTypes02.symbols
new file mode 100644
index 00000000000..e0f1ca79f61
--- /dev/null
+++ b/tests/baselines/reference/mapOnTupleTypes02.symbols
@@ -0,0 +1,17 @@
+=== tests/cases/compiler/mapOnTupleTypes02.ts ===
+
+export type Point = [number, number];
+>Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0))
+
+export function increment(point: Point) {
+>increment : Symbol(increment, Decl(mapOnTupleTypes02.ts, 1, 37))
+>point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26))
+>Point : Symbol(Point, Decl(mapOnTupleTypes02.ts, 0, 0))
+
+  return point.map(d => d + 1);
+>point.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>point : Symbol(point, Decl(mapOnTupleTypes02.ts, 3, 26))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19))
+>d : Symbol(d, Decl(mapOnTupleTypes02.ts, 4, 19))
+}
diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types
new file mode 100644
index 00000000000..bb261f3093a
--- /dev/null
+++ b/tests/baselines/reference/mapOnTupleTypes02.types
@@ -0,0 +1,21 @@
+=== tests/cases/compiler/mapOnTupleTypes02.ts ===
+
+export type Point = [number, number];
+>Point : [number, number]
+
+export function increment(point: Point) {
+>increment : (point: [number, number]) => number[]
+>point : [number, number]
+>Point : [number, number]
+
+  return point.map(d => d + 1);
+>point.map(d => d + 1) : number[]
+>point.map : <U>(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[]
+>d => d + 1 : (d: number) => number
+>d : number
+>d + 1 : number
+>d : number
+>1 : 1
+}