Throw when a required method in optional chain is not present (#1091)

* Throw when a required method is not present

* Add issue link to test

Author: Perryvw

src/lualib/OptionalMethodCall.ts

@@ -2,12 +2,15 @@ function __TS__OptionalMethodCall<TArgs extends any[], TReturn>(
     this: void,
     table: Record<string, (...args: [...TArgs]) => TReturn>,
     methodName: string,
+    isMethodOptional: boolean,
     ...args: [...TArgs]
 ): TReturn | undefined {
     if (table) {
         const method = table[methodName];
         if (method) {
             return method.call(table, ...args);
+        } else if (!isMethodOptional) {
+            throw `${methodName} is not a function`;
         }
     }
     return undefined;

src/transformation/visitors/call.ts

@@ -161,6 +161,7 @@ export function transformContextualCallExpression(
                 node,
                 table,
                 lua.createStringLiteral(left.name.text, left.name),
+                lua.createBooleanLiteral(node.questionDotToken !== undefined), // Require method is present if no ?.() call
                 ...transformArguments(context, args, signature)
             );
         } else {
@@ -331,7 +332,7 @@ function wrapIfRequired(
     shouldWrapInTable: boolean,
     shouldWrapOptional: boolean,
     call: lua.CallExpression | lua.MethodCallExpression,
-    node: ts.Node
+    node: ts.CallExpression
 ): lua.Expression {
     const wrappedOptional = shouldWrapOptional ? wrapOptionalCall(context, call, node) : call;
     return shouldWrapInTable ? wrapInTable(wrappedOptional) : wrappedOptional;
@@ -340,7 +341,7 @@ function wrapIfRequired(
 function wrapOptionalCall(
     context: TransformationContext,
     call: lua.CallExpression | lua.MethodCallExpression,
-    node: ts.Node
+    node: ts.CallExpression
 ): lua.CallExpression {
     if (lua.isMethodCallExpression(call)) {
         return transformLuaLibFunction(
@@ -349,6 +350,7 @@ function wrapOptionalCall(
             node,
             call.prefixExpression,
             lua.createStringLiteral(call.name.text),
+            lua.createBooleanLiteral(node.questionDotToken !== undefined), // Require method is present if no ?.() call
             ...call.params
         );
     } else {

test/unit/optionalChaining.spec.ts

@@ -144,8 +144,8 @@ describe("optional chaining function calls", () => {
             const objWithMethods: typeWithOptional = {};
             const objWithMethods2: typeWithOptional = { a: { b: { c: () => 4 } } };
 
-            return { 
-                expectNil: objWithMethods.a?.b.c(), 
+            return {
+                expectNil: objWithMethods.a?.b.c(),
                 expectFour: objWithMethods2.a?.b.c()
             };
         `.expectToMatchJsResult();
@@ -167,4 +167,12 @@ describe("optional chaining function calls", () => {
             return [obj.a?.().b.c?.() ?? "nil", obj2.a?.().b.c?.() ?? "nil", obj3.a?.().b.c?.() ?? "nil"];
         `.expectToMatchJsResult();
     });
+
+    // https://github.com/TypeScriptToLua/TypeScriptToLua/issues/1085
+    test("incorrect type, method is not a function", () => {
+        util.testFunction`
+            const obj: any = {};
+            obj?.foo();
+        `.expectToEqual(new util.ExecutionError("foo is not a function"));
+    });
 });