Recursive function call generates confusing overflow message

@estebank

error[E0275]: overflow evaluating the requirement &mut bytes::bytes_mut::BytesMut: bytes::buf::buf_impl::Buf

Here's a link to the playground : https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=e0d226183c371b79d9a234ccebdeafd0

I tried this code:

use bytes::{Buf, BytesMut};

fn get_value<B>(buf: &mut B) -> Result<i32, String>
where
    B: Buf,
{
    Ok(42)
}

fn do_more<B>(mut buf: B) -> Result<i32, String>
where
    B: Buf,
{
    if buf.has_remaining() {
        get_value(&mut buf)
    } else {
        do_more(&mut buf)
    }
}

fn main() {
    let payload = vec![1, 2, 3, 4, 5];
    let parsed = do_more(&mut BytesMut::from(&*payload)).unwrap();
}

I expected to see this happen: Nothing really, but I would love to see an error message that would help me out here ^^.

Instead, this happened:

Meta

rustc --version --verbose:

playground (stable) and tested it on my machine: rustc 1.43.1 (8d69840ab 2020-05-04)

Link to the twitter discussion https://twitter.com/ekuber/status/1264962969206525952?s=20

Paging @estebank who might be interested <3

@o0Ignition0o

@o0Ignition0o: You can make this compile by changing get_value(&mut buf) to get_value(buf) - note that this will cause infinite recursion at runtime if buf.has_remaining() == false

Minimized:

struct BytesMut;

trait Buf {}

impl Buf for BytesMut {}
impl<'a, T: Buf> Buf for &'a mut T {}

fn do_more<B>(mut buf: B)
where
    B: Buf,
{
    do_more(&mut buf);
}

fn main() {
    do_more(&mut BytesMut)
}

Trying to monomorphize do_more::<B> causes us to recursively monomorphize do_more::<&mut B>, which will eventually hit the recursion limit.

We should be able to detect this kind of recursive monomorphization in simple cases (when the function directly calls itself rather than going through a helper function).

Oh thanks a lot! So long story short I should try to avoid recursion in this kind of scenario ? (the real life use case is a bit more complicated, but i was willing about to use recursion to solve it ^^')

thanks again :D

Rollup merge of rust-lang#73601 - Aaron1011:fix/better-mono-overflow-…

Current output:

error: reached the recursion limit while instantiating `do_more::<&mut &mut &mut &mut &mut ...>`
  --> src/main.rs:17:9
   |
17 |         do_more(&mut buf)
   |         ^^^^^^^^^^^^^^^^^
   |
note: `do_more` defined here
  --> src/main.rs:10:1
   |
10 | / fn do_more<B>(mut buf: B) -> Result<i32, String>
11 | | where
12 | |     B: Buf,
   | |___________^
   = note: the full type name has been written to '/playground/target/debug/deps/playground-b0d2208020a7eb98.long-type.txt'

Navigation Menu

Repository navigation

Recursive function call generates confusing overflow message #72577

Meta

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Recursive function call generates confusing overflow message #72577

Description

Meta

Activity

Aaron1011 commented on May 25, 2020

o0Ignition0o commented on May 25, 2020

estebank commented on May 27, 2024

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions