Merge branch 'master' into ts-to-lua-ast (#329)

tomblind · web-flow · commit 273a54b96dd1 · 2019-01-09T13:17:28.000-07:00
* fixed compiler crash when unable to determine signature of function… (#321) * fixed compiler crash when unable to determine signature of function argument when passing a function expression * added test * Validation crash fix (#326) * fix for crash when validating assignments of arrays/tuples * added re-assignment code to tuple return test * added new tuple assignment test and fixed others * changed static methods and lambda-properties to take a context parameter by default (#322)
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -2427,13 +2427,23 @@ export class LuaTransformer {
             }
         }
 
-        const fromTypeReference = fromType as ts.TypeReference;
-        const toTypeReference = toType as ts.TypeReference;
-        if (fromTypeReference.typeArguments && toTypeReference.typeArguments) {
-            // Recurse into tuples/arrays
-            toTypeReference.typeArguments.forEach((t, i) => {
-                this.validateFunctionAssignment(node, fromTypeReference.typeArguments[i], t, toName);
-            });
+        const fromTypeNode = this.checker.typeToTypeNode(fromType);
+        const toTypeNode = this.checker.typeToTypeNode(toType);
+
+        if ((ts.isArrayTypeNode(toTypeNode) || ts.isTupleTypeNode(toTypeNode))
+            && (ts.isArrayTypeNode(fromTypeNode) || ts.isTupleTypeNode(fromTypeNode))) {
+            // Recurse into arrays/tuples
+            const fromTypeReference = fromType as ts.TypeReference;
+            const toTypeReference = toType as ts.TypeReference;
+            const count = Math.min(fromTypeReference.typeArguments.length, toTypeReference.typeArguments.length);
+            for (let i = 0; i < count; ++i) {
+                this.validateFunctionAssignment(
+                    node,
+                    fromTypeReference.typeArguments[i],
+                    toTypeReference.typeArguments[i],
+                    toName
+                );
+            }
         }
 
         if ((toType.flags & ts.TypeFlags.Object) !== 0 && ((toType as ts.ObjectType).objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0 &&
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -382,7 +382,9 @@ export class TSHelper {
                     if (i >= 0) {
                         const parentSignature = checker.getResolvedSignature(signatureDeclaration.parent);
                         const parentSignatureDeclaration = parentSignature.getDeclaration();
-                        declType = checker.getTypeAtLocation(parentSignatureDeclaration.parameters[i]);
+                        if (parentSignatureDeclaration) {
+                            declType = checker.getTypeAtLocation(parentSignatureDeclaration.parameters[i]);
+                        }
                     }
                 } else if (ts.isReturnStatement(signatureDeclaration.parent)) {
                     declType = this.getContainingFunctionReturnType(signatureDeclaration.parent, checker);
@@ -409,15 +411,14 @@ export class TSHelper {
             // Explicit 'this'
             return thisParameter.type && thisParameter.type.kind === ts.SyntaxKind.VoidKeyword ? ContextType.Void : ContextType.NonVoid;
         }
-        if ((ts.isMethodDeclaration(signatureDeclaration) || ts.isMethodSignature(signatureDeclaration)) &&
-            !(ts.getCombinedModifierFlags(signatureDeclaration) & ts.ModifierFlags.Static)) {
-            // Non-static method
+        if (ts.isMethodDeclaration(signatureDeclaration) || ts.isMethodSignature(signatureDeclaration)) {
+            // Method
             return ContextType.NonVoid;
         }
-        if ((ts.isPropertySignature(signatureDeclaration.parent) || ts.isPropertyDeclaration(signatureDeclaration.parent) ||
-             ts.isPropertyAssignment(signatureDeclaration.parent)) &&
-            !(ts.getCombinedModifierFlags(signatureDeclaration.parent) & ts.ModifierFlags.Static)) {
-            // Non-static lambda property
+        if (ts.isPropertySignature(signatureDeclaration.parent)
+            || ts.isPropertyDeclaration(signatureDeclaration.parent)
+            || ts.isPropertyAssignment(signatureDeclaration.parent)) {
+            // Lambda property
             return ContextType.NonVoid;
         }
         if (ts.isBinaryExpression(signatureDeclaration.parent)) {
diff --git a/test/translation/lua/namespaceMerge.lua b/test/translation/lua/namespaceMerge.lua
@@ -9,10 +9,10 @@ end
 end
 function MergedClass.constructor(self)
 end
-function MergedClass.staticMethodA()
+function MergedClass.staticMethodA(self)
 end
-function MergedClass.staticMethodB()
-    self.staticMethodA();
+function MergedClass.staticMethodB(self)
+    self:staticMethodA();
 end
 function MergedClass.methodA(self)
 end
@@ -29,5 +29,5 @@ end
 local mergedClass = MergedClass.new(true);
 mergedClass:methodB();
 mergedClass:propertyFunc();
-MergedClass.staticMethodB();
+MergedClass:staticMethodB();
 MergedClass.namespaceFunc();
diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
