E0277 should use short paths when possible

[estebank]

Type errors (and others) use tcx.short_ty_string and similar to write types that are too long to disk, so the cli output is easier to read. Trait bound errors do not do that.

https://twitter.com/ceccon_me/status/1707741832824734186

[fracek]

I created a small repo to reproduce this error message. What was not visible in the tweet but that you will see when you build the repo, is that the types in the error notes are even longer. That's a shame because hidden in that noise the compiler gives the solution to the error (pin).

[Vedaant-Rajoo]

@fracek You can just create a gist with the error generating logic line highlighted. Much more helpful?

[fracek]

I can give more context too. I was implementing a K8s operator using kube.

I start by creating a Controller and then running it with .run. This returns a a stream with a relatively complex type.

type ReconcileItem<K> = Result<(ObjectRef<K>, Action), controller::Error<MyError, watcher::Error>>;

async fn create_controller(
    client: Client,
) -> Result<impl Stream<Item = ReconcileItem<Pod>>, MyError> {
    let pods = Api::<Pod>::all(client.clone());
    let context = Context { client };

    let controller = Controller::new(pods, watcher::Config::default()).run(
        reconcile,
        error_policy,
        context.into(),
    );

    Ok(controller)
}

That stream yields an item every time the reconcile loops reconciles an item or returns an error. For testing, I iterate over the stream to check that it reconciles items the way I expect.

    let mut controller = create_controller(client).await?;
    while let Some(_item) = controller.try_next().await? { // <-- this line generates the error
    }

This is the error I get compiling that piece of code.

The solution is to pin the stream returned by create_controller.

[Milo123459]

how would i go about solving this?

@rustbot claim

[estebank]

@Milo123459 you can look at how we do it here

rust/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

Lines 3000 to 3001 in 94bc9c7

	let (self_ty, file) =
	self.tcx.short_ty_string(parent_trait_pred.skip_binder().self_ty());

You have to do the same thing but at the very least in the places we print out types to string here:

rust/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

Lines 420 to 478 in 8d92c99

	let trait_predicate = bound_predicate.rebind(trait_predicate);
	let trait_predicate = self.resolve_vars_if_possible(trait_predicate);
	// FIXME(effects)
	let predicate_is_const = false;
	if self.tcx.sess.has_errors().is_some()
	&& trait_predicate.references_error()
	{
	return;
	}
	let trait_ref = trait_predicate.to_poly_trait_ref();
	let (post_message, pre_message, type_def) = self
	.get_parent_trait_ref(obligation.cause.code())
	.map(|(t, s)| {
	(
	format!(" in `{t}`"),
	format!("within `{t}`, "),
	s.map(|s| (format!("within this `{t}`"), s)),
	)
	})
	.unwrap_or_default();
	let OnUnimplementedNote {
	message,
	label,
	note,
	parent_label,
	append_const_msg,
	} = self.on_unimplemented_note(trait_ref, &obligation);
	let have_alt_message = message.is_some() || label.is_some();
	let is_try_conversion = self.is_try_conversion(span, trait_ref.def_id());
	let is_unsize =
	Some(trait_ref.def_id()) == self.tcx.lang_items().unsize_trait();
	let (message, note, append_const_msg) = if is_try_conversion {
	(
	Some(format!(
	"`?` couldn't convert the error to `{}`",
	trait_ref.skip_binder().self_ty(),
	)),
	Some(
	"the question mark operation (`?`) implicitly performs a \
	conversion on the error value using the `From` trait"
	.to_owned(),
	),
	Some(AppendConstMessage::Default),
	)
	} else {
	(message, note, append_const_msg)
	};
	let err_msg = self.get_standard_error_message(
	&trait_predicate,
	message,
	predicate_is_const,
	append_const_msg,
	post_message,
	);

[Vedaant-Rajoo]

You also need to ensure that the type-shortening is conditional, based on whether the user wants verbose output or not (similar to the existing logic for type errors).

[estebank]

@Vedaant-Rajoo short_ty_string already checks whether write_long_types_to_disk is enabled or not before shortening.