Trait implementation accepts wrong lifetime in method signature with associated type

[tomjakubowski]

(Sorry for the bad title)

trait Fun {
    type Output;
    fn call<'x>(&'x self) -> Self::Output;
}

struct Holder { x: String }

impl<'a> Fun for Holder {
    type Output = &'a str;
    fn call<'b>(&'b self) -> &'b str {
        &self.x[]
    }
}

This compiles even though the trait's definition should require call's signature in the impl to be fn call<'b>(&'b self) -> &'a str.

[huonw]

This seems to be a problem with associated types, converting Fun to Fun<Output> correctly fails to compile:

trait Fun<Output> {
    fn call<'x>(&'x self) -> Output;
}

struct Holder { x: String }

impl<'a> Fun<&'a str> for Holder {
    fn call<'b>(&'b self) -> &'b str {
        &self.x[]
    }
}

<anon>:8:5: 10:6 error: method `call` has an incompatible type for trait: expected bound lifetime parameter 'x, found concrete lifetime [E0053]
<anon>:8     fn call<'b>(&'b self) -> &'b str {
<anon>:9         &self.x[]
<anon>:10     }

cc @nikomatsakis

[edwardw]

cc me. It feels very closely related to #21750, although on the surface they are quite the opposite. Also, @nikomatsakis may have something in the making for #21974.

[pnkfelix]

P-backcompat-lang, 1.0 beta.

[huonw]

Possibly related to #21259.

[edwardw]

Have an fix in the same vein of #22338. But, it also reports an error

error: method index_mut has an incompatible type for trait: expected type parameter, found a different type parameter [E0053]

for libstd/collections/hash/map.rs:

impl<K, Q: ?Sized, V, S, H> Index<Q> for HashMap<K, V, S>
    where K: Eq + Hash<H>,
          Q: Eq + Hash<H> + BorrowFrom<K>,
          S: HashState<Hasher=H>,
          H: hash::Hasher<Output=u64>
{
    type Output = V;

    #[inline]
    fn index<'a>(&'a self, index: &Q) -> &'a V {
        self.get(index).expect("no entry found for key")
    }
}

impl<K, V, S, H, Q: ?Sized> IndexMut<Q> for HashMap<K, V, S>
    where K: Eq + Hash<H>,
          Q: Eq + Hash<H> + BorrowFrom<K>,
          S: HashState<Hasher=H>,
          H: hash::Hasher<Output=u64>
{
    #[inline]
    fn index_mut<'a>(&'a mut self, index: &Q) -> &'a mut V {
        self.get_mut(index).expect("no entry found for key")
    }
}

Notice, the order of the type parameters is different. So is the error legit or does the fix simply have a regression?