Can use + operator in broken and hilarious ways

[tomjakubowski]

(sorry about the bad title but I really have no clue what's going on here!)

use std::num::Num;

trait BrokenAdd: Num {
    fn broken_add<T>(&self, rhs: T) -> Self {
        *self + rhs
    }
}

impl<T: Num> BrokenAdd for T {}

pub fn main() {
    let foo: u8 = 0u8;
    let x: u8 = foo.broken_add("hello darkness my old friend".to_string());
    println!("{}", x);
}

Compiles and prints 28. I think it's getting at the len of the Vec inside a String.

edit: As one might expect, 0u8 + "hello darkness my old friend".to_string() does not compile.

[huonw]

Seems rather bad.

cc @nikomatsakis

[alexcrichton]

Nominating.

[ben0x539]

This is a fun bug, it's by far not limited to the + operator. I tried to reduce the test case a bit, starting with a new non-operator trait, changed it to a static method that just returns Self for inference, and... (playpen url)

trait Tr<T> {
    fn op(T) -> Self;
}

// these compile as if Self: Tr<U>, even tho only Self: Tr<Self or T>
trait A:    Tr<Self> { fn test<U>(u: U) -> Self { Tr::op(u) } }
trait B<T>: Tr<T>    { fn test<U>(u: U) -> Self { Tr::op(u) } }
// these rightfully fail to compile:
// struct X;
// trait C:    Tr<Self> { fn test   (u: X) -> Self { Tr::op(u) } }
// trait D:    Tr<X>    { fn test<U>(u: U) -> Self { Tr::op(u) } }
// trait E<T>: Tr<T>    { fn test   (u: X) -> Self { Tr::op(u) } }

impl<T> Tr<T> for T {
    fn op(t: T) -> T { t }
}
impl<T> A for T {}

fn main() {
    std::io::println(A::test((&7306634593706211700, 8)));
}

[pnkfelix]

cc me

[pnkfelix]

Assigning 1.0, P-backcompat-lang.

[pcwalton]

Even smaller:

trait Tr {
    fn test<X>(u: X) -> Self {
        u
    }
}

fn main() {}