Must we ditch From Trait to make code navigable

We found the rust From trait is lacking IDE (both PyCharm and vscode) support:

impl From<A> for B {
    fn from(order: A) -> Self {...}  // Impl
}

// order is of Type A
let order: B = order.into();  // Usage

Neither IDE is able to navigate from usage to implementation or vice versa.
If we use

let order = B::from(order);

then navigating from usage to impl is a breeze, but from impl to usage takes vscode 10 seconds on our code base.

If we ditch the From trait altogether, i.e.

impl B {
    pub(crate) fn from(order: A) -> Self {...}
}

then navigating either direction is instantaneous. Our Rust-consultants hate this, but we Rust beginners will understand and maintain the code base so much more efficiently!

Is there a best practice to get IDEs properly navigating (ctrl+left-click and "Go to reference") between From usage and implementation.

The "Go to X" behavior works both ways as I'd expect in VSCode with rust-analyzer, but I can see how it can be unsatisfying due to how From/Into is designed.

The .into() method is not provided by the From trait, it is provided by the Into trait. The reason that implementing From seems to allow .into() to work is due to Into's generic implementation that implements Into<U> for T where U: From<T>. And because of that behavior, almost nothing implements Into directly and would implement From instead.

What this means in your IDE though is that navigating to .into() will almost always lead you to the generic implementation, which isn't very helpful but its also what I'd expect. There is some discussion in this issue that would propose navigating to the relevant From implementation instead, though nothing has come of it yet and would have to be handled as a special case.

But navigating via ::from(_) appears to work just fine: "Go to implementation" on String::from("") for example leads to the From<&str> for String implementation, and navigating from fn from(... there shows me all uses of that particular implementation. It takes a moment but I've only tested on a medium-ish code base so if the performance is a problem for you then you can file an issue.

That all being said, you don't need to use From if you don't want to. A From implementation would be required if you relied on utilizing the conversion in a generic context and thus I would encourage you to provide it anyway if at all appropriate. But that doesn't mean you have to use it directly in your own code: if from_a() or into_b() improves clarity then by all means add that as an option as well. Even the standard library does it (see String::into_bytes vs From<String> for Vec<u8> for example). I wouldn't recommend an inherent from or into method since that would be easily confused with the trait method; give it a better name.

And as a final note, you shouldn't put all your eggs in one basket. Especially as a beginner. Your IDE is only one source of discoverability: the generated documentation and any supplemental examples, tests, and mdbooks work together to form a complete understanding.