Add a lint to check for functions/methods that could be From

[FalkWoldmann]

What it does

Checks for functions and methods that could be a From impl (we could even do this for TryFrom)

Advantage

• Makes the code more idiomatic

Drawbacks

No response

Example

struct StructA {
    some_field: String
}

struct StructB {
    some_field: String
}

fn map_to_struct_b(a: StructA) -> StructB {
    StructB {
        some_field: a.some_field
    }
}

impl StructA {
    fn to_struct_b(self) -> StructB {
        StructB {
            some_field: self.some_field
        }
    }
}

Could be written as:

impl From<StructA> for StructB {
    fn from(a: StructA) -> Self {
        StructB {
            some_field: a.some_field
        }
    }
}

[samueltardieu]

From is typically implemented for lossless, value-preserving obvious conversions. For example, String::from(&str) would give you a String which has the same content of the &str, and you can even build a &str back from the String.

This works in your example, because you simply copy the field. On the other hand, I think StructB should not implement From<StructA> in the following case:

struct StructA<'a> {
    some_field: &'a str
}

struct StructB {
    some_field: String
}

impl StructA<'_> {
    fn to_struct_b(self) -> StructB {
        StructB { some_field: self.some_field.to_uppercase() }
    }
}

Finding a criteria to determine if From should be proposed by default is not easy.

[FalkWoldmann]

Perhaps we can start with linting these simple and obvious cases?