@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

package/dist/diagnostics/DiagnosticCategory.d.ts

@@ -0,0 +1,16 @@
+/** Indicates the category of a {@link DiagnosticMessage}. */
+export declare enum DiagnosticCategory {
+    /** Overly pedantic message. */
+    Pedantic = 0,
+    /** Informatory message. */
+    Info = 1,
+    /** Warning message. */
+    Warning = 2,
+    /** Error message. */
+    Error = 3
+}
+/** Returns the string representation of the specified diagnostic category. */
+export declare function diagnosticCategoryToString(category: DiagnosticCategory): string;
+/** Returns the ANSI escape sequence for the specified category. */
+export declare function diagnosticCategoryToColor(category: DiagnosticCategory): string;
+export type DiagnosticCode = number;

package/dist/diagnostics/DiagnosticCategory.js

@@ -0,0 +1,39 @@
+import { COLOR_CYAN, COLOR_MAGENTA, COLOR_RED, COLOR_YELLOW } from "../utils/terminal.js";
+/** Indicates the category of a {@link DiagnosticMessage}. */
+export var DiagnosticCategory;
+(function (DiagnosticCategory) {
+    /** Overly pedantic message. */
+    DiagnosticCategory[DiagnosticCategory["Pedantic"] = 0] = "Pedantic";
+    /** Informatory message. */
+    DiagnosticCategory[DiagnosticCategory["Info"] = 1] = "Info";
+    /** Warning message. */
+    DiagnosticCategory[DiagnosticCategory["Warning"] = 2] = "Warning";
+    /** Error message. */
+    DiagnosticCategory[DiagnosticCategory["Error"] = 3] = "Error";
+})(DiagnosticCategory || (DiagnosticCategory = {}));
+;
+Object.freeze(DiagnosticCategory);
+/** Returns the string representation of the specified diagnostic category. */
+export function diagnosticCategoryToString(category) {
+    switch (category) {
+        case DiagnosticCategory.Pedantic: return "PEDANTIC";
+        case DiagnosticCategory.Info: return "INFO";
+        case DiagnosticCategory.Warning: return "WARNING";
+        case DiagnosticCategory.Error: return "ERROR";
+        default: {
+            throw new Error(`Unexpected diagnostic category: ${category} ${DiagnosticCategory[category]}`);
+        }
+    }
+}
+/** Returns the ANSI escape sequence for the specified category. */
+export function diagnosticCategoryToColor(category) {
+    switch (category) {
+        case DiagnosticCategory.Pedantic: return COLOR_MAGENTA;
+        case DiagnosticCategory.Info: return COLOR_CYAN;
+        case DiagnosticCategory.Warning: return COLOR_YELLOW;
+        case DiagnosticCategory.Error: return COLOR_RED;
+        default: {
+            throw new Error(`Unexpected diagnostic category: ${category} ${DiagnosticCategory[category]}`);
+        }
+    }
+}

package/dist/diagnostics/DiagnosticEmitter.d.ts

@@ -0,0 +1,32 @@
+import { SourceRange } from "../ast/Source/SourceRange.js";
+import { DiagnosticCode, DiagnosticCategory } from "./DiagnosticCategory.js";
+import { DiagnosticMessage } from "./DiagnosticMessage.js";
+import { HasOwnToString } from "./utils/types.js";
+/** Base class of all diagnostic emitters. */
+export declare abstract class DiagnosticEmitter {
+    /** Diagnostic messages emitted so far. */
+    diagnostics: DiagnosticMessage[];
+    /** Diagnostic messages already seen, by range. */
+    private seen;
+    /** Initializes this diagnostic emitter. */
+    protected constructor(diagnostics?: DiagnosticMessage[] | undefined);
+    emitDiagnosticMessage(message: DiagnosticMessage): void;
+    /** Emits a diagnostic message of the specified category. */
+    emitDiagnostic<A, B, C>(code: DiagnosticCode, category: DiagnosticCategory, range: SourceRange | undefined, relatedRange: SourceRange | undefined, arg0?: string | HasOwnToString<A> | undefined, arg1?: string | HasOwnToString<B> | undefined, arg2?: string | HasOwnToString<C> | undefined): void;
+    /** Emits an overly pedantic diagnostic message. */
+    pedantic(code: DiagnosticCode, range: SourceRange | undefined, arg0?: string | undefined, arg1?: string | undefined, arg2?: string | undefined): void;
+    /** Emits an overly pedantic diagnostic message with a related range. */
+    pedanticRelated(code: DiagnosticCode, range: SourceRange, relatedRange: SourceRange, arg0?: string | undefined, arg1?: string | undefined, arg2?: string | undefined): void;
+    /** Emits an informatory diagnostic message. */
+    info(code: DiagnosticCode, range: SourceRange | undefined, arg0?: string | undefined, arg1?: string | undefined, arg2?: string | undefined): void;
+    /** Emits an informatory diagnostic message with a related range. */
+    infoRelated(code: DiagnosticCode, range: SourceRange, relatedRange: SourceRange, arg0?: string | undefined, arg1?: string | undefined, arg2?: string | undefined): void;
+    /** Emits a warning diagnostic message. */
+    warning(code: DiagnosticCode, range: SourceRange | undefined, arg0?: string | undefined, arg1?: string | undefined, arg2?: string | undefined): undefined;
+    /** Emits a warning diagnostic message with a related range. */
+    warningRelated(code: DiagnosticCode, range: SourceRange, relatedRange: SourceRange, arg0?: string | undefined, arg1?: string | undefined, arg2?: string | undefined): void;
+    /** Emits an error diagnostic message. */
+    error<A, B, C>(code: DiagnosticCode, range: SourceRange | undefined, arg0?: string | HasOwnToString<A> | undefined, arg1?: string | HasOwnToString<B> | undefined, arg2?: string | HasOwnToString<C> | undefined): undefined;
+    /** Emits an error diagnostic message with a related range. */
+    errorRelated(code: DiagnosticCode, range: SourceRange, relatedRange: SourceRange, arg0?: string | undefined, arg1?: string | undefined, arg2?: string | undefined): void;
+}

package/dist/diagnostics/DiagnosticEmitter.js

@@ -0,0 +1,95 @@
+import { assert } from "../utils/assert.js";
+import { DiagnosticCategory } from "./DiagnosticCategory.js";
+import { DiagnosticMessage } from "./DiagnosticMessage.js";
+/** Base class of all diagnostic emitters. */
+export class DiagnosticEmitter {
+    /** Diagnostic messages emitted so far. */
+    diagnostics;
+    /** Diagnostic messages already seen, by range. */
+    seen = new Map();
+    /** Initializes this diagnostic emitter. */
+    constructor(diagnostics = undefined) {
+        if (!Array.isArray(diagnostics))
+            diagnostics = [];
+        this.diagnostics = diagnostics;
+    }
+    emitDiagnosticMessage(message) {
+        this.diagnostics.push(message);
+    }
+    /** Emits a diagnostic message of the specified category. */
+    emitDiagnostic(code, category, range, relatedRange, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        const originalStackLimit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 6;
+        let emitStack = new Error().stack;
+        Error.stackTraceLimit = originalStackLimit;
+        emitStack = emitStack?.split("\n").slice(2).map(l => l.trim()).join("\n");
+        let message = DiagnosticMessage.create(code, category, arg0, arg1, arg2, emitStack);
+        if (range)
+            message = message.withRange(range);
+        if (relatedRange)
+            message.relatedRange = relatedRange;
+        // It is possible that the same diagnostic is emitted twice, for example
+        // when compiling generics with different types or when recompiling a loop
+        // because our initial assumptions didn't hold. It is even possible to get
+        // multiple instances of the same range during parsing. Deduplicate these.
+        if (range) {
+            let seen = this.seen;
+            if (seen.has(range.source)) {
+                let seenInSource = assert(seen.get(range.source));
+                if (seenInSource.has(range.start)) {
+                    let seenMessagesAtPos = assert(seenInSource.get(range.start));
+                    for (let i = 0, k = seenMessagesAtPos.length; i < k; ++i) {
+                        if (seenMessagesAtPos[i].equals(message))
+                            return;
+                    }
+                    seenMessagesAtPos.push(message);
+                }
+                else {
+                    seenInSource.set(range.start, [message]);
+                }
+            }
+            else {
+                let seenInSource = new Map();
+                seenInSource.set(range.start, [message]);
+                seen.set(range.source, seenInSource);
+            }
+        }
+        this.emitDiagnosticMessage(message);
+        // console.log(formatDiagnosticMessage(message, true, true) + "\n"); // temporary
+        // console.log(<string>new Error("stack").stack);
+    }
+    /** Emits an overly pedantic diagnostic message. */
+    pedantic(code, range, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        this.emitDiagnostic(code, DiagnosticCategory.Pedantic, range, undefined, arg0, arg1, arg2);
+    }
+    /** Emits an overly pedantic diagnostic message with a related range. */
+    pedanticRelated(code, range, relatedRange, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        this.emitDiagnostic(code, DiagnosticCategory.Pedantic, range, relatedRange, arg0, arg1, arg2);
+    }
+    /** Emits an informatory diagnostic message. */
+    info(code, range, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        this.emitDiagnostic(code, DiagnosticCategory.Info, range, undefined, arg0, arg1, arg2);
+    }
+    /** Emits an informatory diagnostic message with a related range. */
+    infoRelated(code, range, relatedRange, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        this.emitDiagnostic(code, DiagnosticCategory.Info, range, relatedRange, arg0, arg1, arg2);
+    }
+    /** Emits a warning diagnostic message. */
+    warning(code, range, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        this.emitDiagnostic(code, DiagnosticCategory.Warning, range, undefined, arg0, arg1, arg2);
+        return undefined;
+    }
+    /** Emits a warning diagnostic message with a related range. */
+    warningRelated(code, range, relatedRange, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        this.emitDiagnostic(code, DiagnosticCategory.Warning, range, relatedRange, arg0, arg1, arg2);
+    }
+    /** Emits an error diagnostic message. */
+    error(code, range, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        this.emitDiagnostic(code, DiagnosticCategory.Error, range, undefined, arg0, arg1, arg2);
+        return undefined;
+    }
+    /** Emits an error diagnostic message with a related range. */
+    errorRelated(code, range, relatedRange, arg0 = undefined, arg1 = undefined, arg2 = undefined) {
+        this.emitDiagnostic(code, DiagnosticCategory.Error, range, relatedRange, arg0, arg1, arg2);
+    }
+}

package/dist/diagnostics/DiagnosticMessage.d.ts

@@ -0,0 +1,37 @@
+import { SourceRange } from "../ast/Source/SourceRange.js";
+import { DiagnosticCategory, DiagnosticCode } from "./DiagnosticCategory.js";
+import { HasOwnToString } from "./utils/types.js";
+/** Represents a diagnostic message. */
+export declare class DiagnosticMessage {
+    /** Message code. */
+    code: number;
+    /** Message category. */
+    category: DiagnosticCategory;
+    /** Message text. */
+    message: string;
+    /** Respective source range, if any. */
+    range: SourceRange | undefined;
+    /** Related range, if any. */
+    relatedRange: SourceRange | undefined;
+    /** error stack at `emitDiagnostic` (if any) */
+    emitStack: string | undefined;
+    /** Constructs a new diagnostic message. */
+    private constructor();
+    /** Creates a new diagnostic message of the specified category. */
+    static create<A, B, C>(code: DiagnosticCode, category: DiagnosticCategory, arg0?: string | HasOwnToString<A> | undefined, arg1?: string | HasOwnToString<B> | undefined, arg2?: string | HasOwnToString<C> | undefined, emitStack?: string | undefined): DiagnosticMessage;
+    /** Tests if this message equals the specified. */
+    equals(other: DiagnosticMessage): boolean;
+    /** Adds a source range to this message. */
+    withRange(range: SourceRange): this;
+    /** Adds a related source range to this message. */
+    withRelatedSourceRange(range: SourceRange): this;
+    /** Converts this message to a string. */
+    toString(): string;
+    format({ colors, context }: DiagnosticMessageFormatOptions): string;
+}
+export interface DiagnosticMessageFormatOptions {
+    colors?: boolean;
+    context?: boolean;
+}
+/** a diagnostic message, optionally with terminal colors and source context. */
+export declare function formatDiagnosticMessage(message: DiagnosticMessage, useColors?: boolean, showContext?: boolean): string;

package/dist/diagnostics/DiagnosticMessage.js

@@ -0,0 +1,229 @@
+import { setColorsEnabled, isColorsEnabled, COLOR_RESET, COLOR_RED } from "../utils/terminal.js";
+import { isLineBreak, isWhiteSpace } from "../utils/text.js";
+import { diagnosticCategoryToString, diagnosticCategoryToColor } from "./DiagnosticCategory.js";
+import { diagnosticCodeToString } from "./diagnosticMessages.generated.js";
+/** Represents a diagnostic message. */
+export class DiagnosticMessage {
+    /** Message code. */
+    code;
+    /** Message category. */
+    category;
+    /** Message text. */
+    message;
+    /** Respective source range, if any. */
+    range = undefined;
+    /** Related range, if any. */
+    relatedRange = undefined; // TODO: Make this a related message for chains?
+    /** error stack at `emitDiagnostic` (if any) */
+    emitStack;
+    /** Constructs a new diagnostic message. */
+    constructor(code, category, message, emitStack = undefined) {
+        this.code = code;
+        this.category = category;
+        this.message = message;
+        this.emitStack = emitStack;
+    }
+    /** Creates a new diagnostic message of the specified category. */
+    static create(code, category, arg0 = undefined, arg1 = undefined, arg2 = undefined, emitStack = undefined) {
+        let message = diagnosticCodeToString(code);
+        if (typeof arg0 !== "string" && arg0 !== undefined)
+            arg0 = arg0.toString();
+        if (typeof arg1 !== "string" && arg1 !== undefined)
+            arg1 = arg1.toString();
+        if (typeof arg2 !== "string" && arg2 !== undefined)
+            arg2 = arg2.toString();
+        if (typeof arg0 === "string")
+            message = message.replace("{0}", arg0);
+        if (typeof arg1 === "string")
+            message = message.replace("{1}", arg1);
+        if (typeof arg2 === "string")
+            message = message.replace("{2}", arg2);
+        return new DiagnosticMessage(code, category, message, emitStack);
+    }
+    /** Tests if this message equals the specified. */
+    equals(other) {
+        if (this.code !== other.code)
+            return false;
+        let thisSourceRange = this.range;
+        let otherSourceRange = other.range;
+        if (thisSourceRange) {
+            if (!otherSourceRange || !thisSourceRange.equals(otherSourceRange))
+                return false;
+        }
+        else if (otherSourceRange) {
+            return false;
+        }
+        let thisRelatedSourceRange = this.relatedRange;
+        let otherRelatedSourceRange = other.relatedRange;
+        if (thisRelatedSourceRange) {
+            if (!otherRelatedSourceRange || !thisRelatedSourceRange.equals(otherRelatedSourceRange))
+                return false;
+        }
+        else if (otherRelatedSourceRange) {
+            return false;
+        }
+        return this.message === other.message;
+    }
+    /** Adds a source range to this message. */
+    withRange(range) {
+        this.range = range;
+        return this;
+    }
+    /** Adds a related source range to this message. */
+    withRelatedSourceRange(range) {
+        this.relatedRange = range;
+        return this;
+    }
+    /** Converts this message to a string. */
+    toString() {
+        let category = diagnosticCategoryToString(this.category);
+        let range = this.range;
+        let code = this.code;
+        let message = this.message;
+        if (range) {
+            let source = range.source;
+            let path = source.absoluteProjPath;
+            let line = source.lineAt(range.start);
+            let column = source.columnAt();
+            let len = range.end - range.start;
+            return `${category} ${code}: "${message}" in ${path}:${line}:${column}`;
+        }
+        return `${category} ${code}: ${message}`;
+    }
+    format({ colors, context }) {
+        return formatDiagnosticMessage(this, Boolean(colors ?? false), Boolean(context ?? false));
+    }
+}
+;
+/** a diagnostic message, optionally with terminal colors and source context. */
+export function formatDiagnosticMessage(message, useColors = false, showContext = false) {
+    let wasColorsEnabled = setColorsEnabled(useColors);
+    // general information
+    let sb = [];
+    if (isColorsEnabled())
+        sb.push(diagnosticCategoryToColor(message.category));
+    sb.push(diagnosticCategoryToString(message.category));
+    if (isColorsEnabled())
+        sb.push(COLOR_RESET);
+    sb.push(message.code < 1000 ? " AS" : " TS");
+    sb.push(message.code.toString());
+    sb.push(": ");
+    sb.push(message.message);
+    // include range information if available
+    let range = message.range;
+    if (range) {
+        let source = range.source;
+        let relatedRange = message.relatedRange;
+        let minLine = 0;
+        if (relatedRange) {
+            // Justify context indentation when multiple ranges are present
+            minLine = Math.max(source.lineAt(range.start), relatedRange.source.lineAt(relatedRange.start));
+        }
+        // include context information if requested
+        if (showContext) {
+            sb.push("\n");
+            sb.push(formatDiagnosticContext(range, minLine));
+        }
+        else {
+            sb.push("\n in ");
+            sb.push(source.absoluteProjPath);
+        }
+        sb.push("(");
+        sb.push(source.lineAt(range.start).toString());
+        sb.push(",");
+        sb.push(source.columnAt().toString());
+        sb.push(")");
+        if (relatedRange) {
+            let relatedSource = relatedRange.source;
+            if (showContext) {
+                sb.push("\n");
+                sb.push(formatDiagnosticContext(relatedRange, minLine));
+            }
+            else {
+                sb.push("\n in ");
+                sb.push(relatedSource.absoluteProjPath);
+            }
+            sb.push("(");
+            sb.push(relatedSource.lineAt(relatedRange.start).toString());
+            sb.push(",");
+            sb.push(relatedSource.columnAt().toString());
+            sb.push(")");
+        }
+    }
+    setColorsEnabled(wasColorsEnabled);
+    return sb.join("");
+}
+/** Formats the diagnostic context for the specified range, optionally with terminal colors. */
+function formatDiagnosticContext(range, minLine = 0) {
+    let source = range.source;
+    let text = source.text;
+    let len = text.length;
+    let start = range.start;
+    let end = start;
+    let lineNumber = source.lineAt(start).toString();
+    let lineNumberLength = minLine
+        ? Math.max(minLine.toString().length, lineNumber.length)
+        : lineNumber.length;
+    let lineSpace = " ".repeat(lineNumberLength);
+    // Find preceeding line break
+    while (start > 0 && !isLineBreak(text.charCodeAt(start - 1)))
+        start--;
+    // Skip leading whitespace (assume no supplementary whitespaces)
+    while (start < len && isWhiteSpace(text.charCodeAt(start)))
+        start++;
+    // Find next line break
+    while (end < len && !isLineBreak(text.charCodeAt(end)))
+        end++;
+    let sb = [
+        lineSpace,
+        "  :\n ",
+        " ".repeat(lineNumberLength - lineNumber.length),
+        lineNumber,
+        " │ ",
+        // text.substring(start, end).replaceAll("\t", "  "),
+        text.substring(start, end).replace(/\t/g, "  "),
+        "\n ",
+        lineSpace,
+        " │ "
+    ];
+    while (start < range.start) {
+        if (text.charCodeAt(start) === 9 /* CharCode.Tab */) {
+            sb.push("  ");
+            start += 2;
+        }
+        else {
+            sb.push(" ");
+            start++;
+        }
+    }
+    if (isColorsEnabled())
+        sb.push(COLOR_RED);
+    if (range.start === range.end) {
+        sb.push("^");
+    }
+    else {
+        while (start++ < range.end) {
+            let cc = text.charCodeAt(start);
+            if (cc === 9 /* CharCode.Tab */) {
+                sb.push("~~");
+            }
+            else if (isLineBreak(cc)) {
+                sb.push(start === range.start + 1 ? "^" : "~");
+                break;
+            }
+            else {
+                sb.push("~");
+            }
+        }
+    }
+    if (isColorsEnabled())
+        sb.push(COLOR_RESET);
+    sb.push("\n ");
+    sb.push(lineSpace);
+    sb.push(" └─ in ");
+    sb.push(source.absoluteProjPath);
+    return sb.join("");
+}
+function replaceAll(str, search, replacement) {
+    return str.replace(new RegExp(search, 'g'), replacement);
+}