@velarscript/compiler 0.12.0 → 0.13.0

package/dist/formatter.js

@@ -2,7 +2,7 @@ import { CORE_STATEMENT_HEAD_KEYWORDS } from "./core-vocabulary.js";
 import { scanEmbeddedJavaScriptLiteral } from "./embedded-javascript.js";
 import { MAX_VELAR_SOURCE_CODE_UNITS } from "./limits.js";
 import { findInterpolatedExpressionEnd, scanStringEscape, scanStringLiteral } from "./interpolated-string.js";
-import { isSourceIdentifierPart, isSourceIdentifierStart } from "./source-names.js";
+import { isSourceIdentifierPart, isSourceIdentifierStart, isTypeEvidenceName } from "./source-names.js";
 import { keywordKinds } from "./token.js";
 const multiCharacterOperators = [">>>=", "<<=", ">>=", ">>>", "<<", ">>", "...", "?.", "??", "->", "=>", "==", "!=", "<=", ">=", "**", "+=", "-=", "*=", "/=", "%=", "|=", "&=", "^="];
 const binaryWords = new Set(["and", "or", "in", "is"]);
@@ -49,7 +49,7 @@ export function formatSource(text, options = {}) {
     const lines = protectedStrings.text.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
     const indentation = [0];
     const formatted = [];
-    let embeddedDepth = 0;
+    let embedded = closedEmbeddedScan;
     let statementLevel = 0;
     /** The last token of the previous line — the context a continuation reads. */
     let preceding;
@@ -66,7 +66,7 @@ export function formatSource(text, options = {}) {
         // A leading-dot chain continuation keeps its own canonical indentation —
         // one level past the statement it continues — without opening a block for
         // the lines that follow it.
-        if (embeddedDepth === 0 && isChainContinuationLine(content) && formatted.length > 0) {
+        if (!isEmbeddedLine(embedded) && isChainContinuationLine(content) && formatted.length > 0) {
             const column = (statementLevel + 1) * indentWidth;
             const line = formatInlineLine(content, angleEmbedding, markupLayout(indentWidth, column, angleEmbedding), preceding);
             formatted.push(`${" ".repeat(column)}${line.text}`);
@@ -86,7 +86,7 @@ export function formatSource(text, options = {}) {
         statementLevel = indentation.length - 1;
         const indent = " ".repeat(statementLevel * indentWidth);
         const layout = markupLayout(indentWidth, statementLevel * indentWidth, angleEmbedding);
-        if (embeddedDepth > 0) {
+        if (isEmbeddedLine(embedded)) {
             formatted.push(`${indent}${formatEmbeddedContent(content, angleEmbedding, layout, layout.column)}`);
             preceding = undefined;
         }
@@ -95,14 +95,55 @@ export function formatSource(text, options = {}) {
             formatted.push(`${indent}${line.text}`);
             preceding = line.trailing ?? preceding;
         }
-        embeddedDepth = nextEmbeddedDepth(content, embeddedDepth, angleEmbedding);
+        embedded = nextEmbeddedScan(content, embedded, angleEmbedding);
     }
     while (formatted.at(-1) === "")
         formatted.pop();
-    return protectedStrings.restore(`${formatted.join("\n")}\n`);
+    // The terminating newline is settled on the restored text. An unterminated
+    // block comment or layout string runs to the end of the module, so its
+    // placeholder value carries the file's final newline where neither the trim
+    // above nor an append here can see it — appending one to the joined lines
+    // adds a newline on every run, and charter line 422 makes formatting
+    // idempotent.
+    const restored = protectedStrings.restore(formatted.join("\n"));
+    return restored.endsWith("\n") || restored.endsWith("\r") ? restored : `${restored}\n`;
 }
 function protectMultilineStrings(source, opaqueSourceScanners) {
     const replacements = [];
+    // One scan settles a prefix the module does not already contain, so every
+    // placeholder built from it is unique by construction. Asking the same
+    // question again per replacement re-reads the whole module each time, which
+    // costs O(placeholders x module) on a file full of layout strings.
+    //
+    // The prefix is the marker plus the smallest serial the module does not
+    // already write after it. Growing the marker by a character per collision
+    // instead would let a module spelling the marker followed by a long run of
+    // underscores grow the prefix without bound, and `placeholderPattern` below
+    // then builds a pattern the regular-expression engine refuses — a crashed
+    // formatter rather than a diagnostic. A serial cannot collide: an occurrence
+    // of `marker + serial + "_"` is an occurrence of the marker whose digit run
+    // is exactly that serial, which this scan already recorded.
+    const marker = "__velar_formatter_";
+    const writtenSerials = new Set();
+    for (let at = source.indexOf(marker); at !== -1; at = source.indexOf(marker, at + 1)) {
+        let end = at + marker.length;
+        while (end < source.length && source[end] >= "0" && source[end] <= "9")
+            end += 1;
+        writtenSerials.add(source.slice(at + marker.length, end));
+    }
+    let serial = 0;
+    while (writtenSerials.has(String(serial)))
+        serial += 1;
+    const prefix = `${marker}${serial}_`;
+    // Walking back to the line break costs a column, while asking the module for
+    // its last `\r` before an index costs the whole prefix of the module when it
+    // has none — which is every module with Unix line endings.
+    const lineStartBefore = (position) => {
+        let start = position;
+        while (start > 0 && source[start - 1] !== "\n" && source[start - 1] !== "\r")
+            start -= 1;
+        return start;
+    };
     let output = "";
     let index = 0;
     while (index < source.length) {
@@ -121,12 +162,8 @@ function protectMultilineStrings(source, opaqueSourceScanners) {
                 index = end;
                 continue;
             }
-            let marker = `__velar_formatter_multiline_comment_${replacements.length}__`;
-            while (source.includes(marker))
-                marker += "_";
-            const placeholder = JSON.stringify(marker);
-            const lineStart = Math.max(source.lastIndexOf("\n", index - 1), source.lastIndexOf("\r", index - 1)) + 1;
-            const originalIndent = /^[ \t]*/u.exec(source.slice(lineStart, index))?.[0] ?? "";
+            const placeholder = JSON.stringify(`${prefix}multiline_comment_${replacements.length}__`);
+            const originalIndent = /^[ \t]*/u.exec(source.slice(lineStartBefore(index), index))?.[0] ?? "";
             replacements.push({ placeholder, value, kind: "blockComment", originalIndent });
             output += placeholder;
             index = end;
@@ -137,14 +174,10 @@ function protectMultilineStrings(source, opaqueSourceScanners) {
             const start = index;
             index = opaqueSource.end;
             const value = source.slice(start, index);
-            let marker = opaqueSource.attachedToPrevious
-                ? `__velar_formatter_attached_opaque_source_${replacements.length}__`
-                : `__velar_formatter_opaque_source_${replacements.length}__`;
-            while (source.includes(marker))
-                marker += "_";
-            const placeholder = JSON.stringify(marker);
-            const lineStart = Math.max(source.lastIndexOf("\n", start - 1), source.lastIndexOf("\r", start - 1)) + 1;
-            const originalIndent = /^[ \t]*/u.exec(source.slice(lineStart, start))?.[0] ?? "";
+            const placeholder = JSON.stringify(opaqueSource.attachedToPrevious
+                ? `${prefix}attached_opaque_source_${replacements.length}__`
+                : `${prefix}opaque_source_${replacements.length}__`);
+            const originalIndent = /^[ \t]*/u.exec(source.slice(lineStartBefore(start), start))?.[0] ?? "";
             replacements.push({ placeholder, value, kind: "opaqueString", originalIndent });
             output += placeholder;
             continue;
@@ -163,30 +196,45 @@ function protectMultilineStrings(source, opaqueSourceScanners) {
             output += value;
             continue;
         }
-        let marker = `__velar_formatter_multiline_string_${replacements.length}__`;
-        while (source.includes(marker))
-            marker += "_";
-        const placeholder = JSON.stringify(marker);
-        const lineStart = Math.max(source.lastIndexOf("\n", start - 1), source.lastIndexOf("\r", start - 1)) + 1;
-        const originalIndent = /^[ \t]*/u.exec(source.slice(lineStart, start))?.[0] ?? "";
+        const placeholder = JSON.stringify(`${prefix}multiline_string_${replacements.length}__`);
+        const originalIndent = /^[ \t]*/u.exec(source.slice(lineStartBefore(start), start))?.[0] ?? "";
         replacements.push({ placeholder, value, kind: scanned.layout ? "layout" : "opaqueString", originalIndent });
         output += placeholder;
     }
+    // Every placeholder shares the settled prefix, so one pass over the formatted
+    // text finds them all wherever the printer moved them. Searching for each
+    // placeholder from the start and splicing it into a rebuilt string is the
+    // other half of the same quadratic cost.
+    const byPlaceholder = new Map(replacements.map((replacement) => [replacement.placeholder, replacement]));
+    const placeholderPattern = new RegExp(`"${prefix}[A-Za-z0-9_]*"`, "gu");
     return {
         text: output,
-        restore: (formatted) => replacements.reduce((current, replacement) => {
-            const marker = current.indexOf(replacement.placeholder);
-            if (marker < 0)
-                return current;
-            const lineStart = Math.max(current.lastIndexOf("\n", marker - 1), current.lastIndexOf("\r", marker - 1)) + 1;
-            const formattedIndent = /^[ \t]*/u.exec(current.slice(lineStart, marker))?.[0] ?? "";
-            const value = replacement.kind === "layout"
-                ? reindentLayoutLiteral(replacement.value, replacement.originalIndent, formattedIndent)
-                : replacement.kind === "blockComment"
-                    ? reindentBlockComment(replacement.value, replacement.originalIndent, formattedIndent)
-                    : replacement.value;
-            return `${current.slice(0, marker)}${value}${current.slice(marker + replacement.placeholder.length)}`;
-        }, formatted),
+        restore: (formatted) => {
+            let restored = "";
+            /** The restored text after its last line break — the indent a value reads. */
+            let lineTail = "";
+            let cursor = 0;
+            const append = (segment) => {
+                restored += segment;
+                const lineStart = Math.max(segment.lastIndexOf("\n"), segment.lastIndexOf("\r"));
+                lineTail = lineStart === -1 ? lineTail + segment : segment.slice(lineStart + 1);
+            };
+            for (const match of formatted.matchAll(placeholderPattern)) {
+                const replacement = byPlaceholder.get(match[0]);
+                if (!replacement)
+                    continue;
+                append(formatted.slice(cursor, match.index));
+                const formattedIndent = /^[ \t]*/u.exec(lineTail)?.[0] ?? "";
+                append(replacement.kind === "layout"
+                    ? reindentLayoutLiteral(replacement.value, replacement.originalIndent, formattedIndent)
+                    : replacement.kind === "blockComment"
+                        ? reindentBlockComment(replacement.value, replacement.originalIndent, formattedIndent)
+                        : replacement.value);
+                cursor = match.index + match[0].length;
+            }
+            append(formatted.slice(cursor));
+            return restored;
+        },
     };
 }
 function scanFormattingOpaqueSource(source, start, extensionScanners) {
@@ -270,8 +318,11 @@ function reindentLayoutLiteral(value, originalIndent, formattedIndent) {
             // Blank layout-string lines participate in the literal without needing
             // an indentation payload. Reintroducing the content margin here writes
             // trailing spaces into otherwise canonical source and makes a formatter
-            // result fail `git diff --check`.
-            if (text.trim().length === 0)
+            // result fail `git diff --check`. That holds only for a line whose whole
+            // indentation is the margin or less: whitespace past the margin is the
+            // string's own value (charter lines 381-384 preserve it exactly), so a
+            // line carrying it is re-margined like any other and keeps its payload.
+            if (originalMargin.startsWith(text))
                 text = "";
             else if (text.startsWith(originalMargin))
                 text = `${formattedMargin}${text.slice(originalMargin.length)}`;
@@ -283,72 +334,102 @@ function isChainContinuationLine(content) {
     const member = content.startsWith("?.") ? content[2] : content[1];
     return (content.startsWith(".") || content.startsWith("?.")) && Boolean(member && isSourceIdentifierStart(member));
 }
-function nextEmbeddedDepth(source, currentDepth, embedding) {
+const closedEmbeddedScan = { depth: 0, pending: null };
+/** A line inside an embedding, or inside an open tag, is copied, not formatted. */
+function isEmbeddedLine(scan) {
+    return scan.depth > 0 || scan.pending !== null;
+}
+function nextEmbeddedScan(source, current, embedding) {
     if (!embedding)
-        return 0;
-    let depth = currentDepth;
+        return closedEmbeddedScan;
+    let depth = current.depth;
+    let pending = current.pending;
     let index = 0;
-    if (depth === 0) {
+    if (depth === 0 && pending === null) {
         const start = embeddedStart(source);
         if (start === -1)
-            return 0;
+            return closedEmbeddedScan;
         index = start;
     }
     while (index < source.length) {
-        if (source.startsWith("<!--", index)) {
-            const end = source.indexOf("-->", index + 4);
-            if (end === -1)
-                return depth;
-            index = end + 3;
-            continue;
-        }
-        if (source.startsWith("/*", index)) {
-            index = blockCommentEnd(source, index);
-            continue;
-        }
-        if (source[index] !== "<" || !/[A-Za-z/>]/u.test(source[index + 1] ?? "")) {
-            index += 1;
-            continue;
-        }
-        const closing = source[index + 1] === "/";
-        let cursor = index + (closing ? 2 : 1);
-        const nameStart = cursor;
-        while (/[A-Za-z0-9_.:-]/u.test(source[cursor] ?? ""))
-            cursor += 1;
-        const name = source.slice(nameStart, cursor);
-        const fragment = name === "" && source[cursor] === ">";
-        if (!name && !fragment) {
-            index += 1;
-            continue;
+        if (pending === null) {
+            if (source.startsWith("<!--", index)) {
+                const end = source.indexOf("-->", index + 4);
+                if (end === -1)
+                    break;
+                index = end + 3;
+                continue;
+            }
+            if (source.startsWith("/*", index)) {
+                index = blockCommentEnd(source, index);
+                continue;
+            }
+            if (source[index] !== "<" || !/[A-Za-z/>]/u.test(source[index + 1] ?? "")) {
+                index += 1;
+                continue;
+            }
+            const closing = source[index + 1] === "/";
+            let cursor = index + (closing ? 2 : 1);
+            const nameStart = cursor;
+            while (/[A-Za-z0-9_.:-]/u.test(source[cursor] ?? ""))
+                cursor += 1;
+            const name = source.slice(nameStart, cursor);
+            const fragment = name === "" && source[cursor] === ">";
+            if (!name && !fragment) {
+                index += 1;
+                continue;
+            }
+            pending = { name, closing, slash: false };
+            index = cursor;
         }
         let quote = "";
         let braces = 0;
-        while (cursor < source.length) {
-            const character = source[cursor++];
+        let slash = pending.slash;
+        let terminated = false;
+        while (index < source.length) {
+            const character = source[index++];
             if (quote) {
                 if (character === "\\")
-                    cursor += 1;
+                    index += 1;
                 else if (character === quote)
                     quote = "";
+                continue;
             }
-            else if (character === '"' || character === "'")
+            if (character === '"' || character === "'") {
                 quote = character;
-            else if (character === "{")
+                slash = false;
+            }
+            else if (character === "{") {
                 braces += 1;
-            else if (character === "}")
+                slash = false;
+            }
+            else if (character === "}") {
                 braces = Math.max(0, braces - 1);
-            else if (character === ">" && braces === 0)
+                slash = false;
+            }
+            else if (braces > 0)
+                continue;
+            else if (character === ">") {
+                terminated = true;
                 break;
+            }
+            else if (character === "/")
+                slash = true;
+            else if (!/\s/u.test(character))
+                slash = false;
         }
-        const tag = source.slice(index, cursor);
-        const selfClosing = /\/\s*>$/u.test(tag) || embedding.voidElements?.has(name) === true;
-        if (closing)
+        if (!terminated) {
+            pending = { ...pending, slash };
+            break;
+        }
+        const selfClosing = slash || embedding.voidElements?.has(pending.name) === true;
+        if (pending.closing)
             depth = Math.max(0, depth - 1);
         else if (!selfClosing)
             depth += 1;
-        index = cursor;
+        pending = null;
     }
-    return depth;
+    return { depth, pending };
 }
 function embeddedStart(source) {
     for (let index = 0; index < source.length - 1; index += 1) {
@@ -526,7 +607,8 @@ function tokenizeInline(source, embedding, layout = heldLayoutFor(embedding)) {
             const generic = previous?.kind === "word"
                 && (genericStack.at(-1) === true
                     || beginsTypeBracket(tokens)
-                    || (opensAnnotatedType(tokens) && closesAsTypeArguments(source, index)));
+                    || (opensAnnotatedType(tokens) && closesAsTypeArguments(source, index))
+                    || opensCallTypeArguments(source, index));
             if (generic)
                 genericStack.push(true);
             tokens.push({ kind: generic ? "open" : "operator", text: character, generic });
@@ -613,14 +695,43 @@ function isTypeAliasLine(tokens) {
  * comparisons, so the paren depth is what separates them.
  */
 function closesAsTypeArguments(source, start) {
+    return scanTypeArguments(source, start) !== null;
+}
+/**
+ * D90 (compiler-front-15): the type argument list a TypeScript habit puts on a
+ * call — `Map<string, number>()`, `id<string>("a")`. VelarScript infers type
+ * arguments, so the spelling is always an error and the parser reads it without
+ * regard to spacing. The formatter has to read it too: respacing it into
+ * `Map < string, number > ()` rewrites the author's line into a spelling that
+ * appears nowhere in their source, in exactly the file `velar format` is
+ * pointed at while the teaching diagnostic is on screen.
+ *
+ * The evidence is the parser's (`explicitTypeArgumentsEnd`) minus the same-file
+ * generic roster a line-based formatter cannot see: the brackets close on this
+ * line with `(` directly behind them, and every `,`-separated argument carries
+ * type evidence of its own — so `two(a < Limit, g > (c))`, two comparisons and
+ * a working program, keeps its operator spacing. Being narrower than the parser
+ * can only cost a respace on a line that is an error either way; it can never
+ * change which reading the compiler gives a line, because the parser does not
+ * consult the spacing.
+ */
+function opensCallTypeArguments(source, start) {
+    const scanned = scanTypeArguments(source, start);
+    return scanned !== null && scanned.typed && source[scanned.end] === "(";
+}
+function scanTypeArguments(source, start) {
     let depth = 0;
     let parenthesized = 0;
     let index = start;
+    let everyArgumentIsTyped = true;
+    let argumentIsTyped = false;
     while (index < source.length) {
         const character = source[index];
         if (character === "<") {
             depth += 1;
             index += 1;
+            if (depth >= 2)
+                argumentIsTyped = true;
             continue;
         }
         if (character === ">") {
@@ -629,11 +740,12 @@ function closesAsTypeArguments(source, start) {
             depth -= 1;
             index += 1;
             if (depth === 0)
-                return true;
+                return { end: index, typed: everyArgumentIsTyped && argumentIsTyped };
             continue;
         }
         if (source.startsWith("->", index)) {
             index += 2;
+            argumentIsTyped = true;
             continue;
         }
         if (isSourceIdentifierStart(character)) {
@@ -643,7 +755,9 @@ function closesAsTypeArguments(source, start) {
                 index += 1;
             const word = source.slice(wordStart, index);
             if (binaryWords.has(word) || prefixWords.has(word))
-                return false;
+                return null;
+            if (isTypeEvidenceName(word))
+                argumentIsTyped = true;
             continue;
         }
         if (character === "(") {
@@ -654,7 +768,7 @@ function closesAsTypeArguments(source, start) {
         if (character === ")") {
             parenthesized -= 1;
             if (parenthesized < 0)
-                return false;
+                return null;
             index += 1;
             continue;
         }
@@ -662,13 +776,24 @@ function closesAsTypeArguments(source, start) {
             index += 1;
             continue;
         }
-        if (" \t,.?|".includes(character)) {
+        if (character === "," && depth === 1) {
+            everyArgumentIsTyped &&= argumentIsTyped;
+            argumentIsTyped = false;
             index += 1;
             continue;
         }
-        return false;
+        if (character === "?" || character === "|") {
+            argumentIsTyped = true;
+            index += 1;
+            continue;
+        }
+        if (" \t,.".includes(character)) {
+            index += 1;
+            continue;
+        }
+        return null;
     }
-    return false;
+    return null;
 }
 function formatInterpolatedString(source, start, scanned, embedding) {
     if (!scanned.closed)
@@ -1131,7 +1256,13 @@ function needsSpace(previous, current, next, tokens, index, preceding) {
     return true;
 }
 function isAttachedOpaqueSourcePlaceholder(token) {
-    return token.kind === "string" && token.text.includes("__velar_formatter_attached_opaque_source_");
+    // The marker carries a settled serial, so the placeholder is recognised by
+    // the fixed middle `protectMultilineStrings` gives it rather than by the
+    // marker spelled out — which would stop matching the moment a module made
+    // the marker settle on anything but its first spelling.
+    return token.kind === "string"
+        && token.text.includes("__velar_formatter_")
+        && token.text.includes("attached_opaque_source_");
 }
 function isUnaryOperator(token, previous, statementHead = false) {
     if (prefixWords.has(token.text))