@gi-tcg/gts-transpiler 0.3.2 → 0.3.3

package/src/transform/volar/mappings.ts

@@ -1,13 +1,11 @@
-import { decode } from "@jridgewell/sourcemap-codec";
 import type { CodeInformation, CodeMapping } from "@volar/language-core";
-import type { LeafToken } from "./collect_tokens.ts";
 
 export interface VolarMappingResult {
   code: string;
   mappings: CodeMapping[];
 }
 
-const DEFAULT_VOLAR_MAPPING_DATA: CodeInformation = {
+export const DEFAULT_VOLAR_MAPPING_DATA: CodeInformation = {
   completion: true,
   format: true,
   navigation: true,
@@ -15,354 +13,9 @@ const DEFAULT_VOLAR_MAPPING_DATA: CodeInformation = {
   structure: true,
   verification: true,
 };
-
-interface SourceMap {
-  mappings: string;
-}
-
-interface CodePosition {
-  line: number;
-  column: number;
-  end_line: number;
-  end_column: number;
-  code: string;
-}
-
-type LineOffsets = number[];
-
-type CodeToGeneratedMap = Map<string, CodePosition[]>;
-
-/**
- * Convert byte offset to line/column
- * @param offset
- * @param line_offsets
- * @returns  */
-export const offset_to_line_col = (
-  offset: number,
-  line_offsets: LineOffsets,
-): { line: number; column: number } => {
-  // Binary search
-  let left = 0;
-  let right = line_offsets.length - 1;
-  let line = 1;
-
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    if (
-      offset >= line_offsets[mid] &&
-      (mid === line_offsets.length - 1 || offset < line_offsets[mid + 1])
-    ) {
-      line = mid + 1;
-      break;
-    } else if (offset < line_offsets[mid]) {
-      right = mid - 1;
-    } else {
-      left = mid + 1;
-    }
-  }
-
-  const column = offset - line_offsets[line - 1];
-  return { line, column };
+export const VERIFICATION_ONLY_MAPPING_DATA: CodeInformation = {
+  verification: true,
 };
 
-/**
- * Build a source-to-generated position lookup map from an esrap source map
- * Applies post-processing adjustments during map building for efficiency
- * @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 source-to-generated map
- */
-export function buildSrcToGenMap(
-  source_map: SourceMap,
-  line_offsets: LineOffsets,
-  generated_code: string,
-): CodeToGeneratedMap {
-  const map: CodeToGeneratedMap = new Map();
-
-  // Decode the VLQ-encoded mappings string
-  const decoded = decode(source_map.mappings);
-
-  /**
-   * Convert line/column position to byte offset
-   * @param {number} line - 1-based line number
-   * @param {number} column - 0-based column number
-   * @returns {number} Byte offset
-   */
-  const line_col_to_byte_offset = (line: number, column: number) => {
-    return line_offsets[line - 1] + column;
-  };
-
-  // Apply post-processing adjustments to all segments first
-  const adjusted_segments: {
-    line: number;
-    column: number;
-    sourceLine: number;
-    sourceColumn: number;
-  }[][] = [];
-
-  for (
-    let generated_line = 0;
-    generated_line < decoded.length;
-    generated_line++
-  ) {
-    const line = decoded[generated_line];
-    adjusted_segments[generated_line] = [];
-
-    for (const segment of line) {
-      if (segment.length >= 4) {
-        let adjusted_line = generated_line + 1;
-        let adjusted_column = segment[0];
-        adjusted_segments[generated_line].push({
-          line: adjusted_line,
-          column: adjusted_column,
-          sourceLine: segment[2]!,
-          sourceColumn: segment[3]!,
-        });
-      }
-    }
-  }
-
-  // Now build the map using adjusted positions
-  for (let line_idx = 0; line_idx < adjusted_segments.length; line_idx++) {
-    const line_segments = adjusted_segments[line_idx];
-
-    for (let seg_idx = 0; seg_idx < line_segments.length; seg_idx++) {
-      const segment = line_segments[seg_idx];
-      const line = segment.line;
-      const column = segment.column;
-
-      // Determine end position using next segment
-      let end_line = line;
-      let end_column = column;
-
-      // Look for next segment to determine end position
-      if (seg_idx + 1 < line_segments.length) {
-        // Next segment on same line
-        const next_segment = line_segments[seg_idx + 1];
-        end_line = next_segment.line;
-        end_column = next_segment.column;
-      } else if (
-        line_idx + 1 < adjusted_segments.length &&
-        adjusted_segments[line_idx + 1].length > 0
-      ) {
-        // Look at first segment of next line
-        const next_segment = adjusted_segments[line_idx + 1][0];
-        end_line = next_segment.line;
-        end_column = next_segment.column;
-      }
-
-      // Extract code snippet
-      const start_offset = line_col_to_byte_offset(line, column);
-      const end_offset = line_col_to_byte_offset(end_line, end_column);
-      const code_snippet = generated_code.slice(start_offset, end_offset);
-
-      // Create key from source position (1-indexed line, 0-indexed column)
-      segment.sourceLine += 1;
-      const key = `${segment.sourceLine}:${segment.sourceColumn}`;
-
-      // Store adjusted generated position with code snippet
-      const gen_pos = {
-        line,
-        column,
-        end_line,
-        end_column,
-        code: code_snippet,
-        metadata: {},
-      };
-
-      if (!map.has(key)) {
-        map.set(key, []);
-      }
-      map.get(key)!.push(gen_pos);
-    }
-  }
-
-  return map;
-}
-
-/**
- * Look up generated position for a given source position
- * @param src_line - 1-based line number in source
- * @param src_column - 0-based column number in source
- * @param srcToGenMap - Lookup map
- * @returns Generated position
- */
-export function getGeneratedPosition(
-  src_line: number,
-  src_column: number,
-  srcToGenMap: CodeToGeneratedMap,
-): CodePosition[] {
-  const key = `${src_line}:${src_column}`;
-  const positions = srcToGenMap.get(key);
-
-  // If multiple generated positions map to same source, return the first
-  return positions || [];
-}
-// Helper to create a line-to-offset lookup table
-function createLineOffsets(content: string): number[] {
-  const lines = content.split("\n");
-  const offsets: number[] = [];
-  let currentOffset = 0;
-
-  for (const line of lines) {
-    offsets.push(currentOffset);
-    // +1 for the newline character (handle \r\n vs \n if necessary)
-    currentOffset += line.length + 1;
-  }
-  return offsets;
-}
-
-/**
- * Convert line/column to byte offset
- * @param line
- * @param column
- * @param line_offsets
- * @returns
- */
-function locToOffset(
-  line: number,
-  column: number,
-  line_offsets: number[],
-): number {
-  if (line < 1 || line > line_offsets.length) {
-    // throw new Error(
-    //   `Location line or line offsets length is out of bounds, line: ${line}, line offsets length: ${line_offsets.length}`
-    // );
-  }
-  return line_offsets[line - 1] + column;
-}
-
-export function convertToVolarMappings(
-  generated: string,
-  source: string,
-  sourceMap: SourceMap,
-  tokens: LeafToken[],
-  extraMappings: Map<string, string>,
-): CodeMapping[] {
-  const sourceLineOffsets = createLineOffsets(source);
-  const generatedLineOffsets = createLineOffsets(generated);
-  const srcToGenMap = buildSrcToGenMap(
-    sourceMap,
-    generatedLineOffsets,
-    generated,
-  );
-
-  const mappings: CodeMapping[] = [];
-
-  for (const token of tokens) {
-    let sourceStart = locToOffset(
-      token.loc.start.line,
-      token.loc.start.column,
-      sourceLineOffsets,
-    );
-    sourceStart += token.sourceStartOffset ?? 0;
-
-    const sourceEnd = locToOffset(
-      token.loc.end.line,
-      token.loc.end.column,
-      sourceLineOffsets,
-    );
-
-    let sourceLength = token.sourceLength ?? sourceEnd - sourceStart;
-
-    sourceLength += token.sourceLengthOffset ?? 0;
-    const [genLineCol] = getGeneratedPosition(
-      token.loc.start.line,
-      token.loc.start.column,
-      srcToGenMap,
-    );
-    if (!genLineCol) {
-      // No mapping found for this token - skip it
-      continue;
-    }
-    let genStart = locToOffset(
-      genLineCol.line,
-      genLineCol.column,
-      generatedLineOffsets,
-    );
-    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
-      // all whitespaces and insert the invalid node just before the next token.
-      // But in a mapping context, we need the caret next to the previous token (commonly the `.` dot)
-      // to allow triggering completion correctly. So we adjust the sourceStart and sourceLength accordingly.
-      // After adjustment, the mapping will include all whitespaces as the invalid node and maps to an empty string.
-      while (sourceStart > 0 && /\s/.test(source[sourceStart - 1])) {
-        sourceStart--;
-        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],
-      lengths: [sourceLength],
-      generatedLengths: [generatedLength],
-      data: DEFAULT_VOLAR_MAPPING_DATA,
-    });
-  }
-
-  // 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;
-    }
-    const [lineStr, columnStr] = loc.split(":");
-    const line = Number(lineStr);
-    const column = Number(columnStr);
-    const sourceStart = locToOffset(line, column, sourceLineOffsets);
-    const sourceLength = 1;
-    const generatedLength = codeSnippet.length;
-    mappings.push({
-      sourceOffsets: [sourceStart],
-      generatedOffsets: [generatedStart],
-      lengths: [sourceLength],
-      generatedLengths: [generatedLength],
-      data: {
-        verification: true,
-      },
-    });
-  }
-
-  // Sort mappings by source offset	// Sort mappings by source offset
-  mappings.sort((a, b) => a.sourceOffsets[0] - b.sourceOffsets[0]);
-
-  return mappings;
-}
+Object.freeze(DEFAULT_VOLAR_MAPPING_DATA);
+Object.freeze(VERIFICATION_ONLY_MAPPING_DATA);

package/src/transform/volar/printer.ts

@@ -1,123 +1,107 @@
-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.
+        if (state.diagnosticsOnTopNodes.has(node)) {
+          const generatedEnd = context.generatedOffset;
+          context.createExtraMapping(
+            { start: 0, end: 1 },
+            generatedStart,
+            generatedEnd,
+            VERIFICATION_ONLY_MAPPING_DATA,
+          );
         }
+      },
+      ImportDefaultSpecifier(node, context) {
+        const generatedStart = context.generatedOffset;
+        defaultPrinters.ImportDefaultSpecifier(node, context);
+        if (state.diagnosticsOnTopNodes.has(node as Node)) {
+          const generatedEnd = context.generatedOffset;
+          context.createExtraMapping(
+            { start: 0, end: 1 },
+            generatedStart,
+            generatedEnd,
+            VERIFICATION_ONLY_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;
+  };
+}