@gi-tcg/gts-transpiler 0.1.1 → 0.3.0

package/src/transform/volar/walker.ts

@@ -18,6 +18,7 @@ import type {
   SourceLocation,
   Statement,
   VariableDeclaration,
+  VariableDeclarator,
 } from "estree";
 import {
   commonGtsVisitor,
@@ -37,10 +38,9 @@ export interface TypingTranspileState extends TranspileState {
   externalizedBindings: ExternalizedTypedBinding[];
   idCounter: number;
   rootVmId: Identifier;
-  symbolsId: {
-    Meta: Identifier;
-    NamedDefinition: Identifier;
-  };
+  utilNsId: Identifier;
+  MetaLit: Literal;
+  NamedDefinitionLit: Literal;
   defineLeadingComments: Comment[] | undefined;
   // type of current VM's definition
   vmDefTypeIdStack: Identifier[];
@@ -52,11 +52,10 @@ export interface TypingTranspileState extends TranspileState {
   finalMetaTypeIdStack: Identifier[];
   // `obj` of `obj.attr(...)`
   // attrLhsIdStack: Identifier[];
-  prefaceInserted: boolean;
   /** Pending statements to be inserted to the top-level */
-  pendingStatements: Statement[];
+  typingPendingStatements: Statement[];
   replacementTag: Identifier;
-  additionalMappings: Map<string, string>;
+  extraMappings: Map<string, string>;
 }
 
 const EMPTY: EmptyStatement = { type: "EmptyStatement" };
@@ -73,68 +72,7 @@ const ANY_INIT = {
   typeAnnotation: ANY,
 } as {} as Expression;
 
-const emitPreface = (state: TypingTranspileState) => {
-  if (state.prefaceInserted) {
-    return;
-  }
-  const symbolsLhs = {
-    type: "TSQualifiedName",
-    left: { type: "Identifier", name: state.rootVmId.name },
-    right: { type: "Identifier", name: "_symbols" },
-  };
-  for (const symbolName of [
-    "Meta",
-    "Action",
-    "NamedDefinition",
-    "Prelude",
-  ] as const) {
-    const init = {
-      type: "TSTypeQuery",
-      exprName: {
-        type: "TSQualifiedName",
-        left: symbolsLhs,
-        right: { type: "Identifier", name: symbolName },
-      },
-    };
-    const symbolId =
-      symbolName === "Action"
-        ? state.ActionId
-        : symbolName === "Prelude"
-        ? state.preludeSymbolId
-        : state.symbolsId[symbolName];
-    state.pendingStatements.push(
-      {
-        type: "TSTypeAliasDeclaration",
-        id: symbolId,
-        typeAnnotation: init,
-      } as {} as VariableDeclaration,
-      {
-        type: "VariableDeclaration",
-        kind: "const",
-        declarations: [
-          {
-            type: "VariableDeclarator",
-            id: {
-              ...symbolId,
-              typeAnnotation: {
-                type: "TSTypeAnnotation",
-                typeAnnotation: {
-                  type: "TSTypeReference",
-                  typeName: symbolId,
-                },
-              },
-            } as Identifier,
-            init: ANY_INIT,
-          },
-        ],
-      } as VariableDeclaration
-    );
-  }
-  state.prefaceInserted = true;
-};
-
 const enterVMFromRoot = (state: TypingTranspileState) => {
-  emitPreface(state);
   let defTypeId: Identifier = {
     type: "Identifier",
     name: `__gts_rootVmDefType_${state.idCounter++}`,
@@ -147,13 +85,13 @@ const enterVMFromRoot = (state: TypingTranspileState) => {
     type: "Identifier",
     name: `__gts_rootVmFinalMetaType_${state.idCounter++}`,
   };
-  state.pendingStatements.push(
+  state.typingPendingStatements.push(
     createReplacementHolder(state, {
       type: "enterVMFromRoot",
       vm: state.rootVmId.name,
       defType: defTypeId.name,
       metaType: metaTypeId.name,
-    })
+    }),
   );
   state.vmDefTypeIdStack.push(defTypeId);
   state.metaTypeIdStack.push(metaTypeId);
@@ -162,7 +100,7 @@ const enterVMFromRoot = (state: TypingTranspileState) => {
 };
 const enterVMFromAttr = (
   state: TypingTranspileState,
-  returningId: Identifier
+  returningId: Identifier,
 ) => {
   const defTypeId: Identifier = {
     type: "Identifier",
@@ -176,13 +114,13 @@ const enterVMFromAttr = (
     type: "Identifier",
     name: `__gts_nestedVmFinalMetaType_${state.idCounter++}`,
   };
-  state.pendingStatements.push(
+  state.typingPendingStatements.push(
     createReplacementHolder(state, {
       type: "enterVMFromAttr",
       returnType: returningId.name,
       defType: defTypeId.name,
       metaType: metaTypeId.name,
-    })
+    }),
   );
   state.vmDefTypeIdStack.push(defTypeId);
   state.metaTypeIdStack.push(metaTypeId);
@@ -195,7 +133,7 @@ const exitVM = (state: TypingTranspileState, errorLoc?: string) => {
   const currentMetaId = state.metaTypeIdStack.pop()!;
   const finalMetaId = state.finalMetaTypeIdStack.pop()!;
   const collectedAttrNames = state.attrsOfCurrentVm.pop()!;
-  state.pendingStatements.push(
+  state.typingPendingStatements.push(
     createReplacementHolder(state, {
       type: "exitVM",
       metaType: currentMetaId.name,
@@ -203,13 +141,13 @@ const exitVM = (state: TypingTranspileState, errorLoc?: string) => {
       finalMetaType: finalMetaId.name,
       collectedAttrs: collectedAttrNames,
       errorLoc,
-    })
+    }),
   );
 };
 
 const enterAttr = (
   state: TypingTranspileState,
-  attrName: string
+  attrName: string,
 ): { lhsId: Identifier } => {
   const defTypeId = state.vmDefTypeIdStack.at(-1);
   const metaTypeId = state.metaTypeIdStack.at(-1);
@@ -222,13 +160,14 @@ const enterAttr = (
     type: "Identifier",
     name: `__gts_attr_obj_${state.idCounter++}`,
   };
-  state.pendingStatements.push(
+  state.typingPendingStatements.push(
     createReplacementHolder(state, {
       type: "enterAttr",
       defType: defTypeId.name,
       metaType: metaTypeId.name,
       lhs: lhsId.name,
-    })
+      attrName,
+    }),
   );
   return { lhsId: lhsId };
 };
@@ -238,21 +177,21 @@ const genBindingTyping = (
   info: {
     attrName: string;
     typingId: Identifier;
-  }
+  },
 ) => {
   const finalMetaId = state.finalMetaTypeIdStack.at(-1);
   const defTypeId = state.vmDefTypeIdStack.at(-1);
   if (!finalMetaId || !defTypeId) {
     return;
   }
-  state.pendingStatements.push(
+  state.typingPendingStatements.push(
     createReplacementHolder(state, {
       type: "createBindingTyping",
       finalMetaType: finalMetaId.name,
       defType: defTypeId.name,
       attrName: info.attrName,
       typingId: info.typingId.name,
-    })
+    }),
   );
 };
 
@@ -266,14 +205,14 @@ const exitAttr = (state: TypingTranspileState, returningId: Identifier) => {
     name: `__gts_newMeta__${state.idCounter++}`,
   };
   const [oldMetaTypeId] = state.metaTypeIdStack.splice(-1, 1, newMetaTypeId);
-  state.pendingStatements.push(
+  state.typingPendingStatements.push(
     createReplacementHolder(state, {
       type: "exitAttr",
       defType: currentDefId.name,
       oldMetaType: oldMetaTypeId.name,
       newMetaType: newMetaTypeId.name,
       returnType: returningId.name,
-    })
+    }),
   );
 };
 
@@ -286,133 +225,82 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
       ) {
         state.defineLeadingComments = stmt.leadingComments;
         visit(stmt);
-        body.push(...state.pendingStatements);
-        state.pendingStatements = [];
+        body.push(...state.typingPendingStatements);
+        state.typingPendingStatements = [];
       } else {
         body.push(visit(stmt) as Statement);
       }
     }
-    if (state.externalizedBindings.length > 0) {
-      body.unshift(
-        {
-          type: "ImportDeclaration",
-          specifiers: [
-            {
-              type: "ImportDefaultSpecifier",
-              local: state.binderFnId,
+    for (const extBinding of state.externalizedBindings) {
+      const varDecl: VariableDeclaration = {
+        type: "VariableDeclaration",
+        kind: "const",
+        declarations: [
+          {
+            type: "VariableDeclarator",
+            id: extBinding.bindingName,
+            init: ANY_INIT,
+            typeAnnotation: {
+              type: "TSTypeAnnotation",
+              typeAnnotation: {
+                type: "TSTypeReference",
+                typeName: extBinding.typingId,
+              },
             },
-          ],
-          source: {
-            type: "Literal",
-            value: `${state.providerImportSource}/binder`,
-          },
+          } as VariableDeclarator,
+        ],
+      };
+      if (extBinding.export) {
+        body.unshift({
+          type: "ExportNamedDeclaration",
+          declaration: varDecl,
+          specifiers: [],
+          source: null,
           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: [],
-                    leadingComments: binding.leadingComments,
-                  },
-                ]
-              : [
-                  internalDecl,
-                  {
-                    ...externalDecl,
-                    leadingComments: binding.leadingComments,
-                  },
-                ];
-          }
-        )
-      );
+          leadingComments: extBinding.leadingComments,
+        } as ExportNamedDeclaration);
+      } else {
+        varDecl.leadingComments = extBinding.leadingComments;
+        body.unshift(varDecl);
+      }
     }
-    if (state.prefaceInserted) {
+    if (state.hasQueryExpressions) {
       body.unshift({
         type: "ImportDeclaration",
+        diagnosticsOnTop: true,
         specifiers: [
           {
             type: "ImportDefaultSpecifier",
-            local: state.rootVmId,
+            local: state.queryFnId,
           },
         ],
         source: {
           type: "Literal",
-          value: `${state.providerImportSource}/rootVM`,
+          value: `${state.providerImportSource}/query`,
         },
         attributes: [],
       });
     }
-    if (state.hasQueryExpressions) {
-      body.unshift({
+    body.unshift(
+      {
         type: "ImportDeclaration",
+        diagnosticsOnTop: true,
         specifiers: [
           {
             type: "ImportDefaultSpecifier",
-            local: state.queryFnId,
+            local: state.rootVmId,
           },
         ],
         source: {
           type: "Literal",
-          value: `${state.providerImportSource}/query`,
+          value: `${state.providerImportSource}/vm`,
         },
         attributes: [],
-      });
-    }
+      },
+      createReplacementHolder(state, {
+        type: "preface",
+      }),
+    );
     return {
       ...node,
       body,
@@ -427,18 +315,24 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
   GTSNamedAttributeDefinition(node, { visit, state }) {
     const { name, body, bindingName } = node;
     const attrName = JSON.stringify(
-      name.type === "Literal" ? String(name.value) : name.name
+      name.type === "Literal" ? String(name.value) : name.name,
     );
+    const attributeNameToken = state.leafTokens.find((t) => t.loc === name.loc);
+    if (attributeNameToken) {
+      attributeNameToken.sourceLengthOffset = 1;
+    }
     const { lhsId } = enterAttr(state, attrName);
+    state.extraMappings.set(
+      `${name.loc?.start.line}:${name.loc?.start.column}`,
+      `${lhsId.name}${name.type === "Literal" ? `[` : `.`}`,
+    );
     const positionals = body.positionalAttributes.attributes.map(
       (attr): Expression => {
         if (attr.type === "Identifier" && /^[a-z_]/.test(attr.name)) {
           const token = state.leafTokens.find((t) => t.loc === attr.loc);
           if (token) {
-            token.locationAdjustment = {
-              startOffset: 1,
-              generatedLength: attr.name.length + 2, // quotation mark
-            };
+            token.generatedStartOffset = 1;
+            token.generatedLength = attr.name.length + 2; // quotation mark
           }
           return {
             type: "Literal",
@@ -448,13 +342,13 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         } else {
           return visit(attr) as Expression;
         }
-      }
+      },
     );
     const returnValue: Identifier = {
       type: "Identifier",
       name: `__gts_attrRet_${state.idCounter++}`,
     };
-    state.pendingStatements.push({
+    state.typingPendingStatements.push({
       type: "VariableDeclaration",
       kind: "const",
       declarations: [
@@ -481,15 +375,11 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
       visit(body.namedAttributes);
       exitVM(
         state,
-        `${body.namedAttributes.loc?.start.line}:${body.namedAttributes.loc?.start.column}`
+        `${body.namedAttributes.loc?.start.line}:${body.namedAttributes.loc?.start.column}`,
       );
     }
     if (bindingName) {
       const export_ = node.bindingAccessModifier !== "private";
-      const internalId: Identifier = {
-        type: "Identifier",
-        name: `__gts_internal_binding_${state.externalizedBindings.length}`,
-      };
       const typingId: Identifier = {
         type: "Identifier",
         name: `gts_binding_type_${state.externalizedBindings.length}`,
@@ -510,15 +400,6 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
           },
         } as Identifier,
         export: export_,
-        internalId,
-        value: { type: "Literal", value: null }, // TODO
-        path: [...state.attributeNames, node.name].map((n) => {
-          if (n.type === "Literal") {
-            return String(n.value);
-          } else {
-            return n.name;
-          }
-        }),
         typingId,
         leadingComments: state.defineLeadingComments,
       });
@@ -531,7 +412,14 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
       visit(attr);
     }
     if (node.directAction) {
-      const { lhsId } = enterAttr(state, state.ActionId.name);
+      const attrName = JSON.stringify(state.ActionLit.value);
+      const { lhsId } = enterAttr(state, attrName);
+      const actionNotExistsReplacementStr = `${lhsId.name}[${attrName}]`;
+      const actionNotExistsErrorLoc = `${node.directAction.loc?.start.line}:${node.directAction.loc?.start.column}`;
+      state.extraMappings.set(
+        actionNotExistsErrorLoc,
+        actionNotExistsReplacementStr,
+      );
       const fn: ArrowFunctionExpression = {
         type: "ArrowFunctionExpression",
         params: state.shortcutFunctionParameters,
@@ -545,7 +433,7 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         type: "Identifier",
         name: `__gts_attrRet_${state.idCounter++}`,
       };
-      state.pendingStatements.push({
+      state.typingPendingStatements.push({
         type: "VariableDeclaration",
         kind: "const",
         declarations: [
@@ -558,7 +446,7 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
               callee: {
                 type: "MemberExpression",
                 object: lhsId,
-                property: state.ActionId,
+                property: state.ActionLit,
                 computed: true,
                 optional: false,
               },

package/src/types.ts

@@ -25,6 +25,18 @@ declare module "estree" {
     GTSQueryExpression: GTSQueryExpression;
   }
 
+  interface ImportDeclaration {
+    /** Emit inner diagnostics to the top-of-file */
+    diagnosticsOnTop?: boolean;
+  }
+
+  interface SimpleCallExpression {
+    lParenLoc?: SourceLocation;
+  }
+  interface NewExpression {
+    lParenLoc?: SourceLocation;
+  }
+
   interface GTSDefineStatement extends BaseStatement {
     type: "GTSDefineStatement";
     body: GTSNamedAttributeDefinition;
@@ -32,10 +44,10 @@ declare module "estree" {
 
   interface GTSNamedAttributeDefinition extends BaseNode {
     type: "GTSNamedAttributeDefinition";
-    name: AST.Identifier | AST.Literal;
+    name: Identifier | Literal;
     body: GTSAttributeBody;
     bindingAccessModifier?: "public" | "protected" | "private";
-    bindingName?: AST.Identifier;
+    bindingName?: Identifier;
   }
 
   interface GTSAttributeBody extends BaseNode {
@@ -46,7 +58,7 @@ declare module "estree" {
 
   interface GTSPositionalAttributeList extends BaseNode {
     type: "GTSPositionalAttributeList";
-    attributes: AST.Expression[];
+    attributes: Expression[];
   }
 
   interface GTSNamedAttributeBlock extends BaseNode {
@@ -67,7 +79,7 @@ declare module "estree" {
 
   interface GTSShortcutFunctionExpression extends BaseExpression {
     type: "GTSShortcutFunctionExpression";
-    body: AST.BlockStatement | AST.Expression;
+    body: BlockStatement | Expression;
     expression: boolean;
   }
 

package/src/transform/NOTES.md

@@ -1,112 +0,0 @@
-# transpiler 构思
-
-对于每个 named attribute，生成一个函数返回 attribute information；define 语句返回 `createDefine`
-
-```ts
-define foo bar, baz, {
-  a 42;
-}
-```
-
-```js
-import { createDefine } from "@gi-tcg/gts-runtime";
-import rootVM from "#provider/vm";
-
-createDefine(rootVM, {
-  attributes: [
-    () => ({
-      name: "foo",
-      positionals: ["bar", "baz"],
-      named: {
-        attributes: [
-          () => ({
-            name: "a",
-            positionals: [42],
-          })
-        ]
-      }
-    })
-  ]
-});
-```
-
-## bindings
-
-对于 bindings，将所有 binding 本身的 attribute definition 提出来，然后用 binder 返回具体值：
-
-```
-define foo bar, baz, {
-  id 1101 as Ganyu;
-  a 42;
-}
-```
-
-```js
-import { createDefine } from "@gi-tcg/gts-runtime";
-import rootVM from "#provider/vm";
-import binder from "#provider/binder";
-
-// ALWAYS on top of the module
-const __id_attribute = () => ({
-  name: "id",
-  positionals: [1101],
-})
-export const Ganyu = binder(__id_attribute, {
-  path: ["foo", "id"],
-});
-
-// -----
-
-createDefine(rootVM, {
-  attributes: [
-    () => ({
-      name: "foo",
-      positionals: ["bar", "baz"],
-      named: {
-        attributes: [
-          __id_attribute,
-          () => ({
-            name: "a",
-            positionals: [42],
-          })
-        ]
-      }
-    })
-  ]
-});
-```
-
-## TS VirtualCode
-
-不产出真实运行时代码，只产出类型推导代码
-
-```
-define foo bar, baz, {
-  id 1101 as Ganyu;
-  a 42;
-}
-```
-
-```ts
-import rootVM from "#provider/vm";
-import binder from "#provider/binder";
-
-export const Ganyu: Binding0 = (void 0)!;
-
-type VMDef = (typeof rootVM)[NamedDefinition];
-type Meta0 = VMDef[Meta];
-
-let obj0!: { [Meta]: Meta0 } & Omit<VMDef, Meta>;
-let return0 = obj0.id(123); // <- cursor after `.` for suggestion of attribute name; after `(` for positional args
-type Return0 = typeof return0;
-// Override parent meta: Attatch `rewriteMeta` to obj's [Meta]
-type Meta1 = Return0 extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : Meta0;
-let obj1!: { [Meta]: Meta1 } & Omit<VMDef, Meta>;
-// Infer binding type: Attach `as` to a [Meta]-contained object
-type AsType0 = typeof obj0.id extends { as: infer As } ? As : unknown;
-let inferBindingObj0 = { [Meta]: obj1[Meta], as: 0 as any as AsType1 };
-let binding0 = inferBindingObj0.as();
-type Binding0 = typeof binding0;
-
-let return1 = obj1.a(42); // same as above
-```