diff --git a/tests/baselines/reference/newWithSpread.errors.txt b/tests/baselines/reference/newWithSpread.errors.txt
new file mode 100644
index 00000000000..2b02d91fccc
--- /dev/null
+++ b/tests/baselines/reference/newWithSpread.errors.txt
@@ -0,0 +1,165 @@
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(34,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(35,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(39,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(40,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(44,15): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(45,15): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(49,17): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(50,17): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(54,18): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(55,18): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(59,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(60,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(64,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(65,13): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(69,20): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(70,20): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(74,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(75,22): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(79,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(80,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(84,27): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(85,27): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(89,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+tests/cases/conformance/expressions/functionCalls/newWithSpread.ts(90,23): error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+
+
+==== tests/cases/conformance/expressions/functionCalls/newWithSpread.ts (24 errors) ====
+    
+    function f(x: number, y: number, ...z: string[]) {
+    }
+    
+    interface A {
+        f: {
+            new (x: number, y: number, ...z: string[]);
+        }
+    }
+    
+    class B {
+        constructor(x: number, y: number, ...z: string[]) {}
+    }
+    
+    interface C {
+        "a-b": typeof B;
+    }
+    
+    interface D {
+        1: typeof B;
+    }
+    
+    var a: string[];
+    var b: A;
+    var c: C;
+    var d: A[];
+    var e: { [key: string]: A };
+    var g: C[];
+    var h: { [key: string]: C };
+    var i: C[][];
+    
+    // Basic expression
+    new f(1, 2, "string");
+    new f(1, 2, ...a);
+                ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new f(1, 2, ...a, "string");
+                ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Call expression
+    new f(1, 2, "string")();
+    new f(1, 2, ...a)();
+                ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new f(1, 2, ...a, "string")();
+                ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Property access expression
+    new b.f(1, 2, "string");
+    new b.f(1, 2, ...a);
+                  ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new b.f(1, 2, ...a, "string"); 
+                  ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Parenthesised expression
+    new (b.f)(1, 2, "string");
+    new (b.f)(1, 2, ...a);
+                    ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new (b.f)(1, 2, ...a, "string"); 
+                    ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Element access expression
+    new d[1].f(1, 2, "string");
+    new d[1].f(1, 2, ...a);
+                     ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new d[1].f(1, 2, ...a, "string");
+                     ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Element access expression with a punctuated key
+    new e["a-b"].f(1, 2, "string");
+    new e["a-b"].f(1, 2, ...a);
+                         ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new e["a-b"].f(1, 2, ...a, "string");
+                         ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Basic expression
+    new B(1, 2, "string");
+    new B(1, 2, ...a);
+                ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new B(1, 2, ...a, "string");
+                ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Property access expression
+    new c["a-b"](1, 2, "string");
+    new c["a-b"](1, 2, ...a);
+                       ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new c["a-b"](1, 2, ...a, "string");
+                       ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Parenthesised expression
+    new (c["a-b"])(1, 2, "string");
+    new (c["a-b"])(1, 2, ...a);
+                         ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new (c["a-b"])(1, 2, ...a, "string");
+                         ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Element access expression
+    new g[1]["a-b"](1, 2, "string");
+    new g[1]["a-b"](1, 2, ...a);
+                          ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new g[1]["a-b"](1, 2, ...a, "string");
+                          ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Element access expression with a punctuated key
+    new h["a-b"]["a-b"](1, 2, "string");
+    new h["a-b"]["a-b"](1, 2, ...a);
+                              ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new h["a-b"]["a-b"](1, 2, ...a, "string");
+                              ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    
+    // Element access expression with a number
+    new i["a-b"][1](1, 2, "string");
+    new i["a-b"][1](1, 2, ...a);
+                          ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
+    new i["a-b"][1](1, 2, ...a, "string");
+                          ~~~~
+!!! error TS2472: Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/newWithSpread.js b/tests/baselines/reference/newWithSpread.js
new file mode 100644
index 00000000000..6fba9e9a9e8
--- /dev/null
+++ b/tests/baselines/reference/newWithSpread.js
@@ -0,0 +1,164 @@
+//// [newWithSpread.ts]
+
+function f(x: number, y: number, ...z: string[]) {
+}
+
+interface A {
+    f: {
+        new (x: number, y: number, ...z: string[]);
+    }
+}
+
+class B {
+    constructor(x: number, y: number, ...z: string[]) {}
+}
+
+interface C {
+    "a-b": typeof B;
+}
+
+interface D {
+    1: typeof B;
+}
+
+var a: string[];
+var b: A;
+var c: C;
+var d: A[];
+var e: { [key: string]: A };
+var g: C[];
+var h: { [key: string]: C };
+var i: C[][];
+
+// Basic expression
+new f(1, 2, "string");
+new f(1, 2, ...a);
+new f(1, 2, ...a, "string");
+
+// Call expression
+new f(1, 2, "string")();
+new f(1, 2, ...a)();
+new f(1, 2, ...a, "string")();
+
+// Property access expression
+new b.f(1, 2, "string");
+new b.f(1, 2, ...a);
+new b.f(1, 2, ...a, "string"); 
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (b.f)(1, 2, ...a);
+new (b.f)(1, 2, ...a, "string"); 
+
+// Element access expression
+new d[1].f(1, 2, "string");
+new d[1].f(1, 2, ...a);
+new d[1].f(1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new e["a-b"].f(1, 2, ...a);
+new e["a-b"].f(1, 2, ...a, "string");
+
+// Basic expression
+new B(1, 2, "string");
+new B(1, 2, ...a);
+new B(1, 2, ...a, "string");
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+new c["a-b"](1, 2, ...a);
+new c["a-b"](1, 2, ...a, "string");
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (c["a-b"])(1, 2, ...a);
+new (c["a-b"])(1, 2, ...a, "string");
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new g[1]["a-b"](1, 2, ...a);
+new g[1]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new h["a-b"]["a-b"](1, 2, ...a);
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new i["a-b"][1](1, 2, ...a);
+new i["a-b"][1](1, 2, ...a, "string");
+
+//// [newWithSpread.js]
+function f(x, y) {
+    var z = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        z[_i - 2] = arguments[_i];
+    }
+}
+var B = (function () {
+    function B(x, y) {
+        var z = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            z[_i - 2] = arguments[_i];
+        }
+    }
+    return B;
+})();
+var a;
+var b;
+var c;
+var d;
+var e;
+var g;
+var h;
+var i;
+// Basic expression
+new f(1, 2, "string");
+new f(1, 2, ...a);
+new f(1, 2, ...a, "string");
+// Call expression
+new f(1, 2, "string")();
+new f(1, 2, ...a)();
+new f(1, 2, ...a, "string")();
+// Property access expression
+new b.f(1, 2, "string");
+new b.f(1, 2, ...a);
+new b.f(1, 2, ...a, "string");
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (b.f)(1, 2, ...a);
+new (b.f)(1, 2, ...a, "string");
+// Element access expression
+new d[1].f(1, 2, "string");
+new d[1].f(1, 2, ...a);
+new d[1].f(1, 2, ...a, "string");
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new e["a-b"].f(1, 2, ...a);
+new e["a-b"].f(1, 2, ...a, "string");
+// Basic expression
+new B(1, 2, "string");
+new B(1, 2, ...a);
+new B(1, 2, ...a, "string");
+// Property access expression
+new c["a-b"](1, 2, "string");
+new c["a-b"](1, 2, ...a);
+new c["a-b"](1, 2, ...a, "string");
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (c["a-b"])(1, 2, ...a);
+new (c["a-b"])(1, 2, ...a, "string");
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new g[1]["a-b"](1, 2, ...a);
+new g[1]["a-b"](1, 2, ...a, "string");
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new h["a-b"]["a-b"](1, 2, ...a);
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new i["a-b"][1](1, 2, ...a);
+new i["a-b"][1](1, 2, ...a, "string");
diff --git a/tests/baselines/reference/newWithSpreadES5.js b/tests/baselines/reference/newWithSpreadES5.js
new file mode 100644
index 00000000000..e463f0aaeea
--- /dev/null
+++ b/tests/baselines/reference/newWithSpreadES5.js
@@ -0,0 +1,164 @@
+//// [newWithSpreadES5.ts]
+
+function f(x: number, y: number, ...z: string[]) {
+}
+
+interface A {
+    f: {
+        new (x: number, y: number, ...z: string[]);
+    }
+}
+
+class B {
+    constructor(x: number, y: number, ...z: string[]) {}
+}
+
+interface C {
+    "a-b": typeof B;
+}
+
+interface D {
+    1: typeof B;
+}
+
+var a: string[];
+var b: A;
+var c: C;
+var d: A[];
+var e: { [key: string]: A };
+var g: C[];
+var h: { [key: string]: C };
+var i: C[][];
+
+// Basic expression
+new f(1, 2, "string");
+new f(1, 2, ...a);
+new f(1, 2, ...a, "string");
+
+// Call expression
+new f(1, 2, "string")();
+new f(1, 2, ...a)();
+new f(1, 2, ...a, "string")();
+
+// Property access expression
+new b.f(1, 2, "string");
+new b.f(1, 2, ...a);
+new b.f(1, 2, ...a, "string"); 
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (b.f)(1, 2, ...a);
+new (b.f)(1, 2, ...a, "string"); 
+
+// Element access expression
+new d[1].f(1, 2, "string");
+new d[1].f(1, 2, ...a);
+new d[1].f(1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new e["a-b"].f(1, 2, ...a);
+new e["a-b"].f(1, 2, ...a, "string");
+
+// Basic expression
+new B(1, 2, "string");
+new B(1, 2, ...a);
+new B(1, 2, ...a, "string");
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+new c["a-b"](1, 2, ...a);
+new c["a-b"](1, 2, ...a, "string");
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (c["a-b"])(1, 2, ...a);
+new (c["a-b"])(1, 2, ...a, "string");
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new g[1]["a-b"](1, 2, ...a);
+new g[1]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new h["a-b"]["a-b"](1, 2, ...a);
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new i["a-b"][1](1, 2, ...a);
+new i["a-b"][1](1, 2, ...a, "string");
+
+//// [newWithSpreadES5.js]
+function f(x, y) {
+    var z = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        z[_i - 2] = arguments[_i];
+    }
+}
+var B = (function () {
+    function B(x, y) {
+        var z = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            z[_i - 2] = arguments[_i];
+        }
+    }
+    return B;
+})();
+var a;
+var b;
+var c;
+var d;
+var e;
+var g;
+var h;
+var i;
+// Basic expression
+new f(1, 2, "string");
+new (Function.bind.apply(f, [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(f, [void 0].concat([1, 2].concat(a, ["string"]))));
+// Call expression
+new f(1, 2, "string")();
+new (Function.bind.apply(f, [void 0].concat([1, 2].concat(a))))();
+new (Function.bind.apply(f, [void 0].concat([1, 2].concat(a, ["string"]))))();
+// Property access expression
+new b.f(1, 2, "string");
+new (Function.bind.apply(b.f, [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(b.f, [void 0].concat([1, 2].concat(a, ["string"]))));
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (Function.bind.apply((b.f), [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply((b.f), [void 0].concat([1, 2].concat(a, ["string"]))));
+// Element access expression
+new d[1].f(1, 2, "string");
+new (Function.bind.apply(d[1].f, [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(d[1].f, [void 0].concat([1, 2].concat(a, ["string"]))));
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new (Function.bind.apply(e["a-b"].f, [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(e["a-b"].f, [void 0].concat([1, 2].concat(a, ["string"]))));
+// Basic expression
+new B(1, 2, "string");
+new (Function.bind.apply(B, [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(B, [void 0].concat([1, 2].concat(a, ["string"]))));
+// Property access expression
+new c["a-b"](1, 2, "string");
+new (Function.bind.apply(c["a-b"], [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(c["a-b"], [void 0].concat([1, 2].concat(a, ["string"]))));
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (Function.bind.apply((c["a-b"]), [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply((c["a-b"]), [void 0].concat([1, 2].concat(a, ["string"]))));
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new (Function.bind.apply(g[1]["a-b"], [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(g[1]["a-b"], [void 0].concat([1, 2].concat(a, ["string"]))));
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new (Function.bind.apply(h["a-b"]["a-b"], [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(h["a-b"]["a-b"], [void 0].concat([1, 2].concat(a, ["string"]))));
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new (Function.bind.apply(i["a-b"][1], [void 0].concat([1, 2].concat(a))));
+new (Function.bind.apply(i["a-b"][1], [void 0].concat([1, 2].concat(a, ["string"]))));
diff --git a/tests/baselines/reference/newWithSpreadES5.symbols b/tests/baselines/reference/newWithSpreadES5.symbols
new file mode 100644
index 00000000000..dc37c41f597
--- /dev/null
+++ b/tests/baselines/reference/newWithSpreadES5.symbols
@@ -0,0 +1,258 @@
+=== tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts ===
+
+function f(x: number, y: number, ...z: string[]) {
+>f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0))
+>x : Symbol(x, Decl(newWithSpreadES5.ts, 1, 11))
+>y : Symbol(y, Decl(newWithSpreadES5.ts, 1, 21))
+>z : Symbol(z, Decl(newWithSpreadES5.ts, 1, 32))
+}
+
+interface A {
+>A : Symbol(A, Decl(newWithSpreadES5.ts, 2, 1))
+
+    f: {
+>f : Symbol(f, Decl(newWithSpreadES5.ts, 4, 13))
+
+        new (x: number, y: number, ...z: string[]);
+>x : Symbol(x, Decl(newWithSpreadES5.ts, 6, 13))
+>y : Symbol(y, Decl(newWithSpreadES5.ts, 6, 23))
+>z : Symbol(z, Decl(newWithSpreadES5.ts, 6, 34))
+    }
+}
+
+class B {
+>B : Symbol(B, Decl(newWithSpreadES5.ts, 8, 1))
+
+    constructor(x: number, y: number, ...z: string[]) {}
+>x : Symbol(x, Decl(newWithSpreadES5.ts, 11, 16))
+>y : Symbol(y, Decl(newWithSpreadES5.ts, 11, 26))
+>z : Symbol(z, Decl(newWithSpreadES5.ts, 11, 37))
+}
+
+interface C {
+>C : Symbol(C, Decl(newWithSpreadES5.ts, 12, 1))
+
+    "a-b": typeof B;
+>B : Symbol(B, Decl(newWithSpreadES5.ts, 8, 1))
+}
+
+interface D {
+>D : Symbol(D, Decl(newWithSpreadES5.ts, 16, 1))
+
+    1: typeof B;
+>B : Symbol(B, Decl(newWithSpreadES5.ts, 8, 1))
+}
+
+var a: string[];
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+var b: A;
+>b : Symbol(b, Decl(newWithSpreadES5.ts, 23, 3))
+>A : Symbol(A, Decl(newWithSpreadES5.ts, 2, 1))
+
+var c: C;
+>c : Symbol(c, Decl(newWithSpreadES5.ts, 24, 3))
+>C : Symbol(C, Decl(newWithSpreadES5.ts, 12, 1))
+
+var d: A[];
+>d : Symbol(d, Decl(newWithSpreadES5.ts, 25, 3))
+>A : Symbol(A, Decl(newWithSpreadES5.ts, 2, 1))
+
+var e: { [key: string]: A };
+>e : Symbol(e, Decl(newWithSpreadES5.ts, 26, 3))
+>key : Symbol(key, Decl(newWithSpreadES5.ts, 26, 10))
+>A : Symbol(A, Decl(newWithSpreadES5.ts, 2, 1))
+
+var g: C[];
+>g : Symbol(g, Decl(newWithSpreadES5.ts, 27, 3))
+>C : Symbol(C, Decl(newWithSpreadES5.ts, 12, 1))
+
+var h: { [key: string]: C };
+>h : Symbol(h, Decl(newWithSpreadES5.ts, 28, 3))
+>key : Symbol(key, Decl(newWithSpreadES5.ts, 28, 10))
+>C : Symbol(C, Decl(newWithSpreadES5.ts, 12, 1))
+
+var i: C[][];
+>i : Symbol(i, Decl(newWithSpreadES5.ts, 29, 3))
+>C : Symbol(C, Decl(newWithSpreadES5.ts, 12, 1))
+
+// Basic expression
+new f(1, 2, "string");
+>f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0))
+
+new f(1, 2, ...a);
+>f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new f(1, 2, ...a, "string");
+>f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Call expression
+new f(1, 2, "string")();
+>f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0))
+
+new f(1, 2, ...a)();
+>f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new f(1, 2, ...a, "string")();
+>f : Symbol(f, Decl(newWithSpreadES5.ts, 0, 0))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Property access expression
+new b.f(1, 2, "string");
+>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES5.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+
+new b.f(1, 2, ...a);
+>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES5.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new b.f(1, 2, ...a, "string"); 
+>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES5.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES5.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+
+new (b.f)(1, 2, ...a);
+>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES5.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new (b.f)(1, 2, ...a, "string"); 
+>b.f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES5.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Element access expression
+new d[1].f(1, 2, "string");
+>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>d : Symbol(d, Decl(newWithSpreadES5.ts, 25, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+
+new d[1].f(1, 2, ...a);
+>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>d : Symbol(d, Decl(newWithSpreadES5.ts, 25, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new d[1].f(1, 2, ...a, "string");
+>d[1].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>d : Symbol(d, Decl(newWithSpreadES5.ts, 25, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>e : Symbol(e, Decl(newWithSpreadES5.ts, 26, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+
+new e["a-b"].f(1, 2, ...a);
+>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>e : Symbol(e, Decl(newWithSpreadES5.ts, 26, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new e["a-b"].f(1, 2, ...a, "string");
+>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>e : Symbol(e, Decl(newWithSpreadES5.ts, 26, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES5.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Basic expression
+new B(1, 2, "string");
+>B : Symbol(B, Decl(newWithSpreadES5.ts, 8, 1))
+
+new B(1, 2, ...a);
+>B : Symbol(B, Decl(newWithSpreadES5.ts, 8, 1))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new B(1, 2, ...a, "string");
+>B : Symbol(B, Decl(newWithSpreadES5.ts, 8, 1))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+>c : Symbol(c, Decl(newWithSpreadES5.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+
+new c["a-b"](1, 2, ...a);
+>c : Symbol(c, Decl(newWithSpreadES5.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new c["a-b"](1, 2, ...a, "string");
+>c : Symbol(c, Decl(newWithSpreadES5.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+>c : Symbol(c, Decl(newWithSpreadES5.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+
+new (c["a-b"])(1, 2, ...a);
+>c : Symbol(c, Decl(newWithSpreadES5.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new (c["a-b"])(1, 2, ...a, "string");
+>c : Symbol(c, Decl(newWithSpreadES5.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+>g : Symbol(g, Decl(newWithSpreadES5.ts, 27, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+
+new g[1]["a-b"](1, 2, ...a);
+>g : Symbol(g, Decl(newWithSpreadES5.ts, 27, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new g[1]["a-b"](1, 2, ...a, "string");
+>g : Symbol(g, Decl(newWithSpreadES5.ts, 27, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+>h : Symbol(h, Decl(newWithSpreadES5.ts, 28, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+
+new h["a-b"]["a-b"](1, 2, ...a);
+>h : Symbol(h, Decl(newWithSpreadES5.ts, 28, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+>h : Symbol(h, Decl(newWithSpreadES5.ts, 28, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+>i : Symbol(i, Decl(newWithSpreadES5.ts, 29, 3))
+
+new i["a-b"][1](1, 2, ...a);
+>i : Symbol(i, Decl(newWithSpreadES5.ts, 29, 3))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
+new i["a-b"][1](1, 2, ...a, "string");
+>i : Symbol(i, Decl(newWithSpreadES5.ts, 29, 3))
+>a : Symbol(a, Decl(newWithSpreadES5.ts, 22, 3))
+
diff --git a/tests/baselines/reference/newWithSpreadES5.types b/tests/baselines/reference/newWithSpreadES5.types
new file mode 100644
index 00000000000..9948d075bef
--- /dev/null
+++ b/tests/baselines/reference/newWithSpreadES5.types
@@ -0,0 +1,471 @@
+=== tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts ===
+
+function f(x: number, y: number, ...z: string[]) {
+>f : (x: number, y: number, ...z: string[]) => void
+>x : number
+>y : number
+>z : string[]
+}
+
+interface A {
+>A : A
+
+    f: {
+>f : new (x: number, y: number, ...z: string[]) => any
+
+        new (x: number, y: number, ...z: string[]);
+>x : number
+>y : number
+>z : string[]
+    }
+}
+
+class B {
+>B : B
+
+    constructor(x: number, y: number, ...z: string[]) {}
+>x : number
+>y : number
+>z : string[]
+}
+
+interface C {
+>C : C
+
+    "a-b": typeof B;
+>B : typeof B
+}
+
+interface D {
+>D : D
+
+    1: typeof B;
+>B : typeof B
+}
+
+var a: string[];
+>a : string[]
+
+var b: A;
+>b : A
+>A : A
+
+var c: C;
+>c : C
+>C : C
+
+var d: A[];
+>d : A[]
+>A : A
+
+var e: { [key: string]: A };
+>e : { [key: string]: A; }
+>key : string
+>A : A
+
+var g: C[];
+>g : C[]
+>C : C
+
+var h: { [key: string]: C };
+>h : { [key: string]: C; }
+>key : string
+>C : C
+
+var i: C[][];
+>i : C[][]
+>C : C
+
+// Basic expression
+new f(1, 2, "string");
+>new f(1, 2, "string") : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>"string" : string
+
+new f(1, 2, ...a);
+>new f(1, 2, ...a) : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new f(1, 2, ...a, "string");
+>new f(1, 2, ...a, "string") : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Call expression
+new f(1, 2, "string")();
+>new f(1, 2, "string")() : any
+>new f(1, 2, "string") : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>"string" : string
+
+new f(1, 2, ...a)();
+>new f(1, 2, ...a)() : any
+>new f(1, 2, ...a) : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new f(1, 2, ...a, "string")();
+>new f(1, 2, ...a, "string")() : any
+>new f(1, 2, ...a, "string") : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Property access expression
+new b.f(1, 2, "string");
+>new b.f(1, 2, "string") : any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>"string" : string
+
+new b.f(1, 2, ...a);
+>new b.f(1, 2, ...a) : any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new b.f(1, 2, ...a, "string"); 
+>new b.f(1, 2, ...a, "string") : any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+>new (b.f)(1, 2, "string") : any
+>(b.f) : new (x: number, y: number, ...z: string[]) => any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>"string" : string
+
+new (b.f)(1, 2, ...a);
+>new (b.f)(1, 2, ...a) : any
+>(b.f) : new (x: number, y: number, ...z: string[]) => any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new (b.f)(1, 2, ...a, "string"); 
+>new (b.f)(1, 2, ...a, "string") : any
+>(b.f) : new (x: number, y: number, ...z: string[]) => any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression
+new d[1].f(1, 2, "string");
+>new d[1].f(1, 2, "string") : any
+>d[1].f : new (x: number, y: number, ...z: string[]) => any
+>d[1] : A
+>d : A[]
+>1 : number
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>"string" : string
+
+new d[1].f(1, 2, ...a);
+>new d[1].f(1, 2, ...a) : any
+>d[1].f : new (x: number, y: number, ...z: string[]) => any
+>d[1] : A
+>d : A[]
+>1 : number
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new d[1].f(1, 2, ...a, "string");
+>new d[1].f(1, 2, ...a, "string") : any
+>d[1].f : new (x: number, y: number, ...z: string[]) => any
+>d[1] : A
+>d : A[]
+>1 : number
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+>new e["a-b"].f(1, 2, "string") : any
+>e["a-b"].f : new (x: number, y: number, ...z: string[]) => any
+>e["a-b"] : A
+>e : { [key: string]: A; }
+>"a-b" : string
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>"string" : string
+
+new e["a-b"].f(1, 2, ...a);
+>new e["a-b"].f(1, 2, ...a) : any
+>e["a-b"].f : new (x: number, y: number, ...z: string[]) => any
+>e["a-b"] : A
+>e : { [key: string]: A; }
+>"a-b" : string
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new e["a-b"].f(1, 2, ...a, "string");
+>new e["a-b"].f(1, 2, ...a, "string") : any
+>e["a-b"].f : new (x: number, y: number, ...z: string[]) => any
+>e["a-b"] : A
+>e : { [key: string]: A; }
+>"a-b" : string
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Basic expression
+new B(1, 2, "string");
+>new B(1, 2, "string") : B
+>B : typeof B
+>1 : number
+>2 : number
+>"string" : string
+
+new B(1, 2, ...a);
+>new B(1, 2, ...a) : B
+>B : typeof B
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new B(1, 2, ...a, "string");
+>new B(1, 2, ...a, "string") : B
+>B : typeof B
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+>new c["a-b"](1, 2, "string") : B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>"string" : string
+
+new c["a-b"](1, 2, ...a);
+>new c["a-b"](1, 2, ...a) : B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new c["a-b"](1, 2, ...a, "string");
+>new c["a-b"](1, 2, ...a, "string") : B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+>new (c["a-b"])(1, 2, "string") : B
+>(c["a-b"]) : typeof B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>"string" : string
+
+new (c["a-b"])(1, 2, ...a);
+>new (c["a-b"])(1, 2, ...a) : B
+>(c["a-b"]) : typeof B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new (c["a-b"])(1, 2, ...a, "string");
+>new (c["a-b"])(1, 2, ...a, "string") : B
+>(c["a-b"]) : typeof B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+>new g[1]["a-b"](1, 2, "string") : B
+>g[1]["a-b"] : typeof B
+>g[1] : C
+>g : C[]
+>1 : number
+>"a-b" : string
+>1 : number
+>2 : number
+>"string" : string
+
+new g[1]["a-b"](1, 2, ...a);
+>new g[1]["a-b"](1, 2, ...a) : B
+>g[1]["a-b"] : typeof B
+>g[1] : C
+>g : C[]
+>1 : number
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new g[1]["a-b"](1, 2, ...a, "string");
+>new g[1]["a-b"](1, 2, ...a, "string") : B
+>g[1]["a-b"] : typeof B
+>g[1] : C
+>g : C[]
+>1 : number
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+>new h["a-b"]["a-b"](1, 2, "string") : B
+>h["a-b"]["a-b"] : typeof B
+>h["a-b"] : C
+>h : { [key: string]: C; }
+>"a-b" : string
+>"a-b" : string
+>1 : number
+>2 : number
+>"string" : string
+
+new h["a-b"]["a-b"](1, 2, ...a);
+>new h["a-b"]["a-b"](1, 2, ...a) : B
+>h["a-b"]["a-b"] : typeof B
+>h["a-b"] : C
+>h : { [key: string]: C; }
+>"a-b" : string
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+>new h["a-b"]["a-b"](1, 2, ...a, "string") : B
+>h["a-b"]["a-b"] : typeof B
+>h["a-b"] : C
+>h : { [key: string]: C; }
+>"a-b" : string
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+>new i["a-b"][1](1, 2, "string") : any
+>i["a-b"][1] : any
+>i["a-b"] : any
+>i : C[][]
+>"a-b" : string
+>1 : number
+>1 : number
+>2 : number
+>"string" : string
+
+new i["a-b"][1](1, 2, ...a);
+>new i["a-b"][1](1, 2, ...a) : any
+>i["a-b"][1] : any
+>i["a-b"] : any
+>i : C[][]
+>"a-b" : string
+>1 : number
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new i["a-b"][1](1, 2, ...a, "string");
+>new i["a-b"][1](1, 2, ...a, "string") : any
+>i["a-b"][1] : any
+>i["a-b"] : any
+>i : C[][]
+>"a-b" : string
+>1 : number
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
diff --git a/tests/baselines/reference/newWithSpreadES6.js b/tests/baselines/reference/newWithSpreadES6.js
new file mode 100644
index 00000000000..dae7c9229db
--- /dev/null
+++ b/tests/baselines/reference/newWithSpreadES6.js
@@ -0,0 +1,155 @@
+//// [newWithSpreadES6.ts]
+
+function f(x: number, y: number, ...z: string[]) {
+}
+
+interface A {
+    f: {
+        new (x: number, y: number, ...z: string[]);
+    }
+}
+
+class B {
+    constructor(x: number, y: number, ...z: string[]) {}
+}
+
+interface C {
+    "a-b": typeof B;
+}
+
+interface D {
+    1: typeof B;
+}
+
+var a: string[];
+var b: A;
+var c: C;
+var d: A[];
+var e: { [key: string]: A };
+var g: C[];
+var h: { [key: string]: C };
+var i: C[][];
+
+// Basic expression
+new f(1, 2, "string");
+new f(1, 2, ...a);
+new f(1, 2, ...a, "string");
+
+// Call expression
+new f(1, 2, "string")();
+new f(1, 2, ...a)();
+new f(1, 2, ...a, "string")();
+
+// Property access expression
+new b.f(1, 2, "string");
+new b.f(1, 2, ...a);
+new b.f(1, 2, ...a, "string"); 
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (b.f)(1, 2, ...a);
+new (b.f)(1, 2, ...a, "string"); 
+
+// Element access expression
+new d[1].f(1, 2, "string");
+new d[1].f(1, 2, ...a);
+new d[1].f(1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new e["a-b"].f(1, 2, ...a);
+new e["a-b"].f(1, 2, ...a, "string");
+
+// Basic expression
+new B(1, 2, "string");
+new B(1, 2, ...a);
+new B(1, 2, ...a, "string");
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+new c["a-b"](1, 2, ...a);
+new c["a-b"](1, 2, ...a, "string");
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (c["a-b"])(1, 2, ...a);
+new (c["a-b"])(1, 2, ...a, "string");
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new g[1]["a-b"](1, 2, ...a);
+new g[1]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new h["a-b"]["a-b"](1, 2, ...a);
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new i["a-b"][1](1, 2, ...a);
+new i["a-b"][1](1, 2, ...a, "string");
+
+//// [newWithSpreadES6.js]
+function f(x, y, ...z) {
+}
+class B {
+    constructor(x, y, ...z) {
+    }
+}
+var a;
+var b;
+var c;
+var d;
+var e;
+var g;
+var h;
+var i;
+// Basic expression
+new f(1, 2, "string");
+new f(1, 2, ...a);
+new f(1, 2, ...a, "string");
+// Call expression
+new f(1, 2, "string")();
+new f(1, 2, ...a)();
+new f(1, 2, ...a, "string")();
+// Property access expression
+new b.f(1, 2, "string");
+new b.f(1, 2, ...a);
+new b.f(1, 2, ...a, "string");
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (b.f)(1, 2, ...a);
+new (b.f)(1, 2, ...a, "string");
+// Element access expression
+new d[1].f(1, 2, "string");
+new d[1].f(1, 2, ...a);
+new d[1].f(1, 2, ...a, "string");
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new e["a-b"].f(1, 2, ...a);
+new e["a-b"].f(1, 2, ...a, "string");
+// Basic expression
+new B(1, 2, "string");
+new B(1, 2, ...a);
+new B(1, 2, ...a, "string");
+// Property access expression
+new c["a-b"](1, 2, "string");
+new c["a-b"](1, 2, ...a);
+new c["a-b"](1, 2, ...a, "string");
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (c["a-b"])(1, 2, ...a);
+new (c["a-b"])(1, 2, ...a, "string");
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new g[1]["a-b"](1, 2, ...a);
+new g[1]["a-b"](1, 2, ...a, "string");
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new h["a-b"]["a-b"](1, 2, ...a);
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new i["a-b"][1](1, 2, ...a);
+new i["a-b"][1](1, 2, ...a, "string");
diff --git a/tests/baselines/reference/newWithSpreadES6.symbols b/tests/baselines/reference/newWithSpreadES6.symbols
new file mode 100644
index 00000000000..f16984fb481
--- /dev/null
+++ b/tests/baselines/reference/newWithSpreadES6.symbols
@@ -0,0 +1,258 @@
+=== tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts ===
+
+function f(x: number, y: number, ...z: string[]) {
+>f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0))
+>x : Symbol(x, Decl(newWithSpreadES6.ts, 1, 11))
+>y : Symbol(y, Decl(newWithSpreadES6.ts, 1, 21))
+>z : Symbol(z, Decl(newWithSpreadES6.ts, 1, 32))
+}
+
+interface A {
+>A : Symbol(A, Decl(newWithSpreadES6.ts, 2, 1))
+
+    f: {
+>f : Symbol(f, Decl(newWithSpreadES6.ts, 4, 13))
+
+        new (x: number, y: number, ...z: string[]);
+>x : Symbol(x, Decl(newWithSpreadES6.ts, 6, 13))
+>y : Symbol(y, Decl(newWithSpreadES6.ts, 6, 23))
+>z : Symbol(z, Decl(newWithSpreadES6.ts, 6, 34))
+    }
+}
+
+class B {
+>B : Symbol(B, Decl(newWithSpreadES6.ts, 8, 1))
+
+    constructor(x: number, y: number, ...z: string[]) {}
+>x : Symbol(x, Decl(newWithSpreadES6.ts, 11, 16))
+>y : Symbol(y, Decl(newWithSpreadES6.ts, 11, 26))
+>z : Symbol(z, Decl(newWithSpreadES6.ts, 11, 37))
+}
+
+interface C {
+>C : Symbol(C, Decl(newWithSpreadES6.ts, 12, 1))
+
+    "a-b": typeof B;
+>B : Symbol(B, Decl(newWithSpreadES6.ts, 8, 1))
+}
+
+interface D {
+>D : Symbol(D, Decl(newWithSpreadES6.ts, 16, 1))
+
+    1: typeof B;
+>B : Symbol(B, Decl(newWithSpreadES6.ts, 8, 1))
+}
+
+var a: string[];
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+var b: A;
+>b : Symbol(b, Decl(newWithSpreadES6.ts, 23, 3))
+>A : Symbol(A, Decl(newWithSpreadES6.ts, 2, 1))
+
+var c: C;
+>c : Symbol(c, Decl(newWithSpreadES6.ts, 24, 3))
+>C : Symbol(C, Decl(newWithSpreadES6.ts, 12, 1))
+
+var d: A[];
+>d : Symbol(d, Decl(newWithSpreadES6.ts, 25, 3))
+>A : Symbol(A, Decl(newWithSpreadES6.ts, 2, 1))
+
+var e: { [key: string]: A };
+>e : Symbol(e, Decl(newWithSpreadES6.ts, 26, 3))
+>key : Symbol(key, Decl(newWithSpreadES6.ts, 26, 10))
+>A : Symbol(A, Decl(newWithSpreadES6.ts, 2, 1))
+
+var g: C[];
+>g : Symbol(g, Decl(newWithSpreadES6.ts, 27, 3))
+>C : Symbol(C, Decl(newWithSpreadES6.ts, 12, 1))
+
+var h: { [key: string]: C };
+>h : Symbol(h, Decl(newWithSpreadES6.ts, 28, 3))
+>key : Symbol(key, Decl(newWithSpreadES6.ts, 28, 10))
+>C : Symbol(C, Decl(newWithSpreadES6.ts, 12, 1))
+
+var i: C[][];
+>i : Symbol(i, Decl(newWithSpreadES6.ts, 29, 3))
+>C : Symbol(C, Decl(newWithSpreadES6.ts, 12, 1))
+
+// Basic expression
+new f(1, 2, "string");
+>f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0))
+
+new f(1, 2, ...a);
+>f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new f(1, 2, ...a, "string");
+>f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Call expression
+new f(1, 2, "string")();
+>f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0))
+
+new f(1, 2, ...a)();
+>f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new f(1, 2, ...a, "string")();
+>f : Symbol(f, Decl(newWithSpreadES6.ts, 0, 0))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Property access expression
+new b.f(1, 2, "string");
+>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES6.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+
+new b.f(1, 2, ...a);
+>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES6.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new b.f(1, 2, ...a, "string"); 
+>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES6.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES6.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+
+new (b.f)(1, 2, ...a);
+>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES6.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new (b.f)(1, 2, ...a, "string"); 
+>b.f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>b : Symbol(b, Decl(newWithSpreadES6.ts, 23, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Element access expression
+new d[1].f(1, 2, "string");
+>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>d : Symbol(d, Decl(newWithSpreadES6.ts, 25, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+
+new d[1].f(1, 2, ...a);
+>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>d : Symbol(d, Decl(newWithSpreadES6.ts, 25, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new d[1].f(1, 2, ...a, "string");
+>d[1].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>d : Symbol(d, Decl(newWithSpreadES6.ts, 25, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>e : Symbol(e, Decl(newWithSpreadES6.ts, 26, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+
+new e["a-b"].f(1, 2, ...a);
+>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>e : Symbol(e, Decl(newWithSpreadES6.ts, 26, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new e["a-b"].f(1, 2, ...a, "string");
+>e["a-b"].f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>e : Symbol(e, Decl(newWithSpreadES6.ts, 26, 3))
+>f : Symbol(A.f, Decl(newWithSpreadES6.ts, 4, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Basic expression
+new B(1, 2, "string");
+>B : Symbol(B, Decl(newWithSpreadES6.ts, 8, 1))
+
+new B(1, 2, ...a);
+>B : Symbol(B, Decl(newWithSpreadES6.ts, 8, 1))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new B(1, 2, ...a, "string");
+>B : Symbol(B, Decl(newWithSpreadES6.ts, 8, 1))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+>c : Symbol(c, Decl(newWithSpreadES6.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+
+new c["a-b"](1, 2, ...a);
+>c : Symbol(c, Decl(newWithSpreadES6.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new c["a-b"](1, 2, ...a, "string");
+>c : Symbol(c, Decl(newWithSpreadES6.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+>c : Symbol(c, Decl(newWithSpreadES6.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+
+new (c["a-b"])(1, 2, ...a);
+>c : Symbol(c, Decl(newWithSpreadES6.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new (c["a-b"])(1, 2, ...a, "string");
+>c : Symbol(c, Decl(newWithSpreadES6.ts, 24, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+>g : Symbol(g, Decl(newWithSpreadES6.ts, 27, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+
+new g[1]["a-b"](1, 2, ...a);
+>g : Symbol(g, Decl(newWithSpreadES6.ts, 27, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new g[1]["a-b"](1, 2, ...a, "string");
+>g : Symbol(g, Decl(newWithSpreadES6.ts, 27, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+>h : Symbol(h, Decl(newWithSpreadES6.ts, 28, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+
+new h["a-b"]["a-b"](1, 2, ...a);
+>h : Symbol(h, Decl(newWithSpreadES6.ts, 28, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+>h : Symbol(h, Decl(newWithSpreadES6.ts, 28, 3))
+>"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 14, 13))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+>i : Symbol(i, Decl(newWithSpreadES6.ts, 29, 3))
+
+new i["a-b"][1](1, 2, ...a);
+>i : Symbol(i, Decl(newWithSpreadES6.ts, 29, 3))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
+new i["a-b"][1](1, 2, ...a, "string");
+>i : Symbol(i, Decl(newWithSpreadES6.ts, 29, 3))
+>a : Symbol(a, Decl(newWithSpreadES6.ts, 22, 3))
+
diff --git a/tests/baselines/reference/newWithSpreadES6.types b/tests/baselines/reference/newWithSpreadES6.types
new file mode 100644
index 00000000000..7be42103419
--- /dev/null
+++ b/tests/baselines/reference/newWithSpreadES6.types
@@ -0,0 +1,471 @@
+=== tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts ===
+
+function f(x: number, y: number, ...z: string[]) {
+>f : (x: number, y: number, ...z: string[]) => void
+>x : number
+>y : number
+>z : string[]
+}
+
+interface A {
+>A : A
+
+    f: {
+>f : new (x: number, y: number, ...z: string[]) => any
+
+        new (x: number, y: number, ...z: string[]);
+>x : number
+>y : number
+>z : string[]
+    }
+}
+
+class B {
+>B : B
+
+    constructor(x: number, y: number, ...z: string[]) {}
+>x : number
+>y : number
+>z : string[]
+}
+
+interface C {
+>C : C
+
+    "a-b": typeof B;
+>B : typeof B
+}
+
+interface D {
+>D : D
+
+    1: typeof B;
+>B : typeof B
+}
+
+var a: string[];
+>a : string[]
+
+var b: A;
+>b : A
+>A : A
+
+var c: C;
+>c : C
+>C : C
+
+var d: A[];
+>d : A[]
+>A : A
+
+var e: { [key: string]: A };
+>e : { [key: string]: A; }
+>key : string
+>A : A
+
+var g: C[];
+>g : C[]
+>C : C
+
+var h: { [key: string]: C };
+>h : { [key: string]: C; }
+>key : string
+>C : C
+
+var i: C[][];
+>i : C[][]
+>C : C
+
+// Basic expression
+new f(1, 2, "string");
+>new f(1, 2, "string") : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>"string" : string
+
+new f(1, 2, ...a);
+>new f(1, 2, ...a) : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new f(1, 2, ...a, "string");
+>new f(1, 2, ...a, "string") : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Call expression
+new f(1, 2, "string")();
+>new f(1, 2, "string")() : any
+>new f(1, 2, "string") : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>"string" : string
+
+new f(1, 2, ...a)();
+>new f(1, 2, ...a)() : any
+>new f(1, 2, ...a) : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new f(1, 2, ...a, "string")();
+>new f(1, 2, ...a, "string")() : any
+>new f(1, 2, ...a, "string") : any
+>f : (x: number, y: number, ...z: string[]) => void
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Property access expression
+new b.f(1, 2, "string");
+>new b.f(1, 2, "string") : any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>"string" : string
+
+new b.f(1, 2, ...a);
+>new b.f(1, 2, ...a) : any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new b.f(1, 2, ...a, "string"); 
+>new b.f(1, 2, ...a, "string") : any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+>new (b.f)(1, 2, "string") : any
+>(b.f) : new (x: number, y: number, ...z: string[]) => any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>"string" : string
+
+new (b.f)(1, 2, ...a);
+>new (b.f)(1, 2, ...a) : any
+>(b.f) : new (x: number, y: number, ...z: string[]) => any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new (b.f)(1, 2, ...a, "string"); 
+>new (b.f)(1, 2, ...a, "string") : any
+>(b.f) : new (x: number, y: number, ...z: string[]) => any
+>b.f : new (x: number, y: number, ...z: string[]) => any
+>b : A
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression
+new d[1].f(1, 2, "string");
+>new d[1].f(1, 2, "string") : any
+>d[1].f : new (x: number, y: number, ...z: string[]) => any
+>d[1] : A
+>d : A[]
+>1 : number
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>"string" : string
+
+new d[1].f(1, 2, ...a);
+>new d[1].f(1, 2, ...a) : any
+>d[1].f : new (x: number, y: number, ...z: string[]) => any
+>d[1] : A
+>d : A[]
+>1 : number
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new d[1].f(1, 2, ...a, "string");
+>new d[1].f(1, 2, ...a, "string") : any
+>d[1].f : new (x: number, y: number, ...z: string[]) => any
+>d[1] : A
+>d : A[]
+>1 : number
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+>new e["a-b"].f(1, 2, "string") : any
+>e["a-b"].f : new (x: number, y: number, ...z: string[]) => any
+>e["a-b"] : A
+>e : { [key: string]: A; }
+>"a-b" : string
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>"string" : string
+
+new e["a-b"].f(1, 2, ...a);
+>new e["a-b"].f(1, 2, ...a) : any
+>e["a-b"].f : new (x: number, y: number, ...z: string[]) => any
+>e["a-b"] : A
+>e : { [key: string]: A; }
+>"a-b" : string
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new e["a-b"].f(1, 2, ...a, "string");
+>new e["a-b"].f(1, 2, ...a, "string") : any
+>e["a-b"].f : new (x: number, y: number, ...z: string[]) => any
+>e["a-b"] : A
+>e : { [key: string]: A; }
+>"a-b" : string
+>f : new (x: number, y: number, ...z: string[]) => any
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Basic expression
+new B(1, 2, "string");
+>new B(1, 2, "string") : B
+>B : typeof B
+>1 : number
+>2 : number
+>"string" : string
+
+new B(1, 2, ...a);
+>new B(1, 2, ...a) : B
+>B : typeof B
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new B(1, 2, ...a, "string");
+>new B(1, 2, ...a, "string") : B
+>B : typeof B
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+>new c["a-b"](1, 2, "string") : B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>"string" : string
+
+new c["a-b"](1, 2, ...a);
+>new c["a-b"](1, 2, ...a) : B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new c["a-b"](1, 2, ...a, "string");
+>new c["a-b"](1, 2, ...a, "string") : B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+>new (c["a-b"])(1, 2, "string") : B
+>(c["a-b"]) : typeof B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>"string" : string
+
+new (c["a-b"])(1, 2, ...a);
+>new (c["a-b"])(1, 2, ...a) : B
+>(c["a-b"]) : typeof B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new (c["a-b"])(1, 2, ...a, "string");
+>new (c["a-b"])(1, 2, ...a, "string") : B
+>(c["a-b"]) : typeof B
+>c["a-b"] : typeof B
+>c : C
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+>new g[1]["a-b"](1, 2, "string") : B
+>g[1]["a-b"] : typeof B
+>g[1] : C
+>g : C[]
+>1 : number
+>"a-b" : string
+>1 : number
+>2 : number
+>"string" : string
+
+new g[1]["a-b"](1, 2, ...a);
+>new g[1]["a-b"](1, 2, ...a) : B
+>g[1]["a-b"] : typeof B
+>g[1] : C
+>g : C[]
+>1 : number
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new g[1]["a-b"](1, 2, ...a, "string");
+>new g[1]["a-b"](1, 2, ...a, "string") : B
+>g[1]["a-b"] : typeof B
+>g[1] : C
+>g : C[]
+>1 : number
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+>new h["a-b"]["a-b"](1, 2, "string") : B
+>h["a-b"]["a-b"] : typeof B
+>h["a-b"] : C
+>h : { [key: string]: C; }
+>"a-b" : string
+>"a-b" : string
+>1 : number
+>2 : number
+>"string" : string
+
+new h["a-b"]["a-b"](1, 2, ...a);
+>new h["a-b"]["a-b"](1, 2, ...a) : B
+>h["a-b"]["a-b"] : typeof B
+>h["a-b"] : C
+>h : { [key: string]: C; }
+>"a-b" : string
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+>new h["a-b"]["a-b"](1, 2, ...a, "string") : B
+>h["a-b"]["a-b"] : typeof B
+>h["a-b"] : C
+>h : { [key: string]: C; }
+>"a-b" : string
+>"a-b" : string
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+>new i["a-b"][1](1, 2, "string") : any
+>i["a-b"][1] : any
+>i["a-b"] : any
+>i : C[][]
+>"a-b" : string
+>1 : number
+>1 : number
+>2 : number
+>"string" : string
+
+new i["a-b"][1](1, 2, ...a);
+>new i["a-b"][1](1, 2, ...a) : any
+>i["a-b"][1] : any
+>i["a-b"] : any
+>i : C[][]
+>"a-b" : string
+>1 : number
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+
+new i["a-b"][1](1, 2, ...a, "string");
+>new i["a-b"][1](1, 2, ...a, "string") : any
+>i["a-b"][1] : any
+>i["a-b"] : any
+>i : C[][]
+>"a-b" : string
+>1 : number
+>1 : number
+>2 : number
+>...a : string
+>a : string[]
+>"string" : string
+
diff --git a/tests/cases/conformance/expressions/functionCalls/newWithSpread.ts b/tests/cases/conformance/expressions/functionCalls/newWithSpread.ts
new file mode 100644
index 00000000000..6550658c814
--- /dev/null
+++ b/tests/cases/conformance/expressions/functionCalls/newWithSpread.ts
@@ -0,0 +1,90 @@
+
+function f(x: number, y: number, ...z: string[]) {
+}
+
+interface A {
+    f: {
+        new (x: number, y: number, ...z: string[]);
+    }
+}
+
+class B {
+    constructor(x: number, y: number, ...z: string[]) {}
+}
+
+interface C {
+    "a-b": typeof B;
+}
+
+interface D {
+    1: typeof B;
+}
+
+var a: string[];
+var b: A;
+var c: C;
+var d: A[];
+var e: { [key: string]: A };
+var g: C[];
+var h: { [key: string]: C };
+var i: C[][];
+
+// Basic expression
+new f(1, 2, "string");
+new f(1, 2, ...a);
+new f(1, 2, ...a, "string");
+
+// Call expression
+new f(1, 2, "string")();
+new f(1, 2, ...a)();
+new f(1, 2, ...a, "string")();
+
+// Property access expression
+new b.f(1, 2, "string");
+new b.f(1, 2, ...a);
+new b.f(1, 2, ...a, "string"); 
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (b.f)(1, 2, ...a);
+new (b.f)(1, 2, ...a, "string"); 
+
+// Element access expression
+new d[1].f(1, 2, "string");
+new d[1].f(1, 2, ...a);
+new d[1].f(1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new e["a-b"].f(1, 2, ...a);
+new e["a-b"].f(1, 2, ...a, "string");
+
+// Basic expression
+new B(1, 2, "string");
+new B(1, 2, ...a);
+new B(1, 2, ...a, "string");
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+new c["a-b"](1, 2, ...a);
+new c["a-b"](1, 2, ...a, "string");
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (c["a-b"])(1, 2, ...a);
+new (c["a-b"])(1, 2, ...a, "string");
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new g[1]["a-b"](1, 2, ...a);
+new g[1]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new h["a-b"]["a-b"](1, 2, ...a);
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new i["a-b"][1](1, 2, ...a);
+new i["a-b"][1](1, 2, ...a, "string");
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts b/tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts
new file mode 100644
index 00000000000..0a60c6ff339
--- /dev/null
+++ b/tests/cases/conformance/expressions/functionCalls/newWithSpreadES5.ts
@@ -0,0 +1,91 @@
+//@target: ES5
+
+function f(x: number, y: number, ...z: string[]) {
+}
+
+interface A {
+    f: {
+        new (x: number, y: number, ...z: string[]);
+    }
+}
+
+class B {
+    constructor(x: number, y: number, ...z: string[]) {}
+}
+
+interface C {
+    "a-b": typeof B;
+}
+
+interface D {
+    1: typeof B;
+}
+
+var a: string[];
+var b: A;
+var c: C;
+var d: A[];
+var e: { [key: string]: A };
+var g: C[];
+var h: { [key: string]: C };
+var i: C[][];
+
+// Basic expression
+new f(1, 2, "string");
+new f(1, 2, ...a);
+new f(1, 2, ...a, "string");
+
+// Call expression
+new f(1, 2, "string")();
+new f(1, 2, ...a)();
+new f(1, 2, ...a, "string")();
+
+// Property access expression
+new b.f(1, 2, "string");
+new b.f(1, 2, ...a);
+new b.f(1, 2, ...a, "string"); 
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (b.f)(1, 2, ...a);
+new (b.f)(1, 2, ...a, "string"); 
+
+// Element access expression
+new d[1].f(1, 2, "string");
+new d[1].f(1, 2, ...a);
+new d[1].f(1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new e["a-b"].f(1, 2, ...a);
+new e["a-b"].f(1, 2, ...a, "string");
+
+// Basic expression
+new B(1, 2, "string");
+new B(1, 2, ...a);
+new B(1, 2, ...a, "string");
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+new c["a-b"](1, 2, ...a);
+new c["a-b"](1, 2, ...a, "string");
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (c["a-b"])(1, 2, ...a);
+new (c["a-b"])(1, 2, ...a, "string");
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new g[1]["a-b"](1, 2, ...a);
+new g[1]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new h["a-b"]["a-b"](1, 2, ...a);
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new i["a-b"][1](1, 2, ...a);
+new i["a-b"][1](1, 2, ...a, "string");
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts b/tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts
new file mode 100644
index 00000000000..ec235f7a619
--- /dev/null
+++ b/tests/cases/conformance/expressions/functionCalls/newWithSpreadES6.ts
@@ -0,0 +1,91 @@
+//@target: ES6
+
+function f(x: number, y: number, ...z: string[]) {
+}
+
+interface A {
+    f: {
+        new (x: number, y: number, ...z: string[]);
+    }
+}
+
+class B {
+    constructor(x: number, y: number, ...z: string[]) {}
+}
+
+interface C {
+    "a-b": typeof B;
+}
+
+interface D {
+    1: typeof B;
+}
+
+var a: string[];
+var b: A;
+var c: C;
+var d: A[];
+var e: { [key: string]: A };
+var g: C[];
+var h: { [key: string]: C };
+var i: C[][];
+
+// Basic expression
+new f(1, 2, "string");
+new f(1, 2, ...a);
+new f(1, 2, ...a, "string");
+
+// Call expression
+new f(1, 2, "string")();
+new f(1, 2, ...a)();
+new f(1, 2, ...a, "string")();
+
+// Property access expression
+new b.f(1, 2, "string");
+new b.f(1, 2, ...a);
+new b.f(1, 2, ...a, "string"); 
+
+// Parenthesised expression
+new (b.f)(1, 2, "string");
+new (b.f)(1, 2, ...a);
+new (b.f)(1, 2, ...a, "string"); 
+
+// Element access expression
+new d[1].f(1, 2, "string");
+new d[1].f(1, 2, ...a);
+new d[1].f(1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new e["a-b"].f(1, 2, "string");
+new e["a-b"].f(1, 2, ...a);
+new e["a-b"].f(1, 2, ...a, "string");
+
+// Basic expression
+new B(1, 2, "string");
+new B(1, 2, ...a);
+new B(1, 2, ...a, "string");
+
+// Property access expression
+new c["a-b"](1, 2, "string");
+new c["a-b"](1, 2, ...a);
+new c["a-b"](1, 2, ...a, "string");
+
+// Parenthesised expression
+new (c["a-b"])(1, 2, "string");
+new (c["a-b"])(1, 2, ...a);
+new (c["a-b"])(1, 2, ...a, "string");
+
+// Element access expression
+new g[1]["a-b"](1, 2, "string");
+new g[1]["a-b"](1, 2, ...a);
+new g[1]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a punctuated key
+new h["a-b"]["a-b"](1, 2, "string");
+new h["a-b"]["a-b"](1, 2, ...a);
+new h["a-b"]["a-b"](1, 2, ...a, "string");
+
+// Element access expression with a number
+new i["a-b"][1](1, 2, "string");
+new i["a-b"][1](1, 2, ...a);
+new i["a-b"][1](1, 2, ...a, "string");
\ No newline at end of file