🥮 mooncakes.io

    marianoguerra/wax/syntax/trivia does not have a README file

    Associated

    source
    pub(all) struct Associated {
      before : Array[Entry]
      within : Array[Entry]
      after : Array[Entry]
    } derive(Eq, 
    Debug    )

    Where a comment sits relative to the node that owns it.

    Context

    source
    pub struct Context {
      entries : Array[Entry]
      at_start_of_line : Bool
      prev_token_end : Int
      locations : Array[
    Location    ]
    }

    Collection state, threaded through lexing.

    The reference makes the grammar a Menhir functor over this context so every semantic action can register spans. MoonBit has no functors, so phase 2 will hold it in a package-level Ref instead — see parser/parser.mbty.

    Context::entries

    source
    fn Context::entries(self : Context) -> ArrayView[Entry]

    The collected trivia, in source order.

    The reference accumulates onto the front of a list and reverses on use; pushing onto an array keeps source order directly.

    Context::locations

    source

    Context::new

    source
    fn Context::new() -> Context

    Context::record_pos

    source
    fn Context::record_pos(self : Context, loc : 
    Location    ) -> Unit

    Record that an AST node spans loc, so trivia can be attached to it later.

    Context::report_item

    source
    fn Context::report_item(self : Context, kind : TriviaKind, loc : 
    Location    , content : String) -> Unit

    Record a comment (or annotation) spanning loc.

    A line comment runs to the end of its line, so it leaves the lexer at the start of the next one; a block comment does not.

    Context::report_newline

    source
    fn Context::report_newline(self : Context) -> Unit

    Record a newline.

    A newline while already at the start of a line means the line just ended was empty, which is the only way a blank line is detected.

    Context::report_token

    source
    fn Context::report_token(self : Context, pos : Int) -> Unit

    Record that a real token ending at byte offset pos was consumed.

    Entry

    source
    pub(all) struct Entry {
      anchor : Int
      trivia : Trivia
      position : TriviaPos
    } derive(Eq, 
    Debug    )

    Locations

    source
    pub struct Locations {
      marked : 
    Set    [SpanKey]
    }

    The set of spans the printer actually looks up.

    Filled by a dry printing pass; see associate.

    Locations::contains

    source

    Locations::mark

    source

    Locations::new

    source
    fn Locations::new() -> Locations

    SpanKey

    source

    A span reduced to its byte offsets.

    Keying on offsets alone is deliberate: it is cheap to hash and compare, and the filename is the same for every span in one parse.

    Table

    source
    pub struct Table {
      entries : Map[SpanKey, Associated]
      seen : 
    Set    [SpanKey]
    }

    A location-keyed trivia table.

    Table::empty

    source
    fn Table::empty() -> Table

    Table::get

    source

    The trivia attached to loc, or nothing.

    A span yields its trivia ONCE: several nodes can record the same range (a Get instruction and the identifier it wraps span the same name), the printer looks each up, and only the first may carry the comments.

    Trivia

    source
    pub(all) enum Trivia {
      Item(content~ : String, kind~ : TriviaKind, loc~ : 
    Location    )
      BlankLine
    } derive(Eq, 
    Debug    )

    TriviaKind

    source
    pub(all) enum TriviaKind {
      LineComment
      BlockComment
      Annotation
    } derive(Eq, 
    Debug    )

    TriviaPos

    source
    pub(all) enum TriviaPos {
      LineStart
      Inline
    } derive(Eq, 
    Debug    )

    Whether a piece of trivia began a line or trailed a token on one.

    The printer needs the distinction: a comment on its own line stays on its own line, while one trailing foo; // why has to be held back and emitted after the separator rather than before it.

    associate

    source
    fn associate(ctx : Context, collect : (Locations) -> Unit) -> (Table, Array[Entry])

    Associate collected trivia with the spans the printer will look up.

    collect is a dry printing pass that records those spans. Association runs over the spans that are BOTH a parse node and looked up by the printer -- the two sets clip each other in opposite directions and neither alone will do:

    • dropping a parse node the printer skips keeps its comments from being silently lost; they bubble up to an enclosing node that does print.
    • dropping a looked-up span that no parse node owns keeps a comment from landing somewhere that is not a source construct. The printer stamps some output with the span of a mere TOKEN, and such a span can outrank the real nodes and steal the file's leading comments.

    Returns the table and the leftovers no location owns -- trailing comments past the last node, or the whole file when there are no nodes at all. The caller prints those as tail trivia.

    drop_trailing_blank_lines

    source
    fn drop_trailing_blank_lines(entries : Array[Entry]) -> Array[Entry]

    Drop trailing blank lines from a run of trivia.

    empty_assoc

    source
    let empty_assoc : Associated

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io