Skip to content

Static get/set accessors #424

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 5 commits into from
Feb 20, 2019
Merged

Static get/set accessors #424

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
af17493
static get/set accessors
tomblind Feb 19, 2019
f807902
Merge remote-tracking branch 'origin/master' into static-getters-setters
tomblind Feb 19, 2019
e4947c3
fixed stuff from merge and a little cleanup
tomblind Feb 19, 2019
fe0bf6a
tests
tomblind Feb 19, 2019
9e4f93e
removed FocusTests
tomblind Feb 19, 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
2 changes: 2 additions & 0 deletions src/LuaLib.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,8 @@ export enum LuaLibFeature {
ArraySlice = "ArraySlice",
ArraySome = "ArraySome",
ArraySplice = "ArraySplice",
ClassIndex = "ClassIndex",
ClassNewIndex = "ClassNewIndex",
FunctionApply = "FunctionApply",
FunctionBind = "FunctionBind",
FunctionCall = "FunctionCall",
Expand Down
168 changes: 137 additions & 31 deletions src/LuaTransformer.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -426,9 +426,8 @@ export class LuaTransformer {
const properties = statement.members.filter(ts.isPropertyDeclaration).filter(member => member.initializer);

// Divide properties into static and non-static
const isStatic = prop => prop.modifiers && prop.modifiers.some(m => m.kind === ts.SyntaxKind.StaticKeyword);
const staticFields = properties.filter(isStatic);
const instanceFields = properties.filter(prop => !isStatic(prop));
const staticFields = properties.filter(tsHelper.isStatic);
const instanceFields = properties.filter(prop => !tsHelper.isStatic(prop));

const result: tstl.Statement[] = [];

Expand Down Expand Up @@ -605,6 +604,22 @@ export class LuaTransformer {

const createClassNameWithExport = () => this.addExportToIdentifier(tstl.cloneIdentifier(className));

// className.____getters = {}
if (statement.members.some(m => ts.isGetAccessor(m) && tsHelper.isStatic(m))) {
const classGetters = tstl.createTableIndexExpression(
createClassNameWithExport(),
tstl.createStringLiteral("____getters")
);
const assignClassGetters = tstl.createAssignmentStatement(
classGetters,
tstl.createTableExpression(),
statement
);
result.push(assignClassGetters);

this.importLuaLibFeature(LuaLibFeature.ClassIndex);
}

// className.__index = className
const classIndex = tstl.createTableIndexExpression(
createClassNameWithExport(),
Expand All @@ -613,6 +628,22 @@ export class LuaTransformer {
const assignClassIndex = tstl.createAssignmentStatement(classIndex, createClassNameWithExport(), statement);
result.push(assignClassIndex);

// className.____setters = {}
if (statement.members.some(m => ts.isSetAccessor(m) && tsHelper.isStatic(m))) {
const classSetters = tstl.createTableIndexExpression(
createClassNameWithExport(),
tstl.createStringLiteral("____setters")
);
const assignClassSetters = tstl.createAssignmentStatement(
classSetters,
tstl.createTableExpression(),
statement
);
result.push(assignClassSetters);

this.importLuaLibFeature(LuaLibFeature.ClassNewIndex);
}

// className.prototype = className.prototype or {}
const createClassPrototype = () => tstl.createTableIndexExpression(
createClassNameWithExport(),
Expand All @@ -628,12 +659,8 @@ export class LuaTransformer {
const assignClassPrototype = tstl.createAssignmentStatement(createClassPrototype(), classPrototypeTable);
result.push(assignClassPrototype);

const classPrototypeIndex = tstl.createTableIndexExpression(
createClassPrototype(),
tstl.createStringLiteral("__index")
);
if (tsHelper.hasGetAccessorInClassOrAncestor(statement, this.checker)) {
// className.prototype.____getters = {}
// className.prototype.____getters = {}
if (statement.members.some(m => ts.isGetAccessor(m) && !tsHelper.isStatic(m))) {
const classPrototypeGetters = tstl.createTableIndexExpression(
createClassPrototype(),
tstl.createStringLiteral("____getters")
Expand All @@ -643,7 +670,13 @@ export class LuaTransformer {
tstl.createTableExpression()
);
result.push(assignClassPrototypeGetters);
}

const classPrototypeIndex = tstl.createTableIndexExpression(
createClassPrototype(),
tstl.createStringLiteral("__index")
);
if (tsHelper.hasGetAccessorInClassOrAncestor(statement, false, this.checker)) {
// className.prototype.__index = __TS_Index(className.prototype)
const assignClassPrototypeIndex = tstl.createAssignmentStatement(
classPrototypeIndex,
Expand All @@ -660,7 +693,7 @@ export class LuaTransformer {
result.push(assignClassPrototypeIndex);
}

if (tsHelper.hasSetAccessorInClassOrAncestor(statement, this.checker)) {
if (statement.members.some(m => ts.isSetAccessor(m) && !tsHelper.isStatic(m))) {
// className.prototype.____setters = {}
const classPrototypeSetters = tstl.createTableIndexExpression(
createClassPrototype(),
Expand All @@ -671,7 +704,9 @@ export class LuaTransformer {
tstl.createTableExpression()
);
result.push(assignClassPrototypeSetters);
}

if (tsHelper.hasSetAccessorInClassOrAncestor(statement, false, this.checker)) {
// className.prototype.__newindex = __TS_NewIndex(className.prototype)
const classPrototypeNewIndex = tstl.createTableIndexExpression(
createClassPrototype(),
Expand All @@ -696,6 +731,9 @@ export class LuaTransformer {
);
result.push(assignClassPrototypeConstructor);

const hasStaticGetters = tsHelper.hasGetAccessorInClassOrAncestor(statement, true, this.checker);
const hasStaticSetters = tsHelper.hasSetAccessorInClassOrAncestor(statement, true, this.checker);

if (extendsType) {
const extendedTypeNode = tsHelper.getExtendedTypeNode(statement, this.checker);
const baseName = this.transformExpression(extendedTypeNode.expression);
Expand All @@ -708,14 +746,51 @@ export class LuaTransformer {
const assignClassBase = tstl.createAssignmentStatement(createClassBase(), baseName, statement);
result.push(assignClassBase);

// setmetatable(className, className.____super)
const setClassMetatable = tstl.createExpressionStatement(
tstl.createCallExpression(
tstl.createIdentifier("setmetatable"),
[createClassNameWithExport(), createClassBase()]
)
);
result.push(setClassMetatable);
if (hasStaticGetters || hasStaticSetters) {
const metatableFields: tstl.TableFieldExpression[] = [];
if (hasStaticGetters) {
// __index = __TS__ClassIndex
metatableFields.push(
tstl.createTableFieldExpression(
tstl.createIdentifier("__TS__ClassIndex"),
tstl.createStringLiteral("__index")
)
);
} else {
// __index = className.____super
metatableFields.push(
tstl.createTableFieldExpression(createClassBase(), tstl.createStringLiteral("__index"))
);
}

if (hasStaticSetters) {
// __newindex = __TS__ClassNewIndex
metatableFields.push(
tstl.createTableFieldExpression(
tstl.createIdentifier("__TS__ClassNewIndex"),
tstl.createStringLiteral("__newindex")
)
);
}

const setClassMetatable = tstl.createExpressionStatement(
tstl.createCallExpression(
tstl.createIdentifier("setmetatable"),
[createClassNameWithExport(), tstl.createTableExpression(metatableFields)]
)
);
result.push(setClassMetatable);

} else {
// setmetatable(className, className.____super)
const setClassMetatable = tstl.createExpressionStatement(
tstl.createCallExpression(
tstl.createIdentifier("setmetatable"),
[createClassNameWithExport(), createClassBase()]
)
);
result.push(setClassMetatable);
}

// setmetatable(className.prototype, className.____super.prototype)
const basePrototype = tstl.createTableIndexExpression(
Expand All @@ -729,6 +804,36 @@ export class LuaTransformer {
)
);
result.push(setClassPrototypeMetatable);

} else if (hasStaticGetters || hasStaticSetters) {
const metatableFields: tstl.TableFieldExpression[] = [];
if (hasStaticGetters) {
// __index = __TS__ClassIndex
metatableFields.push(
tstl.createTableFieldExpression(
tstl.createIdentifier("__TS__ClassIndex"),
tstl.createStringLiteral("__index")
)
);
}

if (hasStaticSetters) {
// __newindex = __TS__ClassNewIndex
metatableFields.push(
tstl.createTableFieldExpression(
tstl.createIdentifier("__TS__ClassNewIndex"),
tstl.createStringLiteral("__newindex")
)
);
}

const setClassMetatable = tstl.createExpressionStatement(
tstl.createCallExpression(
tstl.createIdentifier("setmetatable"),
[createClassNameWithExport(), tstl.createTableExpression(metatableFields)]
)
);
result.push(setClassMetatable);
}

const newFuncStatements: tstl.Statement[] = [];
Expand Down Expand Up @@ -904,12 +1009,13 @@ export class LuaTransformer {
[this.createSelfIdentifier()]
);

const classPrototype = tstl.createTableIndexExpression(
this.addExportToIdentifier(tstl.cloneIdentifier(className)),
tstl.createStringLiteral("prototype")
);
const classNameWithExport = this.addExportToIdentifier(tstl.cloneIdentifier(className));
const methodTable = tsHelper.isStatic(getAccessor)
? classNameWithExport
: tstl.createTableIndexExpression(classNameWithExport, tstl.createStringLiteral("prototype"));

const classGetters = tstl.createTableIndexExpression(
classPrototype,
methodTable,
tstl.createStringLiteral("____getters")
);
const getter = tstl.createTableIndexExpression(
Expand Down Expand Up @@ -938,12 +1044,13 @@ export class LuaTransformer {
restParam
);

const classPrototype = tstl.createTableIndexExpression(
this.addExportToIdentifier(tstl.cloneIdentifier(className)),
tstl.createStringLiteral("prototype")
);
const classNameWithExport = this.addExportToIdentifier(tstl.cloneIdentifier(className));
const methodTable = tsHelper.isStatic(setAccessor)
? classNameWithExport
: tstl.createTableIndexExpression(classNameWithExport, tstl.createStringLiteral("prototype"));

const classSetters = tstl.createTableIndexExpression(
classPrototype,
methodTable,
tstl.createStringLiteral("____setters")
);
const setter = tstl.createTableIndexExpression(
Expand All @@ -957,7 +1064,7 @@ export class LuaTransformer {
public transformMethodDeclaration(
node: ts.MethodDeclaration,
className: tstl.Identifier,
usePrototype: boolean
noPrototype: boolean
): tstl.AssignmentStatement
{
// Don't transform methods without body (overload declarations)
Expand All @@ -984,9 +1091,8 @@ export class LuaTransformer {
restParamName
);

const isStatic = node.modifiers && node.modifiers.some(m => m.kind === ts.SyntaxKind.StaticKeyword);
const classNameWithExport = this.addExportToIdentifier(tstl.cloneIdentifier(className));
const methodTable = isStatic || usePrototype
const methodTable = tsHelper.isStatic(node) || noPrototype
? classNameWithExport
: tstl.createTableIndexExpression(classNameWithExport, tstl.createStringLiteral("prototype"));

Expand Down
12 changes: 9 additions & 3 deletions src/TSHelper.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -131,6 +131,10 @@ export class TSHelper {
return false;
}

public static isStatic(node: ts.Node): boolean {
return node.modifiers !== undefined && node.modifiers.some(m => m.kind === ts.SyntaxKind.StaticKeyword);
}

public static isStringType(type: ts.Type): boolean {
return (type.flags & ts.TypeFlags.String) !== 0 || (type.flags & ts.TypeFlags.StringLike) !== 0 ||
(type.flags & ts.TypeFlags.StringLiteral) !== 0;
Expand Down Expand Up @@ -375,24 +379,26 @@ export class TSHelper {

public static hasSetAccessorInClassOrAncestor(
classDeclaration: ts.ClassLikeDeclarationBase,
isStatic: boolean,
checker: ts.TypeChecker
): boolean
{
return TSHelper.findInClassOrAncestor(
classDeclaration,
c => c.members.some(ts.isSetAccessor),
c => c.members.some(m => ts.isSetAccessor(m) && TSHelper.isStatic(m) === isStatic),
checker
) !== undefined;
}

public static hasGetAccessorInClassOrAncestor(
classDeclaration: ts.ClassLikeDeclarationBase,
isStatic: boolean,
checker: ts.TypeChecker
): boolean
{
return TSHelper.findInClassOrAncestor(
classDeclaration,
c => c.members.some(ts.isGetAccessor),
c => c.members.some(m => ts.isGetAccessor(m) && TSHelper.isStatic(m) === isStatic),
checker
) !== undefined;
}
Expand All @@ -417,7 +423,7 @@ export class TSHelper {
checker: ts.TypeChecker
): element is ts.GetAccessorDeclaration
{
if (!ts.isGetAccessor(element)) {
if (!ts.isGetAccessor(element) || TSHelper.isStatic(element)) {
return false;
}

Expand Down
28 changes: 28 additions & 0 deletions src/lualib/ClassIndex.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,28 @@
interface LuaClass {
____super?: LuaClass;
____getters?: { [key: string]: (self: LuaClass) => any };
}

declare function rawget<T, K extends keyof T>(obj: T, key: K): T[K];

function __TS__ClassIndex(classTable: LuaClass, key: keyof LuaClass): any {
while (true) {
const getters = rawget(classTable, "____getters");
if (getters) {
const getter = getters[key];
if (getter) {
return getter(classTable);
}
}

classTable = rawget(classTable, "____super");
if (!classTable) {
break;
}

const val = rawget(classTable, key);
if (val !== null) {
return val;
}
}
}
26 changes: 26 additions & 0 deletions src/lualib/ClassNewIndex.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,26 @@
interface LuaClass {
____super?: LuaClass;
____setters?: { [key: string]: (self: LuaClass, val: any) => void };
}

declare function rawget<T, K extends keyof T>(obj: T, key: K): T[K];
declare function rawset<T, K extends keyof T>(obj: T, key: K, val: T[K]): void;

function __TS__ClassNewIndex(classTable: LuaClass, key: keyof LuaClass, val: any): void {
let tbl = classTable;
do {
const setters = rawget(tbl, "____setters");
if (setters) {
const setter = setters[key];
if (setter) {
setter(tbl, val);
return;
}
}

tbl = rawget(tbl, "____super");
}
while (tbl);

rawset(classTable, key, val);
}
Loading