Merge pull request #194 from gitKrystan/fix-191

Author: gitKrystan

examples/bin/test.mjs

@@ -40,7 +40,7 @@ const run = async () => {
       'node',
       [
         './node_modules/prettier/bin/prettier.cjs',
-        '.',
+        './input',
         '--write',
         debug ? '--log-level' : null,
         debug ? 'debug' : null,

examples/expected-output/example.gts

@@ -11,4 +11,4 @@ export interface Signature {
   module top level component. Explicit default export module top level
   component. Explicit default export module top level component. Explicit
   default export module top level component.
-</template> as TemplateOnlyComponent<Signature>;
+</template> as TemplateOnlyComponent<Signature>

src/options.ts

@@ -8,7 +8,6 @@ import type {
 export interface Options extends ParserOptions<Node | undefined> {
   templateExportDefault?: boolean;
   templateSingleQuote?: boolean;
-  __inputWasPreprocessed?: boolean;
 }
 
 const templateExportDefault: BooleanSupportOption = {
@@ -38,15 +37,7 @@ const templateSingleQuote: BooleanSupportOption = {
     'Use single quotes instead of double quotes within template tags. Since 0.0.3.',
 };
 
-const __inputWasPreprocessed: BooleanSupportOption = {
-  category: 'Format',
-  type: 'boolean',
-  description:
-    'Internal: If true, the template was preprocessed before being run through Prettier. Since 0.1.0.',
-};
-
 export const options: SupportOptions = {
   templateExportDefault,
   templateSingleQuote,
-  __inputWasPreprocessed,
 };

src/parse/index.ts

@@ -1,20 +1,12 @@
-import type { NodePath } from '@babel/core';
 import { traverse } from '@babel/core';
-import type {
-  BlockStatement,
-  Node,
-  ObjectExpression,
-  StaticBlock,
-} from '@babel/types';
+import type { Node, ObjectExpression, StaticBlock } from '@babel/types';
 import type { Parsed as RawGlimmerTemplate } from 'content-tag';
 import { Preprocessor } from 'content-tag';
 import type { Parser } from 'prettier';
 import { parsers as babelParsers } from 'prettier/plugins/babel.js';
 
 import { PRINTER_NAME } from '../config.js';
 import type { Options } from '../options.js';
-import type { GlimmerTemplate } from '../types/glimmer.js';
-import { isDefaultTemplate } from '../types/glimmer.js';
 import { assert } from '../utils/index.js';
 import { preprocessTemplateRange } from './preprocess.js';
 
@@ -23,60 +15,53 @@ const p = new Preprocessor();
 
 /** Converts a node into a GlimmerTemplate node */
 function convertNode(
-  path: NodePath,
-  node: BlockStatement | ObjectExpression | StaticBlock,
+  node: ObjectExpression | StaticBlock,
   rawTemplate: RawGlimmerTemplate,
 ): void {
-  const cast = node as unknown as GlimmerTemplate;
-  // HACK: Changing the node type here isn't recommended by babel
-  cast.type = 'FunctionDeclaration';
-  cast.range = [rawTemplate.range.start, rawTemplate.range.end];
-  cast.start = rawTemplate.range.start;
-  cast.end = rawTemplate.range.end;
-  cast.extra = Object.assign(node.extra ?? {}, {
+  node.extra = Object.assign(node.extra ?? {}, {
     isGlimmerTemplate: true as const,
-    isDefaultTemplate: isDefaultTemplate(path),
     template: rawTemplate,
   });
 }
 
 /** Traverses the AST and replaces the transformed template parts with other AST */
 function convertAst(ast: Node, rawTemplates: RawGlimmerTemplate[]): void {
-  let counter = 0;
+  const unprocessedTemplates = [...rawTemplates];
 
   traverse(ast, {
     enter(path) {
       const { node } = path;
-      if (
-        node.type === 'ObjectExpression' ||
-        node.type === 'BlockStatement' ||
-        node.type === 'StaticBlock'
-      ) {
+      if (node.type === 'ObjectExpression' || node.type === 'StaticBlock') {
         const { range } = node;
         assert('expected range', range);
         const [start, end] = range;
 
-        const rawTemplate = rawTemplates.find(
+        const templateIndex = unprocessedTemplates.findIndex(
           (t) =>
-            (t.range.start === start && t.range.end === end) ||
-            (t.range.start === start - 1 && t.range.end === end + 1) ||
-            (t.range.start === start && t.range.end === end + 1),
+            (node.type === 'StaticBlock' &&
+              t.range.start === start &&
+              t.range.end === end) ||
+            (node.type === 'ObjectExpression' &&
+              t.range.start === start - 1 &&
+              t.range.end === end + 1),
         );
+        const rawTemplate = unprocessedTemplates.splice(templateIndex, 1)[0];
 
         if (!rawTemplate) {
           return null;
         }
 
-        convertNode(path, node, rawTemplate);
-
-        counter++;
+        convertNode(node, rawTemplate);
       }
+
       return null;
     },
   });
 
-  if (counter !== rawTemplates.length) {
-    throw new Error('failed to process all templates');
+  if (unprocessedTemplates.length > 0) {
+    throw new Error(
+      `failed to process all templates, ${unprocessedTemplates.length} remaining`,
+    );
   }
 }
 
@@ -85,26 +70,28 @@ function convertAst(ast: Node, rawTemplates: RawGlimmerTemplate[]): void {
  * fixing the offsets and locations of all nodes also calculates the block
  * params locations & ranges and adding it to the info
  */
-function preprocess(code: string): {
+function preprocess(
+  code: string,
+  fileName: string,
+): {
   code: string;
   rawTemplates: RawGlimmerTemplate[];
 } {
-  const rawTemplates = p.parse(code);
+  const rawTemplates = p.parse(code, fileName);
 
-  let output = code;
   for (const rawTemplate of rawTemplates) {
-    output = preprocessTemplateRange(rawTemplate, code, output);
+    code = preprocessTemplateRange(rawTemplate, code);
   }
 
-  return { rawTemplates, code: output };
+  return { rawTemplates, code };
 }
 
 export const parser: Parser<Node | undefined> = {
   ...typescript,
   astFormat: PRINTER_NAME,
 
   async parse(code: string, options: Options): Promise<Node> {
-    const preprocessed = preprocess(code);
+    const preprocessed = preprocess(code, options.filepath);
     const ast = await typescript.parse(preprocessed.code, options);
     assert('expected ast', ast);
     convertAst(ast, preprocessed.rawTemplates);

src/parse/preprocess.ts

@@ -1,13 +1,65 @@
 import type { Parsed as RawGlimmerTemplate } from 'content-tag';
 
-function replaceRange(
+const EMPTY_SPACE = ' ';
+
+/**
+ * Given a string (`original`), replaces the bytes in the given `range` with
+ * equivalent bytes of empty space (' ') surrounded by the given prefix and
+ * suffix. The total byte length will not change.
+ *
+ * Returns the resulting string.
+ */
+function replaceByteRange(
   original: string,
   range: { start: number; end: number },
-  substitute: string,
+  options: { prefix: string; suffix: string },
 ): string {
-  return (
-    original.slice(0, range.start) + substitute + original.slice(range.end)
-  );
+  // Convert the original string and the prefix, suffix to buffers for byte manipulation
+  const originalBuffer = Buffer.from(original);
+  const prefixBuffer = Buffer.from(options.prefix);
+  const suffixBuffer = Buffer.from(options.suffix);
+
+  // Validate range
+  if (
+    range.start < 0 ||
+    range.end > originalBuffer.length ||
+    range.start > range.end ||
+    prefixBuffer.length + suffixBuffer.length > range.end - range.start
+  ) {
+    throw new Error(
+      `Invalid byte range:\n\tstart=${range.start}\n\tend=${range.end}\n\tprefix=${options.prefix}\n\tsuffix=${options.suffix}\n\tstring=\n\t${original}`,
+    );
+  }
+
+  // Adjust the space length to account for the prefix and suffix lengths
+  const totalReplacementLength = range.end - range.start;
+  const spaceLength =
+    totalReplacementLength - prefixBuffer.length - suffixBuffer.length;
+
+  // Create a buffer for the replacement
+  const spaceBuffer = Buffer.alloc(spaceLength, EMPTY_SPACE);
+
+  // Concatenate prefix, space, and suffix buffers
+  const replacementBuffer = Buffer.concat([
+    prefixBuffer,
+    spaceBuffer,
+    suffixBuffer,
+  ]);
+
+  // Create buffers for before and after the range using subarray
+  const beforeRange = originalBuffer.subarray(0, range.start);
+  const afterRange = originalBuffer.subarray(range.end);
+
+  // Concatenate all parts and convert back to a string
+  const result = Buffer.concat([beforeRange, replacementBuffer, afterRange]);
+
+  if (result.length !== originalBuffer.length) {
+    throw new Error(
+      `Result length (${result.length}) does not match original length (${originalBuffer.length})`,
+    );
+  }
+
+  return result.toString('utf8');
 }
 
 /**
@@ -16,34 +68,23 @@ function replaceRange(
  */
 export function preprocessTemplateRange(
   rawTemplate: RawGlimmerTemplate,
-  originalCode: string,
-  currentCode: string,
+  code: string,
 ): string {
   let prefix: string;
   let suffix: string;
 
   if (rawTemplate.type === 'class-member') {
-    prefix = 'static{`';
-    suffix = '`}';
-  } else {
-    prefix = '{';
+    // Replace with StaticBlock
+    prefix = 'static{';
     suffix = '}';
-    const nextWord = originalCode.slice(rawTemplate.range.end).match(/\S+/);
-    if (nextWord && nextWord[0] === 'as') {
-      prefix = '(' + prefix;
-      suffix = suffix + ')';
-    } else if (!nextWord || ![',', ')'].includes(nextWord[0][0] || '')) {
-      suffix += ';';
-    }
+  } else {
+    // Replace with ObjectExpression
+    prefix = '({';
+    suffix = '})';
   }
 
-  const totalLength = rawTemplate.range.end - rawTemplate.range.start;
-  const placeholderLength = totalLength - prefix.length - suffix.length;
-  const placeholder = ' '.repeat(placeholderLength);
-
-  return replaceRange(
-    currentCode,
-    rawTemplate.range,
-    `${prefix}${placeholder}${suffix}`,
-  );
+  return replaceByteRange(code, rawTemplate.range, {
+    prefix,
+    suffix,
+  });
 }

src/print/ambiguity.ts

@@ -3,22 +3,10 @@ import type { AstPath, doc, Printer } from 'prettier';
 import { printers as estreePrinters } from 'prettier/plugins/estree.js';
 
 import type { Options } from '../options.js';
+import { flattenDoc } from '../utils/doc.js';
 
 const estreePrinter = estreePrinters['estree'] as Printer<Node | undefined>;
 
-/** NOTE: This is highly specialized for use in `fixPreviousPrint` */
-function flattenDoc(doc: doc.builders.Doc): string[] {
-  if (Array.isArray(doc)) {
-    return doc.flatMap(flattenDoc);
-  } else if (typeof doc === 'string') {
-    return [doc];
-  } else if ('contents' in doc) {
-    return flattenDoc(doc.contents);
-  } else {
-    return [];
-  }
-}
-
 /**
  * Search next non EmptyStatement node and set current print, so we can fix it
  * later if its ambiguous