🥮 mooncakes.io

    moonreport

    Source-aware diagnostic reports for MoonBit developer tools

    diagnostic
    source
    span
    compiler
    reporting
    Download zip
    Author
    Version
    0.1.0
    License
    Apache-2.0
    Repository
    Last updated
    last month
    Downloads
    9

    #MoonReport

    MoonReport is a pure MoonBit toolkit for turning byte offsets and validation failures into readable, source-aware diagnostics. It is useful anywhere a developer tool needs to point at the exact part of an input that caused a problem.

    It is designed for parsers, configuration validators, linters, compilers, code generators, test frameworks, and command-line tools. A caller supplies source files, spans, labels, and optional help text; MoonReport produces stable plain-text or ANSI output without requiring a terminal or filesystem.

    #Features

    • UTF-8-aware source files, line indexes, tabs, and display columns
    • errors, warnings, notes, help, codes, and multiple labeled spans
    • deterministic context selection and folding for distant labels
    • single-line and multi-line annotations
    • plain text, ANSI, compact, JSON, and JSON Lines renderers
    • dark/light terminal themes and ANSI stripping
    • diagnostic batches, severity summaries, filtering, and CI exit thresholds
    • stable diagnostic metrics grouped by severity, code, and source
    • atomic source fixes with overlap, bounds, and UTF-8 boundary validation
    • human-readable fix previews and stable machine-readable JSON
    • conservative batch fix plans for unattended formatter and linter workflows

    #Quick start

    let sources = @report.SourceMap::new()
    let id = sources.add("app.conf", "port = 70000")
    let problem = @report.Diagnostic::new(Error, "invalid port")
      .with_code("CFG002")
      .with_label(
        @report.Label::primary(
          id,
          @report.Span::new(7, 12).unwrap(),
          "expected a value from 1 to 65535",
        ),
      )
      .with_help("try port 8080")

    println(@report.render(sources, problem))

    Run the included configuration-validator demo:

    moon run cmd/main

    See docs/quickstart.md for package setup, renderer selection, batch reporting, source fixes, and output integration.

    The implementation is original and released under Apache-2.0. See docs/project-charter.md for the library boundary and docs/roadmap.md for future extension candidates.

    #Development and verification

    moon check --deny-warn
moon test
moon fmt --check
moon build
moon info
moon run cmd/main

    The library has no runtime I/O dependency; callers decide how sources are loaded and where reports are sent. This keeps output deterministic across native, JavaScript, and WebAssembly environments.

    The current release contains more than 4,000 physical lines of MoonBit across the library, tests, and runnable example, with 89 passing tests.

    Applicability

    source
    pub(all) enum Applicability {
      MachineApplicable
      MaybeIncorrect
      HasPlaceholders
      Unspecified
    } derive(Eq, 
    Debug    )

    How confidently an automated edit can be applied.

    Applicability::is_automatic

    source
    fn Applicability::is_automatic(self : Applicability) -> Bool

    Applicability::name

    source
    fn Applicability::name(self : Applicability) -> String

    CodeCount

    source
    pub struct CodeCount {
      code : String
      count : Int
    } derive(Eq, 
    Debug    )

    A stable count associated with one diagnostic code.

    CodeCount::code

    source
    fn CodeCount::code(self : CodeCount) -> String

    CodeCount::count

    source
    fn CodeCount::count(self : CodeCount) -> Int

    Color

    source
    pub(all) enum Color {
      Default
      Black
      Red
      Green
      Yellow
      Blue
      Magenta
      Cyan
      White
      BrightBlack
      BrightRed
      BrightYellow
      BrightBlue
      BrightCyan
      BrightWhite
    } derive(Eq, 
    Debug    )

    Named ANSI color used by terminal themes.

    Diagnostic

    source
    pub struct Diagnostic {
      severity : Severity
      message : String
      code : String?
      help : String?
      notes : Array[String]
      labels : Array[Label]
    } derive(Eq, 
    Debug    )

    A complete problem report independent of presentation format.

    Diagnostic::code

    source
    fn Diagnostic::code(self : Diagnostic) -> String?

    Diagnostic::help

    source
    fn Diagnostic::help(self : Diagnostic) -> String?

    Diagnostic::is_valid

    source
    fn Diagnostic::is_valid(self : Diagnostic) -> Bool

    Diagnostic::labels

    source
    fn Diagnostic::labels(self : Diagnostic) -> Array[Label]

    Diagnostic::message

    source
    fn Diagnostic::message(self : Diagnostic) -> String

    Diagnostic::new

    source
    fn Diagnostic::new(severity : Severity, message : String) -> Diagnostic

    Diagnostic::notes

    source
    fn Diagnostic::notes(self : Diagnostic) -> Array[String]

    Diagnostic::primary_label

    source
    fn Diagnostic::primary_label(self : Diagnostic) -> Label?

    Diagnostic::severity

    source
    fn Diagnostic::severity(self : Diagnostic) -> Severity

    Diagnostic::with_code

    source
    fn Diagnostic::with_code(self : Diagnostic, code : String) -> Diagnostic

    Diagnostic::with_help

    source
    fn Diagnostic::with_help(self : Diagnostic, help : String) -> Diagnostic

    Diagnostic::with_label

    source
    fn Diagnostic::with_label(self : Diagnostic, label : Label) -> Diagnostic

    Diagnostic::with_note

    source
    fn Diagnostic::with_note(self : Diagnostic, note : String) -> Diagnostic

    Diagnostic::with_severity

    source
    fn Diagnostic::with_severity(self : Diagnostic, severity : Severity) -> Diagnostic

    DiagnosticBag

    source
    pub struct DiagnosticBag {
      items : Array[Diagnostic]
    }

    An insertion-ordered batch of diagnostics.

    DiagnosticBag::add

    source
    fn DiagnosticBag::add(self : DiagnosticBag, diagnostic : Diagnostic) -> Unit

    DiagnosticBag::at_least

    source
    fn DiagnosticBag::at_least(self : DiagnosticBag, minimum : Severity) -> Array[Diagnostic]

    Returns diagnostics at or above the requested severity.

    DiagnosticBag::exit_code

    source
    fn DiagnosticBag::exit_code(self : DiagnosticBag, fail_on? : Severity) -> Int

    Conventional process exit code: one when a diagnostic reaches the failure threshold, otherwise zero.

    DiagnosticBag::from_array

    source
    fn DiagnosticBag::from_array(items : Array[Diagnostic]) -> DiagnosticBag

    DiagnosticBag::is_empty

    source
    fn DiagnosticBag::is_empty(self : DiagnosticBag) -> Bool

    DiagnosticBag::length

    source
    fn DiagnosticBag::length(self : DiagnosticBag) -> Int

    DiagnosticBag::metrics

    source

    Computes metrics without changing the bag or its diagnostics.

    A diagnostic contributes at most once to a source's diagnostic count, even when it has several labels in that source. Every label still contributes to the corresponding label count.

    DiagnosticBag::new

    source

    DiagnosticBag::render

    source
    fn DiagnosticBag::render(self : DiagnosticBag, sources : SourceMap, config? : RenderConfig) -> String

    Renders a diagnostic batch, separated by one blank line.

    DiagnosticBag::render_json_lines

    source
    fn DiagnosticBag::render_json_lines(self : DiagnosticBag, sources : SourceMap) -> String

    Serializes a batch as newline-delimited JSON.

    DiagnosticBag::summary

    source
    fn DiagnosticBag::summary(self : DiagnosticBag) -> Summary

    DiagnosticBag::to_array

    source
    fn DiagnosticBag::to_array(self : DiagnosticBag) -> Array[Diagnostic]

    DiagnosticMetrics

    source
    pub struct DiagnosticMetrics {
      summary : Summary
      coded : Int
      labels : Int
      primary_labels : Int
      secondary_labels : Int
      code_counts : Array[CodeCount]
      source_counts : Array[SourceCount]
    } derive(Eq, 
    Debug    )

    Aggregate information for dashboards, CI summaries, and batch reports.

    Code and source groups preserve first-seen order, which makes output stable without imposing a sorting policy on callers.

    DiagnosticMetrics::code_counts

    source

    DiagnosticMetrics::coded

    source
    fn DiagnosticMetrics::coded(self : DiagnosticMetrics) -> Int

    DiagnosticMetrics::count_for_code

    source
    fn DiagnosticMetrics::count_for_code(self : DiagnosticMetrics, code : String) -> Int

    DiagnosticMetrics::diagnostics_for_source

    source
    fn DiagnosticMetrics::diagnostics_for_source(self : DiagnosticMetrics, source : SourceId) -> Int

    DiagnosticMetrics::labels

    source
    fn DiagnosticMetrics::labels(self : DiagnosticMetrics) -> Int

    DiagnosticMetrics::labels_for_source

    source
    fn DiagnosticMetrics::labels_for_source(self : DiagnosticMetrics, source : SourceId) -> Int

    DiagnosticMetrics::primary_labels

    source
    fn DiagnosticMetrics::primary_labels(self : DiagnosticMetrics) -> Int

    DiagnosticMetrics::secondary_labels

    source
    fn DiagnosticMetrics::secondary_labels(self : DiagnosticMetrics) -> Int

    DiagnosticMetrics::source_counts

    source

    DiagnosticMetrics::summary

    source

    DiagnosticMetrics::uncoded

    source
    fn DiagnosticMetrics::uncoded(self : DiagnosticMetrics) -> Int

    DiagnosticMetrics::unique_codes

    source
    fn DiagnosticMetrics::unique_codes(self : DiagnosticMetrics) -> Int

    DiagnosticMetrics::unique_sources

    source
    fn DiagnosticMetrics::unique_sources(self : DiagnosticMetrics) -> Int

    DiagnosticPolicy

    source
    pub struct DiagnosticPolicy {
      minimum : Severity
      allowed_codes : Array[String]
      selected_codes : Array[String]
      denied_codes : Array[String]
      warnings_as_errors : Bool
      deduplicate : Bool
      advice_limit : Int?
      warning_limit : Int?
      error_limit : Int?
      total_limit : Int?
    }

    Filtering, promotion, de-duplication, and output-budget rules.

    Rules are evaluated in this order: minimum severity, allow-list suppression, selection, promotion, de-duplication, per-severity budget, then total budget.

    DiagnosticPolicy::allow_code

    source
    fn DiagnosticPolicy::allow_code(self : DiagnosticPolicy, code : String) -> DiagnosticPolicy

    DiagnosticPolicy::apply

    source

    DiagnosticPolicy::deduplicates

    source
    fn DiagnosticPolicy::deduplicates(self : DiagnosticPolicy) -> Bool

    DiagnosticPolicy::deny_code

    source
    fn DiagnosticPolicy::deny_code(self : DiagnosticPolicy, code : String) -> DiagnosticPolicy

    DiagnosticPolicy::limits

    source
    fn DiagnosticPolicy::limits(self : DiagnosticPolicy, advice? : Int?, warnings? : Int?, errors? : Int?, total? : Int?) -> DiagnosticPolicy

    DiagnosticPolicy::minimum

    source

    DiagnosticPolicy::new

    source

    DiagnosticPolicy::select_code

    source
    fn DiagnosticPolicy::select_code(self : DiagnosticPolicy, code : String) -> DiagnosticPolicy

    DiagnosticPolicy::warnings_as_errors

    source
    fn DiagnosticPolicy::warnings_as_errors(self : DiagnosticPolicy) -> Bool

    DiagnosticPolicy::with_advice_limit

    source
    fn DiagnosticPolicy::with_advice_limit(self : DiagnosticPolicy, limit : Int) -> DiagnosticPolicy

    DiagnosticPolicy::with_deduplication

    source
    fn DiagnosticPolicy::with_deduplication(self : DiagnosticPolicy, enabled : Bool) -> DiagnosticPolicy

    DiagnosticPolicy::with_error_limit

    source
    fn DiagnosticPolicy::with_error_limit(self : DiagnosticPolicy, limit : Int) -> DiagnosticPolicy

    DiagnosticPolicy::with_minimum

    source
    fn DiagnosticPolicy::with_minimum(self : DiagnosticPolicy, minimum : Severity) -> DiagnosticPolicy

    DiagnosticPolicy::with_total_limit

    source
    fn DiagnosticPolicy::with_total_limit(self : DiagnosticPolicy, limit : Int) -> DiagnosticPolicy

    DiagnosticPolicy::with_warning_limit

    source
    fn DiagnosticPolicy::with_warning_limit(self : DiagnosticPolicy, limit : Int) -> DiagnosticPolicy

    DiagnosticPolicy::with_warnings_as_errors

    source
    fn DiagnosticPolicy::with_warnings_as_errors(self : DiagnosticPolicy, enabled : Bool) -> DiagnosticPolicy

    DisplayConfig

    source
    pub struct DisplayConfig {
      tab_width : Int
      ambiguous_width : Int
    } derive(Eq, 
    Debug    )

    Rendering policy for tabs and non-ASCII source text.

    DisplayConfig::default

    source
    fn DisplayConfig::default() -> DisplayConfig

    DisplayConfig::new

    source
    fn DisplayConfig::new(tab_width : Int, ambiguous_width : Int) -> DisplayConfig

    DisplayConfig::tab_width

    source
    fn DisplayConfig::tab_width(self : DisplayConfig) -> Int

    EditPreview

    source
    pub struct EditPreview {
      source : SourceId
      source_name : String
      span : Span
      start : Location
      end : Location
      original : String
      replacement : String
    }

    One edit enriched with source locations for display and transport.

    EditPreview::end

    source
    fn EditPreview::end(self : EditPreview) -> Location

    EditPreview::is_deletion

    source
    fn EditPreview::is_deletion(self : EditPreview) -> Bool

    EditPreview::is_insertion

    source
    fn EditPreview::is_insertion(self : EditPreview) -> Bool

    EditPreview::original

    source
    fn EditPreview::original(self : EditPreview) -> String

    EditPreview::replacement

    source
    fn EditPreview::replacement(self : EditPreview) -> String

    EditPreview::source

    source
    fn EditPreview::source(self : EditPreview) -> SourceId

    EditPreview::source_name

    source
    fn EditPreview::source_name(self : EditPreview) -> String

    EditPreview::span

    source
    fn EditPreview::span(self : EditPreview) -> Span

    EditPreview::start

    source
    fn EditPreview::start(self : EditPreview) -> Location

    Fix

    source
    pub struct Fix {
      title : String
      applicability : Applicability
      edits : Array[TextEdit]
    }

    A named group of edits that should be accepted or rejected together.

    Fix::applicability

    source
    fn Fix::applicability(self : Fix) -> Applicability

    Fix::apply

    source
    fn Fix::apply(self : Fix, sources : SourceMap) -> (SourceMap?, FixValidation)

    Applies this fix and returns a new source map.

    The original map is never mutated. Invalid fixes return their validation result and no partial edit is observable.

    Fix::apply_to_source

    source
    fn Fix::apply_to_source(self : Fix, sources : SourceMap, source_id : SourceId) -> (String?, FixValidation)

    Applies only edits for one source and leaves validation explicit.

    Fix::edits

    source
    fn Fix::edits(self : Fix) -> Array[TextEdit]

    Fix::is_automatic

    source
    fn Fix::is_automatic(self : Fix) -> Bool

    Fix::new

    source
    fn Fix::new(title : String, applicability? : Applicability) -> Fix

    Fix::preview

    source
    fn Fix::preview(self : Fix, sources : SourceMap) -> (FixPreview?, FixValidation)

    Builds a preview only after the complete fix has passed validation.

    Fix::render_json

    source
    fn Fix::render_json(self : Fix, sources : SourceMap) -> (String?, FixValidation)

    Convenience operation for callers that want validation and JSON in one step.

    Fix::render_preview

    source
    fn Fix::render_preview(self : Fix, sources : SourceMap) -> (String?, FixValidation)

    Convenience operation for callers that want validation and text in one step.

    Fix::title

    source
    fn Fix::title(self : Fix) -> String

    Fix::validate

    source
    fn Fix::validate(self : Fix, sources : SourceMap) -> FixValidation

    Fix::with_edit

    source
    fn Fix::with_edit(self : Fix, edit : TextEdit) -> Fix

    FixMode

    source
    pub(all) enum FixMode {
      AllFixes
      AutomaticFixes
    } derive(Eq, 
    Debug    )

    Selects which fixes participate in a batch operation.

    FixMode::name

    source
    fn FixMode::name(self : FixMode) -> String

    FixPlan

    source
    pub struct FixPlan {
      fixes : Array[Fix]
    }

    An ordered collection of independent fixes.

    A plan validates the complete edit set before changing any source. This makes unattended formatter, linter, migration, and code-action workflows atomic: either every selected edit is safe to apply, or nothing changes.

    FixPlan::apply

    source
    fn FixPlan::apply(self : FixPlan, sources : SourceMap, mode? : FixMode) -> (SourceMap?, FixPlanValidation)

    Applies the selected fixes atomically to a copy of the source map.

    The default is deliberately conservative: only machine-applicable fixes are selected. Pass AllFixes when a user has reviewed every suggestion.

    FixPlan::fixes

    source
    fn FixPlan::fixes(self : FixPlan) -> Array[Fix]

    FixPlan::is_empty

    source
    fn FixPlan::is_empty(self : FixPlan) -> Bool

    FixPlan::length

    source
    fn FixPlan::length(self : FixPlan) -> Int

    FixPlan::new

    source
    fn FixPlan::new() -> FixPlan

    FixPlan::summary

    source
    fn FixPlan::summary(self : FixPlan, mode? : FixMode) -> FixPlanSummary

    FixPlan::validate

    source
    fn FixPlan::validate(self : FixPlan, sources : SourceMap, mode? : FixMode) -> FixPlanValidation

    Validates every selected fix and then detects conflicts across fixes.

    FixPlan::with_fix

    source
    fn FixPlan::with_fix(self : FixPlan, fix : Fix) -> FixPlan

    FixPlanSummary

    source
    pub struct FixPlanSummary {
      total_fixes : Int
      selected_fixes : Int
      skipped_fixes : Int
      selected_edits : Int
    }

    Counts describing a plan before it is applied.

    FixPlanSummary::selected_edits

    source
    fn FixPlanSummary::selected_edits(self : FixPlanSummary) -> Int

    FixPlanSummary::selected_fixes

    source
    fn FixPlanSummary::selected_fixes(self : FixPlanSummary) -> Int

    FixPlanSummary::skipped_fixes

    source
    fn FixPlanSummary::skipped_fixes(self : FixPlanSummary) -> Int

    FixPlanSummary::total_fixes

    source
    fn FixPlanSummary::total_fixes(self : FixPlanSummary) -> Int

    FixPlanValidation

    source
    pub(all) enum FixPlanValidation {
      PlanValid
      EmptyPlan
      NoSelectedFixes
      InvalidPlannedFix(Int, FixValidation)
      ConflictingPlannedFixes(FixValidation)
    } derive(Eq, 
    Debug    )

    The result of validating a selected batch of fixes.

    FixPlanValidation::is_valid

    source
    fn FixPlanValidation::is_valid(self : FixPlanValidation) -> Bool

    FixPlanValidation::message

    source
    fn FixPlanValidation::message(self : FixPlanValidation) -> String

    FixPreview

    source
    pub struct FixPreview {
      title : String
      applicability : Applicability
      edits : Array[EditPreview]
    }

    A validated, presentation-ready view of a fix.

    FixPreview::applicability

    source
    fn FixPreview::applicability(self : FixPreview) -> Applicability

    FixPreview::edit_count

    source
    fn FixPreview::edit_count(self : FixPreview) -> Int

    FixPreview::edits

    source
    fn FixPreview::edits(self : FixPreview) -> Array[EditPreview]

    FixPreview::source_count

    source
    fn FixPreview::source_count(self : FixPreview) -> Int

    FixPreview::title

    source
    fn FixPreview::title(self : FixPreview) -> String

    FixValidation

    source
    pub(all) enum FixValidation {
      Valid
      Empty
      UnknownSource(SourceId)
      OutOfBounds(SourceId, Span, Int)
      Overlapping(SourceId, Span, Span)
    } derive(Eq, 
    Debug    )

    The outcome of checking a fix against a source registry.

    FixValidation::is_valid

    source
    fn FixValidation::is_valid(self : FixValidation) -> Bool

    FixValidation::message

    source
    fn FixValidation::message(self : FixValidation) -> String

    Label

    source
    pub struct Label {
      source : SourceId
      span : Span
      message : String
      primary : Bool
    } derive(Eq, 
    Debug    )

    A source range and its optional explanatory text.

    Label::is_primary

    source
    fn Label::is_primary(self : Label) -> Bool

    Label::message

    source
    fn Label::message(self : Label) -> String

    Label::primary

    source
    fn Label::primary(source : SourceId, span : Span, message : String) -> Label

    Label::secondary

    source
    fn Label::secondary(source : SourceId, span : Span, message : String) -> Label

    Label::source

    source
    fn Label::source(self : Label) -> SourceId

    Label::span

    source
    fn Label::span(self : Label) -> Span

    LineWindow

    source
    pub struct LineWindow {
      first : Int
      last : Int
      focus_first : Int
      focus_last : Int
    } derive(Eq, 
    Debug    )

    Inclusive source-line window selected for a diagnostic label.

    LineWindow::first

    source
    fn LineWindow::first(self : LineWindow) -> Int

    LineWindow::focus_first

    source
    fn LineWindow::focus_first(self : LineWindow) -> Int

    LineWindow::focus_last

    source
    fn LineWindow::focus_last(self : LineWindow) -> Int

    LineWindow::last

    source
    fn LineWindow::last(self : LineWindow) -> Int

    Location

    source
    pub struct Location {
      line : Int
      column : Int
      offset : Int
    } derive(Eq, 
    Debug    )

    A zero-based line and byte column.

    Location::column

    source
    fn Location::column(self : Location) -> Int

    Location::line

    source
    fn Location::line(self : Location) -> Int

    Location::offset

    source
    fn Location::offset(self : Location) -> Int

    PolicyResult

    source
    pub struct PolicyResult {
      emitted : DiagnosticBag
      suppressed : Array[SuppressedDiagnostic]
      summary : PolicySummary
    }

    Result of applying a policy without mutating the input bag.

    PolicyResult::emitted

    source
    fn PolicyResult::emitted(self : PolicyResult) -> DiagnosticBag

    PolicyResult::has_suppressed

    source
    fn PolicyResult::has_suppressed(self : PolicyResult) -> Bool

    PolicyResult::summary

    source
    fn PolicyResult::summary(self : PolicyResult) -> PolicySummary

    PolicyResult::suppressed

    source

    PolicySummary

    source
    pub struct PolicySummary {
      input : Int
      emitted : Int
      promoted : Int
      suppressed : Int
      duplicates : Int
      budgeted : Int
    }

    Statistics produced while applying a diagnostic policy.

    PolicySummary::budgeted

    source
    fn PolicySummary::budgeted(self : PolicySummary) -> Int

    PolicySummary::duplicates

    source
    fn PolicySummary::duplicates(self : PolicySummary) -> Int

    PolicySummary::emitted

    source
    fn PolicySummary::emitted(self : PolicySummary) -> Int

    PolicySummary::input

    source
    fn PolicySummary::input(self : PolicySummary) -> Int

    PolicySummary::promoted

    source
    fn PolicySummary::promoted(self : PolicySummary) -> Int

    PolicySummary::suppressed

    source
    fn PolicySummary::suppressed(self : PolicySummary) -> Int

    RenderConfig

    source
    pub struct RenderConfig {
      context_lines : Int
      tab_width : Int
      show_source_name : Bool
      show_code : Bool
    } derive(Eq, 
    Debug    )

    Options for human-readable source reports.

    RenderConfig::default

    source
    fn RenderConfig::default() -> RenderConfig

    RenderConfig::new

    source
    fn RenderConfig::new(context_lines? : Int, tab_width? : Int, show_source_name? : Bool, show_code? : Bool) -> RenderConfig

    Severity

    source
    pub(all) enum Severity {
      Advice
      Warning
      Error
    } derive(Eq, 
    Debug    )

    Importance of a diagnostic, ordered from least to most severe.

    Severity::name

    source
    fn Severity::name(self : Severity) -> String

    Severity::rank

    source
    fn Severity::rank(self : Severity) -> Int

    Source

    source
    pub struct Source {
      name : String
      text : String
      bytes : Bytes
      line_starts : Array[Int]
    }

    Immutable source text with a precomputed line-start index.

    Source::byte_length

    source
    fn Source::byte_length(self : Source) -> Int

    Source::line_count

    source
    fn Source::line_count(self : Source) -> Int

    Source::line_span

    source
    fn Source::line_span(self : Source, line : Int) -> Span?

    Source::line_text

    source
    fn Source::line_text(self : Source, line : Int) -> String?

    Source::location

    source
    fn Source::location(self : Source, offset : Int) -> Location

    Source::name

    source
    fn Source::name(self : Source) -> String

    Source::new

    source
    fn Source::new(name : String, text : String) -> Source

    Source::slice

    source
    fn Source::slice(self : Source, span : Span) -> String

    Source::slice_offsets

    source
    fn Source::slice_offsets(self : Source, start : Int, end : Int) -> String

    Returns the source text between two byte offsets after clamping both ends.

    This is primarily useful to consumers that assemble transformed source without exposing the source's internal UTF-8 byte buffer.

    Source::text

    source
    fn Source::text(self : Source) -> String

    Source::window

    source
    fn Source::window(self : Source, span : Span, context_lines? : Int) -> LineWindow

    Selects a bounded context window around a span.

    SourceCount

    source
    pub struct SourceCount {
      source : SourceId
      diagnostics : Int
      labels : Int
    } derive(Eq, 
    Debug    )

    A stable count associated with one source.

    SourceCount::diagnostics

    source
    fn SourceCount::diagnostics(self : SourceCount) -> Int

    SourceCount::labels

    source
    fn SourceCount::labels(self : SourceCount) -> Int

    SourceCount::source

    source
    fn SourceCount::source(self : SourceCount) -> SourceId

    SourceId

    source
    pub(all) struct SourceId(Int) derive(Compare, Eq, Hash, 
    Debug    )

    A stable identifier for one source registered in a SourceMap.

    SourceId::new

    source
    fn SourceId::new(value : Int) -> SourceId?

    SourceId::value

    source
    fn SourceId::value(self : SourceId) -> Int

    SourceMap

    source
    pub struct SourceMap {
      sources : Array[Source]
    }

    Registry that assigns stable IDs to source files used by diagnostics.

    SourceMap::add

    source
    fn SourceMap::add(self : SourceMap, name : String, text : String) -> SourceId

    SourceMap::contains

    source
    fn SourceMap::contains(self : SourceMap, id : SourceId) -> Bool

    SourceMap::find_by_name

    source
    fn SourceMap::find_by_name(self : SourceMap, name : String) -> SourceId?

    SourceMap::get

    source
    fn SourceMap::get(self : SourceMap, id : SourceId) -> Source?

    SourceMap::is_empty

    source
    fn SourceMap::is_empty(self : SourceMap) -> Bool

    SourceMap::length

    source
    fn SourceMap::length(self : SourceMap) -> Int

    SourceMap::new

    source
    fn SourceMap::new() -> SourceMap

    SourceMap::validate

    source
    fn SourceMap::validate(self : SourceMap, diagnostic : Diagnostic) -> Bool

    SourceMap::validate_label

    source
    fn SourceMap::validate_label(self : SourceMap, label : Label) -> Bool

    Span

    source
    pub struct Span {
      start : Int
      end : Int
    } derive(Eq, 
    Debug    )

    A half-open byte range in a source file.

    Span::at

    source
    fn Span::at(offset : Int) -> Span?

    Span::clamp

    source
    fn Span::clamp(self : Span, length : Int) -> Span

    Span::contains

    source
    fn Span::contains(self : Span, offset : Int) -> Bool

    Span::cover

    source
    fn Span::cover(self : Span, other : Span) -> Span

    Span::end

    source
    fn Span::end(self : Span) -> Int

    Span::intersects

    source
    fn Span::intersects(self : Span, other : Span) -> Bool

    Span::is_empty

    source
    fn Span::is_empty(self : Span) -> Bool

    Span::length

    source
    fn Span::length(self : Span) -> Int

    Span::new

    source
    fn Span::new(start : Int, end : Int) -> Span?

    Creates a span when both offsets are non-negative and ordered.

    Span::start

    source
    fn Span::start(self : Span) -> Int

    Span::touches

    source
    fn Span::touches(self : Span, other : Span) -> Bool

    Summary

    source
    pub struct Summary {
      advice : Int
      warnings : Int
      errors : Int
    } derive(Eq, 
    Debug    )

    Counts diagnostics by severity without exposing mutable internal state.

    Summary::advice

    source
    fn Summary::advice(self : Summary) -> Int

    Summary::errors

    source
    fn Summary::errors(self : Summary) -> Int

    Summary::has_errors

    source
    fn Summary::has_errors(self : Summary) -> Bool

    Summary::total

    source
    fn Summary::total(self : Summary) -> Int

    Summary::warnings

    source
    fn Summary::warnings(self : Summary) -> Int

    SuppressedDiagnostic

    source
    pub struct SuppressedDiagnostic {
      diagnostic : Diagnostic
      reason : SuppressionReason
    }

    A diagnostic together with the reason it was suppressed.

    SuppressedDiagnostic::diagnostic

    source

    SuppressedDiagnostic::reason

    source

    SuppressionReason

    source
    pub(all) enum SuppressionReason {
      BelowMinimum
      CodeAllowed(String)
      NotSelected(String)
      Duplicate
      SeverityBudget(Severity, Int)
      TotalBudget(Int)
    } derive(Eq, 
    Debug    )

    Why a diagnostic was not emitted by a policy evaluation.

    SuppressionReason::message

    source
    fn SuppressionReason::message(self : SuppressionReason) -> String

    SuppressionReason::name

    source
    fn SuppressionReason::name(self : SuppressionReason) -> String

    TextEdit

    source
    pub struct TextEdit {
      source : SourceId
      span : Span
      replacement : String
    } derive(Eq, 
    Debug    )

    One UTF-8 byte-range replacement in a registered source.

    TextEdit::delete

    source
    fn TextEdit::delete(source : SourceId, span : Span) -> TextEdit

    TextEdit::insert

    source
    fn TextEdit::insert(source : SourceId, offset : Int, text : String) -> TextEdit?

    TextEdit::is_deletion

    source
    fn TextEdit::is_deletion(self : TextEdit) -> Bool

    TextEdit::is_insertion

    source
    fn TextEdit::is_insertion(self : TextEdit) -> Bool

    TextEdit::replace

    source
    fn TextEdit::replace(source : SourceId, span : Span, replacement : String) -> TextEdit

    TextEdit::replacement

    source
    fn TextEdit::replacement(self : TextEdit) -> String

    TextEdit::source

    source
    fn TextEdit::source(self : TextEdit) -> SourceId

    TextEdit::span

    source
    fn TextEdit::span(self : TextEdit) -> Span

    Theme

    source
    pub struct Theme {
      error : Color
      warning : Color
      advice : Color
      line_number : Color
      primary : Color
      secondary : Color
      note : Color
      help : Color
      bold_header : Bool
    } derive(Eq, 
    Debug    )

    Semantic terminal colors for a diagnostic report.

    Theme::dark

    source
    fn Theme::dark() -> Theme

    A legible theme for dark terminal backgrounds.

    Theme::light

    source
    fn Theme::light() -> Theme

    A lower-intensity theme for light terminal backgrounds.

    Theme::severity

    source
    fn Theme::severity(self : Theme, severity : Severity) -> Color

    diagnostic_fingerprint

    source
    fn diagnostic_fingerprint(diagnostic : Diagnostic) -> String

    Stable identity used by policy de-duplication.

    Notes and help are intentionally excluded: producers often attach contextual notes at different layers while referring to the same underlying problem.

    display_column

    source
    fn display_column(text : String, byte_offset : Int, config? : DisplayConfig) -> Int

    Converts a UTF-8 byte offset into a terminal-cell column.

    display_width

    source
    fn display_width(text : String, config? : DisplayConfig) -> Int

    Returns the number of terminal cells occupied by UTF-8 text.

    expand_tabs

    source
    fn expand_tabs(text : String, config? : DisplayConfig) -> String

    Replaces tabs with spaces while preserving tab-stop alignment.

    merge_windows

    source
    fn merge_windows(windows : Array[LineWindow], gap? : Int) -> Array[LineWindow]

    Merges windows that overlap or are separated by at most gap lines.

    render

    source
    fn render(sources : SourceMap, diagnostic : Diagnostic, config? : RenderConfig) -> String

    Renders a diagnostic with source context and aligned labels.

    Invalid source IDs are omitted from source blocks but the diagnostic header, notes, and help remain visible.

    render_all

    source
    fn render_all(sources : SourceMap, diagnostics : Array[Diagnostic], config? : RenderConfig) -> String

    Renders multiple reports with one blank line between them.

    render_ansi

    source
    fn render_ansi(sources : SourceMap, diagnostic : Diagnostic, enabled? : Bool, theme? : Theme, config? : RenderConfig) -> String

    Adds ANSI color to a plain report. When enabled is false, the output is byte-for-byte identical to render.

    render_compact

    source
    fn render_compact(sources : SourceMap, diagnostic : Diagnostic) -> String

    Renders one diagnostic as a stable, grep-friendly line plus notes.

    render_compact_all

    source
    fn render_compact_all(sources : SourceMap, diagnostics : Array[Diagnostic]) -> String

    Renders diagnostics separated by newlines without a trailing newline.

    render_fix_json

    source
    fn render_fix_json(preview : FixPreview) -> String

    Serializes a validated fix preview to stable JSON for editor integrations.

    render_fix_preview

    source
    fn render_fix_preview(preview : FixPreview) -> String

    Renders a compact unified-diff-like preview.

    Locations are one-based for humans. The format is deliberately a preview rather than a patch file: replacements may start or end mid-line.

    render_json

    source
    fn render_json(sources : SourceMap, diagnostic : Diagnostic) -> String

    Serializes one diagnostic to a stable, compact JSON object.

    Byte offsets are zero-based. Human-facing line and column values are one-based. Unknown source IDs remain representable with a null name.

    render_json_lines

    source
    fn render_json_lines(sources : SourceMap, diagnostics : Array[Diagnostic]) -> String

    Emits newline-delimited JSON for streaming into editors and CI systems.

    strip_ansi

    source
    fn strip_ansi(text : String) -> String

    Removes common Select Graphic Rendition sequences emitted by MoonReport. This is useful for snapshot tests and log sanitization.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io