false default binding pattern values (#538)

hazzard993 · Perryvw · commit 247cebaded56 · 2019-04-28T16:19:50.000+02:00
* false default binding pattern values

* Tidied up tests

* Added array binding pattern default test

* Array binding pattern default parameters
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -1370,14 +1370,26 @@ export class LuaTransformer {
                     const expression = isObjectBindingPattern
                         ? tstl.createTableIndexExpression(tableExpression, tstl.createStringLiteral(propertyName.text))
                         : tstl.createTableIndexExpression(tableExpression, tstl.createNumericLiteral(index + 1));
+                    yield* this.createLocalOrExportedOrGlobalDeclaration(variableName, expression);
                     if (element.initializer) {
-                        const defaultExpression = tstl.createBinaryExpression(expression,
-                            this.expectExpression(this.transformExpression(element.initializer)),
-                            tstl.SyntaxKind.OrOperator
+                        const identifier = this.shouldExportIdentifier(variableName)
+                            ? this.createExportedIdentifier(variableName)
+                            : variableName;
+                        yield tstl.createIfStatement(
+                            tstl.createBinaryExpression(
+                                identifier,
+                                tstl.createNilLiteral(),
+                                tstl.SyntaxKind.EqualityOperator
+                            ),
+                            tstl.createBlock(
+                                [
+                                    tstl.createAssignmentStatement(
+                                        identifier,
+                                        this.transformExpression(element.initializer)
+                                    ),
+                                ]
+                            )
                         );
-                        yield* this.createLocalOrExportedOrGlobalDeclaration(variableName, defaultExpression);
-                    } else {
-                        yield* this.createLocalOrExportedOrGlobalDeclaration(variableName, expression);
                     }
                 }
             }
@@ -1802,6 +1814,8 @@ export class LuaTransformer {
         } else if (ts.isArrayBindingPattern(statement.name) || ts.isObjectBindingPattern(statement.name)) {
             // Destructuring types
 
+            const statements: tstl.Statement[] = [];
+
             // For nested bindings and object bindings, fall back to transformBindingPattern
             if (ts.isObjectBindingPattern(statement.name)
                 || statement.name.elements.some(elem => !ts.isBindingElement(elem) || !ts.isIdentifier(elem.name))) {
@@ -1835,26 +1849,58 @@ export class LuaTransformer {
             // Don't unpack TupleReturn decorated functions
             if (statement.initializer) {
                 if (tsHelper.isTupleReturnCall(statement.initializer, this.checker)) {
-                    return this.createLocalOrExportedOrGlobalDeclaration(
-                        vars,
-                        this.transformExpression(statement.initializer),
-                        statement
+                    statements.push(
+                        ...this.createLocalOrExportedOrGlobalDeclaration(
+                            vars,
+                            this.transformExpression(statement.initializer),
+                            statement
+                        )
                     );
                 } else {
                     // local vars = this.transpileDestructingAssignmentValue(node.initializer);
                     const initializer = this.createUnpackCall(
                         this.expectExpression(this.transformExpression(statement.initializer)),
                         statement.initializer
                     );
-                    return this.createLocalOrExportedOrGlobalDeclaration(vars, initializer, statement);
+                    statements.push(...this.createLocalOrExportedOrGlobalDeclaration(vars, initializer, statement));
                 }
             } else {
-                return this.createLocalOrExportedOrGlobalDeclaration(
-                    vars,
-                    tstl.createNilLiteral(),
-                    statement
+                statements.push(
+                    ...this.createLocalOrExportedOrGlobalDeclaration(
+                        vars,
+                        tstl.createNilLiteral(),
+                        statement
+                    )
                 );
             }
+
+            statement.name.elements.forEach(element => {
+                if (!ts.isOmittedExpression(element) && element.initializer) {
+                    const variableName = this.transformIdentifier(element.name as ts.Identifier);
+                    const identifier = this.shouldExportIdentifier(variableName)
+                        ? this.createExportedIdentifier(variableName)
+                        : variableName;
+                    statements.push(
+                        tstl.createIfStatement(
+                            tstl.createBinaryExpression(
+                                identifier,
+                                tstl.createNilLiteral(),
+                                tstl.SyntaxKind.EqualityOperator
+                            ),
+                            tstl.createBlock(
+                                [
+                                    tstl.createAssignmentStatement(
+                                        identifier,
+                                        this.transformExpression(element.initializer)
+                                    ),
+                                ]
+                            )
+                        )
+                    );
+                }
+            });
+
+            return statements;
         }
     }
 
diff --git a/test/unit/bindingpatterns.spec.ts b/test/unit/bindingpatterns.spec.ts
@@ -90,3 +90,22 @@ test.each(testCases)(
         expect(result).toBe(true);
     },
 );
+
+test.each([
+    { bindingString: "{x, y = true}", objectString: "{x: false, y: false}", returnVariable: "y" },
+    {
+        bindingString: "{x, y: [z = true]}",
+        objectString: "{x: false, y: [false]}",
+        returnVariable: "z",
+    },
+    { bindingString: "[x = true]", objectString: "[false]", returnVariable: "x" },
+])(
+    "Binding patterns handle false correctly (%p)",
+    ({ bindingString, objectString, returnVariable }) => {
+        const result = util.transpileExecuteAndReturnExport(
+            `export const ${bindingString} = ${objectString};`,
+            returnVariable,
+        );
+        expect(result).toBe(false);
+    },
+);
