TypeScriptToLua
diff --git a/‎src/transformation/transformers/literal.ts‎
Lines changed: 5 additions & 1 deletion b/‎src/transformation/transformers/literal.ts‎
Lines changed: 5 additions & 1 deletion
diff --git a/‎src/transformation/transformers/todo-move-somewhere.ts‎
Lines changed: 1 addition & 30 deletions b/‎src/transformation/transformers/todo-move-somewhere.ts‎
Lines changed: 1 addition & 30 deletions
diff --git a/‎src/transformation/transformers/variable.ts‎
Lines changed: 1 addition & 1 deletion b/‎src/transformation/transformers/variable.ts‎
Lines changed: 1 addition & 1 deletion
@@ -128,7 +128,11 @@ const transformObjectLiteralExpression: FunctionVisitor<ts.ObjectLiteralExpressi
 
 const transformArrayLiteralExpression: FunctionVisitor<ts.ArrayLiteralExpression> = (expression, context) => {
     const values = expression.elements.map(element =>
-        lua.createTableFieldExpression(context.transformExpression(element), undefined, element)
+        lua.createTableFieldExpression(
+            ts.isOmittedExpression(element) ? lua.createNilLiteral(element) : context.transformExpression(element),
+            undefined,
+            element
+        )
     );
 
     return lua.createTableExpression(values, expression);
 
@@ -2,7 +2,6 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, Visitors } from "../context";
 import { validateAssignment } from "../utils/assignment-validation";
-import { isInDestructingAssignment } from "../utils/typescript";
 
 const transformAssertionExpression: FunctionVisitor<ts.AssertionExpression> = (expression, context) => {
     if (!ts.isConstTypeReference(expression.type)) {
@@ -17,43 +16,15 @@ const transformAssertionExpression: FunctionVisitor<ts.AssertionExpression> = (e
     return context.transformExpression(expression.expression);
 };
 
-function isWithinLiteralAssignmentStatement(node: ts.Node): boolean {
-    if (!node.parent) {
-        return false;
-    }
-
-    if (
-        ts.isArrayLiteralExpression(node.parent) ||
-        ts.isArrayBindingPattern(node.parent) ||
-        ts.isObjectLiteralExpression(node.parent)
-    ) {
-        return isWithinLiteralAssignmentStatement(node.parent);
-    } else if (isInDestructingAssignment(node)) {
-        return true;
-    } else if (ts.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-        return true;
-    } else {
-        return false;
-    }
-}
-
-// TODO: Consider handling without a visitor since it depends on context too much
-const transformOmittedExpression: FunctionVisitor<ts.OmittedExpression> = node => {
-    const isWithinBindingAssignmentStatement = isWithinLiteralAssignmentStatement(node);
-    return isWithinBindingAssignmentStatement ? lua.createAnonymousIdentifier() : lua.createNilLiteral(node);
-};
-
 export const todoMoveSomewhereVisitors: Visitors = {
-    [ts.SyntaxKind.EmptyStatement]: () => undefined,
-    [ts.SyntaxKind.OmittedExpression]: transformOmittedExpression,
-
     [ts.SyntaxKind.TypeAliasDeclaration]: () => undefined,
     [ts.SyntaxKind.InterfaceDeclaration]: () => undefined,
 
     [ts.SyntaxKind.NonNullExpression]: (node, context) => context.transformExpression(node.expression),
     [ts.SyntaxKind.AsExpression]: transformAssertionExpression,
     [ts.SyntaxKind.TypeAssertionExpression]: transformAssertionExpression,
 
+    [ts.SyntaxKind.EmptyStatement]: () => undefined,
     [ts.SyntaxKind.ParenthesizedExpression]: (node, context) =>
         lua.createParenthesizedExpression(context.transformExpression(node.expression), node),
 };
@@ -16,7 +16,7 @@ export function transformArrayBindingElement(
     name: ts.ArrayBindingElement | ts.Expression
 ): lua.Expression {
     if (ts.isOmittedExpression(name)) {
-        return context.transformExpression(name);
+        return lua.createAnonymousIdentifier(name);
     } else if (ts.isIdentifier(name)) {
         return transformIdentifier(context, name);
     } else if (ts.isBindingElement(name) && ts.isIdentifier(name.name)) {