@gi-tcg/gts-transpiler 0.3.2 → 0.3.3

package/src/transform/volar/replacements.ts

@@ -1,5 +1,12 @@
 import type { ExpressionStatement } from "estree";
 import type { TypingTranspileState } from "./walker.ts";
+import dedent from "dedent";
+import type { CodeMapping } from "@volar/language-core";
+
+interface MatchInfo {
+  sourceEnd: number;
+  lengthOffset: number;
+}
 
 type ReplacementPayload =
   | {
@@ -23,7 +30,7 @@ type ReplacementPayload =
       defType: string;
       collectedAttrs: string[];
       finalMetaType: string;
-      errorLoc?: string;
+      errorRange?: [number, number];
     }
   | {
       type: "enterAttr";
@@ -75,55 +82,54 @@ export const createReplacementHolder = (
 export function applyReplacements(
   state: TypingTranspileState,
   code: string,
+  mappings: CodeMapping[],
 ): string {
   const replacementRegex = new RegExp(
-    "\\b" + state.replacementTag.name + "`(.*?)`",
+    "\\b" + state.replacementTag.name + "`(.*?)(?<!\\\\)`",
     "gm",
   );
   const { NamedDefinitionLit, MetaLit } = state;
   const NamedDefinition = JSON.stringify(NamedDefinitionLit.value);
   const Meta = JSON.stringify(MetaLit.value);
-  const oneLine = (
-    strings: TemplateStringsArray,
-    ...values: Array<string | number | boolean>
-  ): string =>
-    strings
-      .reduce(
-        (result, chunk, index) =>
-          result + chunk + (index < values.length ? values[index] : ""),
-        "",
-      )
-      .replace(/\n[ \t]*/g, " ")
-      .trim();
-  // All replacement should be written in one line to avoid messing up source map
-  return code.replace(replacementRegex, (_, rawPayload) => {
-    const payload: ReplacementPayload = JSON.parse(rawPayload);
-    if (payload.type === "preface") {
-      return oneLine`
+  const matchInfos: MatchInfo[] = [];
+
+  const result = code.replace(
+    replacementRegex,
+    (match, rawPayload: string, offset: number) => {
+      const payload: ReplacementPayload = JSON.parse(
+        rawPayload.replace(/\\`/g, "`"),
+      );
+      let replacement: string;
+      if (payload.type === "preface") {
+        replacement = dedent`
         namespace ${state.utilNsId.name} {
           export type UniqueKeyProbSegment = "__gts_unique_prob_seg__";
           export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
         }
       `;
-    } else if (payload.type === "enterVMFromRoot") {
-      return oneLine`
+      } else if (payload.type === "enterVMFromRoot") {
+        replacement = dedent`
         type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition}];
         type ${payload.metaType} = ${payload.defType}[${Meta}];
       `;
-    } else if (payload.type === "enterVMFromAttr") {
-      return oneLine`
+      } else if (payload.type === "enterVMFromAttr") {
+        replacement = dedent`
         type ${payload.defType} = ${payload.returnType} extends { namedDefinition: infer Def } ? Def : { ${Meta}: unknown };
         type ${payload.metaType} = ${payload.defType}[${Meta}];
       `;
-    } else if (payload.type === "exitVM") {
-      const lhs = `${payload.finalMetaType}_lhs`;
-      const requiredAttrsNs = `${payload.finalMetaType}_rans`;
-      const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ")}`;
-      const needleString = `"${requiredAttrsNs}_NeedleString" as any as "required attributes are missing"`;
-      if (payload.errorLoc) {
-        state.extraMappings.set(payload.errorLoc, needleString);
-      }
-      return oneLine`
+      } else if (payload.type === "exitVM") {
+        const lhs = `${payload.finalMetaType}_lhs`;
+        const requiredAttrsNs = `${payload.finalMetaType}_rans`;
+        const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ")}`;
+        const needleString = `"${requiredAttrsNs}_NeedleString" as any as "required attributes are missing"`;
+        if (payload.errorRange) {
+          state.extraMappings.push({
+            sourceOffset: payload.errorRange[0],
+            length: payload.errorRange[1] - payload.errorRange[0],
+            generatedNeedle: needleString,
+          });
+        }
+        replacement = dedent`
         type ${payload.finalMetaType} = ${payload.metaType};
         let ${lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${Meta}>;
         type ${lhs} = typeof ${lhs};
@@ -133,16 +139,17 @@ export function applyReplacements(
         };
         ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
       `;
-    } else if (payload.type === "enterAttr") {
-      const uniqueKeyLhs = `${payload.lhs}_uniqueKey_lhs`;
-      const uniqueKey = `${payload.lhs}_uniqueKey`;
-      const uniqueKeyForThis = `${payload.lhs}_uniqueKeyFor_${payload.lhs}`;
-      const uniqueKeyHelperIntf = `${payload.defType}_uniqueKeyProbeHelper`;
-      const omittedKeys = `${payload.lhs}_omittedKeys`;
-      return oneLine`
+      } else if (payload.type === "enterAttr") {
+        const uniqueKeyLhs = `${payload.lhs}_uniqueKey_lhs`;
+        const uniqueKey = `${payload.lhs}_uniqueKey`;
+        const uniqueKeyForThis = `${payload.lhs}_uniqueKeyFor_${payload.lhs}`;
+        const uniqueKeyHelperIntf = `${payload.defType}_uniqueKeyProbeHelper`;
+        const omittedKeys = `${payload.lhs}_omittedKeys`;
+        replacement = dedent`
         type ${uniqueKeyLhs} = {
           ${Meta}: ${payload.metaType}; 
           uniqueKey: ${payload.defType} extends { [${payload.attrName}]: { uniqueKey: infer UniqueKey } } ? UniqueKey : () => 0;
+        };
         
         let ${uniqueKeyLhs}!: ${uniqueKeyLhs};
         let ${uniqueKey} = ${uniqueKeyLhs}.uniqueKey();
@@ -164,9 +171,9 @@ export function applyReplacements(
         );
         let ${payload.lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${omittedKeys}>;
       `;
-    } else if (payload.type === "createBindingTyping") {
-      const typingIdLhs = `${payload.typingId}_lhs`;
-      return oneLine`
+      } else if (payload.type === "createBindingTyping") {
+        const typingIdLhs = `${payload.typingId}_lhs`;
+        replacement = dedent`
         type ${typingIdLhs} = {
           ${Meta}: ${payload.finalMetaType};
           as: ${payload.defType} extends { [${payload.attrName}]: { as: infer As } } ? As : unknown;
@@ -175,13 +182,34 @@ export function applyReplacements(
         let ${payload.typingId} = ${typingIdLhs}.as();
         type ${payload.typingId} = typeof ${payload.typingId};
       `;
-    } else if (payload.type === "exitAttr") {
-      return oneLine`
+      } else if (payload.type === "exitAttr") {
+        replacement = dedent`
         type ${payload.returnType} = typeof ${payload.returnType};
         type ${payload.newMetaType} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType}
       `;
-    } else {
-      return "";
+      } else {
+        replacement = "";
+      }
+      matchInfos.push({
+        sourceEnd: offset + match.length,
+        lengthOffset: replacement.length - match.length,
+      });
+      return replacement;
+    },
+  );
+
+  for (const mapping of mappings) {
+    for (let i = 0; i < mapping.generatedOffsets.length; i++) {
+      const orig = mapping.generatedOffsets[i];
+      let shift = 0;
+      for (const info of matchInfos) {
+        if (orig >= info.sourceEnd) {
+          shift += info.lengthOffset;
+        }
+      }
+      mapping.generatedOffsets[i] = orig + shift;
     }
-  });
+  }
+
+  return result;
 }

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,7 +52,29 @@ 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>;
+  /** 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;
+  }[];
 }
 
 const EMPTY: EmptyStatement = { type: "EmptyStatement" };
@@ -128,7 +147,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 +159,7 @@ const exitVM = (state: TypingTranspileState, errorLoc?: string) => {
       defType: currentDefTypeId.name,
       finalMetaType: finalMetaId.name,
       collectedAttrs: collectedAttrNames,
-      errorLoc,
+      errorRange,
     }),
   );
 };
@@ -153,7 +172,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 = {
@@ -264,10 +283,10 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         body.unshift(varDecl);
       }
     }
+    const importDecls: ImportDeclaration[] = [];
     if (state.hasQueryExpressions) {
-      body.unshift({
+      importDecls.push({
         type: "ImportDeclaration",
-        diagnosticsOnTop: true,
         specifiers: [
           {
             type: "ImportDefaultSpecifier",
@@ -281,22 +300,28 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         attributes: [],
       });
     }
-    body.unshift(
-      {
-        type: "ImportDeclaration",
-        diagnosticsOnTop: true,
-        specifiers: [
-          {
-            type: "ImportDefaultSpecifier",
-            local: state.rootVmId,
-          },
-        ],
-        source: {
-          type: "Literal",
-          value: `${state.providerImportSource}/vm`,
+    importDecls.push({
+      type: "ImportDeclaration",
+      specifiers: [
+        {
+          type: "ImportDefaultSpecifier",
+          local: state.rootVmId,
         },
-        attributes: [],
+      ],
+      source: {
+        type: "Literal",
+        value: `${state.providerImportSource}/vm`,
       },
+      attributes: [],
+    });
+    for (const importDecl of importDecls) {
+      state.diagnosticsOnTopNodes.add(importDecl.source);
+      for (const specifier of importDecl.specifiers) {
+        state.diagnosticsOnTopNodes.add(specifier);
+      }
+    }
+    body.unshift(
+      ...importDecls,
       createReplacementHolder(state, {
         type: "preface",
       }),
@@ -317,30 +342,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 +363,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 +394,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 +403,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 +442,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 +488,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 {