TypeScriptToLua · Zamiell · May 20, 2021 · May 20, 2021 · May 20, 2021 · May 20, 2021
diff --git a/src/lualib/declarations/luatable.d.ts b/src/lualib/declarations/luatable.d.ts
@@ -3,4 +3,5 @@ declare class LuaTable<K extends {}, V> {
     public readonly length: number;
     public set(key: K, value: V | undefined): void;
     public get(key: K): V | undefined;
+    public has(key: K): boolean;
 }
diff --git a/src/transformation/utils/language-extensions.ts b/src/transformation/utils/language-extensions.ts
@@ -48,6 +48,8 @@ export enum ExtensionKind {
     TableGetMethodType = "TableGetMethodType",
     TableSetType = "TableSetType",
     TableSetMethodType = "TableSetMethodType",
+    TableHasType = "TableHasType",
+    TableHasMethodType = "TableHasMethodType",
 }
 
 const extensionKindToValueName: { [T in ExtensionKind]?: string } = {
@@ -103,6 +105,8 @@ const extensionKindToTypeBrand: { [T in ExtensionKind]: string } = {
     [ExtensionKind.TableGetMethodType]: "__luaTableGetMethodBrand",
     [ExtensionKind.TableSetType]: "__luaTableSetBrand",
     [ExtensionKind.TableSetMethodType]: "__luaTableSetMethodBrand",
+    [ExtensionKind.TableHasType]: "__luaTableHasBrand",
+    [ExtensionKind.TableHasMethodType]: "__luaTableHasMethodBrand",
 };
 
 export function isExtensionType(type: ts.Type, extensionKind: ExtensionKind): boolean {

diff --git a/src/transformation/visitors/call.ts b/src/transformation/visitors/call.ts
@@ -15,9 +15,11 @@ import { shouldMultiReturnCallBeWrapped } from "./language-extensions/multi";
 import { isOperatorMapping, transformOperatorMappingExpression } from "./language-extensions/operators";
 import {
     isTableGetCall,
+    isTableHasCall,
     isTableSetCall,
     transformTableGetExpression,
     transformTableSetExpression,
+    transformTableHasExpression,
 } from "./language-extensions/table";
 import { invalidTableSetExpression } from "../utils/diagnostics";
 import {
@@ -253,6 +255,10 @@ export const transformCallExpression: FunctionVisitor<ts.CallExpression> = (node
         );
     }
 
+    if (isTableHasCall(context, node)) {
+        return transformTableHasExpression(context, node);
+    }
+
     if (ts.isPropertyAccessExpression(node.expression)) {
         const result = transformPropertyCall(context, node as PropertyCallExpression);
         return wrapResult ? wrapInTable(result) : result;

diff --git a/src/transformation/visitors/language-extensions/table.ts b/src/transformation/visitors/language-extensions/table.ts
@@ -6,10 +6,15 @@ import { getFunctionTypeForCall } from "../../utils/typescript";
 import { assert } from "../../../utils";
 
 const tableGetExtensions = [extensions.ExtensionKind.TableGetType, extensions.ExtensionKind.TableGetMethodType];
-
 const tableSetExtensions = [extensions.ExtensionKind.TableSetType, extensions.ExtensionKind.TableSetMethodType];
+const tableHasExtensions = [extensions.ExtensionKind.TableHasType, extensions.ExtensionKind.TableHasMethodType];
 
-const tableExtensions = [extensions.ExtensionKind.TableNewType, ...tableGetExtensions, ...tableSetExtensions];
+const tableExtensions = [
+    extensions.ExtensionKind.TableNewType,
+    ...tableGetExtensions,
+    ...tableSetExtensions,
+    ...tableHasExtensions,
+];
 
 function getTableExtensionKindForCall(
     context: TransformationContext,
@@ -33,6 +38,10 @@ export function isTableSetCall(context: TransformationContext, node: ts.CallExpr
     return getTableExtensionKindForCall(context, node, tableSetExtensions) !== undefined;
 }
 
+export function isTableHasCall(context: TransformationContext, node: ts.CallExpression) {
+    return getTableExtensionKindForCall(context, node, tableHasExtensions) !== undefined;
+}
+
 export function isTableNewCall(context: TransformationContext, node: ts.NewExpression) {
     const type = context.checker.getTypeAtLocation(node.expression);
     return extensions.isExtensionType(type, extensions.ExtensionKind.TableNewType);
@@ -78,3 +87,22 @@ export function transformTableSetExpression(context: TransformationContext, node
         context.transformExpression(args[2])
     );
 }
+
+export function transformTableHasExpression(context: TransformationContext, node: ts.CallExpression): lua.Statement {
+    const extensionKind = getTableExtensionKindForCall(context, node, tableSetExtensions);
+    assert(extensionKind);
+
+    const args = node.arguments.slice();
+    if (
+        args.length === 1 &&
+        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))
+    ) {
+        args.unshift(node.expression.expression);
+    }
+
+    return lua.createTableIndexExpression(
+        context.transformExpression(args[0]),
+        context.transformExpression(args[1]),
+        node
+    );
+}
diff --git a/src/transformation/visitors/lua-table.ts b/src/transformation/visitors/lua-table.ts
@@ -37,6 +37,15 @@ function validateLuaTableCall(
                 );
             }
             break;
+
+        case "has": {
+            if (callArguments.length !== 1) {
+                context.diagnostics.push(
+                    luaTableForbiddenUsage(node, `Expected 1 arguments, but got ${callArguments.length}`)
+                );
+            }
+            break;
+        }
     }
 }
 
@@ -56,17 +65,22 @@ export function transformLuaTableExpressionStatement(
     validateLuaTableCall(context, expression, methodName, expression.arguments);
     const signature = context.checker.getResolvedSignature(expression);
     const params = transformArguments(context, expression.arguments, signature);
+    const tableIndexExpression = lua.createTableIndexExpression(
+        luaTable,
+        params[0] ?? lua.createNilLiteral(),
+        expression
+    );
 
     switch (methodName) {
         case "get":
             return lua.createVariableDeclarationStatement(
                 lua.createAnonymousIdentifier(expression),
-                lua.createTableIndexExpression(luaTable, params[0] ?? lua.createNilLiteral(), expression),
+                tableIndexExpression,
                 expression
             );
         case "set":
             return lua.createAssignmentStatement(
-                lua.createTableIndexExpression(luaTable, params[0] ?? lua.createNilLiteral(), expression),
+                tableIndexExpression,
                 [params[1] ?? lua.createNilLiteral()],
                 expression
             );
@@ -93,6 +107,8 @@ export function transformLuaTableCallExpression(
     switch (methodName) {
         case "get":
             return lua.createTableIndexExpression(luaTable, params[0] ?? lua.createNilLiteral(), node);
+        case "has":
+            return lua.createBinaryExpression(luaTable, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
         default:
             context.diagnostics.push(unsupportedProperty(node.expression.name, "LuaTable", methodName));
     }

diff --git a/test/unit/annotations/luaTable.spec.ts b/test/unit/annotations/luaTable.spec.ts
@@ -145,6 +145,7 @@ test.each([tableLibClass])("LuaTable functional tests", tableLib => {
         ["const t = new Table(); t.set(1, true); return t.length", 1],
         ["const t = new Table(); t.set(t.length + 1, true); t.set(t.length + 1, true); return t.length", 2],
         ['const k = "k"; const t = { data: new Table() }; t.data.set(k, 3); return t.data.get(k);', 3],
+        ['const t = new Table(); t.set("foo", "bar"); return t.has("foo");', "bar"],
     ])("LuaTable test (%p)", (code, expectedReturnValue) => {
         util.testFunction(code).setTsHeader(tableLib).expectToEqual(expectedReturnValue);
     });