Loop evaluating Cow<'a, T>: Sized in recursive structure

[freebroccolo]

The example causes the checker to loop with build rustc 1.0.0-dev (81938ec58 2015-03-25) (built 2015-03-25):

src/lib.rs:1:1: 1:1 error: overflow evaluating the requirement `collections::borrow::Cow<'static, Foo> : core::marker::Sized` [E0275]

It does still work using the Rust playpen here. I'm not sure if something changed in the API or if it's a bug or something else. The docs show ToOwned::Owned: Sized so the requirement should be satisfied. /cc @aturon

use std::borrow::*;

enum Foo {
    Bar,
    Baz { cow: Cow<'static, Foo> }
}

impl ToOwned for Foo {
    type Owned = Box<Foo>;
    fn to_owned(&self) -> Box<Foo> {
        let res = match self {
            &Foo::Bar => {
                Foo::Bar
            },
            &Foo::Baz { ref cow } => {
                Foo::Baz { cow: cow.to_owned() }
            }
        };
        Box::new(res)
    }
}

impl Borrow<Foo> for Box<Foo> {
    fn borrow(&self) -> &Foo {
        &**self
    }
}

[aturon]

I believe that @nikomatsakis recently made a change that detected overflow, that may be related (I don't recall the details offhand).

[freebroccolo]

I haven't pinpointed the commit which causes the issue but it is somewhere within 1be8fcb..c5c3de0.

[mitchmindtree]

I think #23707 might be related

[nikomatsakis]

so yes I think this is a dup of #23707 but the error was being swallowed somewhere

[nikomatsakis]

and I think #23707 is a dup of an older issue too :)

[nikomatsakis]

sorry I'm not sure if this is a dup of #23707 specifically; I was thinking of another issue

[jmgrosen]

Any progress here? I'm running into this as well.

[aturon]

Nominating for discussion at compiler team meeting.

[pnkfelix]

assigning P-medium

[eddyb]

This produces "error: overflow evaluating the requirement Foo: std::marker::Sized [E0275]":

use std::borrow::ToOwned;

enum Foo {
    Bar,
    Baz { cow: Result<&'static Foo, <Foo as ToOwned>::Owned> }
}

impl ToOwned for Foo {
    type Owned = Box<Foo>;
    fn to_owned(&self) -> Box<Foo> { loop {} }
}

However, this works:

use std::borrow::Borrow;

pub trait ToOwned {
    type Owned: Borrow<Self>;
    fn to_owned(&self) -> Self::Owned;
}

enum Foo {
    Bar,
    Baz { cow: Result<&'static Foo, <Foo as ToOwned>::Owned> }
}

impl ToOwned for Foo {
    type Owned = Box<Foo>;
    fn to_owned(&self) -> Box<Foo> { loop {} }
}

Does this have to do with coherence cross-crate interactions?

[jonas-schievink]

Both of @eddyb's examples compile now, while the code in the OP still fails.