@gi-tcg/gts-transpiler 0.1.1 → 0.3.0

package/src/transform/volar/index.ts

@@ -2,7 +2,6 @@ import type { AST } from "../../types";
 import { walk } from "zimmerframe";
 import type { SourceInfo, TranspileResult } from "..";
 import { print } from "esrap";
-import tsPrinter from "esrap/languages/ts";
 import {
   initialTranspileState,
   type TranspileOption,
@@ -13,16 +12,19 @@ import { applyReplacements } from "./replacements";
 import type { Program } from "estree";
 import { convertToVolarMappings, type VolarMappingResult } from "./mappings";
 import { collectLeafTokens, type LeafToken } from "./collect_tokens";
+import { patchedPrinter } from "./printer";
 
 interface TypingTranspileOption extends TranspileOption {
   leafTokens: LeafToken[];
-  // "row:col" -> "replacement string"
-  additionalMappings: Map<string, string>;
+  /**
+   * "row:col" -> "replacement string"
+   */
+  extraMappings: Map<string, string>;
 }
 
 function gtsToTypings(
   ast: AST.Program,
-  option: TypingTranspileOption
+  option: TypingTranspileOption,
 ): TranspileResult {
   const state: TypingTranspileState = {
     ...(initialTranspileState(option) as Pick<
@@ -31,34 +33,21 @@ function gtsToTypings(
     >),
     leafTokens: option.leafTokens,
     idCounter: 0,
-    pendingStatements: [],
-    prefaceInserted: false,
-    rootVmId: { type: "Identifier", name: "__root_vm" },
+    typingPendingStatements: [],
+    rootVmId: { type: "Identifier", name: "__gts_root_vm" },
+    utilNsId: { type: "Identifier", name: "__gts_util" },
     replacementTag: { type: "Identifier", name: "__gts_replacement_tag" },
-    symbolsId: {
-      Meta: { type: "Identifier", name: "__gts_symbols_meta" },
-      NamedDefinition: { type: "Identifier", name: "__gts_symbols_namedDef" },
-    },
+    MetaLit: { type: "Literal", value: "~meta" },
+    NamedDefinitionLit: { type: "Literal", value: "~namedDefinition" },
+    defineLeadingComments: [],
     vmDefTypeIdStack: [],
     metaTypeIdStack: [],
     finalMetaTypeIdStack: [],
     attrsOfCurrentVm: [],
-    additionalMappings: option.additionalMappings,
+    extraMappings: option.extraMappings,
   };
   const newAst = walk(ast as AST.Node, state, gtsToTypingsWalker);
-  const printer = tsPrinter({
-    getLeadingComments: (node) => (node as AST.Node).leadingComments,
-    getTrailingComments: (node) => (node as AST.Node).trailingComments,
-  });
-  const prevIdentifier = printer.Identifier!;
-  printer.Identifier = function (node, context) {
-    if (node.isDummy) {
-      context.write("", node);
-    } else {
-      prevIdentifier(node, context);
-    }
-  };
-  const { code, map } = print(newAst, printer, {
+  const { code, map } = print(newAst, patchedPrinter, {
     indent: "  ",
   });
   return {
@@ -70,21 +59,21 @@ function gtsToTypings(
 export function transformForVolar(
   ast: Program,
   option: TranspileOption,
-  sourceInfo: Required<SourceInfo>
+  sourceInfo: Required<SourceInfo>,
 ): VolarMappingResult {
   const tokens = collectLeafTokens(ast);
-  const additionalMappings = new Map<string, string>();
+  const extraMappings = new Map<string, string>();
   const { code, sourceMap } = gtsToTypings(ast, {
     ...option,
     leafTokens: tokens,
-    additionalMappings,
+    extraMappings,
   });
   const volarMappings = convertToVolarMappings(
     code,
     sourceInfo.content,
     sourceMap,
     tokens,
-    additionalMappings
+    extraMappings,
   );
   return {
     code,

package/src/transform/volar/mappings.ts

@@ -39,8 +39,8 @@ type CodeToGeneratedMap = Map<string, CodePosition[]>;
  * @returns  */
 export const offset_to_line_col = (
   offset: number,
-  line_offsets: LineOffsets
-) => {
+  line_offsets: LineOffsets,
+): { line: number; column: number } => {
   // Binary search
   let left = 0;
   let right = line_offsets.length - 1;
@@ -71,13 +71,13 @@ export const offset_to_line_col = (
  * @param source_map - The source map object from esrap (v3 format)
  * @param line_offsets - Pre-computed line offsets array
  * @param generated_code - The final generated code (after post-processing)
- * @returns Tuple of [source-to-generated map, generated-to-source map]
+ * @returns source-to-generated map
  */
 export function buildSrcToGenMap(
   source_map: SourceMap,
   line_offsets: LineOffsets,
-  generated_code: string
-) {
+  generated_code: string,
+): CodeToGeneratedMap {
   const map: CodeToGeneratedMap = new Map();
 
   // Decode the VLQ-encoded mappings string
@@ -191,20 +191,13 @@ export function buildSrcToGenMap(
 export function getGeneratedPosition(
   src_line: number,
   src_column: number,
-  srcToGenMap: CodeToGeneratedMap
-) {
+  srcToGenMap: CodeToGeneratedMap,
+): CodePosition[] {
   const key = `${src_line}:${src_column}`;
   const positions = srcToGenMap.get(key);
 
-  if (!positions || positions.length === 0) {
-    // No mapping found in source map - this shouldn't happen since all tokens should have mappings
-    // throw new Error(
-    //   `No source map entry for position "${src_line}:${src_column}"`
-    // );
-  }
-
   // If multiple generated positions map to same source, return the first
-  return positions?.[0];
+  return positions || [];
 }
 // Helper to create a line-to-offset lookup table
 function createLineOffsets(content: string): number[] {
@@ -230,7 +223,7 @@ function createLineOffsets(content: string): number[] {
 function locToOffset(
   line: number,
   column: number,
-  line_offsets: number[]
+  line_offsets: number[],
 ): number {
   if (line < 1 || line > line_offsets.length) {
     // throw new Error(
@@ -245,14 +238,14 @@ export function convertToVolarMappings(
   source: string,
   sourceMap: SourceMap,
   tokens: LeafToken[],
-  additionalMappings: Map<string, string>
+  extraMappings: Map<string, string>,
 ): CodeMapping[] {
   const sourceLineOffsets = createLineOffsets(source);
   const generatedLineOffsets = createLineOffsets(generated);
   const srcToGenMap = buildSrcToGenMap(
     sourceMap,
     generatedLineOffsets,
-    generated
+    generated,
   );
 
   const mappings: CodeMapping[] = [];
@@ -261,18 +254,23 @@ export function convertToVolarMappings(
     let sourceStart = locToOffset(
       token.loc.start.line,
       token.loc.start.column,
-      sourceLineOffsets
+      sourceLineOffsets,
     );
+    sourceStart += token.sourceStartOffset ?? 0;
+
     const sourceEnd = locToOffset(
       token.loc.end.line,
       token.loc.end.column,
-      sourceLineOffsets
+      sourceLineOffsets,
     );
+
     let sourceLength = token.sourceLength ?? sourceEnd - sourceStart;
-    const genLineCol = getGeneratedPosition(
+
+    sourceLength += token.sourceLengthOffset ?? 0;
+    const [genLineCol] = getGeneratedPosition(
       token.loc.start.line,
       token.loc.start.column,
-      srcToGenMap
+      srcToGenMap,
     );
     if (!genLineCol) {
       // No mapping found for this token - skip it
@@ -281,21 +279,8 @@ export function convertToVolarMappings(
     let genStart = locToOffset(
       genLineCol.line,
       genLineCol.column,
-      generatedLineOffsets
+      generatedLineOffsets,
     );
-    if (token.locationAdjustment) {
-      // maps verification back to the start of source
-      mappings.push({
-        sourceOffsets: [sourceStart],
-        generatedOffsets: [genStart],
-        lengths: [0],
-        generatedLengths: [token.locationAdjustment.generatedLength],
-        data: {
-          verification: true,
-        },
-      });
-      genStart += token.locationAdjustment.startOffset;
-    }
     if (token.isDummy) {
       // A dummy token might be generated for a missing property / argument.
       // Notice that when facing this scenario, the parser tries to 'defer' and step through
@@ -308,9 +293,25 @@ export function convertToVolarMappings(
         sourceLength++;
       }
     }
-
     const generatedLength = token.generatedLength ?? sourceLength;
 
+    if (
+      typeof token.generatedStartOffset === "number" &&
+      token.generatedStartOffset > 0
+    ) {
+      // maps verification back to the start of source
+      mappings.push({
+        sourceOffsets: [sourceStart],
+        generatedOffsets: [genStart],
+        lengths: [0],
+        generatedLengths: [generatedLength],
+        data: {
+          verification: true,
+        },
+      });
+      genStart += token.generatedStartOffset;
+    }
+
     mappings.push({
       sourceOffsets: [sourceStart],
       generatedOffsets: [genStart],
@@ -320,7 +321,25 @@ export function convertToVolarMappings(
     });
   }
 
-  for (const [loc, codeSnippet] of additionalMappings) {
+  // Handle extra mappings that purely generated and wants a diagnostic
+  // that appears on the top of file.
+  // We'd add these mappings at walker that they will have a `loc` to `1:0`
+  // so find them by looking up a source position of `1:0` will work
+  const locMapsToTop = getGeneratedPosition(1, 0, srcToGenMap);
+  for (const loc of locMapsToTop) {
+    const offset = locToOffset(loc.line, loc.column, generatedLineOffsets);
+    mappings.push({
+      sourceOffsets: [0],
+      generatedOffsets: [offset],
+      lengths: [0],
+      generatedLengths: [0],
+      data: {
+        verification: true,
+      },
+    });
+  }
+
+  for (const [loc, codeSnippet] of extraMappings) {
     const generatedStart = generated.indexOf(codeSnippet);
     if (generatedStart === -1) {
       continue;

package/src/transform/volar/printer.ts

@@ -0,0 +1,123 @@
+import tsPrinter from "esrap/languages/ts";
+import type { AST } from "../../types";
+import type { Context, Visitors } from "esrap";
+import type { Node, SimpleCallExpression } from "estree";
+
+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;
+        }
+        if (prop === "visit") {
+          return patchedVisit;
+        }
+        if (prop === "append") {
+          return patchedAppend;
+        }
+      }
+      const value = Reflect.get(target, prop);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    },
+  });
+  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

@@ -2,6 +2,9 @@ import type { ExpressionStatement } from "estree";
 import type { TypingTranspileState } from "./walker";
 
 type ReplacementPayload =
+  | {
+      type: "preface";
+    }
   | {
       type: "enterVMFromRoot";
       vm: string;
@@ -27,6 +30,7 @@ type ReplacementPayload =
       defType: string;
       metaType: string;
       lhs: string;
+      attrName: string;
     }
   | {
       type: "createBindingTyping";
@@ -45,7 +49,7 @@ type ReplacementPayload =
 
 export const createReplacementHolder = (
   state: TypingTranspileState,
-  value: ReplacementPayload
+  value: ReplacementPayload,
 ): ExpressionStatement => {
   const rawValue = JSON.stringify(value);
   return {
@@ -68,37 +72,114 @@ export const createReplacementHolder = (
   };
 };
 
-export function applyReplacements(state: TypingTranspileState, code: string) {
+export function applyReplacements(
+  state: TypingTranspileState,
+  code: string,
+): string {
   const replacementRegex = new RegExp(
     "\\b" + state.replacementTag.name + "`(.*?)`",
-    "gm"
+    "gm",
   );
-  const {
-    symbolsId: { NamedDefinition, Meta },
-  } = state;
+  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 === "enterVMFromRoot") {
-      return `type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition.name}]; type ${payload.metaType} = ${payload.defType}[${Meta.name}];`;
+    if (payload.type === "preface") {
+      return oneLine`
+        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`
+        type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition}];
+        type ${payload.metaType} = ${payload.defType}[${Meta}];
+      `;
     } else if (payload.type === "enterVMFromAttr") {
-      return `type ${payload.defType} = ${payload.returnType} extends { namedDefinition: infer Def } ? Def : { [${Meta.name}]: unknown }; type ${payload.metaType} = ${payload.defType}[${Meta.name}];`;
+      return oneLine`
+        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 = `null! as ${requiredAttrsNs}.RequiredAttributes`;
+      const needleString = `"${requiredAttrsNs}_NeedleString" as any as "required attributes are missing"`;
       if (payload.errorLoc) {
-        state.additionalMappings.set(payload.errorLoc, needleString);
+        state.extraMappings.set(payload.errorLoc, needleString);
       }
-      return `type ${payload.finalMetaType} = ${payload.metaType}; const ${lhs}: { [${Meta.name}]: ${payload.metaType} } & Omit<${payload.defType}, ${Meta.name}> = 0 as any; type ${lhs} = typeof ${lhs}; namespace ${requiredAttrsNs} { export type CollectedAttributes = ${collectedAttrsExpr}; export type RequiredAttributes = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}]; }; ((_: ${requiredAttrsNs}.CollectedAttributes) => 0)(${needleString});`;
+      return oneLine`
+        type ${payload.finalMetaType} = ${payload.metaType};
+        let ${lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${Meta}>;
+        type ${lhs} = typeof ${lhs};
+        namespace ${requiredAttrsNs} {
+          export type Collected = ${collectedAttrsExpr};
+          export type Expected = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}];
+        };
+        ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
+      `;
     } else if (payload.type === "enterAttr") {
-      return `const ${payload.lhs}: { [${Meta.name}]: ${payload.metaType} } & Omit<${payload.defType}, ${Meta.name}> = 0 as any;`;
+      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`
+        type ${uniqueKeyLhs} = {
+          ${Meta}: ${payload.metaType}; 
+          uniqueKey: ${payload.defType} extends { [${payload.attrName}]: { uniqueKey: infer UniqueKey } } ? UniqueKey : () => 0;
+        
+        let ${uniqueKeyLhs}!: ${uniqueKeyLhs};
+        let ${uniqueKey} = ${uniqueKeyLhs}.uniqueKey();
+        type ${uniqueKey} = typeof ${uniqueKey};
+        let ${uniqueKeyForThis}!: \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}${payload.lhs}\`;
+        interface ${uniqueKeyHelperIntf} {
+          [${uniqueKeyForThis}]: 1;
+        }
+        type ${omittedKeys} = ${Meta} | (
+          ${uniqueKey} extends 0
+          ? never                                                 /* no unique requirement */
+            : string extends keyof ${uniqueKeyHelperIntf}
+              ? keyof ${payload.defType}                          /* too loose, disable all */
+              : ${state.utilNsId.name}.UnionToIntersection<
+                keyof ${uniqueKeyHelperIntf} & \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}\${string}\`
+              > extends never
+                ? ${payload.attrName}                             /* have duplicate, disable this */
+                : never
+        );
+        let ${payload.lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${omittedKeys}>;
+      `;
     } else if (payload.type === "createBindingTyping") {
       const typingIdLhs = `${payload.typingId}_lhs`;
-      return `type ${typingIdLhs} = { [${Meta.name}]: ${payload.finalMetaType}; as: ${payload.defType}[${payload.attrName}] extends { as: infer As } ? As : unknown }; let ${typingIdLhs}!: ${typingIdLhs}; let ${payload.typingId} = ${typingIdLhs}.as(); type ${payload.typingId} = typeof ${payload.typingId};`;
+      return oneLine`
+        type ${typingIdLhs} = {
+          ${Meta}: ${payload.finalMetaType};
+          as: ${payload.defType} extends { [${payload.attrName}]: { as: infer As } } ? As : unknown;
+        };
+        let ${typingIdLhs}!: ${typingIdLhs};
+        let ${payload.typingId} = ${typingIdLhs}.as();
+        type ${payload.typingId} = typeof ${payload.typingId};
+      `;
     } else if (payload.type === "exitAttr") {
-      return `type ${payload.returnType} = typeof ${payload.returnType}; type ${payload.newMetaType} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType}`;
+      return oneLine`
+        type ${payload.returnType} = typeof ${payload.returnType};
+        type ${payload.newMetaType} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType}
+      `;
     } else {
       return "";
     }