@gi-tcg/gts-transpiler 0.2.0 → 0.3.0

package/src/transform/volar/walker.ts

@@ -38,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[];
@@ -53,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 */
   typingPendingStatements: Statement[];
   replacementTag: Identifier;
-  additionalMappings: Map<string, string>;
+  extraMappings: Map<string, string>;
 }
 
 const EMPTY: EmptyStatement = { type: "EmptyStatement" };
@@ -74,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.typingPendingStatements.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++}`,
@@ -154,7 +91,7 @@ const enterVMFromRoot = (state: TypingTranspileState) => {
       vm: state.rootVmId.name,
       defType: defTypeId.name,
       metaType: metaTypeId.name,
-    })
+    }),
   );
   state.vmDefTypeIdStack.push(defTypeId);
   state.metaTypeIdStack.push(metaTypeId);
@@ -163,7 +100,7 @@ const enterVMFromRoot = (state: TypingTranspileState) => {
 };
 const enterVMFromAttr = (
   state: TypingTranspileState,
-  returningId: Identifier
+  returningId: Identifier,
 ) => {
   const defTypeId: Identifier = {
     type: "Identifier",
@@ -183,7 +120,7 @@ const enterVMFromAttr = (
       returnType: returningId.name,
       defType: defTypeId.name,
       metaType: metaTypeId.name,
-    })
+    }),
   );
   state.vmDefTypeIdStack.push(defTypeId);
   state.metaTypeIdStack.push(metaTypeId);
@@ -204,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);
@@ -229,7 +166,8 @@ const enterAttr = (
       defType: defTypeId.name,
       metaType: metaTypeId.name,
       lhs: lhsId.name,
-    })
+      attrName,
+    }),
   );
   return { lhsId: lhsId };
 };
@@ -239,7 +177,7 @@ const genBindingTyping = (
   info: {
     attrName: string;
     typingId: Identifier;
-  }
+  },
 ) => {
   const finalMetaId = state.finalMetaTypeIdStack.at(-1);
   const defTypeId = state.vmDefTypeIdStack.at(-1);
@@ -253,7 +191,7 @@ const genBindingTyping = (
       defType: defTypeId.name,
       attrName: info.attrName,
       typingId: info.typingId.name,
-    })
+    }),
   );
 };
 
@@ -274,7 +212,7 @@ const exitAttr = (state: TypingTranspileState, returningId: Identifier) => {
       oldMetaType: oldMetaTypeId.name,
       newMetaType: newMetaTypeId.name,
       returnType: returningId.name,
-    })
+    }),
   );
 };
 
@@ -311,7 +249,6 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
             },
           } as VariableDeclarator,
         ],
-        leadingComments: extBinding.leadingComments,
       };
       if (extBinding.export) {
         body.unshift({
@@ -320,43 +257,50 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
           specifiers: [],
           source: null,
           attributes: [],
+          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}/vm`,
+          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,
@@ -371,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",
@@ -392,7 +342,7 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         } else {
           return visit(attr) as Expression;
         }
-      }
+      },
     );
     const returnValue: Identifier = {
       type: "Identifier",
@@ -425,7 +375,7 @@ 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) {
@@ -462,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,
@@ -489,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;
   }