Merge pull request #3601 from Microsoft/emptyBindingPatternParam

Emit valid code when a parameter's binding pattern has no elements

Author: DanielRosenwasser

src/compiler/emitter.ts

@@ -3140,33 +3140,49 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
             function emitDefaultValueAssignments(node: FunctionLikeDeclaration) {
                 if (languageVersion < ScriptTarget.ES6) {
                     let tempIndex = 0;
-                    forEach(node.parameters, p => {
+                    forEach(node.parameters, parameter => {
                         // A rest parameter cannot have a binding pattern or an initializer,
                         // so let's just ignore it.
-                        if (p.dotDotDotToken) {
+                        if (parameter.dotDotDotToken) {
                             return;
                         }
 
-                        if (isBindingPattern(p.name)) {
-                            writeLine();
-                            write("var ");
-                            emitDestructuring(p, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex]);
-                            write(";");
-                            tempIndex++;
+                        let { name: paramName, initializer } = parameter;
+                        if (isBindingPattern(paramName)) {
+                            // In cases where a binding pattern is simply '[]' or '{}',
+                            // we usually don't want to emit a var declaration; however, in the presence
+                            // of an initializer, we must emit that expression to preserve side effects.
+                            let hasBindingElements = paramName.elements.length > 0;
+                            if (hasBindingElements || initializer) {
+                                writeLine();
+                                write("var ");
+
+                                if (hasBindingElements) {
+                                    emitDestructuring(parameter, /*isAssignmentExpressionStatement*/ false, tempParameters[tempIndex]);
+                                }
+                                else {
+                                    emit(tempParameters[tempIndex]);
+                                    write(" = ");
+                                    emit(initializer);
+                                }
+
+                                write(";");
+                                tempIndex++;
+                            }
                         }
-                        else if (p.initializer) {
+                        else if (initializer) {
                             writeLine();
-                            emitStart(p);
+                            emitStart(parameter);
                             write("if (");
-                            emitNodeWithoutSourceMap(p.name);
+                            emitNodeWithoutSourceMap(paramName);
                             write(" === void 0)");
-                            emitEnd(p);
+                            emitEnd(parameter);
                             write(" { ");
-                            emitStart(p);
-                            emitNodeWithoutSourceMap(p.name);
+                            emitStart(parameter);
+                            emitNodeWithoutSourceMap(paramName);
                             write(" = ");
-                            emitNodeWithoutSourceMap(p.initializer);
-                            emitEnd(p);
+                            emitNodeWithoutSourceMap(initializer);
+                            emitEnd(parameter);
                             write("; }");
                         }
                     });

src/compiler/utilities.ts

@@ -1065,7 +1065,7 @@ namespace ts {
         return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken;
     }
 
-    export function isBindingPattern(node: Node) {
+    export function isBindingPattern(node: Node): node is BindingPattern {
         return !!node && (node.kind === SyntaxKind.ArrayBindingPattern || node.kind === SyntaxKind.ObjectBindingPattern);
     }
 

tests/baselines/reference/declarationEmitDestructuring4.js

@@ -15,20 +15,16 @@ function baz4({} = { x: 10 }) { }
 // For an array binding pattern with empty elements,
 // we will not make any modification and will emit
 // the similar binding pattern users' have written
-function baz(_a) {
-    var ;
-}
+function baz(_a) { }
 function baz1(_a) {
-    var _b = _a === void 0 ? [1, 2, 3] : _a;
+    var _a = [1, 2, 3];
 }
 function baz2(_a) {
     var _b = (_a === void 0 ? [[1, 2, 3]] : _a)[0];
 }
-function baz3(_a) {
-    var ;
-}
+function baz3(_a) { }
 function baz4(_a) {
-    var _b = _a === void 0 ? { x: 10 } : _a;
+    var _a = { x: 10 };
 }
 
 

tests/baselines/reference/emptyArrayBindingPatternParameter01.js

@@ -0,0 +1,11 @@
+//// [emptyArrayBindingPatternParameter01.ts]
+
+
+function f([]) {
+	var x, y, z;
+}
+
+//// [emptyArrayBindingPatternParameter01.js]
+function f(_a) {
+    var x, y, z;
+}

tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts ===
+
+
+function f([]) {
+>f : Symbol(f, Decl(emptyArrayBindingPatternParameter01.ts, 0, 0))
+
+	var x, y, z;
+>x : Symbol(x, Decl(emptyArrayBindingPatternParameter01.ts, 3, 4))
+>y : Symbol(y, Decl(emptyArrayBindingPatternParameter01.ts, 3, 7))
+>z : Symbol(z, Decl(emptyArrayBindingPatternParameter01.ts, 3, 10))
+}

tests/baselines/reference/emptyArrayBindingPatternParameter01.types

@@ -0,0 +1,11 @@
+=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts ===
+
+
+function f([]) {
+>f : ([]: any[]) => void
+
+	var x, y, z;
+>x : any
+>y : any
+>z : any
+}

tests/baselines/reference/emptyArrayBindingPatternParameter02.js

@@ -0,0 +1,11 @@
+//// [emptyArrayBindingPatternParameter02.ts]
+
+
+function f(a, []) {
+    var x, y, z;
+}
+
+//// [emptyArrayBindingPatternParameter02.js]
+function f(a, _a) {
+    var x, y, z;
+}

tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols

@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts ===
+
+
+function f(a, []) {
+>f : Symbol(f, Decl(emptyArrayBindingPatternParameter02.ts, 0, 0))
+>a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 2, 11))
+
+    var x, y, z;
+>x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 3, 7))
+>y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 3, 10))
+>z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 3, 13))
+}

tests/baselines/reference/emptyArrayBindingPatternParameter02.types

@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts ===
+
+
+function f(a, []) {
+>f : (a: any, []: any[]) => void
+>a : any
+
+    var x, y, z;
+>x : any
+>y : any
+>z : any
+}

tests/baselines/reference/emptyArrayBindingPatternParameter03.js

@@ -0,0 +1,11 @@
+//// [emptyArrayBindingPatternParameter03.ts]
+
+
+function f(a, []) {
+    var x, y, z;
+}
+
+//// [emptyArrayBindingPatternParameter03.js]
+function f(a, _a) {
+    var x, y, z;
+}