@gi-tcg/gts-transpiler 0.3.2 → 0.3.4

package/src/transform/volar/walker.ts

@@ -1,21 +1,19 @@
 import type { Visitors } from "zimmerframe";
 import type {
-  ArrayExpression,
   ArrowFunctionExpression,
-  BlockStatement,
   Comment,
-  Declaration,
   EmptyStatement,
   ExportNamedDeclaration,
   Expression,
   ExpressionStatement,
   GTSDefineStatement,
   Identifier,
+  ImportDeclaration,
   Literal,
   MemberExpression,
   Node,
   Program,
-  SourceLocation,
+  SimpleLiteral,
   Statement,
   VariableDeclaration,
   VariableDeclarator,
@@ -25,8 +23,8 @@ import {
   type ExternalizedBinding,
   type TranspileState,
 } from "../gts.ts";
-import type { LeafToken } from "./collect_tokens.ts";
 import { createReplacementHolder } from "./replacements.ts";
+import type { SourceRange } from "espolar";
 
 interface ExternalizedTypedBinding extends ExternalizedBinding {
   typingId: Identifier;
@@ -34,7 +32,6 @@ interface ExternalizedTypedBinding extends ExternalizedBinding {
 }
 
 export interface TypingTranspileState extends TranspileState {
-  leafTokens: LeafToken[];
   externalizedBindings: ExternalizedTypedBinding[];
   idCounter: number;
   rootVmId: Identifier;
@@ -55,23 +52,40 @@ export interface TypingTranspileState extends TranspileState {
   /** Pending statements to be inserted to the top-level */
   typingPendingStatements: Statement[];
   replacementTag: Identifier;
-  extraMappings: Map<string, string>;
+  /** untouched source nodes */
+  sourceNodes: WeakSet<Node>;
+  /**
+   * The callee of typing source of GTS' attribute names. Map the character
+   * after the name (typically whitespace) as the lParen of CallExpression
+   */
+  namedAttributeCalleeLParenRange: WeakMap<Node, SourceRange>;
+  /**
+   * String literal nodes that are derived from identifiers.
+   * - sourceStart += 1
+   * - sourceLength -= 2
+   */
+  literalFromIdentifier: WeakSet<Literal>;
+  /** Nodes that are last arguments of a CallExpression */
+  lastArgNodes: WeakSet<Node>;
+  /**
+   * The last import declaration, record if it is a generated one.
+   * This declaration marks the TS auto-import insertion point.
+   */
+  lastImportDeclarationIfGen: ImportDeclaration | null;
+  /** Nodes that have a diagnostic mappings to the top of the file */
+  diagnosticsOnTopNodes: WeakSet<Node>;
+  /** Extra mappings, the generated range will be found by the needle after replacement */
+  extraMappings: {
+    sourceOffset: number;
+    length: number;
+    generatedNeedle: string;
+  }[];
+  /** Character offset after hashbang and file-scope leading comments */
+  contentStartOffset: number;
 }
 
 const EMPTY: EmptyStatement = { type: "EmptyStatement" };
 
-const ANY = {
-  type: "TSAnyKeyword",
-};
-
-// definite not supported by esrap yet, so we init the binding with an `as any` cast
-// https://github.com/sveltejs/esrap/issues/95
-const ANY_INIT = {
-  type: "TSAsExpression",
-  expression: { type: "Literal", value: 0 },
-  typeAnnotation: ANY,
-} as {} as Expression;
-
 const enterVMFromRoot = (state: TypingTranspileState) => {
   let defTypeId: Identifier = {
     type: "Identifier",
@@ -128,7 +142,7 @@ const enterVMFromAttr = (
   state.attrsOfCurrentVm.push([]);
 };
 
-const exitVM = (state: TypingTranspileState, errorLoc?: string) => {
+const exitVM = (state: TypingTranspileState, errorRange?: [number, number]) => {
   const currentDefTypeId = state.vmDefTypeIdStack.pop()!;
   const currentMetaId = state.metaTypeIdStack.pop()!;
   const finalMetaId = state.finalMetaTypeIdStack.pop()!;
@@ -140,7 +154,7 @@ const exitVM = (state: TypingTranspileState, errorLoc?: string) => {
       defType: currentDefTypeId.name,
       finalMetaType: finalMetaId.name,
       collectedAttrs: collectedAttrNames,
-      errorLoc,
+      errorRange,
     }),
   );
 };
@@ -153,7 +167,7 @@ const enterAttr = (
   const metaTypeId = state.metaTypeIdStack.at(-1);
   if (!defTypeId || !metaTypeId) {
     // TODO error handling?
-    return { lhsId: { type: "Identifier", name: "__invalid_attr_obj" } };
+    return { lhsId: { type: "Identifier", name: "__gts_invalid_attr_obj" } };
   }
   state.attrsOfCurrentVm.at(-1)!.push(attrName);
   const lhsId: Identifier = {
@@ -239,7 +253,7 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
           {
             type: "VariableDeclarator",
             id: extBinding.bindingName,
-            init: ANY_INIT,
+            // @ts-expect-error TS property not provided in ESTree
             typeAnnotation: {
               type: "TSTypeAnnotation",
               typeAnnotation: {
@@ -247,7 +261,14 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
                 typeName: extBinding.typingId,
               },
             },
-          } as VariableDeclarator,
+            init: {
+              type: "TSNonNullExpression",
+              expression: {
+                type: "Literal",
+                value: null,
+              } satisfies Expression,
+            } as any,
+          },
         ],
       };
       if (extBinding.export) {
@@ -264,39 +285,66 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         body.unshift(varDecl);
       }
     }
-    if (state.hasQueryExpressions) {
-      body.unshift({
+    const importDecls: ImportDeclaration[] = [];
+    importDecls.push(
+      {
         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: [],
-      });
-    }
-    body.unshift(
+      },
       {
         type: "ImportDeclaration",
-        diagnosticsOnTop: true,
         specifiers: [
           {
-            type: "ImportDefaultSpecifier",
-            local: state.rootVmId,
+            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.providerImportSource}/vm`,
-        },
+        source: { type: "Literal", value: state.runtimeImportSource },
         attributes: [],
       },
+    );
+    for (const importDecl of importDecls) {
+      state.diagnosticsOnTopNodes.add(importDecl.source);
+      for (const specifier of importDecl.specifiers) {
+        state.diagnosticsOnTopNodes.add(specifier);
+      }
+    }
+    const lastImportDecl = importDecls.pop() ?? {
+      type: "ImportDeclaration",
+      specifiers: [],
+      source: { type: "Literal", value: "" },
+      attributes: [],
+    } satisfies ImportDeclaration;
+    body.unshift(
+      ...importDecls,
+      // Add an unrelated statement between system generated imports to make them unsorted,
+      // so that TSServer will always insert auto-imports after the last ImportDeclaration.
+      // `lastImportDecl` will be marked as insertion point in printer if no user's
+      // ImportDeclaration is provided
+      {
+        type: "ExpressionStatement",
+        expression: {
+          type: "Literal",
+          value: 0,
+        }
+      },
+      lastImportDecl,
       createReplacementHolder(state, {
         type: "preface",
       }),
@@ -317,30 +365,20 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
     const attrName = JSON.stringify(
       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.generatedStartOffset = 1;
-            token.generatedLength = attr.name.length + 2; // quotation mark
-          }
-          return {
+          const lit: SimpleLiteral = {
             type: "Literal",
             value: attr.name,
             loc: attr.loc,
+            range: attr.range,
           };
+          state.literalFromIdentifier.add(lit);
+          return lit;
         } else {
-          return visit(attr) as Expression;
+          return { ...(visit(attr) as Expression) };
         }
       },
     );
@@ -348,6 +386,27 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
       type: "Identifier",
       name: `__gts_attrRet_${state.idCounter++}`,
     };
+    const callee: MemberExpression = {
+      type: "MemberExpression",
+      object: lhsId,
+      property: name,
+      computed: name.type === "Literal",
+      optional: false,
+    };
+    if (name.range) {
+      // If the `obj.name` is not callable, the error squiggle begins from `obj` not `name`
+      // Add a diagnostic-only mapping from the `name` to a call starting from `obj.`
+      // This should be unique since each attribute decl generates a new obj name
+      state.extraMappings.push({
+        sourceOffset: name.range[0],
+        length: name.range[1] - name.range[0],
+        generatedNeedle: `${lhsId.name}${name.type === "Literal" ? `[` : `.`}`,
+      });
+      state.namedAttributeCalleeLParenRange.set(callee, {
+        start: name.range[1],
+        end: name.range[1] + 1,
+      });
+    }
     state.typingPendingStatements.push({
       type: "VariableDeclaration",
       kind: "const",
@@ -358,13 +417,7 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
           init: {
             type: "CallExpression",
             optional: false,
-            callee: {
-              type: "MemberExpression",
-              object: lhsId,
-              property: name,
-              computed: name.type === "Literal",
-              optional: false,
-            },
+            callee,
             arguments: positionals,
           },
         },
@@ -373,16 +426,13 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
     if (body.namedAttributes) {
       enterVMFromAttr(state, returnValue);
       visit(body.namedAttributes);
-      exitVM(
-        state,
-        `${body.namedAttributes.loc?.start.line}:${body.namedAttributes.loc?.start.column}`,
-      );
+      exitVM(state, body.namedAttributes.range);
     }
     if (bindingName) {
       const export_ = node.bindingAccessModifier !== "private";
       const typingId: Identifier = {
         type: "Identifier",
-        name: `gts_binding_type_${state.externalizedBindings.length}`,
+        name: `__gts_binding_type_${state.externalizedBindings.length}`,
       };
       genBindingTyping(state, {
         attrName,
@@ -415,11 +465,13 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
       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,
-      );
+      if (node.directAction.range) {
+        state.extraMappings.push({
+          sourceOffset: node.directAction.range[0],
+          length: node.directAction.range[1] - node.directAction.range[0],
+          generatedNeedle: actionNotExistsReplacementStr,
+        });
+      }
       const fn: ArrowFunctionExpression = {
         type: "ArrowFunctionExpression",
         params: state.shortcutFunctionParameters,
@@ -459,14 +511,4 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
     return EMPTY;
   },
   ...(commonGtsVisitor as Visitors<Node, TypingTranspileState>),
-  GTSShortcutArgumentExpression(node, { state, visit }): MemberExpression {
-    const lhs = { ...state.fnArgId };
-    return {
-      type: "MemberExpression",
-      object: lhs,
-      computed: false,
-      optional: false,
-      property: visit(node.property) as Identifier,
-    };
-  },
 };

package/src/types.ts

@@ -6,7 +6,6 @@ import type * as AST from "estree";
 type ForInit = boolean | "await";
 
 declare module "estree" {
-  
   interface Identifier {
     isDummy?: boolean;
   }
@@ -24,17 +23,12 @@ declare module "estree" {
     GTSShortcutFunctionExpression: GTSShortcutFunctionExpression;
     GTSQueryExpression: GTSQueryExpression;
   }
-
-  interface ImportDeclaration {
-    /** Emit inner diagnostics to the top-of-file */
-    diagnosticsOnTop?: boolean;
-  }
-
+  
   interface SimpleCallExpression {
-    lParenLoc?: SourceLocation;
+    lParenRange?: [number, number];
   }
   interface NewExpression {
-    lParenLoc?: SourceLocation;
+    lParenRange?: [number, number];
   }
 
   interface GTSDefineStatement extends BaseStatement {