Emit downlevel parameter initializers unless we are certain they don't have any side effects.

src/compiler/emitter.ts

@@ -3899,7 +3899,9 @@ module ts {
                     emitSignatureParameters(node);
                 }
 
-                if (isSingleLineEmptyBlock(node.body) || !node.body) {
+                if (!node.body) {
+                    // There can be no body when there are parse errors.  Just emit an empty block 
+                    // in that case.
                     write(" { }");
                 }
                 else if (node.body.kind === SyntaxKind.Block) {
@@ -3979,15 +3981,57 @@ module ts {
             }
 
             function emitBlockFunctionBody(node: FunctionLikeDeclaration, body: Block) {
+                // If the body has no statements, and we know there's no code that would cause any 
+                // prologue to be emitted, then just do a simple emit if the empty block.
+                if (body.statements.length === 0 && !anyParameterHasBindingPatternOrInitializer(node)) {
+                    emitFunctionBodyWithNoStatements(node, body);
+                }
+                else {
+                    emitFunctionBodyWithStatements(node, body);
+                }
+            }
+
+            function anyParameterHasBindingPatternOrInitializer(func: FunctionLikeDeclaration) {
+                return forEach(func.parameters, hasBindingPatternOrInitializer);
+            }
+
+            function hasBindingPatternOrInitializer(parameter: ParameterDeclaration) {
+                return parameter.initializer || isBindingPattern(parameter.name);
+            }
+
+            function emitFunctionBodyWithNoStatements(node: FunctionLikeDeclaration, body: Block) {
+                var singleLine = isSingleLineEmptyBlock(node.body);
+
+                write(" {");
+                if (singleLine) {
+                    write(" ");
+                }
+                else {
+                    increaseIndent();
+                    writeLine();
+                }
+
+                emitLeadingCommentsOfPosition(body.statements.end);
+
+                if (!singleLine) {
+                    decreaseIndent();
+                }
+
+                emitToken(SyntaxKind.CloseBraceToken, body.statements.end);
+            }
+
+            function emitFunctionBodyWithStatements(node: FunctionLikeDeclaration, body: Block) {
                 write(" {");
                 scopeEmitStart(node);
 
                 var outPos = writer.getTextPos();
+
                 increaseIndent();
                 emitDetachedComments(body.statements);
                 var startIndex = emitDirectivePrologues(body.statements, /*startWithNewLine*/ true);
                 emitFunctionBodyPreamble(node);
                 decreaseIndent();
+
                 var preambleEmitted = writer.getTextPos() !== outPos;
 
                 if (!preambleEmitted && nodeEndIsOnSameLineAsNodeStart(body, body)) {

tests/baselines/reference/accessorWithInitializer.js

@@ -10,12 +10,16 @@ var C = (function () {
     function C() {
     }
     Object.defineProperty(C.prototype, "X", {
-        set: function (v) { },
+        set: function (v) {
+            if (v === void 0) { v = 0; }
+        },
         enumerable: true,
         configurable: true
     });
     Object.defineProperty(C, "X", {
-        set: function (v2) { },
+        set: function (v2) {
+            if (v2 === void 0) { v2 = 0; }
+        },
         enumerable: true,
         configurable: true
     });

tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.js

@@ -57,9 +57,15 @@ b.b(1);
 
 //// [callSignatureWithOptionalParameterAndInitializer.js]
 // Optional parameters cannot also have initializer expressions, these are all errors
-function foo(x) { }
-var f = function foo(x) { };
-var f2 = function (x, y) { };
+function foo(x) {
+    if (x === void 0) { x = 1; }
+}
+var f = function foo(x) {
+    if (x === void 0) { x = 1; }
+};
+var f2 = function (x, y) {
+    if (y === void 0) { y = 1; }
+};
 foo(1);
 foo();
 f(1);
@@ -69,7 +75,9 @@ f2(1, 2);
 var C = (function () {
     function C() {
     }
-    C.prototype.foo = function (x) { };
+    C.prototype.foo = function (x) {
+        if (x === void 0) { x = 1; }
+    };
     return C;
 })();
 var c;
@@ -86,9 +94,15 @@ a(1);
 a.foo();
 a.foo(1);
 var b = {
-    foo: function (x) { },
-    a: function foo(x, y) { },
-    b: function (x) { }
+    foo: function (x) {
+        if (x === void 0) { x = 1; }
+    },
+    a: function foo(x, y) {
+        if (y === void 0) { y = ''; }
+    },
+    b: function (x) {
+        if (x === void 0) { x = ''; }
+    }
 };
 b.foo();
 b.foo(1);

tests/baselines/reference/callSignaturesWithParameterInitializers.js

@@ -59,9 +59,15 @@ b.b(1);
 
 //// [callSignaturesWithParameterInitializers.js]
 // Optional parameters allow initializers only in implementation signatures
-function foo(x) { }
-var f = function foo(x) { };
-var f2 = function (x, y) { };
+function foo(x) {
+    if (x === void 0) { x = 1; }
+}
+var f = function foo(x) {
+    if (x === void 0) { x = 1; }
+};
+var f2 = function (x, y) {
+    if (y === void 0) { y = 1; }
+};
 foo(1);
 foo();
 f(1);
@@ -71,7 +77,9 @@ f2(1, 2);
 var C = (function () {
     function C() {
     }
-    C.prototype.foo = function (x) { };
+    C.prototype.foo = function (x) {
+        if (x === void 0) { x = 1; }
+    };
     return C;
 })();
 var c;
@@ -89,9 +97,15 @@ a(1);
 a.foo();
 a.foo(1);
 var b = {
-    foo: function (x) { },
-    a: function foo(x, y) { },
-    b: function (x) { }
+    foo: function (x) {
+        if (x === void 0) { x = 1; }
+    },
+    a: function foo(x, y) {
+        if (y === void 0) { y = 1; }
+    },
+    b: function (x) {
+        if (x === void 0) { x = 1; }
+    }
 };
 b.foo();
 b.foo(1);

tests/baselines/reference/callSignaturesWithParameterInitializers2.js

@@ -28,21 +28,29 @@ b.foo(1);
 //// [callSignaturesWithParameterInitializers2.js]
 // Optional parameters allow initializers only in implementation signatures
 // All the below declarations are errors
-function foo(x) { }
+function foo(x) {
+    if (x === void 0) { x = 1; }
+}
 foo(1);
 foo();
 var C = (function () {
     function C() {
     }
-    C.prototype.foo = function (x) { };
+    C.prototype.foo = function (x) {
+        if (x === void 0) { x = 1; }
+    };
     return C;
 })();
 var c;
 c.foo();
 c.foo(1);
 var b = {
-    foo: function (x) { },
-    foo: function (x) { }
+    foo: function (x) {
+        if (x === void 0) { x = 1; }
+    },
+    foo: function (x) {
+        if (x === void 0) { x = 1; }
+    }
 };
 b.foo();
 b.foo(1);

tests/baselines/reference/callWithSpread.js

@@ -61,10 +61,6 @@ var __extends = this.__extends || function (d, b) {
     d.prototype = new __();
 };
 function foo(x, y) {
-    var z = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        z[_i - 2] = arguments[_i];
-    }
 }
 var a;
 var z;
@@ -93,10 +89,6 @@ var C = (function () {
         this.foo.apply(this, [x, y].concat(z));
     }
     C.prototype.foo = function (x, y) {
-        var z = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            z[_i - 2] = arguments[_i];
-        }
     };
     return C;
 })();

tests/baselines/reference/collisionCodeGenModuleWithFunctionChildren.js

@@ -23,7 +23,9 @@ module M {
 var M;
 (function (_M) {
     _M.x = 3;
-    function fn(M, p) { }
+    function fn(M, p) {
+        if (p === void 0) { p = _M.x; }
+    }
 })(M || (M = {}));
 var M;
 (function (_M_1) {

tests/baselines/reference/collisionCodeGenModuleWithMethodChildren.js

@@ -39,7 +39,9 @@ var M;
     var c = (function () {
         function c() {
         }
-        c.prototype.fn = function (M, p) { };
+        c.prototype.fn = function (M, p) {
+            if (p === void 0) { p = _M.x; }
+        };
         return c;
     })();
 })(M || (M = {}));

tests/baselines/reference/collisionRestParameterFunction.js

@@ -56,10 +56,6 @@ function f3NoError() {
     var _i = 10; // no error
 }
 function f4(_i) {
-    var rest = [];
-    for (var _a = 1; _a < arguments.length; _a++) {
-        rest[_a - 1] = arguments[_a];
-    }
 }
 function f4NoError(_i) {
 }

tests/baselines/reference/collisionRestParameterFunctionExpressions.js

@@ -47,10 +47,6 @@ function foo() {
         var _i = 10; // no error
     }
     function f4(_i) {
-        var rest = [];
-        for (var _a = 1; _a < arguments.length; _a++) {
-            rest[_a - 1] = arguments[_a];
-        }
     }
     function f4NoError(_i) {
     }

tests/baselines/reference/contextualTyping.sourcemap.txt

@@ -2197,18 +2197,21 @@ sourceFile:contextualTyping.ts
 2 >         ^^^^
 3 >             ^
 4 >              ^
-5 >               ^^^^^
+5 >               ^^^^
+6 >                   ^
 1 >
   >function 
 2 >         c9t5
 3 >             (
 4 >              f: (n: number) => IFoo
-5 >               ) {}
+5 >               ) {
+6 >                   }
 1 >Emitted(87, 10) Source(146, 10) + SourceIndex(0)
 2 >Emitted(87, 14) Source(146, 14) + SourceIndex(0)
 3 >Emitted(87, 15) Source(146, 15) + SourceIndex(0)
 4 >Emitted(87, 16) Source(146, 37) + SourceIndex(0)
-5 >Emitted(87, 21) Source(146, 41) + SourceIndex(0)
+5 >Emitted(87, 20) Source(146, 40) + SourceIndex(0)
+6 >Emitted(87, 21) Source(146, 41) + SourceIndex(0)
 ---
 >>>;
 1 >