Adds spread syntax in new expressions in ES5

Author: tinganho

src/compiler/checker.ts

@@ -6585,7 +6585,7 @@ module ts {
                 result.splice(spliceIndex, 0, signature);
             }
         }
-
+
         function getSpreadArgumentIndex(args: Expression[]): number {
             for (let i = 0; i < args.length; i++) {
                 if (args[i].kind === SyntaxKind.SpreadElementExpression) {
@@ -7107,10 +7107,10 @@ module ts {
         }
 
         function resolveNewExpression(node: NewExpression, candidatesOutArray: Signature[]): Signature {
-            if (node.arguments && languageVersion < ScriptTarget.ES6) {
+            if (node.arguments && languageVersion < ScriptTarget.ES5) {
                 let spreadIndex = getSpreadArgumentIndex(node.arguments);
                 if (spreadIndex >= 0) {
-                    error(node.arguments[spreadIndex], Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_6_and_higher);
+                    error(node.arguments[spreadIndex], Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher);
                 }
             }
 
@@ -7128,7 +7128,7 @@ module ts {
             // If ConstructExpr's apparent type(section 3.8.1) is an object type with one or
             // more construct signatures, the expression is processed in the same manner as a
             // function call, but using the construct signatures as the initial set of candidate
-            // signatures for overload resolution.The result type of the function call becomes
+            // signatures for overload resolution. The result type of the function call becomes
             // the result type of the operation.
             expressionType = getApparentType(expressionType);
             if (expressionType === unknownType) {

src/compiler/diagnosticInformationMap.generated.ts

@@ -334,7 +334,7 @@ module ts {
         The_0_operator_cannot_be_applied_to_type_symbol: { code: 2469, category: DiagnosticCategory.Error, key: "The '{0}' operator cannot be applied to type 'symbol'." },
         Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object: { code: 2470, category: DiagnosticCategory.Error, key: "'Symbol' reference does not refer to the global Symbol constructor object." },
         A_computed_property_name_of_the_form_0_must_be_of_type_symbol: { code: 2471, category: DiagnosticCategory.Error, key: "A computed property name of the form '{0}' must be of type 'symbol'." },
-        Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_6_and_higher: { code: 2472, category: DiagnosticCategory.Error, key: "Spread operator in 'new' expressions is only available when targeting ECMAScript 6 and higher." },
+        Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: { code: 2472, category: DiagnosticCategory.Error, key: "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher." },
         Enum_declarations_must_all_be_const_or_non_const: { code: 2473, category: DiagnosticCategory.Error, key: "Enum declarations must all be const or non-const." },
         In_const_enum_declarations_member_initializer_must_be_constant_expression: { code: 2474, category: DiagnosticCategory.Error, key: "In 'const' enum declarations member initializer must be constant expression." },
         const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment: { code: 2475, category: DiagnosticCategory.Error, key: "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment." },

src/compiler/diagnosticMessages.json

@@ -1324,7 +1324,7 @@
         "category": "Error",
         "code": 2471
     },
-    "Spread operator in 'new' expressions is only available when targeting ECMAScript 6 and higher.": {
+    "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher.": {
         "category": "Error",
         "code": 2472
     },

src/compiler/emitter.ts

@@ -1809,28 +1809,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
             }
 
             function emitCallWithSpread(node: CallExpression) {
-                let target: Expression;
-                let expr = skipParentheses(node.expression);
-                if (expr.kind === SyntaxKind.PropertyAccessExpression) {
-                    // Target will be emitted as "this" argument
-                    target = emitCallTarget((<PropertyAccessExpression>expr).expression);
-                    write(".");
-                    emit((<PropertyAccessExpression>expr).name);
-                }
-                else if (expr.kind === SyntaxKind.ElementAccessExpression) {
-                    // Target will be emitted as "this" argument
-                    target = emitCallTarget((<PropertyAccessExpression>expr).expression);
-                    write("[");
-                    emit((<ElementAccessExpression>expr).argumentExpression);
-                    write("]");
-                }
-                else if (expr.kind === SyntaxKind.SuperKeyword) {
-                    target = expr;
-                    write("_super");
-                }
-                else {
-                    emit(node.expression);
-                }
+                let { target } = emitCallTargetAndAccessor(node.expression);
                 write(".apply(");
                 if (target) {
                     if (target.kind === SyntaxKind.SuperKeyword) {
@@ -1881,13 +1860,109 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                 }
             }
 
+            /** Emit call target and accessor from an expression. The call target represents
+              * the default call context of "this". If it can be decided — this function will
+              * return the node representhing the call target — otherwise it returns undefined.
+              * The accessor is a property accessor of the target. If an expression has an 
+              * accessor this function will both emit it and return it. To support spread syntax 
+              * in TypeScript, we sometimes need to emit the target twice in an expression that
+              * only expresses it once. The target could be a call expression and therefore calling 
+              * it twice would alter its' state differently as oppose to calling it once. This 
+              * function is very handy for those situations because it is emitting and returning
+              * the call target and the accessor. */
+            function emitCallTargetAndAccessor(node: Expression): CallTargetAndAccessor {
+                node = skipParentheses(node);
+                let target: Expression;
+                let accessor: Expression;
+                if (node.kind === SyntaxKind.PropertyAccessExpression) {
+                    // Target will be emitted as "this" argument
+                    target = emitCallTarget((<PropertyAccessExpression>node).expression);
+                    accessor = (<PropertyAccessExpression>node).name;
+                    write(".");
+                    emit(accessor);
+                }
+                else if (node.kind === SyntaxKind.ElementAccessExpression) {
+                    // Target will be emitted as "this" argument
+                    target = emitCallTarget((<PropertyAccessExpression>node).expression);
+                    accessor = (<ElementAccessExpression>node).argumentExpression;
+                    write("[");
+                    emit(accessor);
+                    write("]");
+                }
+                else if (node.kind === SyntaxKind.SuperKeyword) {
+                    target = node;
+                    write("_super");
+                }
+                else {
+                    emit(node);
+                }
+                return { target, accessor };
+            }
+
             function emitNewExpression(node: NewExpression) {
                 write("new ");
-                emit(node.expression);
-                if (node.arguments) {
+
+                // Spread operator logic can be supported in new expressions in ES5 using a combination
+                // of Function.prototype.bind() and Function.prototype.apply().
+                //
+                //     Example 1, with a non property accessor constructor:
+                //
+                //         var arguments = [1, 2, 3, 4, 5];
+                //         new Array(...arguments);
+                //
+                //         Could be transpiled into ES5:
+                //
+                //         var arguments = [1, 2, 3, 4, 5];
+                //         new (Array.bind.apply(Array, [void 0].concat(arguments)));
+                //
+                //     Example 2, with a property accessor constructor:
+                //
+                //         var arguments = [1, 2, 3, 4, 5];
+                //         new object.Array(...arguments);
+                //
+                //         Could be transpiled into ES5:
+                //
+                //         var arguments = [1, 2, 3, 4, 5];
+                //         new ((_a = object.Array).bind.apply(_a, [void 0].concat(arguments)));
+                //         var _a;
+                //
+                // `[void 0]` is the first argument which represents `thisArg` to the bind method above. 
+                // And `thisArg` will be set to the return value of the constructor when instantiated 
+                // with the new operator — regardless of any value we set `thisArg` to. Thus, we set it 
+                // to an empty object, `void 0`.
+                if (languageVersion === ScriptTarget.ES5 &&
+                    node.arguments &&
+                    hasSpreadElement(node.arguments)) {
+
                     write("(");
-                    emitCommaList(node.arguments);
-                    write(")");
+                    let { target, accessor } = emitCallTargetAndAccessor(node.expression);
+                    write(".bind.apply(");
+                    if (target) {
+                        emit(target);
+                        if (accessor.kind === SyntaxKind.Identifier) {
+                            write(".");
+                            emit(accessor);
+                        }
+                        else {
+                            write("[");
+                            emit(accessor);
+                            write("]");
+                        }
+                    }
+                    else {
+                        emit(node.expression);
+                    }
+                    write(", [void 0].concat(");
+                    emitListWithSpread(node.arguments, /*multiline*/false, /*trailingComma*/false);
+                    write(")))");
+                }
+                else {
+                    emit(node.expression);
+                    if (node.arguments) {
+                        write("(");
+                        emitCommaList(node.arguments);
+                        write(")");
+                    }
                 }
             }
 

src/compiler/types.ts

@@ -394,6 +394,15 @@ module ts {
         originalKeywordKind?: SyntaxKind;              // Original syntaxKind which get set so that we can report an error later
     }
 
+    /** Target and accessor from a function like call. Target is the object that represent the default call context
+      * "this". The accessor is a property member of the target used in a call expression. This interface is only 
+      * used in the emitter for emitting expressions with spread syntax.*/
+    /* @internal */
+    export interface CallTargetAndAccessor {
+        target?: Expression;
+        accessor?: Expression;
+    }
+
     export interface QualifiedName extends Node {
         // Must have same layout as PropertyAccess
         left: EntityName;