@gi-tcg/gts-transpiler 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "repository": "https://github.com/piovium/gts.git",
   "license": "Apache-2.0",
   "type": "module",
@@ -19,8 +19,8 @@
   "dependencies": {
     "@jridgewell/sourcemap-codec": "^1.5.5",
     "@sveltejs/acorn-typescript": "^1.0.8",
-    "acorn": "^8.15.0",
-    "esrap": "^2.2.1",
+    "acorn": "8.15.0",
+    "esrap": "2.2.1",
     "magic-string": "^0.30.21",
     "zimmerframe": "^1.1.4"
   },

package/src/config.ts

@@ -1,6 +1,90 @@
-import path from "node:path";
 import type { TranspileOption } from "./transform/gts";
 
+export interface PathPolyfill {
+  isAbsolute(filePath: string): boolean;
+  dirname(filePath: string): string;
+  resolve(...segments: string[]): string;
+}
+
+export const path: PathPolyfill = globalThis.require
+  ? (globalThis.require("node:path") as typeof import("node:path"))
+  : {
+      isAbsolute(filePath) {
+        return filePath.startsWith("/");
+      },
+      dirname(filePath) {
+        if (!filePath) {
+          return ".";
+        }
+        const normalized = normalizeSlashes(filePath);
+        if (normalized === "/") {
+          return "/";
+        }
+        const trimmed =
+          normalized.length > 1 && normalized.endsWith("/")
+            ? normalized.slice(0, -1)
+            : normalized;
+        const idx = trimmed.lastIndexOf("/");
+        if (idx < 0) {
+          return ".";
+        }
+        if (idx === 0) {
+          return "/";
+        }
+        return trimmed.slice(0, idx);
+      },
+      resolve(...segments) {
+        if (segments.length === 0) {
+          return ".";
+        }
+        let resolved = "";
+        for (let i = segments.length - 1; i >= 0; i--) {
+          const segment = segments[i];
+          if (!segment) {
+            continue;
+          }
+          if (resolved) {
+            resolved = `${segment}/${resolved}`;
+          } else {
+            resolved = segment;
+          }
+          if (path.isAbsolute(segment)) {
+            break;
+          }
+        }
+        return normalizeResolvedPath(resolved || ".");
+      },
+    };
+
+function normalizeSlashes(filePath: string): string {
+  return filePath.replace(/\\+/g, "/");
+}
+
+function normalizeResolvedPath(filePath: string): string {
+  const normalized = normalizeSlashes(filePath);
+  const isAbsolute = normalized.startsWith("/");
+  const parts = normalized.split("/");
+  const stack: string[] = [];
+  for (const part of parts) {
+    if (!part || part === ".") {
+      continue;
+    }
+    if (part === "..") {
+      if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+        stack.pop();
+      } else if (!isAbsolute) {
+        stack.push("..");
+      }
+      continue;
+    }
+    stack.push(part);
+  }
+  if (isAbsolute) {
+    return `/${stack.join("/")}` || "/";
+  }
+  return stack.join("/") || ".";
+}
+
 export interface GtsConfig extends TranspileOption {}
 
 export interface PackageJson {
@@ -106,7 +190,7 @@ function* findNearestPackageConfig(
 ): Generator<string | Promise<string>, GtsConfig, string> {
   let currentDir = startDir;
   while (true) {
-    const pkgPath = path.join(currentDir, "package.json");
+    const pkgPath = path.resolve(currentDir, "package.json");
     const config = yield* readPackageConfig(readFileFn, pkgPath);
     if (config) {
       return config;

package/src/index.ts

@@ -25,7 +25,9 @@ export function transpileForVolar(
   filename: string,
   option: TranspileOption,
 ): VolarMappingResult {
-  const ast = parseLoose(source);
+  const ast = parseLoose(source, {
+    recordCallLParens: true,
+  });
   return transformForVolar(ast, option, {
     content: source,
     filename,
@@ -33,4 +35,10 @@ export function transpileForVolar(
 }
 
 export type { TranspileOption, TranspileResult, VolarMappingResult };
-export { resolveGtsConfig, resolveGtsConfigSync, type GtsConfig } from "./config";
+export {
+  resolveGtsConfig,
+  resolveGtsConfigSync,
+  type GtsConfig,
+  path,
+  type PathPolyfill,
+} from "./config";

package/src/parse/gts_plugin.ts

@@ -75,7 +75,7 @@ export interface GtsPluginOption {
 
 export function gtsPlugin(options: GtsPluginOption = {}) {
   return function gtsPluginTransformer(
-    Parser: typeof ParserClass
+    Parser: typeof ParserClass,
   ): typeof ParserClass {
     const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
     const lineBreak = /\r\n?|\n|\u2028|\u2029/;
@@ -95,7 +95,7 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
       override parseStatement(
         context?: string | null,
         topLevel?: boolean,
-        exports?: AST.ExportSpecifier
+        exports?: AST.ExportSpecifier,
       ) {
         if (topLevel && this.gts_isDefineStatement()) {
           const node = this.startNode() as AST.GTSDefineStatement;
@@ -119,13 +119,20 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
       gts_parseNamedAttributeDefinition() {
         const node = this.startNode() as AST.GTSNamedAttributeDefinition;
         // AttributeName
-        let name: any;
+        const start = this.start;
+        let name: AST.Identifier | AST.SimpleLiteral;
         if (this.type.label === "string") {
-          name = this.parseExprAtom();
+          name = this.parseExprAtom() as AST.SimpleLiteral;
+          if (typeof name.value === "string" && name.value.startsWith("~")) {
+            this.raise(
+              start,
+              `Attribute name starts with '~' is reserved for internal use.`,
+            );
+          }
         } else if (this.type.label === "name") {
           name = this.parseIdent();
         } else {
-          this.raise(this.start, "Expected attribute name");
+          this.raise(start, "Expected attribute name");
         }
         node.name = name;
         // AttributeBody
@@ -215,7 +222,7 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
           if (stmt.type === "GTSDefineStatement") {
             this.raise(
               startPos,
-              "DefineStatement is not allowed in direct function."
+              "DefineStatement is not allowed in direct function.",
             );
           }
           node.body.push(stmt);
@@ -274,13 +281,13 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
       override parseExprAtom(
         refDestructuringErrors?: Parse.DestructuringErrors,
         forInit?: boolean | "await",
-        forNew?: boolean
+        forNew?: boolean,
       ): AST.Expression {
         if (this.type === tokTypes.colon) {
           if (!this.isShortcutContext) {
             this.raise(
               this.start,
-              "ShortcutArgumentExpression ':' must be inside ShortcutFunction or DirectShortcutFunction."
+              "ShortcutArgumentExpression ':' must be inside ShortcutFunction or DirectShortcutFunction.",
             );
           }
           const node = this.startNode() as AST.GTSShortcutArgumentExpression;
@@ -307,7 +314,7 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
         refDestructuringErrors?: Parse.DestructuringErrors | null,
         sawUnary?: boolean,
         incDec?: boolean,
-        forInit?: boolean | "await"
+        forInit?: boolean | "await",
       ): AST.Expression {
         if (this.isContextual("query")) {
           const expr = this.gts_parseQueryExpression();
@@ -320,12 +327,12 @@ export function gtsPlugin(options: GtsPluginOption = {}) {
           refDestructuringErrors,
           sawUnary,
           incDec,
-          forInit
+          forInit,
         );
       }
 
       gts_parseQueryExpression(
-        forInit?: boolean | "await"
+        forInit?: boolean | "await",
       ): AST.GTSQueryExpression {
         const node = this.startNode() as AST.GTSQueryExpression;
         this.next(); // consume 'query'

package/src/parse/index.ts

@@ -5,6 +5,7 @@ import { gtsPlugin, type GtsPluginOption } from "./gts_plugin.js";
 import { loosePlugin } from "./loose_plugin.js";
 import { getCommentHandlers } from "./comment.js";
 import { GtsTranspilerError } from "../error.js";
+import { recordCallLParenPlugin } from "./record_call_lparen_plugin.js";
 
 const TsParser = Parser.extend(tsPlugin());
 
@@ -29,15 +30,24 @@ export function parse(input: string, options?: GtsPluginOption): Program {
   }
 }
 
-export function parseLoose(input: string, options?: GtsPluginOption): Program {
+export interface ParseLooseOptions extends GtsPluginOption {
+  recordCallLParens?: boolean;
+}
+
+export function parseLoose(
+  input: string,
+  options?: ParseLooseOptions,
+): Program {
   try {
     const GtsParser = TsParser.extend(
       loosePlugin(),
+      ...(options?.recordCallLParens ? [recordCallLParenPlugin()] : []),
       gtsPlugin({
-        ...options,
-        allowEmptyShortcutMember: true,
-        allowEmptyPositionalAttribute: true,
-      })
+        allowEmptyShortcutMember:
+          options?.allowEmptyPositionalAttribute || true,
+        allowEmptyPositionalAttribute:
+          options?.allowEmptyPositionalAttribute || true,
+      }),
     );
     const { onComment, addComments } = getCommentHandlers(input, []);
     const ast = GtsParser.parse(input, {

package/src/parse/loose_plugin.ts

@@ -15,7 +15,7 @@ export function loosePlugin() {
           return super.parseIdent(liberal);
         }
       };
-      private _proxiedThis = new Proxy(this, {
+      readonly #proxiedThis = new Proxy(this, {
         get: (target, prop) => {
           if (prop === "parseIdent") {
             return this._patchedParseIdent;
@@ -45,7 +45,7 @@ export function loosePlugin() {
         forInit?: boolean | "await",
       ): AST.Expression {
         return super.parseSubscript.call(
-          this._proxiedThis,
+          this.#proxiedThis,
           base,
           startPos,
           startLoc,

package/src/parse/record_call_lparen_plugin.ts

@@ -0,0 +1,85 @@
+import { tokTypes, type Parser } from "acorn";
+import type { AST, Parse } from "../types.js";
+
+/**
+ * A plugin that records the location of the left parenthesis in CallExpression and 
+ * NewExpression.
+ * 
+ * This is useful for Language tooling, that we can maps the '(' token from its location, 
+ * to provide  * a signature help for user when they press `(` after a function name.
+ *
+ * The recorded location will be stored in `lParenLoc` property of the 
+ * CallExpression/NewExpression node.
+ * @returns
+ */
+export function recordCallLParenPlugin() {
+  return function recordCallLParenPluginTransformer(
+    parser: typeof Parser,
+  ): typeof Parser {
+    return class RecordCallLParenParser extends (parser as typeof Parse.Parser) {
+      override parseSubscript(
+        base: AST.Expression,
+        startPos: number,
+        startLoc: AST.Position,
+        noCalls?: boolean,
+        maybeAsyncArrow?: boolean,
+        optionalChained?: boolean,
+        forInit?: boolean | "await",
+      ): AST.Expression {
+        let recordedLParenLoc: AST.SourceLocation | null = null;
+        if (!noCalls && this.type === tokTypes.parenL) {
+          recordedLParenLoc = {
+            start: this.startLoc,
+            end: this.endLoc,
+          };
+        }
+        const result = super.parseSubscript(
+          base,
+          startPos,
+          startLoc,
+          noCalls,
+          maybeAsyncArrow,
+          optionalChained,
+          forInit,
+        );
+        if (recordedLParenLoc && result.type === "CallExpression") {
+          result.lParenLoc = recordedLParenLoc;
+        }
+        return result;
+      }
+
+      private _capturedLParenLocFromNew: AST.SourceLocation | null = null;
+      private readonly _patchedEat = (type: any) => {
+        if (type === tokTypes.parenL) {
+          this._capturedLParenLocFromNew = {
+            start: this.startLoc,
+            end: this.endLoc,
+          };
+        }
+        return this.eat(type);
+      };
+
+      readonly #proxiedThis = new Proxy(this, {
+        get: (target, prop) => {
+          if (prop === "eat") {
+            return this._patchedEat;
+          }
+          const value = Reflect.get(target, prop);
+          if (typeof value === "function") {
+            return value.bind(target);
+          }
+          return value;
+        },
+      });
+
+      override parseNew() {
+        const result = super.parseNew.apply(this.#proxiedThis);
+        if (this._capturedLParenLocFromNew && result.type === "NewExpression") {
+          result.lParenLoc = this._capturedLParenLocFromNew;
+          this._capturedLParenLocFromNew = null;
+        }
+        return result;
+      }
+    };
+  };
+}

package/src/transform/gts.ts

@@ -30,8 +30,8 @@ export interface ExternalizedBinding {
 export interface TranspileState {
   readonly createDefineFnId: Identifier;
   readonly createBindingFnId: Identifier;
-  readonly ActionId: Identifier;
-  readonly preludeSymbolId: Identifier;
+  readonly ActionLit: Literal;
+  readonly PreludeLit: Literal;
   readonly fnArgId: Identifier;
   readonly shortcutFunctionParameters: Pattern[];
   readonly rootVmId: Identifier;
@@ -48,8 +48,8 @@ export interface TranspileState {
   /** Internal counters / state for emitting per-define nodes & bindings */
   defineIdCounter: number;
 
-  /** Buffered statements to be inserted after visiting a define statement */
-  pendingStatements: (Statement | ModuleDeclaration)[];
+  /** Binding statements to be inserted before all define statement */
+  bindingStatements: (Statement | ModuleDeclaration)[];
 }
 
 export const commonGtsVisitor: Visitors<Node, TranspileState> = {
@@ -64,7 +64,7 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
           kind: "init",
           method: false,
           shorthand: false,
-          value: state.ActionId,
+          value: state.ActionLit,
           loc: node.loc,
         },
         {
@@ -182,16 +182,12 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
     const body: Program["body"] = [];
     for (const stmt of node.body) {
       const visited = visit(stmt) as Statement;
-      // `GTSDefineStatement` is expanded into multiple statements via buffer
-      if (visited.type !== "EmptyStatement") {
-        body.push(visited);
-      }
-      if (state.pendingStatements.length > 0) {
-        body.push(...(state.pendingStatements));
-        state.pendingStatements = [];
-      }
+      body.push(visited);
     }
 
+    body.unshift(...state.bindingStatements);
+    state.bindingStatements = [];
+
     if (state.hasQueryExpressions) {
       body.unshift({
         type: "ImportDeclaration",
@@ -222,16 +218,6 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
             imported: { type: "Identifier", name: "createBinding" },
             local: state.createBindingFnId,
           },
-          {
-            type: "ImportSpecifier",
-            imported: { type: "Identifier", name: "Action" },
-            local: state.ActionId,
-          },
-          {
-            type: "ImportSpecifier",
-            imported: { type: "Identifier", name: "Prelude" },
-            local: state.preludeSymbolId,
-          },
         ],
         source: { type: "Literal", value: state.runtimeImportSource },
         attributes: [],
@@ -272,9 +258,8 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
 
     const newBindings = state.externalizedBindings;
     state.externalizedBindings = [];
-    const statements: (Statement | ModuleDeclaration)[] = [];
 
-    statements.push({
+    state.bindingStatements.push({
       type: "VariableDeclaration",
       kind: "const",
       declarations: [
@@ -287,7 +272,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
       loc: node.loc,
     });
 
-    statements.push({
+    state.bindingStatements.push({
       type: "VariableDeclaration",
       kind: "const",
       declarations: [
@@ -325,33 +310,26 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         ],
       };
       if (binding.export) {
-        statements.push({
+        state.bindingStatements.push({
           type: "ExportNamedDeclaration",
           declaration: decl,
           specifiers: [],
           attributes: [],
         });
       } else {
-        statements.push(decl);
+        state.bindingStatements.push(decl);
       }
     }
-
-    statements.push({
+    return {
       type: "ExpressionStatement",
       expression: {
         type: "CallExpression",
         optional: false,
-        callee: {
-          ...state.createDefineFnId,
-          loc: node.loc,
-        },
+        callee: state.createDefineFnId,
         arguments: [state.rootVmId, nodeVarId],
       },
       loc: node.loc,
-    });
-
-    state.pendingStatements.push(...statements);
-    return { type: "EmptyStatement" };
+    };
   },
   GTSNamedAttributeDefinition(node, { visit, state }) {
     const namedBody = visit(node.body) as ObjectExpression;
@@ -503,9 +481,9 @@ export const initialTranspileState = (
     option.shortcutFunctionPreludes ?? DEFAULT_SHORTCUT_FUNCTION_PRELUDES;
   const queryBindings = option.queryBindings ?? DEFAULT_QUERY_BINDINGS;
   const fnArgId: Identifier = { type: "Identifier", name: "__gts_fnArg" };
-  const preludeSymbolId: Identifier = {
-    type: "Identifier",
-    name: "__gts_Prelude",
+  const PreludeLit: Literal = {
+    type: "Literal",
+    value: "~prelude",
   };
   const shortcutFunctionParameters: Pattern[] = [
     fnArgId,
@@ -526,7 +504,7 @@ export const initialTranspileState = (
       right: {
         type: "MemberExpression",
         object: fnArgId,
-        property: preludeSymbolId,
+        property: PreludeLit,
         computed: true,
         optional: false,
       },
@@ -549,8 +527,8 @@ export const initialTranspileState = (
   return {
     createDefineFnId: { type: "Identifier", name: "__gts_createDefine" },
     createBindingFnId: { type: "Identifier", name: "__gts_createBinding" },
-    ActionId: { type: "Identifier", name: "__gts_Action" },
-    preludeSymbolId,
+    ActionLit: { type: "Literal", value: "~action" },
+    PreludeLit,
     fnArgId,
     shortcutFunctionParameters,
     rootVmId: { type: "Identifier", name: "__gts_rootVm" },
@@ -576,7 +554,7 @@ export const initialTranspileState = (
     hasQueryExpressions: false,
     defineIdCounter: 0,
 
-    pendingStatements: [],
+    bindingStatements: [],
   };
 };
 

package/src/transform/volar/collect_tokens.ts

@@ -1,4 +1,4 @@
-import type { SourceLocation } from "estree";
+import type { Node, SourceLocation } from "estree";
 import { walk } from "zimmerframe";
 
 function isLeafNode(node: any): boolean {
@@ -28,43 +28,69 @@ function isLeafNode(node: any): boolean {
   return true;
 }
 
-export interface LocationAdjustment {
+export interface LeafToken {
+  loc: SourceLocation;
+  isDummy?: boolean;
+  /**
+   * Override source length (instead of loc.end - loc.start)
+   */
+  sourceLength?: number;
+  /**
+   * Adjust the start position of source code
+   */
+  sourceStartOffset?: number;
   /**
    * Adjust the start position of generated code
    */
-  startOffset: number;
+  generatedStartOffset?: number;
+  /**
+   * Make the source length longer
+   */
+  sourceLengthOffset?: number;
   /**
    * The original length of generated code, used for mapping diagnostics
    */
-  generatedLength: number;
-}
-
-export interface LeafToken {
-  loc: SourceLocation;
-  isDummy?: boolean;
-  sourceLength?: number;
   generatedLength?: number;
-  locationAdjustment?: LocationAdjustment;
 }
 
 export function collectLeafTokens(ast: any): LeafToken[] {
-  const tokens: LeafToken[] = [];
-  walk(ast, tokens, {
+  const state = {
+    tokens: [] as LeafToken[],
+  };
+  walk(ast as Node, state, {
     _(node, { state, next }) {
       if (isLeafNode(node) && node.loc) {
         const token: LeafToken = {
-          loc: node.loc
+          loc: node.loc,
         };
-        if (node.isDummy) {
+        if ("isDummy" in node && node.isDummy) {
           token.isDummy = true;
           token.sourceLength = 0;
-          // include next character for diagnostic
+          // add 1 for squiggle on next character
           token.generatedLength = 1;
         }
-        state.push(token);
+        state.tokens.push(token);
+      }
+      next();
+    },
+    NewExpression(node, { state, next }) {
+      const lParenLoc = node.lParenLoc;
+      if (lParenLoc) {
+        state.tokens.push({
+          loc: lParenLoc,
+        });
+      }
+      next();
+    },
+    CallExpression(node, { state, next }) {
+      const lParenLoc = node.lParenLoc;
+      if (lParenLoc) {
+        state.tokens.push({
+          loc: lParenLoc,
+        });
       }
       next();
     },
   });
-  return tokens;
+  return state.tokens;
 }