More controlability for the `label`

[attila-lin]

More controlability for the `label`

[zkat]

I'm having a hard time understanding what you're missing here. The Diagnostic object in lsp seems to be almost a 1:1 translation to a miette::Diagnostic (aside from the specific format of the range, but there's already a utility provided to do that conversion)

[attila-lin]

I might miss it. Can you tell me the utility's name or an example?

lsp Range need the line number and the character count, while Diagnostic provide the start offset and length.

[zkat]

@attila-lin https://docs.rs/miette/latest/miette/struct.SourceOffset.html#method.from_location

So in order to give miette a SourceSpan from your LSP Range, you would do something like:

#[derive(miette::Diagnostic)]
struct MyDiag {
  #[source_code]
  src: String,
  #[label("bad here")]
  span: miette::SourceSpan,
}
let start = miette::SourceOffset::from(your_source_code, lsp_range.start.line, lsp_range.start.column);
let end = miette::SourceOffset::from(your_source_code, lsp_range.end.line, lsp_range.end.column);
let diag = MyDiag { src: your_source_code, span: (start, end - start).into()) }

[attila-lin]

Thank you for your response. Get it! It would work~

But I have some different conditions.

First, I don't have my source_code in error (and also in lint checks), because I will try to test and create a lot of lint results for one file. In the lint checks, I just need an AST tree and no need the source.

I will create do the lint check like this

/// lint A result
#[derive(miette::Diagnostic)]
struct LintAError {
    #[lable("this is bad for lint A")]
    span: (usize, usize)
}

/// lint B result
#[derive(miette::Diagnostic)]
struct LintBError {
    #[lable("this is bad for lint B")]
    span: (usize, usize)
}

let mut reports = Vec::new();

// Do some check

reports.push(miette::Report::from(lint_a_error));
reports.push(miette::Report::from(lint_b_error));
// .. more lint result

for report in reports {
    println!("{:?}", report.with_source_code(code));
}

It works, but hard for me to add lsp support, I want to reuse the error and the position.

Second, I think we may have a better ergonomics like this.

/// lint A result
#[derive(miette::Diagnostic)]
struct LintAError {
    #[lable("this is bad for lint A")]
    span: MyRange
}

/// lint B result
#[derive(miette::Diagnostic)]
struct LintBError {
    #[lable("this is bad for lint B")]
    span: MyRange
}


struct MyPosition {
    bytes: usize,
    line: usize,
    character: usize
}

struct MyRange {
    start: MyPosition,
    end: MyPosition
}


/// It will work for `lable` macro
impl IntoSourceSpan for MyRange {
    fn into_source_span() -> SourceSpan {
        // do some convert
        
    }
}

// If i'm working for lsp, I can add my trait
impl LspRange for LintAError {
    fn lsp_range() {
       // some
    }
}
impl LspRange for LintBError {
    fn lsp_range() {
       // some
    }
}


// with the cli the same

// with the lsp 
for error in errors {
    let diag = lsp_types::Diagnostic {
        range: error.lsp_range(),
        code: error.code()
        severity: error.severity()
        ...
    }
}

What's your opinion?

[zkat]

the idea is that you would have source code when you create your linting errors. Do you not have source code at that point? Is it possible to create the spans when you're scanning through the source code?