Feature request: Use 'trampolines' to make most of the body of a generic function non-generic

[jyn514]

A common pattern in Rust, especially in the standard library, is to have two versions of a function: one generic and one with the actual implementation. For example, Error::new() immediately delegates to a non-generic function _new():

rust/library/std/src/io/error.rs

Lines 250 to 260 in 5565241

	#[stable(feature = "rust1", since = "1.0.0")]
	pub fn new<E>(kind: ErrorKind, error: E) -> Error
	where
	E: Into<Box<dyn error::Error + Send + Sync>>,
	{
	Self::_new(kind, error.into())
	}
	fn _new(kind: ErrorKind, error: Box<dyn error::Error + Send + Sync>) -> Error {
	Error { repr: Repr::Custom(Box::new(Custom { kind, error })) }
	}

This benefits both compile- and run-time: compiletime because LLVM has to do less work compiling the large implementation of the function body many times, and runtime because generic version can safely be marked as #[inline] without bloating the instruction cache.

However, most libraries do not do this, for the simple reason that it's tedious and annoying to do (and you have to already know about it). It would be amazing if rustc could do this transformation itself. I expect this would help greatly with #65031, as well as compile times across the ecosystem.

[jyn514]

Thanks to @matklad for bringing this up in https://matklad.github.io/2020/10/15/study-of-std-io-error.html !

[dlight]

@llogiq wrote a library to perform this translation with a function attribute, momo. It works with a small number of traits (Into, AsRef and AsMut). Having rustc first optimize those three traits would be a good first step before working with arbitrary traits.

In the far future, I wish that rustc were able to automatically transform generics into code that uses trait objects, whenever applicable (the opposite of the "devirtualization" optimization).

[dylni]

#77767 is a similar issue for const generics.

[thomcc]

This is a specific case of "outlining", and while outlining would help various things in a lot of places, its probably better to handle this specifically.

[camelid]

For those (like me!) who don't know what 'trampoline' means in this sense of the word, I think it's related to this part of the Wikipedia article "Trampolines (computing)":

In embedded systems, trampolines are short snippets of code that start up other snippets of code. For example, rather than write interrupt handlers entirely in assembly language, another option is to write interrupt handlers mostly in C, and use a short trampoline to convert the assembly-language interrupt calling convention into the C calling convention.