@gi-tcg/gts-transpiler 0.1.1 → 0.3.0

package/src/transform/gts.ts

@@ -2,14 +2,12 @@ import type {
   ArrayExpression,
   ArrowFunctionExpression,
   BlockStatement,
-  CallExpression,
   Declaration,
-  ExportNamedDeclaration,
   Expression,
-  ExpressionStatement,
   Identifier,
   Literal,
   MemberExpression,
+  ModuleDeclaration,
   Node,
   ObjectExpression,
   ObjectPattern,
@@ -27,57 +25,59 @@ import {
 export interface ExternalizedBinding {
   bindingName: Identifier;
   export: boolean;
-  internalId: Identifier;
-  value: Expression;
-  path: string[];
 }
 
 export interface TranspileState {
   readonly createDefineFnId: Identifier;
-  readonly ActionId: Identifier;
-  readonly preludeSymbolId: Identifier;
+  readonly createBindingFnId: Identifier;
+  readonly ActionLit: Literal;
+  readonly PreludeLit: Literal;
   readonly fnArgId: Identifier;
   readonly shortcutFunctionParameters: Pattern[];
   readonly rootVmId: Identifier;
-  readonly binderFnId: Identifier;
   readonly queryFnId: Identifier;
   readonly queryParameters: Pattern[];
 
   readonly runtimeImportSource: string;
   readonly providerImportSource: string;
   readonly queryArg: ObjectPattern;
-
-  readonly attributeNames: (Identifier | Literal)[];
-  readonly externalizedBindings: ExternalizedBinding[];
+  
   hasQueryExpressions: boolean;
+
+  externalizedBindings: ExternalizedBinding[];
+  /** Internal counters / state for emitting per-define nodes & bindings */
+  defineIdCounter: number;
+
+  /** Binding statements to be inserted before all define statement */
+  bindingStatements: (Statement | ModuleDeclaration)[];
 }
 
 export const commonGtsVisitor: Visitors<Node, TranspileState> = {
-  GTSDirectFunction(node, { visit, state }): ArrowFunctionExpression {
+  GTSDirectFunction(node, { visit, state }): ObjectExpression {
     return {
-      type: "ArrowFunctionExpression",
-      params: [],
-      body: {
-        type: "ObjectExpression",
-        properties: [
-          {
-            type: "Property",
-            key: { type: "Identifier", name: "name" },
-            computed: false,
-            kind: "init",
-            method: false,
-            shorthand: false,
-            value: state.ActionId,
-            loc: node.loc,
-          },
-          {
-            type: "Property",
-            key: { type: "Identifier", name: "positionals" },
-            computed: false,
-            kind: "init",
-            method: false,
-            shorthand: false,
-            value: {
+      type: "ObjectExpression",
+      properties: [
+        {
+          type: "Property",
+          key: { type: "Identifier", name: "name" },
+          computed: false,
+          kind: "init",
+          method: false,
+          shorthand: false,
+          value: state.ActionLit,
+          loc: node.loc,
+        },
+        {
+          type: "Property",
+          key: { type: "Identifier", name: "positionals" },
+          computed: false,
+          kind: "init",
+          method: false,
+          shorthand: false,
+          value: {
+            type: "ArrowFunctionExpression",
+            params: [],
+            body: {
               type: "ArrayExpression",
               elements: [
                 {
@@ -91,22 +91,22 @@ export const commonGtsVisitor: Visitors<Node, TranspileState> = {
                 },
               ],
             },
+            expression: true,
           },
-          {
-            type: "Property",
-            key: { type: "Identifier", name: "named" },
-            computed: false,
-            kind: "init",
-            method: false,
-            shorthand: false,
-            value: {
-              type: "Literal",
-              value: null,
-            },
+        },
+        {
+          type: "Property",
+          key: { type: "Identifier", name: "named" },
+          computed: false,
+          kind: "init",
+          method: false,
+          shorthand: false,
+          value: {
+            type: "Literal",
+            value: null,
           },
-        ],
-      },
-      expression: true,
+        },
+      ],
       loc: node.loc,
     };
   },
@@ -178,91 +178,16 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
   //   }
   //   return next();
   // },
-  Program(node, { state, next }) {
-    node = (next() as Program) ?? node;
-    const body = [...node.body];
-    if (state.externalizedBindings.length > 0) {
-      body.unshift(
-        {
-          type: "ImportDeclaration",
-          specifiers: [
-            {
-              type: "ImportDefaultSpecifier",
-              local: state.binderFnId,
-            },
-          ],
-          source: {
-            type: "Literal",
-            value: `${state.providerImportSource}/binder`,
-          },
-          attributes: [],
-        },
-        ...state.externalizedBindings.flatMap(
-          (binding): (Declaration | ExportNamedDeclaration)[] => {
-            const internalDecl: Declaration = {
-              type: "VariableDeclaration",
-              kind: "const",
-              declarations: [
-                {
-                  type: "VariableDeclarator",
-                  id: binding.internalId,
-                  init: binding.value,
-                },
-              ],
-            };
-            const externalDecl: Declaration = {
-              type: "VariableDeclaration",
-              kind: "const",
-              declarations: [
-                {
-                  type: "VariableDeclarator",
-                  id: binding.bindingName,
-                  init: {
-                    type: "CallExpression",
-                    optional: false,
-                    callee: state.binderFnId,
-                    arguments: [
-                      binding.internalId,
-                      {
-                        type: "ObjectExpression",
-                        properties: [
-                          {
-                            type: "Property",
-                            key: { type: "Identifier", name: "path" },
-                            computed: false,
-                            kind: "init",
-                            method: false,
-                            shorthand: false,
-                            value: {
-                              type: "ArrayExpression",
-                              elements: binding.path.map((segment) => ({
-                                type: "Literal",
-                                value: segment,
-                              })),
-                            },
-                          },
-                        ],
-                      },
-                    ],
-                  },
-                },
-              ],
-            };
-            return binding.export
-              ? [
-                  internalDecl,
-                  {
-                    type: "ExportNamedDeclaration",
-                    declaration: externalDecl,
-                    specifiers: [],
-                    attributes: [],
-                  },
-                ]
-              : [internalDecl, externalDecl];
-          }
-        )
-      );
+  Program(node, { state, visit }) {
+    const body: Program["body"] = [];
+    for (const stmt of node.body) {
+      const visited = visit(stmt) as Statement;
+      body.push(visited);
     }
+
+    body.unshift(...state.bindingStatements);
+    state.bindingStatements = [];
+
     if (state.hasQueryExpressions) {
       body.unshift({
         type: "ImportDeclaration",
@@ -279,70 +204,135 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         attributes: [],
       });
     }
-    body.unshift({
-      type: "ImportDeclaration",
-      specifiers: [
-        {
-          type: "ImportSpecifier",
-          imported: { type: "Identifier", name: "createDefine" },
-          local: state.createDefineFnId,
-        },
-        {
-          type: "ImportSpecifier",
-          imported: { type: "Identifier", name: "Action" },
-          local: state.ActionId,
-        },
-        {
-          type: "ImportSpecifier",
-          imported: { type: "Identifier", name: "Prelude" },
-          local: state.preludeSymbolId,
+    body.unshift(
+      {
+        type: "ImportDeclaration",
+        specifiers: [
+          {
+            type: "ImportSpecifier",
+            imported: { type: "Identifier", name: "createDefine" },
+            local: state.createDefineFnId,
+          },
+          {
+            type: "ImportSpecifier",
+            imported: { type: "Identifier", name: "createBinding" },
+            local: state.createBindingFnId,
+          },
+        ],
+        source: { type: "Literal", value: state.runtimeImportSource },
+        attributes: [],
+      },
+      {
+        type: "ImportDeclaration",
+        specifiers: [
+          {
+            type: "ImportDefaultSpecifier",
+            local: state.rootVmId,
+          },
+        ],
+        source: {
+          type: "Literal",
+          value: `${state.providerImportSource}/vm`,
         },
-      ],
-      source: { type: "Literal", value: state.runtimeImportSource },
-      attributes: [],
-    });
+        attributes: [],
+      }
+    );
     return {
       ...node,
       body,
     };
   },
-  GTSDefineStatement(node, { state, visit }): ExpressionStatement {
-    const body = visit(node.body) as Expression;
-    const wrapper: ObjectExpression = {
-      type: "ObjectExpression",
-      properties: [
+  GTSDefineStatement(node, { state, visit }): Statement {
+    const defineId = state.defineIdCounter++;
+
+    const rootAttr = visit(node.body) as Expression;
+
+    const nodeVarId: Identifier = {
+      type: "Identifier",
+      name: `__gts_node_${defineId}`,
+    };
+    const bindingsVarId: Identifier = {
+      type: "Identifier",
+      name: `__gts_bindings_${defineId}`,
+    };
+
+    const newBindings = state.externalizedBindings;
+    state.externalizedBindings = [];
+
+    state.bindingStatements.push({
+      type: "VariableDeclaration",
+      kind: "const",
+      declarations: [
         {
-          type: "Property",
-          key: { type: "Identifier", name: "attributes" },
-          computed: false,
-          kind: "init",
-          method: false,
-          shorthand: false,
-          value: {
-            type: "ArrayExpression",
-            elements: [body],
+          type: "VariableDeclarator",
+          id: nodeVarId,
+          init: rootAttr,
+        },
+      ],
+      loc: node.loc,
+    });
+
+    state.bindingStatements.push({
+      type: "VariableDeclaration",
+      kind: "const",
+      declarations: [
+        {
+          type: "VariableDeclarator",
+          id: bindingsVarId,
+          init: {
+            type: "CallExpression",
+            optional: false,
+            callee: state.createBindingFnId,
+            arguments: [state.rootVmId, nodeVarId],
           },
         },
       ],
-    };
+      loc: node.loc,
+    });
+
+    for (let i = 0; i < newBindings.length; i++) {
+      const binding = newBindings[i];
+      const decl: Declaration = {
+        type: "VariableDeclaration",
+        kind: "const",
+        declarations: [
+          {
+            type: "VariableDeclarator",
+            id: binding.bindingName,
+            init: {
+              type: "MemberExpression",
+              object: bindingsVarId,
+              property: { type: "Literal", value: i },
+              computed: true,
+              optional: false,
+            },
+          },
+        ],
+      };
+      if (binding.export) {
+        state.bindingStatements.push({
+          type: "ExportNamedDeclaration",
+          declaration: decl,
+          specifiers: [],
+          attributes: [],
+        });
+      } else {
+        state.bindingStatements.push(decl);
+      }
+    }
     return {
       type: "ExpressionStatement",
       expression: {
         type: "CallExpression",
         optional: false,
-        callee: {
-          ...state.createDefineFnId,
-          loc: node.loc,
-        },
-        arguments: [state.rootVmId, wrapper],
+        callee: state.createDefineFnId,
+        arguments: [state.rootVmId, nodeVarId],
       },
       loc: node.loc,
     };
   },
   GTSNamedAttributeDefinition(node, { visit, state }) {
-    state.attributeNames.push(node.name);
     const namedBody = visit(node.body) as ObjectExpression;
-    state.attributeNames.pop();
     const properties = [...namedBody.properties];
     const nameValue: Literal =
       node.name.type === "Literal"
@@ -366,13 +356,6 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
       loc: node.loc,
     });
     const body = { ...namedBody, properties };
-    const arrow: ArrowFunctionExpression = {
-      type: "ArrowFunctionExpression",
-      params: [],
-      expression: true,
-      body,
-      loc: node.loc,
-    };
     if (node.bindingName) {
       if (node.bindingAccessModifier === "protected") {
         throw new GtsTranspilerError(
@@ -381,27 +364,25 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
         );
       }
       const export_ = node.bindingAccessModifier !== "private";
-      const internalId: Identifier = {
-        type: "Identifier",
-        name: `__gts_internal_binding_${state.externalizedBindings.length}`,
-      };
       state.externalizedBindings.push({
         bindingName: node.bindingName,
         export: export_,
-        internalId,
-        value: arrow,
-        path: [...state.attributeNames, node.name].map((n) => {
-          if (n.type === "Literal") {
-            return String(n.value);
-          } else {
-            return n.name;
-          }
-        }),
       });
-      return internalId;
-    } else {
-      return arrow;
+
+      body.properties.push({
+        type: "Property",
+        key: { type: "Identifier", name: "binding" },
+        computed: false,
+        kind: "init",
+        method: false,
+        shorthand: false,
+        value: {
+          type: "Literal",
+          value: export_ ? "public" : "private",
+        },
+      });
     }
+    return body;
   },
   GTSAttributeBody(node, { visit }) {
     const positionals = visit(node.positionalAttributes) as ArrayExpression;
@@ -418,7 +399,13 @@ const gtsVisitor: Visitors<Node, TranspileState> = {
           kind: "init",
           method: false,
           shorthand: false,
-          value: positionals,
+          value: {
+            type: "ArrowFunctionExpression",
+            params: [],
+            body: positionals,
+            expression: true,
+            loc: positionals.loc,
+          },
           loc: positionals.loc,
         },
         {
@@ -494,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,
@@ -517,7 +504,7 @@ export const initialTranspileState = (
       right: {
         type: "MemberExpression",
         object: fnArgId,
-        property: preludeSymbolId,
+        property: PreludeLit,
         computed: true,
         optional: false,
       },
@@ -539,12 +526,12 @@ export const initialTranspileState = (
   ];
   return {
     createDefineFnId: { type: "Identifier", name: "__gts_createDefine" },
-    ActionId: { type: "Identifier", name: "__gts_Action" },
-    preludeSymbolId,
+    createBindingFnId: { type: "Identifier", name: "__gts_createBinding" },
+    ActionLit: { type: "Literal", value: "~action" },
+    PreludeLit,
     fnArgId,
     shortcutFunctionParameters,
     rootVmId: { type: "Identifier", name: "__gts_rootVm" },
-    binderFnId: { type: "Identifier", name: "__gts_Binder" },
     queryFnId: { type: "Identifier", name: "__gts_query" },
     queryParameters,
 
@@ -563,9 +550,11 @@ export const initialTranspileState = (
       })),
     },
 
-    attributeNames: [],
     externalizedBindings: [],
     hasQueryExpressions: false,
+    defineIdCounter: 0,
+
+    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;
 }