Merge branch 'master' into ts-to-lua-ast

Perryvw · Perryvw · commit 6ac05e21345d · 2019-01-21T22:11:12.000+01:00
# Conflicts:
#	src/Errors.ts
#	src/Transpiler.ts
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -1679,16 +1679,23 @@ export class LuaTransformer {
     }
 
     public transformAssignment(lhs: ts.Expression, right: tstl.Expression): tstl.Statement {
-        if (ts.isPropertyAccessExpression(lhs) && tsHelper.hasSetAccessor(lhs, this.checker)) {
-            return tstl.createExpressionStatement(this.transformSetAccessor(lhs, right), undefined, lhs.parent);
-        } else {
-            return tstl.createAssignmentStatement(
-                this.transformExpression(lhs) as tstl.IdentifierOrTableIndexExpression,
-                right,
-                undefined,
-                lhs.parent
-            );
+        if (ts.isPropertyAccessExpression(lhs)) {
+            const hasSetAccessor = tsHelper.hasSetAccessor(lhs, this.checker);
+            if (hasSetAccessor) {
+                return tstl.createExpressionStatement(this.transformSetAccessor(lhs, right), undefined, lhs.parent);
+            } else if (hasSetAccessor === undefined) {
+                // Undefined hasSetAccessor indicates a union with both set accessors and no accessors
+                // on the same field.
+                throw TSTLErrors.UnsupportedUnionAccessor(lhs);
+            }
         }
+
+        return tstl.createAssignmentStatement(
+            this.transformExpression(lhs) as tstl.IdentifierOrTableIndexExpression,
+            right,
+            undefined,
+            lhs.parent
+        );
     }
 
     public transformAssignmentStatement(expression: ts.BinaryExpression): tstl.Statement {
@@ -2495,8 +2502,12 @@ export class LuaTransformer {
     public transformPropertyAccessExpression(node: ts.PropertyAccessExpression): tstl.Expression {
         const property = node.name.text;
 
-        if (tsHelper.hasGetAccessor(node, this.checker)) {
+        const hasGetAccessor = tsHelper.hasGetAccessor(node, this.checker);
+        if (hasGetAccessor) {
             return this.transformGetAccessor(node);
+        } else if (hasGetAccessor === undefined) {
+            // Undefined hasGetAccessor indicates a union with both get accessors and no accessors on the same field.
+            throw TSTLErrors.UnsupportedUnionAccessor(node);
         }
 
         // Check for primitive types to override
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -268,11 +268,22 @@ export class TSHelper {
         }
     }
 
-    public static hasGetAccessor(node: ts.Node, checker: ts.TypeChecker): boolean {
+    public static typeHasGetAccessor(type: ts.Type, name: ts.__String, checker: ts.TypeChecker): boolean | undefined {
+        if (type.isUnion()) {
+            if (type.types.some(t => this.typeHasGetAccessor(t, name, checker))) {
+                // undefined if only a subset of types implements the accessor
+                return type.types.every(t => this.typeHasGetAccessor(t, name, checker)) ? true : undefined;
+            }
+            return false;
+        }
+        return this.forTypeOrAnySupertype(type, checker, t => this.hasExplicitGetAccessor(t, name));
+    }
+
+    public static hasGetAccessor(node: ts.Node, checker: ts.TypeChecker): boolean | undefined {
         if (ts.isPropertyAccessExpression(node)) {
             const name = node.name.escapedText;
             const type = checker.getTypeAtLocation(node.expression);
-            return this.forTypeOrAnySupertype(type, checker, t => this.hasExplicitGetAccessor(t, name));
+            return this.typeHasGetAccessor(type, name, checker);
         }
         return false;
     }
@@ -284,11 +295,22 @@ export class TSHelper {
         }
     }
 
+    public static typeHasSetAccessor(type: ts.Type, name: ts.__String, checker: ts.TypeChecker): boolean | undefined {
+        if (type.isUnion()) {
+            if (type.types.some(t => this.typeHasSetAccessor(t, name, checker))) {
+                // undefined if only a subset of types implements the accessor
+                return type.types.every(t => this.typeHasSetAccessor(t, name, checker)) ? true : undefined;
+            }
+            return false;
+        }
+        return this.forTypeOrAnySupertype(type, checker, t => this.hasExplicitSetAccessor(t, name));
+    }
+
     public static hasSetAccessor(node: ts.Node, checker: ts.TypeChecker): boolean {
         if (ts.isPropertyAccessExpression(node)) {
             const name = node.name.escapedText;
             const type = checker.getTypeAtLocation(node.expression);
-            return this.forTypeOrAnySupertype(type, checker, t => this.hasExplicitSetAccessor(t, name));
+            return this.typeHasSetAccessor(type, name, checker);
         }
         return false;
     }
diff --git a/src/TSTLErrors.ts b/src/TSTLErrors.ts
@@ -65,6 +65,9 @@ export class TSTLErrors {
     public static UnsupportedObjectLiteralElement = (elementKind: ts.SyntaxKind, node: ts.Node) =>
         new TranspileError(`Unsupported object literal element: ${elementKind}.`, node);
 
+    public static UnsupportedUnionAccessor = (node: ts.Node) =>
+        new TranspileError(`Unsupported mixed union of accessor and non-accessor types for the same property.`, node);
+
     public static UnsupportedFunctionConversion = (node: ts.Node, name?: string) => {
         if (name) {
             return new TranspileError(
diff --git a/test/unit/expressions.spec.ts b/test/unit/expressions.spec.ts
@@ -310,6 +310,34 @@ export class ExpressionTests {
         Expect(result).toBe(expected);
     }
 
+    @TestCase("return x.value;", 1)
+    @TestCase("x.value = 3; return x.value;", 3)
+    @Test("Union accessors")
+    public unionAccessors(expression: string, expected: any): void {
+        const result = util.transpileAndExecute(
+            `class A{ get value(){ return this.v || 1; } set value(v){ this.v = v; } v: number; }
+            class B{ get value(){ return this.v || 2; } set value(v){ this.v = v; } v: number; }
+            let x: A|B = new A();
+            ${expression}`
+        );
+
+        Expect(result).toBe(expected);
+    }
+
+    @TestCase("x.value = 3;")
+    @TestCase("return x.value;")
+    @Test("Unsupported Union accessors")
+    public unsupportedUnionAccessors(expression: string): void {
+        const source = `class A{ get value(){ return 1; } }
+                        class B{ value:number = 3; }
+                        let x: A|B = new A();
+                        ${expression}`;
+        Expect(() => { util.transpileString(source); }).toThrowError(
+            TranspileError,
+            "Unsupported mixed union of accessor and non-accessor types for the same property."
+        );
+    }
+
     @TestCase("i++", 10)
     @TestCase("i--", 10)
     @TestCase("++i", 11)
