Compilation bug? error: cannot determine a type for this bounded type parameter: unconstrained type

[carllerche]

Hello,

I believe that the following GIST demonstrates a bug with the compiler:

https://gist.github.com/wycats/e3b34bf041bd750a604a

Line 60 fails, but you can see that line 55 is exactly the same except for the fact that all components are broken into variables.

[alexcrichton]

I found that changing the last line to the following gets it to compile:

assertThat(&1, &is(&equalTo(&1) as &Matcher<T>));

So perhaps this is a trait coercion bug?

[carllerche]

@alexcrichton I assume you mean as &Matcher<int>? I tried what you used and it doesn't compile for me.

[alexcrichton]

Which version of rustc are you using? This diff gets it to compile locally for me:

--- foo.rs  2014-03-07 17:07:36.000000000 -0800
+++ bar.rs  2014-03-07 17:07:25.000000000 -0800
@@ -57,6 +57,6 @@
   // hamcrest.rs:55:18: 55:35 error: cannot determine a type for this bounded type parameter: unconstrained type
   // hamcrest.rs:55   assertThat(&1, &is(&equalTo(&1)));
   //                                 ^~~~~~~~~~~~~~~~~
-  assertThat(&1, &is(&equalTo(&1)));
+  assertThat(&1, &is(&equalTo(&1) as &Matcher<int>));
 }

[nikomatsakis]

cc me

[carllerche]

This seems to compile for me now. I have updated the snippet:

pub trait Matcher<T> {
  fn matches(&self, actual: &T) -> bool;
}

/*
 *
 * ===== Matchers =====
 *
 */

struct Is<'r, T:'r> {
  matcher: &'r (Matcher<T> + 'r)
}

impl<'r, T> Matcher<T> for Is<'r, T> {
  fn matches(&self, actual: &T) -> bool {
    self.matcher.matches(actual)
  }
}

fn is<'r, T:'r>(matcher: &'r Matcher<T>) -> Is<'r, T> {
  Is { matcher: matcher }
}

struct EqualTo<'r, T:'r> {
  expected: &'r T
}

impl<'r, T : Eq> Matcher<T> for EqualTo<'r, T> {
  fn matches(&self, actual: &T) -> bool {
    self.expected.eq(actual)
  }
}

fn equalTo<'r, T : Eq>(expected: &'r T) -> EqualTo<'r, T> {
  EqualTo { expected: expected }
}

fn assertThat<T>(actual: &T, matcher: &Matcher<T>) {
  if (!matcher.matches(actual)) {
    panic!("NOPE");
  }
}

#[test]
fn do_some_stuff() {
  let one = &1;
  let e = &equalTo(one);
  let p = &is(e);
  let one_b = &1;

  // this works
  assertThat(one_b, p);

  // hamcrest.rs:55:18: 55:35 error: cannot determine a type for this bounded type parameter: unconstrained type
  // hamcrest.rs:55   assertThat(&1, &is(&equalTo(&1)));
  //                                 ^~~~~~~~~~~~~~~~~
  assertThat(&1, &is(&equalTo(&1)));
}