@defold-typescript/transpiler 0.5.0 → 0.5.1

package/dist/index.js

@@ -9,11 +9,20 @@ import * as tstl2 from "typescript-to-lua";
 import * as ts from "typescript";
 import {
   createAssignmentStatement,
+  createBinaryExpression,
   createBlock,
+  createCallExpression,
   createExpressionStatement,
+  createForInStatement,
   createFunctionExpression,
   createIdentifier,
-  NodeFlags
+  createIfStatement,
+  createNilLiteral,
+  createReturnStatement,
+  createTableIndexExpression,
+  createVariableDeclarationStatement,
+  NodeFlags,
+  SyntaxKind as SyntaxKind2
 } from "typescript-to-lua";
 var FACTORY_MODULE = "@defold-typescript/types";
 var FACTORY_NAMES = new Set(["defineScript", "defineGuiScript", "defineRenderScript"]);
@@ -65,6 +74,43 @@ function transformHookBody(fn, context) {
   }
   return [createExpressionStatement(context.transformExpression(fn.body))];
 }
+function crossesFunctionBoundary(node) {
+  return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node);
+}
+function initReturnsValue(fn) {
+  if (!ts.isBlock(fn.body)) {
+    return true;
+  }
+  let found = false;
+  const visit = (node) => {
+    if (found || crossesFunctionBoundary(node)) {
+      return;
+    }
+    if (ts.isReturnStatement(node) && node.expression !== undefined) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(fn.body, visit);
+  return found;
+}
+function initBuilderBody(fn, context) {
+  if (ts.isBlock(fn.body)) {
+    return context.transformStatements(fn.body.statements);
+  }
+  return [createReturnStatement([context.transformExpression(fn.body)])];
+}
+function emitInitMerge(fn, context, property) {
+  const builder = createFunctionExpression(createBlock(initBuilderBody(fn, context)), [], undefined, NodeFlags.Declaration, fn);
+  const builderDecl = createVariableDeclarationStatement(createIdentifier("____init"), builder);
+  const stateDecl = createVariableDeclarationStatement(createIdentifier("____s"), createCallExpression(createIdentifier("____init"), []));
+  const mergeAssignment = createAssignmentStatement(createTableIndexExpression(createIdentifier("self"), createIdentifier("____k")), createIdentifier("____v"));
+  const forIn = createForInStatement(createBlock([mergeAssignment]), [createIdentifier("____k"), createIdentifier("____v")], [createCallExpression(createIdentifier("pairs"), [createIdentifier("____s")])]);
+  const guard = createIfStatement(createBinaryExpression(createIdentifier("____s"), createNilLiteral(), SyntaxKind2.InequalityOperator), createBlock([forIn]));
+  const initFn = createFunctionExpression(createBlock([stateDecl, guard]), [createIdentifier("self")], undefined, NodeFlags.Declaration, fn);
+  return [builderDecl, createAssignmentStatement(createIdentifier("init"), initFn, property)];
+}
 function eraseFactoryCall(expression, context) {
   if (!ts.isCallExpression(expression)) {
     return;
@@ -83,6 +129,10 @@ function eraseFactoryCall(expression, context) {
     if (name === undefined || fn === undefined) {
       continue;
     }
+    if (name === "init" && initReturnsValue(fn)) {
+      statements.push(...emitInitMerge(fn, context, property));
+      continue;
+    }
     const params = fn.parameters.filter((param) => !isThisParameter(param) && ts.isIdentifier(param.name)).map((param) => context.transformExpression(param.name));
     const fnExpression = createFunctionExpression(createBlock(transformHookBody(fn, context)), params, undefined, NodeFlags.Declaration, fn);
     statements.push(createAssignmentStatement(createIdentifier(name), fnExpression, property));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/transpiler",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "TypeScript-to-Lua build pipeline tuned for Defold's runtime.",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@defold-typescript/types": "0.5.0",
+    "@defold-typescript/types": "0.5.1",
     "@typescript-to-lua/language-extensions": "1.19.0",
     "typescript-to-lua": "^1.36.0"
   }

package/src/lifecycle-erasure.ts

@@ -1,14 +1,23 @@
 import * as ts from "typescript";
 import {
   createAssignmentStatement,
+  createBinaryExpression,
   createBlock,
+  createCallExpression,
   createExpressionStatement,
+  createForInStatement,
   createFunctionExpression,
   createIdentifier,
+  createIfStatement,
+  createNilLiteral,
+  createReturnStatement,
+  createTableIndexExpression,
+  createVariableDeclarationStatement,
   type Identifier,
   NodeFlags,
   type Plugin,
   type Statement,
+  SyntaxKind,
   type TransformationContext,
 } from "typescript-to-lua";
 
@@ -75,6 +84,92 @@ function transformHookBody(fn: HookFunction, context: TransformationContext): St
   return [createExpressionStatement(context.transformExpression(fn.body))];
 }
 
+function crossesFunctionBoundary(node: ts.Node): boolean {
+  return (
+    ts.isFunctionDeclaration(node) ||
+    ts.isFunctionExpression(node) ||
+    ts.isArrowFunction(node) ||
+    ts.isMethodDeclaration(node) ||
+    ts.isGetAccessorDeclaration(node) ||
+    ts.isSetAccessorDeclaration(node)
+  );
+}
+
+function initReturnsValue(fn: HookFunction): boolean {
+  if (!ts.isBlock(fn.body)) {
+    return true;
+  }
+  let found = false;
+  const visit = (node: ts.Node): void => {
+    if (found || crossesFunctionBoundary(node)) {
+      return;
+    }
+    if (ts.isReturnStatement(node) && node.expression !== undefined) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(fn.body, visit);
+  return found;
+}
+
+function initBuilderBody(fn: HookFunction, context: TransformationContext): Statement[] {
+  if (ts.isBlock(fn.body)) {
+    return context.transformStatements(fn.body.statements);
+  }
+  return [createReturnStatement([context.transformExpression(fn.body)])];
+}
+
+// init-merge: Defold owns `self` (a userdata-backed table) and a script can
+// populate but not replace it, so a returning `init(): TSelf` can't be emitted
+// verbatim. Wrap the body in a `____init` builder and merge its result onto the
+// engine `self`; a `nil` return (stateless script) merges nothing.
+function emitInitMerge(
+  fn: HookFunction,
+  context: TransformationContext,
+  property: ts.ObjectLiteralElementLike,
+): Statement[] {
+  const builder = createFunctionExpression(
+    createBlock(initBuilderBody(fn, context)),
+    [],
+    undefined,
+    NodeFlags.Declaration,
+    fn,
+  );
+  const builderDecl = createVariableDeclarationStatement(createIdentifier("____init"), builder);
+
+  const stateDecl = createVariableDeclarationStatement(
+    createIdentifier("____s"),
+    createCallExpression(createIdentifier("____init"), []),
+  );
+  const mergeAssignment = createAssignmentStatement(
+    createTableIndexExpression(createIdentifier("self"), createIdentifier("____k")),
+    createIdentifier("____v"),
+  );
+  const forIn = createForInStatement(
+    createBlock([mergeAssignment]),
+    [createIdentifier("____k"), createIdentifier("____v")],
+    [createCallExpression(createIdentifier("pairs"), [createIdentifier("____s")])],
+  );
+  const guard = createIfStatement(
+    createBinaryExpression(
+      createIdentifier("____s"),
+      createNilLiteral(),
+      SyntaxKind.InequalityOperator,
+    ),
+    createBlock([forIn]),
+  );
+  const initFn = createFunctionExpression(
+    createBlock([stateDecl, guard]),
+    [createIdentifier("self")],
+    undefined,
+    NodeFlags.Declaration,
+    fn,
+  );
+  return [builderDecl, createAssignmentStatement(createIdentifier("init"), initFn, property)];
+}
+
 function eraseFactoryCall(
   expression: ts.Expression,
   context: TransformationContext,
@@ -96,6 +191,10 @@ function eraseFactoryCall(
     if (name === undefined || fn === undefined) {
       continue;
     }
+    if (name === "init" && initReturnsValue(fn)) {
+      statements.push(...emitInitMerge(fn, context, property));
+      continue;
+    }
     const params: Identifier[] = fn.parameters
       .filter((param) => !isThisParameter(param) && ts.isIdentifier(param.name))
       .map((param) => context.transformExpression(param.name as ts.Identifier) as Identifier);