Rust: détecter quand des "paramètres de type sans contrainte" peuvent être fournis explicitement à un appel fn

En nous basant sur https://github.com/rust-lang/rust/pull/39361 , nous voudrons peut-être déterminer quand les utilisateurs doivent ajouter des paramètres de type explicites à un appel fn. J'imagine un exemple comme celui-ci :

fn foo<T>() { }

fn main() {
    foo();
}

Ce serait bien de suggérer à l'utilisateur d'écrire foo::<T> pour un T explicite. Cela demandera un peu de réflexion :

Quand voulons-nous suggérer cela de préférence à l'annotation d'une variable locale ? Je préférerais attacher l'annotation sur la variable locale, mais peut-être pas si le type de la variable locale est quelque chose de complexe qui mentionne le type non inféré profondément à l'intérieur, alors qu'annoter la fonction nous permettrait de spécifier le type non inféré directement .

Un exemple:

fn foo<T>() -> Option<T> { }

fn main() {
    let x = foo();
}

Devrions-nous suggérer d'étiqueter x: Option<T> ou foo::<T> ? Ce cas est limite, mais si vous remplacez Option par un type plus complexe, cela fait encore pencher la balance.

Que fait-on quand le fn prend plusieurs types, et qu'on les connaît partiellement ? Nous avons évité le problème avant de savoir quoi faire lorsque nous avons quelques informations mais pas toutes. Mais on dirait qu'ici, c'est peut-être plus important. Un exemple:

fn foo<T, U>() -> T { }

fn main() {
    let x: i32 = foo();
}

Ici, nous connaissons T , mais pas U . Devrions-nous suggérer foo::<_, XXX> ? Comment formulons-nous le XXX pour indiquer à l'utilisateur que c'est ce qu'il doit fournir ?

cc @cengizIO -- intéressant à poursuivre ?

cc @estebank @jonathandturner -- réflexions sur la façon de formuler ?