Bad suggestion for dependency_on_unit_never_type_fallback for wildcard assignment expression

[ehuss]

The dependency_on_unit_never_type_fallback lint seems to provide a bad suggestion for an assignment to a wildcard pattern. Example (sorry, not minimized further, this is based on serde):

#![deny(dependency_on_unit_never_type_fallback)]

pub trait Deserialize: Sized {
    fn deserialize<D>(deserializer: D) -> Result<Self, ()>
    where
        D: Deserializer;
}

pub trait Deserializer: Sized {}

pub trait MapAccess {
    fn next_value<V>(&mut self) -> Result<V, ()>
    where
        V: Deserialize;
}

impl Deserialize for () {
    fn deserialize<D>(_: D) -> Result<Self, ()>
    where
        D: Deserializer,
    {
        Ok(())
    }
}

fn visit_map<A>(mut map: A) -> Result<i32, ()>
where
    A: MapAccess,
{
    _ = map.next_value()?;
    Ok(1)
}

This gives a suggestion to modify it with:

@@ -29,7 +29,7 @@
 where
     A: MapAccess,
 {
-    _ = map.next_value()?;
+    _: () = map.next_value()?;
     Ok(1)
 }

This is not valid syntax, as an assignment expression does not allow qualifying with types.

In this case, I'm uncertain if the fallback can actually be a problem? If not, then maybe the lint shouldn't fire? Or if a type annotation is needed, then maybe use fully-qualified syntax?

cc @WaffleLapkin

[compiler-errors]

Never type fallback definitely matters in this case. In edition 2024, this code fails to compile.

I'll fix the suggestion.