TypeScriptToLua
diff --git a/‎…nsformation/utils/annotations/collect.ts‎ ‎src/transformation/utils/annotations.ts‎src/transformation/utils/annotations/collect.ts renamed to src/transformation/utils/annotations.ts
Lines changed: 76 additions & 2 deletions b/‎…nsformation/utils/annotations/collect.ts‎ ‎src/transformation/utils/annotations.ts‎src/transformation/utils/annotations/collect.ts renamed to src/transformation/utils/annotations.ts
Lines changed: 76 additions & 2 deletions
diff --git a/‎src/transformation/utils/annotations/index.ts‎
Lines changed: 0 additions & 2 deletions b/‎src/transformation/utils/annotations/index.ts‎
Lines changed: 0 additions & 2 deletions
diff --git a/‎src/transformation/utils/annotations/utils.ts‎
Lines changed: 0 additions & 77 deletions b/‎src/transformation/utils/annotations/utils.ts‎
Lines changed: 0 additions & 77 deletions
@@ -1,6 +1,7 @@
 import * as ts from "typescript";
-import { flatMap } from "../../../utils";
-import { TransformationContext } from "../../context";
+import { flatMap } from "../../utils";
+import { TransformationContext } from "../context";
+import { findFirstNodeAbove, inferAssignedType } from "./typescript";
 
 export enum AnnotationKind {
     Extension = "extension",
@@ -129,3 +130,76 @@ export function getSignatureAnnotations(context: TransformationContext, signatur
 
     return annotationsMap;
 }
+
+export function isTupleReturnCall(context: TransformationContext, node: ts.Node): boolean {
+    if (!ts.isCallExpression(node)) {
+        return false;
+    }
+
+    const signature = context.checker.getResolvedSignature(node);
+    if (signature) {
+        if (getSignatureAnnotations(context, signature).has(AnnotationKind.TupleReturn)) {
+            return true;
+        }
+
+        // Only check function type for directive if it is declared as an interface or type alias
+        const declaration = signature.getDeclaration();
+        const isInterfaceOrAlias =
+            declaration &&
+            declaration.parent &&
+            ((ts.isInterfaceDeclaration(declaration.parent) && ts.isCallSignatureDeclaration(declaration)) ||
+                ts.isTypeAliasDeclaration(declaration.parent));
+        if (!isInterfaceOrAlias) {
+            return false;
+        }
+    }
+
+    const type = context.checker.getTypeAtLocation(node.expression);
+    return getTypeAnnotations(context, type).has(AnnotationKind.TupleReturn);
+}
+
+export function isInTupleReturnFunction(context: TransformationContext, node: ts.Node): boolean {
+    const declaration = findFirstNodeAbove(node, ts.isFunctionLike);
+    if (!declaration) {
+        return false;
+    }
+
+    let functionType: ts.Type | undefined;
+    if (ts.isFunctionExpression(declaration) || ts.isArrowFunction(declaration)) {
+        functionType = inferAssignedType(context, declaration);
+    } else if (ts.isMethodDeclaration(declaration) && ts.isObjectLiteralExpression(declaration.parent)) {
+        // Manually lookup type for object literal properties declared with method syntax
+        const interfaceType = inferAssignedType(context, declaration.parent);
+        const propertySymbol = interfaceType.getProperty(declaration.name.getText());
+        if (propertySymbol) {
+            functionType = context.checker.getTypeOfSymbolAtLocation(propertySymbol, declaration);
+        }
+    }
+
+    if (functionType === undefined) {
+        functionType = context.checker.getTypeAtLocation(declaration);
+    }
+
+    // Check all overloads for directive
+    const signatures = functionType.getCallSignatures();
+    if (signatures && signatures.some(s => getSignatureAnnotations(context, s).has(AnnotationKind.TupleReturn))) {
+        return true;
+    }
+
+    return getTypeAnnotations(context, functionType).has(AnnotationKind.TupleReturn);
+}
+
+export function isLuaIteratorType(context: TransformationContext, node: ts.Node): boolean {
+    const type = context.checker.getTypeAtLocation(node);
+    return getTypeAnnotations(context, type).has(AnnotationKind.LuaIterator);
+}
+
+export function isVarArgType(context: TransformationContext, node: ts.Node): boolean {
+    const type = context.checker.getTypeAtLocation(node);
+    return getTypeAnnotations(context, type).has(AnnotationKind.VarArg);
+}
+
+export function isForRangeType(context: TransformationContext, node: ts.Node): boolean {
+    const type = context.checker.getTypeAtLocation(node);
+    return getTypeAnnotations(context, type).has(AnnotationKind.ForRange);
+}