@gi-tcg/gts-transpiler 0.3.2 → 0.3.4

package/src/transform/volar/printer.ts

@@ -1,123 +1,145 @@
-import tsPrinter from "esrap/languages/ts";
-import type { AST } from "../../types.ts";
-import type { Context, Visitors } from "esrap";
-import type { Node, SimpleCallExpression } from "estree";
+import type {
+  Identifier,
+  NewExpression,
+  Node,
+  SimpleCallExpression,
+} from "estree";
+import {
+  type PrintOptions,
+  type AST as EspolarAST,
+  defaultPrinters,
+} from "espolar";
+import type { CodeInformation } from "@volar/language-core";
+import {
+  DEFAULT_VOLAR_MAPPING_DATA,
+  VERIFICATION_ONLY_MAPPING_DATA,
+} from "./mappings.ts";
+import type { TypingTranspileState } from "./walker.ts";
 
-const printer = tsPrinter({
-  getLeadingComments: (node) => (node as AST.Node).leadingComments,
-  getTrailingComments: (node) => (node as AST.Node).trailingComments,
-});
-
-// Make the print of dummy identifier print nothing.
-// Exception: if GTS attribute list's last argument is dummy, e.g.
-//     foo bar, ;
-//             ^~ here
-// Then the printed JS will be `foo(bar, )` which WILL NOT be syntax error in ES6.
-// So we mark the lastArg manually and print an additional comma
-// for this dummy identifier, i.e. `foo(bar,,)` and TypeScript will recognize the error.
-
-const prevIdentifier = printer.Identifier!;
-printer.Identifier = function (node, context) {
-  if (node.isDummy) {
-    const text = Reflect.get(node, "lastArg") ? "," : "";
-    context.write(text, node);
-  } else {
-    prevIdentifier(node, context);
-  }
-};
-
-const prevCallNewExpression = printer.CallExpression!;
-const newCallNewExpression: typeof prevCallNewExpression = function (
-  node: SimpleCallExpression,
-  context,
-) {
-  const lastArg = node.arguments.at(-1);
-  if (lastArg) {
-    Reflect.set(lastArg, "lastArg", true);
-  }
-  if (!node.lParenLoc) {
-    return prevCallNewExpression(node, context);
-  }
-  let hasDeferredWrite = false;
-  let interceptionDone = false;
-  const lParenFakeNode = {
-    loc: node.lParenLoc!,
-  } as AST.Node;
-
-  // Map the print of `(` with the fake lParen node.
-  // The print of `(` can be happened in two area:
-  // 1. The wrapped parenthesis towards callee, which follows a `context.visit` to the callee;
-  // 2. The argument list (what we should map), which follows a `context.append` call
-  // so we defer the write of `(` to the next call of `context.visit|append`.
-  // If it is `context.append`, then make `context.write("(")` happens with our fake node
-  // and mapping will be added to the final code-mapping. Otherwise, keep original write.
-
-  const patchedWrite = (text: string, node?: AST.Node) => {
-    if (text === "(") {
-      hasDeferredWrite = true;
-    } else {
-      context.write(text, node);
-    }
-  };
-  const patchedVisit = (node: AST.Node) => {
-    if (hasDeferredWrite) {
-      context.write("(");
-    }
-    return context.visit(node);
-  };
-  const patchedAppend = (subcontext: Context) => {
-    if (hasDeferredWrite) {
-      context.write("(", lParenFakeNode);
-      // console.log("Inserted fake [LPAREN] for node at ", lParenFakeNode.loc);
-      interceptionDone = true;
-    }
-    return context.append(subcontext);
-  };
-  const proxiedContext = new Proxy(context, {
-    get(target, prop) {
-      if (!interceptionDone) {
-        if (prop === "write") {
-          return patchedWrite;
+export function getPrintOptions(
+  source: string,
+  state: TypingTranspileState,
+): PrintOptions<CodeInformation> {
+  return {
+    source,
+    isUntouched: (node) => {
+      if (node.type === "Identifier" && (node as Identifier).isDummy) {
+        return false;
+      }
+      return state.sourceNodes.has(node as Node);
+    },
+    getLeadingComments: (node) => (node as Node).leadingComments,
+    getTrailingComments: (node) => (node as Node).trailingComments,
+    getMappingData: () => DEFAULT_VOLAR_MAPPING_DATA,
+    printers: {
+      // Make the print of dummy identifier print nothing.
+      // Exception: if GTS attribute list's last argument is dummy, e.g.
+      //     foo bar, ;
+      //             ^~ here
+      // Then the printed JS will be `foo(bar, )` which WILL NOT be syntax error in ES6.
+      // So we mark the lastArg manually and print an additional comma
+      // for this dummy identifier, i.e. `foo(bar,,)` and TypeScript will recognize the error.
+      Identifier(node, context) {
+        const identifier = node as Identifier;
+        if (identifier.isDummy && identifier.range) {
+          const text = state.lastArgNodes.has(identifier) ? "," : "";
+          // extend the source mapping of dummy id to the before next token
+          let firstNonWhiteSpaceIndex = context.source
+            .slice(identifier.range[1])
+            .search(/\S/);
+          const rangeEnd =
+            firstNonWhiteSpaceIndex === -1
+              ? context.source.length
+              : identifier.range[1] + firstNonWhiteSpaceIndex;
+          context.writeMapped(text, identifier.range[0], rangeEnd);
+        } else {
+          return defaultPrinters.Identifier(node, context);
         }
-        if (prop === "visit") {
-          return patchedVisit;
+      },
+      Literal(node, context) {
+        const generatedStart = context.generatedOffset;
+        if (state.literalFromIdentifier.has(node) && node.range) {
+          const text = JSON.stringify(node.value);
+          context.write('"');
+          context.writeMapped(text.slice(1, -1), node.range[0], node.range[1]);
+          context.write('"');
+        } else {
+          defaultPrinters.Literal(node, context);
         }
-        if (prop === "append") {
-          return patchedAppend;
+        // For generated `import xxx from "yyy"`, add mappings from xxx and yyy
+        // to the top-of-file for diagnostics around missing / wrong imports. [[1]]
+        if (state.diagnosticsOnTopNodes.has(node)) {
+          const generatedEnd = context.generatedOffset;
+          context.createExtraMapping(
+            { start: 0, end: 1 },
+            generatedStart,
+            generatedEnd,
+            VERIFICATION_ONLY_MAPPING_DATA,
+          );
         }
+      },
+      // Same as [[1]]
+      ImportDefaultSpecifier(node, context) {
+        const generatedStart = context.generatedOffset;
+        defaultPrinters.ImportDefaultSpecifier(node, context);
+        if (state.diagnosticsOnTopNodes.has(node)) {
+          const generatedEnd = context.generatedOffset;
+          context.createExtraMapping(
+            { start: 0, end: 1 },
+            generatedStart,
+            generatedEnd,
+            VERIFICATION_ONLY_MAPPING_DATA,
+          );
+        }
+      },
+      // Same as [[1]]
+      ImportSpecifier(node, context) {
+        const generatedStart = context.generatedOffset;
+        defaultPrinters.ImportSpecifier(node, context);
+        if (state.diagnosticsOnTopNodes.has(node)) {
+          const generatedEnd = context.generatedOffset;
+          context.createExtraMapping(
+            { start: 0, end: 1 },
+            generatedStart,
+            generatedEnd,
+            VERIFICATION_ONLY_MAPPING_DATA,
+          );
+        }
+      },
+      // If the last import declaration is a generated one, because of we ensured that
+      // the generated import declarations are always unsorted, so TSServer will set the
+      // auto-insertion point next to this last import declaration.
+      // Add a mapping to that position (a written newline character) to the top-of-file,
+      // after skipping hashbang and leading comments.
+      // NOTE: since the insertion derived from here won't add additional newline *before*
+      // the inserted text, so here is a difference behavior from standard TSServer and our
+      // language server. We'd try our best.
+      ImportDeclaration(node, context) {
+        defaultPrinters.ImportDeclaration(node, context);
+        if (state.lastImportDeclarationIfGen === node) {
+          context.write("\n");
+          context.createExtraMapping(
+            {
+              start: state.contentStartOffset,
+              end: state.contentStartOffset + 1,
+            },
+            context.generatedOffset,
+            context.generatedOffset + 1,
+            DEFAULT_VOLAR_MAPPING_DATA,
+          );
+        }
+      },
+    },
+    // Enable triggering signature completion
+    experimentalGetLeftParenSourceRange: (node) => {
+      const callLike = node as SimpleCallExpression | NewExpression;
+      if (callLike.lParenRange) {
+        return {
+          start: callLike.lParenRange[0],
+          end: callLike.lParenRange[1],
+        };
       }
-      const value = Reflect.get(target, prop);
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
+      return state.namedAttributeCalleeLParenRange.get(callLike.callee);
     },
-  });
-  return prevCallNewExpression(node, proxiedContext);
-};
-printer.CallExpression = newCallNewExpression;
-printer.NewExpression = newCallNewExpression;
-
-// Handle node with `diagnosticsOnTop`. These nodes and their children will be
-// printed with an extra `loc` that point to the beginning of the source file,
-// so the source-mapping will include them with a 0:1 -> generated position entry.
-
-const prevWildcard = printer._!;
-printer._ = (node: Node, context, visit) => {
-  const contextProto = Object.getPrototypeOf(context);
-  const prevContextWrite: typeof context.write = contextProto.write;
-  if ("diagnosticsOnTop" in node && node.diagnosticsOnTop) {
-    contextProto.write = function (text: string, node?: AST.Node) {
-      node ??= {} as AST.Node;
-      node.loc ??= {
-        start: { line: 1, column: 0 },
-        end: { line: 1, column: 0 },
-      };
-      return prevContextWrite.call(this, text, node);
-    };
-  }
-  prevWildcard(node, context, visit);
-  contextProto.write = prevContextWrite;
-};
-
-export const patchedPrinter: Visitors<AST.Node> = printer;
+  };
+}

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;
 }