dtzrttp/moonbit-rtl/src/diagnostic does not have a README file

    Diagnostic

    pub(all) struct Diagnostic {
    code : String
    severity : Severity
    message : String
    file : String
    span :
    Span

    rule : String
    notes : Array[String]
    } derive(Eq,
    Debug
    )

    Diagnostic::at_line_col

    fn Diagnostic::at_line_col(self : Diagnostic, source :
    SourceFile
    ) -> (Int, Int)

    Diagnostic::column

    Diagnostic::is_at_least

    fn Diagnostic::is_at_least(self : Diagnostic, minimum : Severity) -> Bool

    Diagnostic::is_zero_width

    fn Diagnostic::is_zero_width(self : Diagnostic) -> Bool

    Diagnostic::line

    Diagnostic::location

    Diagnostic::location_key

    fn Diagnostic::location_key(self : Diagnostic) -> String

    Diagnostic::new

    fn Diagnostic::new(code : String, severity : Severity, message : String, span :
    Span
    ) -> Diagnostic

    Diagnostic::overlaps

    Diagnostic::source_text

    Diagnostic::with_file

    fn Diagnostic::with_file(self : Diagnostic, file : String) -> Diagnostic

    Diagnostic::with_note

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

    Add a note while preserving the original diagnostic value.

    Diagnostic::with_notes

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

    Diagnostic::with_rule

    fn Diagnostic::with_rule(self : Diagnostic, rule : String) -> Diagnostic

    DiagnosticReport

    pub(all) struct DiagnosticReport {
    diagnostics : Array[Diagnostic]
    errors : Int
    warnings : Int
    infos : Int
    } derive(
    Debug
    )

    A stable aggregate for a batch of diagnostics.

    DiagnosticReport::code_counts

    fn DiagnosticReport::code_counts(self : DiagnosticReport) -> Array[(String, Int)]

    DiagnosticReport::codes

    fn DiagnosticReport::codes(self : DiagnosticReport) -> Array[String]

    DiagnosticReport::deduplicated

    DiagnosticReport::files

    fn DiagnosticReport::files(self : DiagnosticReport) -> Array[String]

    DiagnosticReport::filter

    DiagnosticReport::for_code

    fn DiagnosticReport::for_code(self : DiagnosticReport, code : String) -> Array[Diagnostic]

    DiagnosticReport::has_errors

    fn DiagnosticReport::has_errors(self : DiagnosticReport) -> Bool

    DiagnosticReport::has_infos

    fn DiagnosticReport::has_infos(self : DiagnosticReport) -> Bool

    DiagnosticReport::has_warnings

    fn DiagnosticReport::has_warnings(self : DiagnosticReport) -> Bool

    DiagnosticReport::highest_severity

    fn DiagnosticReport::highest_severity(self : DiagnosticReport) -> Severity?

    DiagnosticReport::json

    DiagnosticReport::markdown

    fn DiagnosticReport::markdown(self : DiagnosticReport, title : String) -> String

    DiagnosticReport::new

    DiagnosticReport::sarif

    DiagnosticReport::summary

    fn DiagnosticReport::summary(self : DiagnosticReport) -> String

    DiagnosticReport::text

    DiagnosticReport::total

    fn DiagnosticReport::total(self : DiagnosticReport) -> Int

    Severity

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

    Severity::label

    fn Severity::label(self : Severity) -> String

    annotate

    fn annotate(diagnostics : Array[Diagnostic], note : String) -> Array[Diagnostic]

    Add a note to every diagnostic in a batch.

    deduplicate

    fn deduplicate(diagnostics : Array[Diagnostic]) -> Array[Diagnostic]

    Return one copy of each structurally equal diagnostic.

    diagnostic_json_line

    fn diagnostic_json_line(diagnostic : Diagnostic) -> String

    diagnostic_summary

    fn diagnostic_summary(diagnostics : Array[Diagnostic]) -> String

    diagnostics_at_line

    fn diagnostics_at_line(diagnostics : Array[Diagnostic], source :
    SourceFile
    , line : Int) -> Array[Diagnostic]

    diagnostics_for_file

    fn diagnostics_for_file(diagnostics : Array[Diagnostic], file : String) -> Array[Diagnostic]

    diagnostics_have_code

    fn diagnostics_have_code(diagnostics : Array[Diagnostic], code : String) -> Bool

    diagnostics_location_summary

    fn diagnostics_location_summary(diagnostics : Array[Diagnostic], source :
    SourceFile
    ) -> String

    diagnostics_overlapping

    fn diagnostics_overlapping(diagnostics : Array[Diagnostic], span :
    Span
    ) -> Array[Diagnostic]

    filter_codes

    fn filter_codes(diagnostics : Array[Diagnostic], codes : Array[String]) -> Array[Diagnostic]

    Return diagnostics whose rule code is in the requested set.

    filter_severity

    fn filter_severity(diagnostics : Array[Diagnostic], minimum : Severity) -> Array[Diagnostic]

    Return only diagnostics at or above the requested severity.

    group_diagnostics_by_code

    fn group_diagnostics_by_code(diagnostics : Array[Diagnostic]) -> Array[(String, Int)]

    render_diagnostic_table

    fn render_diagnostic_table(diagnostics : Array[Diagnostic]) -> String

    render_graph

    Render a semantic dependency index as a Graphviz DOT document.

    render_json

    fn render_json(diagnostics : Array[Diagnostic]) -> String

    Render one JSON object per diagnostic for CI and editor integrations.

    render_markdown_report

    fn render_markdown_report(diagnostics : Array[Diagnostic], title : String) -> String

    render_report_json

    fn render_report_json(diagnostics : Array[Diagnostic], source :
    SourceFile
    , file_name : String) -> String

    Render a stable machine-readable report around diagnostics from one source.

    render_rule_catalog

    fn render_rule_catalog(rules : Array[String]) -> String

    render_sarif

    fn render_sarif(diagnostics : Array[Diagnostic], source :
    SourceFile
    ) -> String

    Render diagnostics in the SARIF 2.1.0 shape used by code scanning tools.

    render_text

    fn render_text(diagnostics : Array[Diagnostic], source :
    SourceFile
    ) -> String

    Render diagnostics in a compiler-friendly file:line:column format.

    severity_counts

    fn severity_counts(diagnostics : Array[Diagnostic]) -> (Int, Int, Int)

    Count diagnostics by severity in a stable tuple.

    stable_diagnostic_order

    fn stable_diagnostic_order(diagnostics : Array[Diagnostic]) -> Array[Diagnostic]