Prelude collision lint: invalid suggestion for T::from_iter when T is generic.

[m-ou-se]

For generic types, the prelude collision lint can produce suggestions that do not compile:

Code:

struct Generic<T>(T);

trait Hey { fn from_iter(_: i32) -> Self; }

impl Hey for Generic<i32> { fn from_iter(x: i32) -> Self { Self(x) } }

impl std::iter::FromIterator<i32> for Generic<i32> { fn from_iter<T: IntoIterator<Item = i32>>(_: T) -> Self { todo!() } }

fn main() {
    Generic::from_iter(1);
}

Suggestion from the prelude collision lint:

warning: trait-associated function `from_iter` will become ambiguous in Rust 2021
  --> src/main.rs:10:5
   |
10 |     Generic::from_iter(1);
   |     ^^^^^^^^^^^^^^^^^^ help: disambiguate the associated function: `<Generic as Hey>::from_iter`
   |
   = note: `-W rust-2021-prelude-collisions` implied by `-W rust-2021-compatibility`
   = warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
   = note: for more information, see issue #85684 <https://github.com/rust-lang/rust/issues/85684>

Error after applying the suggestion:

error[E0107]: missing generics for struct `Generic`
  --> src/main.rs:10:6
   |
10 |     <Generic as Hey>::from_iter(1);
   |      ^^^^^^^ expected 1 generic argument
   |

[m-ou-se]

cc @nikomatsakis @jam1garner

[jam1garner]

My guess is this should be a simple fix, just copying the code the lint already uses for adding unspecified generics (Foo<_, _>). Will try implementing a fix soon.

[nikomatsakis]

@rustbot assign @jam1garner

[nikomatsakis]

@rustbot release-assignment

[nikomatsakis]

Mentoring notes

The code related to this lint lives in the prelude2021 module.

The relevant suggestion is generated here:

rust/compiler/rustc_typeck/src/check/method/prelude2021.rs

Lines 264 to 269 in b919797

	lint.span_suggestion(
	span,
	"disambiguate the associated function",
	format!("<{} as {}>::{}", self_ty, trait_name, method_name.name,),
	Applicability::MachineApplicable,
	);

The "self type" string comes from here:

rust/compiler/rustc_typeck/src/check/method/prelude2021.rs

Lines 258 to 262 in b919797

	let self_ty = self
	.sess()
	.source_map()
	.span_to_snippet(self_ty_span)
	.unwrap_or_else(|_| self_ty.to_string());

The code for traits is here:

rust/compiler/rustc_typeck/src/check/method/prelude2021.rs

Lines 242 to 251 in b919797

	let parameter_count = trait_generics.count() - (trait_generics.has_self as usize);
	let trait_name = if parameter_count == 0 {
	trait_path
	} else {
	format!(
	"{}<{}>",
	trait_path,
	std::iter::repeat("_").take(parameter_count).collect::<Vec<_>>().join(", ")
	)
	};

This is actually just a touch tricky, because currently we are getting the "self type" just by copying the text the user wrote. Probably the most correct thing for us to do would be to examine the 'self expression' HIR and, if it is a plain path, then to append the <_> and otherwise skip it.

Specifically, the other case that I am thinking about is code like this:

#![warn(rust_2021_compatibility)]

struct Generic<T>(T);

trait Hey { fn from_iter(_: i32) -> Self; }

impl Hey for Generic<i32> { fn from_iter(x: i32) -> Self { Self(x) } }

impl std::iter::FromIterator<i32> for Generic<i32> { fn from_iter<T: IntoIterator<Item = i32>>(_: T) -> Self { todo!() } }

fn main() {
    <Generic<_>>::from_iter(1);
}

Currently this test works, meaning that it offers the suggestion "disambiguate the associated function: <Generic<_> as Hey>::from_iter".

[FinnRG]

@rustbot claim

[nikomatsakis]

@Pyther99 great! Let us know if you need anything or make progress. This issue is fairly time sensitive.