Change:
The following code fails to compile despite : The exact error is: Per comment , it seems that could imply .
contains the following comment:
I'd be interested in digging into this if you can give me some advice on how to get started.
hmm, probably best would be to privmsg me on IRC, if that's possible (). It should be fairly easy to write a targeted patch covering cases like , where the bound region only appears on the RHS; doing a more general fix (e.g., one that handles ) would be somewhat harder, though some of the recent refactoring I've been doing would help there.

Discussion:
} ty::Predicate::TypeOutlives(ref binder) => { <del> // For now, we just check that there are no higher-ranked // regions.  If there are, we will call this obligation an // error. Eventually we should be able to support some // cases here, I imagine (e.g., `for<'a> int : 'a`). </del> <ins> // Check if there are higher-ranked regions. </ins> match selcx.tcx().no_late_bound_regions(binder) { <ins> // If there are, inspect the underlying type further. </ins> None => { <del> errors.push( FulfillmentError::new( obligation.clone(), CodeSelectionError(Unimplemented))) </del> <ins> // Convert from `Binder<OutlivesPredicate<Ty, Region>>` to `Binder<Ty>`. let binder = binder.map_bound_ref(|pred| pred.0); // Check if the type has any bound regions. match selcx.tcx().no_late_bound_regions(&binder) { // If so, this obligation is an error (for now). Eventually we should be // able to support additional cases here, like `for<'a> &'a str: 'a`. None => { errors.push( FulfillmentError::new( obligation.clone(), CodeSelectionError(Unimplemented))) } // Otherwise, we have something of the form // `for<'a> T: 'a where 'a not in T`, which we can treat as `T: 'static`. Some(t_a) => { register_region_obligation(t_a, ty::ReStatic, obligation.cause.clone(), region_obligations); } } </ins> } <ins> // If there aren't, register the obligation. </ins> Some(ty::OutlivesPredicate(t_a, r_b)) => { register_region_obligation(t_a, r_b, obligation.cause.clone(),

<del> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // Test what happens when a HR obligation is applied to an impl with // "outlives" bounds. Currently we're pretty conservative here; this // will probably improve in time. trait Foo<X> { fn foo(&self, x: X) { } } fn want_foo<T>() where T : for<'a> Foo<&'a isize> { } /////////////////////////////////////////////////////////////////////////// // Expressed as a where clause struct SomeStruct<X> { x: X } impl<'a,X> Foo<&'a isize> for SomeStruct<X> where X : 'a { } fn one() { // In fact there is no good reason for this to be an error, but // whatever, I'm mostly concerned it doesn't ICE right now: want_foo::<SomeStruct<usize>>(); //~^ ERROR requirement `for<'a> usize : 'a` is not satisfied } /////////////////////////////////////////////////////////////////////////// // Expressed as shorthand struct AnotherStruct<X> { x: X } impl<'a,X:'a> Foo<&'a isize> for AnotherStruct<X> { } fn two() { want_foo::<AnotherStruct<usize>>(); //~^ ERROR requirement `for<'a> usize : 'a` is not satisfied } fn main() { } </del>

<ins> // Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn foo<T>() where for<'a> T: 'a {} fn main<'a>() { foo::<&'a i32>(); //~^ ERROR the type `&'a i32` does not fulfill the required lifetime } </ins>

<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // Test what happens when a HR obligation is applied to an impl with // "outlives" bounds. Currently we're pretty conservative here; this // will probably improve in time. trait Foo<X> { fn foo(&self, x: X) { } } fn want_foo<T>() where T : for<'a> Foo<&'a isize> { } /////////////////////////////////////////////////////////////////////////// // Expressed as a where clause struct SomeStruct<X> { x: X } impl<'a,X> Foo<&'a isize> for SomeStruct<X> where X : 'a { } fn one() { want_foo::<SomeStruct<usize>>(); } /////////////////////////////////////////////////////////////////////////// // Expressed as shorthand struct AnotherStruct<X> { x: X } impl<'a,X:'a> Foo<&'a isize> for AnotherStruct<X> { } fn two() { want_foo::<AnotherStruct<usize>>(); } fn main() { } </ins>