nll should respect lifetime annotations from multi-segment paths

[nikomatsakis]

This example should not compile:

#![feature(nll)]

struct A<'a> { x: &'a u32 }

impl<'a> A<'a> {
    fn new(x: &'a u32) -> Self {
        Self { x }
    }
}

fn foo<'a>() {
    let v = 22;
    let x = A::<'a>::new(&v);
}

fn main() {}

But it does =)

[nikomatsakis]

I did some investigation. I believe this problem is specific to inherent methods. There a bit of a challenge here:

The substitutions on the impl are not directly given by the user. The user only gives the self-type. The instantiate_value_path function handles this via unification:

rust/src/librustc_typeck/check/mod.rs

Lines 5219 to 5236 in 1c5e9c6

	if let Some((ty::ImplContainer(impl_def_id), self_ty)) = ufcs_associated {
	// In the case of `Foo<T>::method` and `<Foo<T>>::method`, if `method`
	// is inherent, there is no `Self` parameter, instead, the impl needs
	// type parameters, which we can infer by unifying the provided `Self`
	// with the substituted impl type.
	let ty = self.tcx.type_of(impl_def_id);
	let impl_ty = self.instantiate_type_scheme(span, &substs, &ty);
	match self.at(&self.misc(span), self.param_env).sup(impl_ty, self_ty) {
	Ok(ok) => self.register_infer_ok_obligations(ok),
	Err(_) => {
	span_bug!(span,
	"instantiate_value_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
	self_ty,
	impl_ty);
	}
	}
	}

which is pretty reasonable, but it does't work for us. The end result is that when we (later) invoke write_user_substs_from_substs the region information has been lost:

rust/src/librustc_typeck/check/mod.rs

Line 5246 in 1c5e9c6

self.write_user_substs_from_substs(hir_id, substs);

In fact, it's mildly invalid to call write_user_substs_from_substs at that point -- it's meant to be called before we start doing unifications, actually, although in this case it's sort of ok since the only unification we've done comes pretty directly from user-given types.

I don't think there's a super nice way to fix this. We might have to propagate the "user-given self type" all the way down to MIR, actually: in particular I don't think we can readily translate a "user-given self type" into a set of substitutions, due to annoying things like higher-ranked functions, for which equality is kind of complex.