WIP LinkedString

Author: laa-odoo

src/components/composer/composer/prettifier_content.ts

@@ -119,74 +119,72 @@ function flatten(doc: Doc): Doc {
 // ---------------------------------------
 
 /**
- * The `SubString` represents a reduced version of the `Doc` structure,
- * representing a single way to format an AST into a human-readable string.
+ * A linked list for string segments.
  */
-type SubString = SubLine | SubText | null;
-
-type SubLine = {
-  type: "subLine";
-  indent: number;
-  subString: SubString;
-};
-type SubText = {
-  type: "subText";
-  text: string;
-  subString: SubString;
-};
+interface LinkedString {
+  subString: string;
+  next: LinkedString | null;
+}
 
 /**
- * `PrettifyFitState` represents the current state of the formatting process,
- * including the remaining `Doc` to process and the current indentation level.
+ * Memoized helper to build indentation strings.
  */
-type PrettifyFitState = {
-  indentLevel: number;
-  doc: Doc;
-  next: PrettifyFitState | null;
-};
+const memoizedIndentation: Record<number, string> = {};
+function getIndentation(indentLevel: number): string {
+  if (!(indentLevel in memoizedIndentation)) {
+    memoizedIndentation[indentLevel] = "\n" + "\t".repeat(indentLevel);
+  }
+  return memoizedIndentation[indentLevel];
+}
 
 /**
  * Converts a `Doc` structure into a string representation that fits within
  * the specified width.
  */
 function print(doc: Doc, width: number): string {
-  return stringify(selectBestSubString(width, doc));
+  return stringify(selectBestLinkedString(width, doc));
 }
 
 /**
- * Recursively converts a `SubString` object into a human-readable string.
+ * Recursively converts a `LinkedString` object into a human-readable string.
  * This is the final step of the prettifier process.
  */
-function stringify(x: SubString): string {
-  if (x && "type" in x) {
-    if (x.type === "subLine") {
-      return "\n" + "\t".repeat(x.indent) + stringify(x.subString);
-    }
-    if (x.type === "subText") {
-      return x.text + stringify(x.subString);
-    }
+function stringify(linkedString: LinkedString | null): string {
+  let result = "";
+  while (linkedString) {
+    result += linkedString.subString;
+    linkedString = linkedString.next;
   }
-  return "";
+  return result;
 }
 
 /**
- * Selects the best `SubString` representation of a `Doc` that fits within
+ * Selects the best `LinkedString` representation of a `Doc` that fits within
  * the given width.
  */
-function selectBestSubString(width: number, doc: Doc): SubString {
-  const head: PrettifyFitState = {
+function selectBestLinkedString(width: number, doc: Doc): LinkedString | null {
+  const head: RestToFitNode = {
     indentLevel: 0,
     doc,
     next: null,
   };
-  return _selectBestSubString(width, 0, head);
+  return _selectBestLinkedString(width, 0, head);
 }
 
-function _selectBestSubString(
+/**
+ * A specialized linked list node for tracking the remaining `Doc` to fit.
+ */
+interface RestToFitNode {
+  indentLevel: number;
+  doc: Doc;
+  next: RestToFitNode | null;
+}
+
+function _selectBestLinkedString(
   width: number,
   currentIndentLevel: number,
-  head: PrettifyFitState | null
-): SubString {
+  head: RestToFitNode | null
+): LinkedString | null {
   if (head === null) {
     return null;
   }
@@ -195,58 +193,56 @@ function _selectBestSubString(
 
   if (typeof doc === "string") {
     return {
-      type: "subText",
-      text: doc,
-      subString: _selectBestSubString(width, currentIndentLevel + doc.length, next),
+      subString: doc,
+      next: _selectBestLinkedString(width, currentIndentLevel + doc.length, next),
     };
   }
   if (doc.type === "concat") {
     let newHead = next;
     for (let i = doc.docs.length - 1; i >= 0; i--) {
       newHead = { indentLevel, doc: doc.docs[i], next: newHead };
     }
-    return _selectBestSubString(width, currentIndentLevel, newHead);
+    return _selectBestLinkedString(width, currentIndentLevel, newHead);
   }
   if (doc.type === "nest") {
-    return _selectBestSubString(width, currentIndentLevel, {
+    return _selectBestLinkedString(width, currentIndentLevel, {
       indentLevel: indentLevel + doc.indentLevel,
       doc: doc.doc,
       next,
     });
   }
   if (doc.type === "insertLine") {
     return {
-      type: "subLine",
-      indent: indentLevel,
-      subString: _selectBestSubString(width, indentLevel, next),
+      subString: getIndentation(indentLevel),
+      next: _selectBestLinkedString(width, indentLevel, next),
     };
   }
   if (doc.type === "chooseBetween") {
     const head1 = { indentLevel, doc: doc.doc1, next };
-    const possibleSubString = _selectBestSubString(width, currentIndentLevel, head1);
-    if (fits(width - currentIndentLevel, possibleSubString)) {
-      return possibleSubString;
+    const possibleLinkedString = _selectBestLinkedString(width, currentIndentLevel, head1);
+    if (fits(width - currentIndentLevel, possibleLinkedString)) {
+      return possibleLinkedString;
     }
 
     const head2 = { indentLevel, doc: doc.doc2, next };
-    return _selectBestSubString(width, currentIndentLevel, head2);
+    return _selectBestLinkedString(width, currentIndentLevel, head2);
   }
   return null;
 }
 
 /**
- * Checks whether a given `SubString` fits within the specified width.
+ * Checks whether a given `LinkedString` fits within the specified width.
  */
-function fits(width: number, x: SubString): boolean {
-  if (width < 0) return false;
-  if (x === null) {
-    return true;
-  } else if (x.type === "subLine") {
-    return true;
-  } else if (x.type === "subText") {
-    return fits(width - x.text.length, x.subString);
+function fits(width: number, linkedString: LinkedString | null): boolean {
+  while (linkedString) {
+    if (linkedString.subString[0] === "\n") {
+      return true;
+    }
+    width -= linkedString.subString.length;
+    if (width < 0) return false;
+    linkedString = linkedString.next;
   }
-  return false;
+  return true;
 }
 
 // ---------------------------------------