`Report::with_source_code` overrides already provided source code about miette

[erratic-pattern]

I'm not convinced this is the intuitive behavior. I would expect with_source_code to override any existing source code that was given prior, via the derive macro or otherwise. I think it would be more confusing for the user if with_source_code didn't override the source code, and it would make it impossible to use this feature in cases where you do want to override it.

I'm also not sure how this could be implemented, due to the type erasure of boxing the Diagnostic. You could downcast, but you would need to know the specific concrete type, not just "some type that implements Diagnostic".

Maybe a separate helper method for this behavior would be better? Assuming there's some way to fetch the existing source code (which I'm not sure there is currently). It could be named to make it clear that it's only adding source code if missing.

--EDIT--

You can get the behavior you want by checking for existing source code conditionally.

Example:

#[test]
fn miette_two_source_codes() -> miette::Result<()> {
    #[derive(thiserror::Error, miette::Diagnostic, Debug, Clone, PartialEq)]
    #[error("error")]
    struct E {
        #[label("here")]
        at: miette::SourceSpan,
        #[source_code]
        source_code: String,
    }
    let source1 = "source1";
    let source2 = "source2";
    // create report with source1
    let report = miette::Report::from(E {
        at: (4..5).into(),
        source_code: source1.to_string(),
    });
    // shadow previous variable (or you can use mut instead)
    let report = match report.source_code() {
        None => report.with_source_code(source2),
        _ => report,
    };
    Err(report)
}

I think this is more clear because it makes the behavior explicit, whereas implicitly and silently ignoring with_source_code when a source code is already provided would be more confusing IMO.

[gavrilikhin-d]

I'm not convinced this is the intuitive behavior.
I would expect with_source_code to override any existing source code

It's hard for me to name a single use-case for changing source code without changing any locations.

[gavrilikhin-d]

Here is a real-life example when I need non-overriding Report::with_source_code:

1. There is a TypeMismatch error for passing arguments of incorrect type to function.
   Function declaration, of course, may be located in a different file than a function call

/// Diagnostic for not convertible types
#[derive(Error, Debug, Clone, PartialEq)]
#[error("expected `{expected}` type, got `{got}`")]
pub struct TypeMismatch {
    /// Expected type
    pub expected: TypeWithSpan,
    /// Real type
    pub got: TypeWithSpan,
}

impl Diagnostic for TypeMismatch {
    fn code<'a>(&'a self) -> Option<Box<dyn Display + 'a>> {
        Some(Box::new("semantics::type_mismatch"))
    }

    fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>> {
        Some(Box::new(
            vec![
                &self.expected as &dyn Diagnostic,
                &self.got as &dyn Diagnostic,
            ]
            .into_iter(),
        ))
    }
}

2. TypeWithSpan stores a SourceFile or None, if it's located in the current file.

#[derive(Error, Diagnostic, Debug, Clone, PartialEq)]
#[error("{ty}")]
pub struct TypeWithSpan {
    /// Type to show
    pub ty: Type,

    /// Span of the thing with the type
    #[label("this has `{ty}` type")]
    pub at: SourceSpan,

    /// Source code of the module, this type is located at
    #[source_code]
    pub source_file: Option<SourceFile>,
}

impl From<TypeWithSpan> for SourceSpan {
    fn from(value: TypeWithSpan) -> Self {
        value.at
    }
}