@velarscript/compiler 0.12.1 → 0.13.0

package/dist/lexer.d.ts

@@ -1,9 +1,14 @@
-import { type Diagnostic } from "./diagnostic.ts";
+import { type AdvisorySuppression } from "./advisory-suppression.ts";
+import { type Advisory, type Diagnostic } from "./diagnostic.ts";
 import type { CompilerLexicalExtension } from "./extension.ts";
 import { type Token } from "./token.ts";
 export interface LexResult {
     readonly tokens: readonly Token[];
     readonly diagnostics: readonly Diagnostic[];
+    /** D89: the advisory channel, accumulated beside the diagnostics and never merged into them. */
+    readonly advisories: readonly Advisory[];
+    /** D89: the reasoned `velar-allow` suppressions this module's line comments carry. */
+    readonly suppressions: readonly AdvisorySuppression[];
 }
 export declare class Lexer {
     private readonly text;
@@ -12,11 +17,22 @@ export declare class Lexer {
     private readonly numericSuffixes;
     private readonly tokens;
     private readonly diagnostics;
+    private readonly advisories;
+    private readonly suppressions;
     private readonly diagnosedBidirectionalOffsets;
     private readonly indentStack;
+    private readonly classBodyStack;
+    private readonly openBrackets;
     private index;
     private atLineStart;
+    private bracketLineStart;
     private nesting;
+    private logicalLineIndent;
+    private scannedLineStart;
+    private scannedTo;
+    private cachedLineEndFrom;
+    private cachedLineEnd;
+    private semicolonRunEnd;
     private readonly bracketFragment;
     private readonly scanSourceHygiene;
     constructor(text: string, extensions?: readonly CompilerLexicalExtension[], options?: {
@@ -25,14 +41,152 @@ export declare class Lexer {
     });
     lex(): LexResult;
     private readIndentation;
+    /** The width of a leading member step, or 0 where the line does not open with one. */
+    private leadingDotWidth;
+    /**
+     * Whether the leading-dot line at `width` joins the line above it. Two
+     * conditions, and the file's own contract has always claimed both:
+     *
+     * - It is the *next* line. The backward walk used to skip an unbounded run of
+     *   `newline` tokens, so a chain joined a value that appeared any number of
+     *   blank lines and whole-line comments earlier — the case the header comment
+     *   says "never join accidentally" (D90, compiler-front-10). One `newline`
+     *   token is the line that ended the statement; a second is a blank or
+     *   comment line, and the statement ended there.
+     * - It is indented past the statement it continues. The charter called the
+     *   deeper indentation canonical and nothing enforced it, so a column-0
+     *   `.sorted()` dedented out of a function body and silently became part of
+     *   it. `logicalLineIndent` is the *statement's* indentation rather than the
+     *   previous physical line's, so every line of one chain answers to one rule.
+     */
     private isChainContinuation;
+    /**
+     * Whether the logical line that just ended opens a class body. Read by the
+     * member-name exemption: `def with(...)` declares a member here and a binding
+     * anywhere else, and only the enclosing block distinguishes them.
+     */
+    private opensClassBody;
     private readNewline;
+    /**
+     * D90 (compiler-front-14): an unclosed bracket used to swallow the rest of
+     * the module. While `nesting > 0` no newline token is emitted and no
+     * indentation is read, so one mistyped `(` turned every declaration below it
+     * into a continuation of one logical line — a file of fifty exports became
+     * one symbol, and none of the reported diagnostics named the bracket.
+     *
+     * Recovery is narrow because line breaks inside brackets really are
+     * insignificant: `compute(` with its arguments at column 0 is legal and must
+     * keep compiling, so indentation alone decides nothing. What decides is a
+     * physical line that begins a declaration or a statement — a word no
+     * bracketed expression can continue with — at or below the indentation of the
+     * line that opened the bracket. An indentation-significant language can read
+     * on from there; a brace language cannot.
+     */
+    private recoverUnclosedBrackets;
+    private openBracket;
+    private closeBracket;
     private readComment;
+    /**
+     * D89 A1: `//` is VelarScript's only comment spelling, so a Python author's
+     * floor division reads as a finished line followed by a comment and the
+     * compiler has nothing to object to. `#` cannot take the comment role over:
+     * of the branches the `#` dispatch reads (`readJavaScriptPrivateIdentifier`,
+     * `readHexColor`, `readHashComment`), `readHexColor` carries bare
+     * hexadecimal colors — a hot path in a language with `look:` — and a `#`
+     * that opened a comment would swallow `#ff0000` and the rest of its line
+     * instead of guiding it to the quoted spelling. With no comment spelling
+     * left to give up, an advisory is the only remaining move.
+     *
+     * The trigger is narrow on both sides. D89 asks for a syntactically complete
+     * expression or assignment ahead of the `//`, which here means three things:
+     * the line carries code, every bracket *this physical line* opened is closed
+     * before the comment (an unclosed one leaves the line unfinished, so
+     * `print(   // 2` is silent), and the last token can end a dividend. The
+     * bracket test counts opens and closes on the line itself rather than reading
+     * `nesting`: a bracket opened on an earlier line and closed on a later one
+     * leaves the text before `//` complete, so `print(` / `    total // 2` / `)`
+     * is exactly the mistake this advisory exists for and used to compile in
+     * silence (D90). The comment's own text — with any `velar-allow` clause
+     * removed, which is what `contentEnd` is for — must then be a bare arithmetic
+     * body carrying a digit and no letter anywhere, so `// TODO`,
+     * `// 2. then handle X`, a bare `//`, and a whole-line comment are all
+     * silent.
+     *
+     * A bracket fragment is exempt because its lexer holds the fragment's text
+     * rather than the module's: `lineStart` there answers with the fragment's own
+     * beginning, and "the rest of this line is a comment" would be a claim about
+     * an interpolation rather than about a physical line.
+     *
+     * No mechanical fix is registered: deciding that the comment really was a
+     * divisor is the judgment D38 §48 keeps out of the fix registry.
+     */
+    private adviseFloorDivisionComment;
+    /**
+     * Whether a bracket opened on this physical line is still open at the
+     * comment. This is the "syntactically complete" half of A1's trigger that
+     * `nesting` was standing in for: `nesting` also counts a bracket opened three
+     * lines up, whose text before the `//` is complete all the same.
+     */
+    private hasBracketOpenedOnLine;
+    /**
+     * What Python's `//` would have divided: the primary expression the comment
+     * follows, read back from the source so the advisory quotes the author's own
+     * spelling. The walk stops at the first operator or keyword outside brackets,
+     * because `//` binds as tightly as `*` — in `a + b // 2` the dividend is `b`,
+     * and naming `a + b` would hand back a rewrite that changes the result.
+     *
+     * A leading unary sign belongs to the dividend. Python's `-7 // 2` is -4, so
+     * quoting `7` and suggesting `(7 / 2).floor()` — which answers 3 — is the same
+     * class of wrong rewrite the divisor side used to hand back. The sign is unary
+     * exactly when nothing that could end an operand stands in front of it, which
+     * keeps the binary reading in `a - 7 // 2`, where the dividend is still `7`.
+     *
+     * `target` is the name the value lands in, and only a plain `=` produces one:
+     * a compound assignment reads its target as well as writing it, so calling it
+     * the receiver would be a second claim this advisory has not checked.
+     */
+    private dividendBeforeComment;
     private readBlockComment;
     private blockCommentOwnsLine;
     private readIdentifier;
+    /**
+     * The three positions in which a name is a member name rather than a binding:
+     * after a member step, as a record-literal key, and as the name of a member
+     * declared in a class body. The first two are the reads — `q.with("cte")`,
+     * `{with: 1}` — and the third is the declaration an extern module needs to
+     * describe such an API at all.
+     *
+     * A class body is the only place the declaration is legal: `def with(...)`
+     * outside one binds a name, and the generated module would say
+     * `function with`, which is not JavaScript.
+     */
+    private isMemberNamePosition;
+    /**
+     * D90 (coherence): the one position where `this` is the Python receiver
+     * reflex rather than JavaScript's dynamic receiver — a parameter name in the
+     * list of an instance method or a constructor inside a class body. The
+     * analyzer owns that report, because only it knows the declaration carries
+     * an implicit receiver, and its rewrite deletes the parameter instead of
+     * renaming it to a spelling that is an error in the same position.
+     *
+     * The walk is paren-balanced so a default value cannot be mistaken for the
+     * list that encloses it — `def m(a = f(this))` is an ordinary receiver read
+     * — and `static def make(this)` is excluded because a static method has no
+     * receiver to delete, so the rename is still the honest answer there.
+     */
+    private isReceiverParameterPosition;
     private readNumber;
     private readRadixNumber;
+    /**
+     * A number token, carrying the author's own spelling whenever the value it
+     * holds is spelled differently — `1_000` loses its separators and `0X20`
+     * loses its uppercase prefix on the way to the token. D90 R6 quotes the
+     * literal back when it is not exactly representable, and it must quote what
+     * was written: reporting `'10000000000000000001'` for a source line that
+     * reads `1_000_000_000_000_000_000_1` sends the author looking for text that
+     * is not there.
+     */
+    private pushNumber;
     private isRadixDigit;
     /**
      * LOK-I5: `%` right after a number is the percentage unit only where a
@@ -45,6 +199,49 @@ export declare class Lexer {
     private readDigitsWithSeparators;
     private readString;
     private readEmbeddedJavaScript;
+    /**
+     * D89 A5/A6: JavaScript's `${...}` never interpolates in VelarScript. The
+     * charter keeps it literal on purpose — generating JavaScript source is a
+     * real use of these literals — so the spelling cannot become an error, and a
+     * string that carries it compiles in silence with a meaning the JavaScript
+     * reflex behind it did not intend. That is D89's admission shape exactly,
+     * on both sides of the `f` prefix:
+     *
+     * - A5, a plain double-quoted or backtick string: nothing interpolates, the
+     *   `${name}` stays text. The way out is the `f` prefix with `{name}`.
+     * - A6, an `f` or `rf` string: the `$` ahead of `{` keeps that brace
+     *   literal, so the author who wrote the prefix *and* the JavaScript
+     *   spelling still gets text. The way out is dropping the `$`.
+     *
+     * The non-triggers, each deliberate: an empty `${}` or an unclosed `${`
+     * carries no expression to interpolate; a raw `r"..."` string is the author
+     * asking for literal text by name, so the deliberate-literal reading wins
+     * there (`rf` still triggers A6 — its rawness is about backslashes, not
+     * about interpolation); a single-quoted string is already VEL1005; an
+     * unterminated string is already VEL1003; and an inline `extern js` /
+     * `unsafe js` block never reaches this method at all — it is scanned by
+     * `readEmbeddedJavaScript`, where `${...}` is documented literal
+     * JavaScript. One advisory speaks per literal: the rewrite names the whole
+     * string, so a second occurrence adds nothing the first did not say.
+     *
+     * The fix is registered only where D38 §48's no-judgment bar holds: every
+     * `${...}` well-formed, every body a plain dotted name path (see
+     * `interpolationPathBody`), no `$` immediately ahead of an occurrence's own
+     * `$` — JavaScript's `$${x}` spells a literal `$` before an interpolation,
+     * and deleting the occurrence's `$` leaves `${x}`, whose surviving `$`
+     * holds the brace literal all over again, so the quoted rewrite would not
+     * interpolate — and, for A5, no bare brace outside the occurrences, because
+     * the `f` prefix would turn `{` into an interpolation opener and `{{` into
+     * a single literal brace. Everything else keeps the message and loses the
+     * one-click edit.
+     *
+     * A bracket fragment is exempt for A1's reason: its lexer holds the
+     * fragment's text rather than the module's, so a span there would not land
+     * on the physical line a `velar-allow` reads.
+     */
+    private adviseTemplateInterpolation;
+    /** The literal's source text with each occurrence's `$` removed, for the message that quotes the rewrite. */
+    private literalWithoutDollars;
     private diagnoseStringContents;
     private decodeStringText;
     private legacyTripleQuotePrefix;
@@ -72,7 +269,26 @@ export declare class Lexer {
     private diagnoseForbiddenSourceCharacters;
     private isBidirectionalControl;
     private isForbiddenLiteralControl;
+    /**
+     * The start of the physical line `index` sits on. D90 (compiler-front-2): the
+     * backward scan this used to be is O(column) per call, and its callers — A1,
+     * the block-comment reader, the semicolon fix, and every opening bracket —
+     * run once per token, so one long physical line cost O(n²). A line of 20000
+     * semicolons took 673 ms and a 4 MiB one would have taken hours, with nothing
+     * to stop it: a ';' produces no token, so `MAX_TOKENS` never fires.
+     *
+     * The offsets those callers ask about only move forward, so the scan is
+     * carried across the file once and each call pays for the characters since
+     * the last one. An earlier offset still falls back to the backward scan,
+     * which is correct and, being off the hot path, is not the cost.
+     */
     private lineStart;
+    /**
+     * The end of the physical line `index` sits on. Every offset between a line's
+     * start and its end shares that end, so one line answers every call about it
+     * once — which is what keeps a line of N semicolons from paying N forward
+     * scans of its own tail.
+     */
     private lineEnd;
     private invalidCharacter;
     private isAtEnd;

package/dist/lexer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../src/lexer.ts"],"names":[],"mappings":"AACA,OAAO,EAAkD,KAAK,UAAU,EAAsB,MAAM,iBAAiB,CAAC;AAEtH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAK/D,OAAO,EAAgB,KAAK,KAAK,EAAkB,MAAM,YAAY,CAAC;AA0BtE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,6BAA6B,CAA6B;IAC3E,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuD;IAMzF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0C;IAC1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,6BAA6B,CAAqB;IACnE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAO;IACnC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,OAAO,CAAK;IAKpB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAU;IAE5C,YACE,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,SAAS,wBAAwB,EAAO,EACpD,OAAO,GAAE;QAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAAO,EAY3F;IAED,GAAG,IAAI,SAAS,CAgRf;IAED,OAAO,CAAC,eAAe;IA0DvB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,gBAAgB;IAyCxB,OAAO,CAAC,oBAAoB;IAmB5B,OAAO,CAAC,cAAc;IAiDtB,OAAO,CAAC,UAAU;IA0ElB,OAAO,CAAC,eAAe;IAqCvB,OAAO,CAAC,YAAY;IAOpB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,wBAAwB;IAqBhC,OAAO,CAAC,UAAU;IAqDlB,OAAO,CAAC,sBAAsB;IA+B9B,OAAO,CAAC,sBAAsB;IA2C9B,OAAO,CAAC,gBAAgB;IAmBxB,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,qBAAqB;IAyB7B,OAAO,CAAC,kBAAkB;IAqB1B,OAAO,CAAC,QAAQ;IAIhB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,wBAAwB;IAMhC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,+BAA+B;IAuBvC,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,iCAAiC;IAiBzC,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,yBAAyB;IAOjC,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,OAAO;CAGhB"}
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../src/lexer.ts"],"names":[],"mappings":"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"}