@gi-tcg/gts-transpiler 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "repository": "https://github.com/piovium/gts.git",
   "license": "Apache-2.0",
   "type": "module",
@@ -19,9 +19,10 @@
   "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",
+    "path-browserify-esm": "^1.0.6",
     "zimmerframe": "^1.1.4"
   },
   "devDependencies": {

package/src/config.ts

@@ -1,5 +1,5 @@
-import path from "node:path";
 import type { TranspileOption } from "./transform/gts";
+import path from "path-browserify-esm";
 
 export interface GtsConfig extends TranspileOption {}
 
@@ -106,7 +106,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,8 @@ export function transpileForVolar(
 }
 
 export type { TranspileOption, TranspileResult, VolarMappingResult };
-export { resolveGtsConfig, resolveGtsConfigSync, type GtsConfig } from "./config";
+export {
+  resolveGtsConfig,
+  resolveGtsConfigSync,
+  type GtsConfig,
+} 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,9 +314,9 @@ 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")) {
+        if (this.isShortcutContext && this.isContextual("query")) {
           const expr = this.gts_parseQueryExpression();
           if (!incDec && this.eat(tokTypes.starstar)) {
             this.unexpected(this.lastTokStart);
@@ -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,
         },
         {
@@ -162,6 +162,15 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
                 value: !!node.star,
               },
             },
+            {
+              type: "Property",
+              key: { type: "Identifier", name: "context" },
+              computed: false,
+              kind: "init",
+              method: false,
+              shorthand: false,
+              value: state.fnArgId,
+            }
           ],
         },
       ],
@@ -182,16 +191,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 +227,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 +267,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 +281,7 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
       loc: node.loc,
     });
 
-    statements.push({
+    state.bindingStatements.push({
       type: "VariableDeclaration",
       kind: "const",
       declarations: [
@@ -325,33 +319,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 +490,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 +513,7 @@ export const initialTranspileState = (
       right: {
         type: "MemberExpression",
         object: fnArgId,
-        property: preludeSymbolId,
+        property: PreludeLit,
         computed: true,
         optional: false,
       },
@@ -549,8 +536,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 +563,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;
 }

package/src/transform/volar/index.ts

@@ -2,7 +2,6 @@ import type { AST } from "../../types";
 import { walk } from "zimmerframe";
 import type { SourceInfo, TranspileResult } from "..";
 import { print } from "esrap";
-import tsPrinter from "esrap/languages/ts";
 import {
   initialTranspileState,
   type TranspileOption,
@@ -13,16 +12,19 @@ import { applyReplacements } from "./replacements";
 import type { Program } from "estree";
 import { convertToVolarMappings, type VolarMappingResult } from "./mappings";
 import { collectLeafTokens, type LeafToken } from "./collect_tokens";
+import { patchedPrinter } from "./printer";
 
 interface TypingTranspileOption extends TranspileOption {
   leafTokens: LeafToken[];
-  // "row:col" -> "replacement string"
-  additionalMappings: Map<string, string>;
+  /**
+   * "row:col" -> "replacement string"
+   */
+  extraMappings: Map<string, string>;
 }
 
 function gtsToTypings(
   ast: AST.Program,
-  option: TypingTranspileOption
+  option: TypingTranspileOption,
 ): TranspileResult {
   const state: TypingTranspileState = {
     ...(initialTranspileState(option) as Pick<
@@ -32,34 +34,20 @@ function gtsToTypings(
     leafTokens: option.leafTokens,
     idCounter: 0,
     typingPendingStatements: [],
-    prefaceInserted: false,
-    rootVmId: { type: "Identifier", name: "__root_vm" },
+    rootVmId: { type: "Identifier", name: "__gts_root_vm" },
+    utilNsId: { type: "Identifier", name: "__gts_util" },
     replacementTag: { type: "Identifier", name: "__gts_replacement_tag" },
-    symbolsId: {
-      Meta: { type: "Identifier", name: "__gts_symbols_meta" },
-      NamedDefinition: { type: "Identifier", name: "__gts_symbols_namedDef" },
-    },
+    MetaLit: { type: "Literal", value: "~meta" },
+    NamedDefinitionLit: { type: "Literal", value: "~namedDefinition" },
     defineLeadingComments: [],
     vmDefTypeIdStack: [],
     metaTypeIdStack: [],
     finalMetaTypeIdStack: [],
     attrsOfCurrentVm: [],
-    additionalMappings: option.additionalMappings,
+    extraMappings: option.extraMappings,
   };
   const newAst = walk(ast as AST.Node, state, gtsToTypingsWalker);
-  const printer = tsPrinter({
-    getLeadingComments: (node) => (node as AST.Node).leadingComments,
-    getTrailingComments: (node) => (node as AST.Node).trailingComments,
-  });
-  const prevIdentifier = printer.Identifier!;
-  printer.Identifier = function (node, context) {
-    if (node.isDummy) {
-      context.write("", node);
-    } else {
-      prevIdentifier(node, context);
-    }
-  };
-  const { code, map } = print(newAst, printer, {
+  const { code, map } = print(newAst, patchedPrinter, {
     indent: "  ",
   });
   return {
@@ -71,21 +59,21 @@ function gtsToTypings(
 export function transformForVolar(
   ast: Program,
   option: TranspileOption,
-  sourceInfo: Required<SourceInfo>
+  sourceInfo: Required<SourceInfo>,
 ): VolarMappingResult {
   const tokens = collectLeafTokens(ast);
-  const additionalMappings = new Map<string, string>();
+  const extraMappings = new Map<string, string>();
   const { code, sourceMap } = gtsToTypings(ast, {
     ...option,
     leafTokens: tokens,
-    additionalMappings,
+    extraMappings,
   });
   const volarMappings = convertToVolarMappings(
     code,
     sourceInfo.content,
     sourceMap,
     tokens,
-    additionalMappings
+    extraMappings,
   );
   return {
     code,