Skip to content

properly handling bitwise operators #331

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
tomblind merged 4 commits into from
Jan 11, 2019
Merged

properly handling bitwise operators #331

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
76b6c22
properly handling bitwise operators and passing original nodes in som…
tomblind Jan 10, 2019
e5af7dd
Fixes and cleanup
tomblind Jan 10, 2019
cdff2e0
moved bitop handling properly into transformer
tomblind Jan 11, 2019
762c0ee
broke lua52/luajit bitops out to their own functions
tomblind Jan 11, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 9 additions & 3 deletions src/LuaAST.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -71,20 +71,26 @@ export enum SyntaxKind {
BitwiseOrOperator,
BitwiseExclusiveOrOperator,
BitwiseRightShiftOperator,
BitwiseArithmeticRightShift,
BitwiseLeftShiftOperator,
BitwiseNotOperator, // Unary
}

// TODO maybe name this PrefixUnary? not sure it makes sense to do so, because all unary ops in Lua are prefix
export type UnaryOperator = SyntaxKind.NegationOperator | SyntaxKind.LengthOperator | SyntaxKind.NotOperator | SyntaxKind.BitwiseNotOperator;
export type UnaryBitwiseOperator = SyntaxKind.BitwiseNotOperator;

export type UnaryOperator = SyntaxKind.NegationOperator | SyntaxKind.LengthOperator | SyntaxKind.NotOperator | UnaryBitwiseOperator;

export type BinaryBitwiseOperator =
SyntaxKind.BitwiseAndOperator | SyntaxKind.BitwiseOrOperator | SyntaxKind.BitwiseExclusiveOrOperator |
SyntaxKind.BitwiseRightShiftOperator | SyntaxKind.BitwiseArithmeticRightShift | SyntaxKind.BitwiseLeftShiftOperator;

export type BinaryOperator =
SyntaxKind.AdditionOperator | SyntaxKind.SubractionOperator | SyntaxKind.MultiplicationOperator | SyntaxKind.DivisionOperator |
SyntaxKind.FloorDivisionOperator | SyntaxKind.ModuloOperator | SyntaxKind.PowerOperator | SyntaxKind.ConcatOperator |
SyntaxKind.EqualityOperator | SyntaxKind.InequalityOperator | SyntaxKind.LessThanOperator | SyntaxKind.LessEqualOperator |
SyntaxKind.GreaterThanOperator | SyntaxKind.GreaterEqualOperator | SyntaxKind.AndOperator | SyntaxKind.OrOperator |
SyntaxKind.BitwiseAndOperator | SyntaxKind.BitwiseOrOperator | SyntaxKind.BitwiseExclusiveOrOperator |
SyntaxKind.BitwiseRightShiftOperator | SyntaxKind.BitwiseLeftShiftOperator | SyntaxKind.BitwiseNotOperator;
BinaryBitwiseOperator;

export type Operator = UnaryOperator | BinaryOperator;

Expand Down
3 changes: 2 additions & 1 deletion src/LuaPrinter.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,6 +31,7 @@ export class LuaPrinter {
[tstl.SyntaxKind.BitwiseOrOperator]: "|",
[tstl.SyntaxKind.BitwiseExclusiveOrOperator]: "~",
[tstl.SyntaxKind.BitwiseRightShiftOperator]: ">>",
[tstl.SyntaxKind.BitwiseArithmeticRightShift]: ">>>",
[tstl.SyntaxKind.BitwiseLeftShiftOperator]: "<<",
[tstl.SyntaxKind.BitwiseNotOperator]: "~",
};
Expand All @@ -57,7 +58,7 @@ export class LuaPrinter {
|| this.options.luaLibImport === LuaLibImportKind.Always)
{
header += `require("lualib_bundle");\n`;
}
}
// Inline lualib features
else if (this.options.luaLibImport === LuaLibImportKind.Inline && luaLibFeatures.size > 0)
{
Expand Down
294 changes: 240 additions & 54 deletions src/LuaTransformer.ts
View file
Open in desktop

Large diffs are not rendered by default.

20 changes: 1 addition & 19 deletions src/TSHelper.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -293,30 +293,12 @@ export class TSHelper {
case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
return [true, tstl.SyntaxKind.BitwiseRightShiftOperator];
case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
// return [true, ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken];
throw new Error("Not yet implemented in lua AST"); // TODO
return [true, tstl.SyntaxKind.BitwiseArithmeticRightShift];
}

return [false, undefined];
}

public static isCompoundPrefixUnaryOperator(node: ts.PrefixUnaryExpression): boolean {
return node.operator !== ts.SyntaxKind.ExclamationToken && node.operator !== ts.SyntaxKind.MinusToken &&
node.operator !== ts.SyntaxKind.PlusToken && node.operator !== ts.SyntaxKind.TildeToken;
}

public static getUnaryCompoundAssignmentOperator(node: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression): ts.BinaryOperator {
switch (node.operator) {
case ts.SyntaxKind.PlusPlusToken:
return ts.SyntaxKind.PlusToken;
case ts.SyntaxKind.MinusMinusToken:
return ts.SyntaxKind.MinusToken;
default:
throw TSTLErrors.UnsupportedKind(
`unary ${ts.isPrefixUnaryExpression(node) ? "prefix" : "postfix"} operator`, node.operator, node);
}
}

public static isExpressionStatement(node: ts.Expression): boolean {
return node.parent === undefined || ts.isExpressionStatement(node.parent) || ts.isForStatement(node.parent);
}
Expand Down
39 changes: 1 addition & 38 deletions src/targets/LuaTransformer.52.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
import * as ts from "typescript";

import * as tstl from "../LuaAST";
import {LuaTransformer, StatementVisitResult, ScopeType} from "../LuaTransformer";
import {ExpressionVisitResult, StatementVisitResult, ScopeType} from "../LuaTransformer";
import {TSHelper as tsHelper} from "../TSHelper";
import { LuaTransformer51 } from "./LuaTransformer.51";

Expand Down Expand Up @@ -31,13 +31,6 @@ export class LuaTransformer52 extends LuaTransformer51
);
}

/** @override */
public createUnpackCall(expression: tstl.Expression): tstl.Expression {
return tstl.createCallExpression(
tstl.createTableIndexExpression(tstl.createIdentifier("table"), tstl.createStringLiteral("unpack")),
[expression]);
}

// /** @override */
// public transpileBreak(node: ts.BreakStatement): string {
// const topScope = this.peekSpecialScope();
Expand All @@ -49,36 +42,6 @@ export class LuaTransformer52 extends LuaTransformer51
// }
// }

// /** @override */
// public transpileUnaryBitOperation(node: ts.PrefixUnaryExpression, operand: string): string {
// switch (node.operator) {
// case ts.SyntaxKind.TildeToken:
// return `bit32.bnot(${operand})`;
// default:
// throw TSTLErrors.UnsupportedKind("bitwise operator", node.operator, node);
// }
// }

// /** @override */
// public transpileBitOperation(node: ts.BinaryExpression, lhs: string, rhs: string): string {
// switch (node.operatorToken.kind) {
// case ts.SyntaxKind.AmpersandToken:
// return `bit32.band(${lhs},${rhs})`;
// case ts.SyntaxKind.BarToken:
// return `bit32.bor(${lhs},${rhs})`;
// case ts.SyntaxKind.CaretToken:
// return `bit32.bxor(${lhs},${rhs})`;
// case ts.SyntaxKind.LessThanLessThanToken:
// return `bit32.lshift(${lhs},${rhs})`;
// case ts.SyntaxKind.GreaterThanGreaterThanToken:
// return `bit32.rshift(${lhs},${rhs})`;
// case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
// return `bit32.arshift(${lhs},${rhs})`;
// default:
// throw TSTLErrors.UnsupportedKind("bitwise operator", node.operatorToken.kind, node);
// }
// }

// /** @override */
// public transpileSwitch(node: ts.SwitchStatement): string {
// const expression = this.transpileExpression(node.expression, true);
Expand Down
33 changes: 3 additions & 30 deletions src/targets/LuaTransformer.53.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,40 +1,13 @@
import * as ts from "typescript";

import {LuaTransformer} from "../LuaTransformer";
import * as tstl from "../LuaAST";
import {ExpressionVisitResult} from "../LuaTransformer";
import {TSHelper as tsHelper} from "../TSHelper";
import { LuaTransformer52 } from "./LuaTransformer.52";
import {TSTLErrors} from "../TSTLErrors";

export class LuaTransformer53 extends LuaTransformer52 {
// TODO
// /** @override */
// public transpileUnaryBitOperation(node: ts.PrefixUnaryExpression, operand: string): string {
// switch (node.operator) {
// case ts.SyntaxKind.TildeToken:
// return `~${operand}`;
// default:
// throw TSTLErrors.UnsupportedKind("bitwise operator", node.operator, node);
// }
// }

// /** @override */
// public transpileBitOperation(node: ts.BinaryExpression, lhs: string, rhs: string): string {
// switch (node.operatorToken.kind) {
// case ts.SyntaxKind.AmpersandToken:
// return `${lhs} & ${rhs}`;
// case ts.SyntaxKind.BarToken:
// return `${lhs} | ${rhs}`;
// case ts.SyntaxKind.CaretToken:
// return `${lhs} ~ ${rhs}`;
// case ts.SyntaxKind.LessThanLessThanToken:
// return `${lhs} << ${rhs}`;
// case ts.SyntaxKind.GreaterThanGreaterThanToken:
// return `${lhs} >> ${rhs}`;
// case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
// throw TSTLErrors.UnsupportedForTarget("Bitwise >>> operator", this.options.luaTarget, node);
// default:
// throw TSTLErrors.UnsupportedKind("bitwise operator", node.operatorToken.kind, node);
// }
// }

// /** @override */
// public getValidStringProperties(): { [js: string]: string } {
Expand Down
25 changes: 0 additions & 25 deletions src/targets/LuaTransformer.JIT.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,11 +6,6 @@ import {TSHelper as tsHelper} from "../TSHelper";
import { LuaTransformer52 } from "./LuaTransformer.52";

export class LuaTransformerJIT extends LuaTransformer52 {
/** @override */
public createUnpackCall(expression: tstl.Expression): tstl.Expression {
return tstl.createCallExpression(tstl.createIdentifier("unpack"), [expression]);
}

// TODO
// /** @override */
// public transpileUnaryBitOperation(node: ts.PrefixUnaryExpression, operand: string): string {
Expand All @@ -22,26 +17,6 @@ export class LuaTransformerJIT extends LuaTransformer52 {
// }
// }

// /** @override */
// public transpileBitOperation(node: ts.BinaryExpression, lhs: string, rhs: string): string {
// switch (node.operatorToken.kind) {
// case ts.SyntaxKind.AmpersandToken:
// return `bit.band(${lhs},${rhs})`;
// case ts.SyntaxKind.BarToken:
// return `bit.bor(${lhs},${rhs})`;
// case ts.SyntaxKind.CaretToken:
// return `bit.bxor(${lhs},${rhs})`;
// case ts.SyntaxKind.LessThanLessThanToken:
// return `bit.lshift(${lhs},${rhs})`;
// case ts.SyntaxKind.GreaterThanGreaterThanToken:
// return `bit.rshift(${lhs},${rhs})`;
// case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
// return `bit.arshift(${lhs},${rhs})`;
// default:
// throw TSTLErrors.UnsupportedKind("bitwise operator", node.operatorToken.kind, node);
// }
// }

// /** @override */
// public transpileDestructingAssignmentValue(node: ts.Expression): string {
// return `unpack(${this.transpileExpression(node)})`;
Expand Down
58 changes: 29 additions & 29 deletions test/unit/expressions.spec.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -113,52 +113,52 @@ export class ExpressionTests {
}

@TestCase("~a", "bit.bnot(a);")
@TestCase("a&b", "bit.band(a,b);")
@TestCase("a&=b", "a = (bit.band(a,b));")
@TestCase("a|b", "bit.bor(a,b);")
@TestCase("a|=b", "a = (bit.bor(a,b));")
@TestCase("a^b", "bit.bxor(a,b);")
@TestCase("a^=b", "a = (bit.bxor(a,b));")
@TestCase("a<<b", "bit.lshift(a,b);")
@TestCase("a<<=b", "a = (bit.lshift(a,b));")
@TestCase("a>>b", "bit.rshift(a,b);")
@TestCase("a>>=b", "a = (bit.rshift(a,b));")
@TestCase("a>>>b", "bit.arshift(a,b);")
@TestCase("a>>>=b", "a = (bit.arshift(a,b));")
@TestCase("a&b", "bit.band(a, b);")
@TestCase("a&=b", "a = bit.band(a, b);")
@TestCase("a|b", "bit.bor(a, b);")
@TestCase("a|=b", "a = bit.bor(a, b);")
@TestCase("a^b", "bit.bxor(a, b);")
@TestCase("a^=b", "a = bit.bxor(a, b);")
@TestCase("a<<b", "bit.lshift(a, b);")
@TestCase("a<<=b", "a = bit.lshift(a, b);")
@TestCase("a>>b", "bit.rshift(a, b);")
@TestCase("a>>=b", "a = bit.rshift(a, b);")
@TestCase("a>>>b", "bit.arshift(a, b);")
@TestCase("a>>>=b", "a = bit.arshift(a, b);")
@Test("Bitop [JIT]")
public bitOperatorOverrideJIT(input: string, lua: string): void {
Expect(util.transpileString(input, { luaTarget: LuaTarget.LuaJIT, luaLibImport: "none" })).toBe(lua);
}

@TestCase("~a", "bit32.bnot(a);")
@TestCase("a&b", "bit32.band(a,b);")
@TestCase("a&=b", "a = (bit32.band(a,b));")
@TestCase("a|b", "bit32.bor(a,b);")
@TestCase("a|=b", "a = (bit32.bor(a,b));")
@TestCase("a^b", "bit32.bxor(a,b);")
@TestCase("a^=b", "a = (bit32.bxor(a,b));")
@TestCase("a<<b", "bit32.lshift(a,b);")
@TestCase("a<<=b", "a = (bit32.lshift(a,b));")
@TestCase("a>>b", "bit32.rshift(a,b);")
@TestCase("a>>=b", "a = (bit32.rshift(a,b));")
@TestCase("a>>>b", "bit32.arshift(a,b);")
@TestCase("a>>>=b", "a = (bit32.arshift(a,b));")
@TestCase("a&b", "bit32.band(a, b);")
@TestCase("a&=b", "a = bit32.band(a, b);")
@TestCase("a|b", "bit32.bor(a, b);")
@TestCase("a|=b", "a = bit32.bor(a, b);")
@TestCase("a^b", "bit32.bxor(a, b);")
@TestCase("a^=b", "a = bit32.bxor(a, b);")
@TestCase("a<<b", "bit32.lshift(a, b);")
@TestCase("a<<=b", "a = bit32.lshift(a, b);")
@TestCase("a>>b", "bit32.rshift(a, b);")
@TestCase("a>>=b", "a = bit32.rshift(a, b);")
@TestCase("a>>>b", "bit32.arshift(a, b);")
@TestCase("a>>>=b", "a = bit32.arshift(a, b);")
@Test("Bitop [5.2]")
public bitOperatorOverride52(input: string, lua: string): void {
Expect(util.transpileString(input, { luaTarget: LuaTarget.Lua52, luaLibImport: "none" })).toBe(lua);
}

@TestCase("~a", "~a;")
@TestCase("a&b", "a & b;")
@TestCase("a&=b", "a = (a & b);")
@TestCase("a&=b", "a = a & b;")
@TestCase("a|b", "a | b;")
@TestCase("a|=b", "a = (a | b);")
@TestCase("a|=b", "a = a | b;")
@TestCase("a^b", "a ~ b;")
@TestCase("a^=b", "a = (a ~ b);")
@TestCase("a^=b", "a = a ~ b;")
@TestCase("a<<b", "a << b;")
@TestCase("a<<=b", "a = (a << b);")
@TestCase("a<<=b", "a = a << b;")
@TestCase("a>>b", "a >> b;")
@TestCase("a>>=b", "a = (a >> b);")
@TestCase("a>>=b", "a = a >> b;")
@Test("Bitop [5.3]")
public bitOperatorOverride53(input: string, lua: string): void {
Expect(util.transpileString(input, { luaTarget: LuaTarget.Lua53, luaLibImport: "none" })).toBe(lua);
Expand Down