pub fn try_report_anon_anon_conflict(&self, error: &RegionResolutionError<'tcx>) -> bool {
let (span, sub, sup) = match *error {
ConcreteFailure(ref origin, sub, sup) => (origin.span(), sub, sup),
+ SubSupConflict(_, ref origin, sub, _, sup) => (origin.span(), sub, sup),
_ => return false, // inapplicable
};
pub fn try_report_named_anon_conflict(&self, error: &RegionResolutionError<'tcx>) -> bool {
let (span, sub, sup) = match *error {
ConcreteFailure(ref origin, sub, sup) => (origin.span(), sub, sup),
+ SubSupConflict(_, ref origin, sub, _, sup) => (origin.span(), sub, sup),
_ => return false, // inapplicable
};
{
// x and y here have two distinct lifetimes:
let z: I::A = if cond { x } else { y };
- //~^ ERROR cannot infer
+ //~^ ERROR lifetime mismatch
}
pub fn main() {}
#[cfg(krisskross)] // two instantiations, mixing and matching: BAD
fn transmute<'a,'b>(x: &'a u32, y: &'b u32) -> (&'a u32, &'b u32) {
- let a = bar(foo, y); //[krisskross]~ ERROR E0495
- let b = bar(foo, x); //[krisskross]~ ERROR E0495
- (a, b)
+ let a = bar(foo, y);
+ let b = bar(foo, x);
+ (a, b) //[krisskross]~ ERROR 55:5: 55:6: lifetime mismatch [E0623]
+ //[krisskross]~^ ERROR 55:8: 55:9: lifetime mismatch [E0623]
}
#[rustc_error]
#[cfg(oneuse)] // one instantiation: BAD
fn baz<'a,'b>(x: Type<'a>, y: Type<'b>) -> (Type<'a>, Type<'b>) {
let f = foo; // <-- No consistent type can be inferred for `f` here.
- let a = bar(f, x); //[oneuse]~^ ERROR E0495
+ let a = bar(f, x);
let b = bar(f, y);
- (a, b)
+ (a, b) //[oneuse]~ ERROR E0623
}
#[cfg(transmute)] // one instantiations: BAD
#[cfg(krisskross)] // two instantiations, mixing and matching: BAD
fn transmute<'a,'b>(x: Type<'a>, y: Type<'b>) -> (Type<'a>, Type<'b>) {
- let a = bar(foo, y); //[krisskross]~ ERROR E0495
- let b = bar(foo, x); //[krisskross]~ ERROR E0495
- (a, b)
+ let a = bar(foo, y);
+ let b = bar(foo, x);
+ (a, b) //[krisskross]~ ERROR E0623
+ //[krisskross]~^ ERROR E0623
}
#[rustc_error]
fn copy_borrowed_ptr<'a,'b>(p: &'a mut S<'b>) -> S<'b> {
S { pointer: &mut *p.pointer }
- //~^ ERROR cannot infer
+ //~^ ERROR lifetime mismatch
}
fn main() {
fn attemptTraverse(&self, room: &Room, directionStr: &str) -> Result<&Room, &str> {
let direction = str_to_direction(directionStr);
let maybe_room = room.direction_to_room.get(&direction);
- //~^ ERROR cannot infer an appropriate lifetime for autoref due to conflicting requirements
match maybe_room {
Some(entry) => Ok(entry),
+ //~^ ERROR 25:28: 25:37: lifetime mismatch [E0623]
_ => Err("Direction does not exist in room.")
}
}
fn lifetime_transmute_slice<'a, T: ?Sized>(x: &'a T, y: &T) -> &'a T {
let mut out = [x];
- //~^ ERROR cannot infer an appropriate lifetime due to conflicting requirements
{
let slice: &mut [_] = &mut out;
slice[0] = y;
}
out[0]
+ //~^ ERROR 19:5: 19:11: explicit lifetime required in the type of `y` [E0621]
}
struct Struct<T, U: ?Sized> {
fn lifetime_transmute_struct<'a, T: ?Sized>(x: &'a T, y: &T) -> &'a T {
let mut out = Struct { head: x, _tail: [()] };
- //~^ ERROR cannot infer an appropriate lifetime due to conflicting requirements
{
let dst: &mut Struct<_, [()]> = &mut out;
dst.head = y;
}
out.head
+ //~^ ERROR 34:5: 34:13: explicit lifetime required in the type of `y` [E0621]
}
fn main() {
fn store1<'b>(ss: &mut SomeStruct, b: Box<SomeTrait+'b>) {
// Here we override the lifetimes explicitly, and so naturally we get an error.
- ss.r = b; //~ ERROR cannot infer an appropriate lifetime
+ ss.r = b; //~ ERROR 41:12: 41:13: explicit lifetime required in the type of `ss` [E0621]
}
fn main() {
fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
// Here we try to call `foo` but do not know that `'a` and `'b` are
// related as required.
- a(x, y); //~ ERROR cannot infer
+ a(x, y); //~ ERROR 24:7: 24:8: lifetime mismatch [E0623]
}
fn d() {
fn c<'a,'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) {
// Here we try to call `foo` but do not know that `'a` and `'b` are
// related as required.
- a(x, y, z); //~ ERROR cannot infer
+ a(x, y, z); //~ ERROR 26:7: 26:8: lifetime mismatch [E0623]
}
fn d() {
fn call_bigger_region<'x, 'y>(a: Inv<'x>, b: Inv<'y>) {
// Here the value provided for 'y is 'y, and hence 'y:'x does not hold.
- a.bigger_region(b) //~ ERROR cannot infer
+ a.bigger_region(b) //~ ERROR 30:7: 30:20: lifetime mismatch [E0623]
}
fn main() { }
fn caller2<'a,'b,F:Foo<'a>>(a: Inv<'a>, b: Inv<'b>, f: F) {
// Here the value provided for 'y is 'b, and hence 'b:'a does not hold.
- f.method(b); //~ ERROR cannot infer
+ f.method(b); //~ ERROR 30:7: 30:13: lifetime mismatch [E0623]
}
fn caller3<'a,'b:'a,F:Foo<'a>>(a: Inv<'a>, b: Inv<'b>, f: F) {
}
fn mk_add_bad1<'a,'b>(x: &'a ast<'a>, y: &'b ast<'b>) -> ast<'a> {
- ast::add(x, y) //~ ERROR cannot infer
+ ast::add(x, y) //~ ERROR 17:5: 17:19: lifetime mismatch [E0623]
}
fn main() {
fn ordering2<'a, 'b>(x: &'a &'b usize, y: &'a usize) -> &'b usize {
// However, it is not safe to assume that 'b <= 'a
- &*y //~ ERROR cannot infer
+ &*y //~ ERROR 23:5: 23:8: lifetime mismatch [E0623]
}
fn ordering3<'a, 'b>(x: &'a usize, y: &'b usize) -> &'a &'b usize {
// Do not infer an ordering from the return value.
let z: &'b usize = &*x;
- //~^ ERROR cannot infer
+ //~^ ERROR 28:24: 28:27: lifetime mismatch [E0623]
panic!();
}
fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
// Here we try to call `foo` but do not know that `'a` and `'b` are
// related as required.
- a(x, y); //~ ERROR E0495
+ a(x, y); //~ ERROR 24:7: 24:8: lifetime mismatch [E0623]
}
fn d() {
// Issue #8624. Test for reborrowing with 3 levels, not just two.
fn copy_borrowed_ptr<'a, 'b, 'c>(p: &'a mut &'b mut &'c mut isize) -> &'b mut isize {
- &mut ***p //~ ERROR cannot infer
+ &mut ***p //~ ERROR 14:5: 14:14: lifetime mismatch [E0623]
}
fn main() {
// for `'a` (which must be a sublifetime of `'b`).
fn copy_borrowed_ptr<'a, 'b>(p: &'a mut &'b mut isize) -> &'b mut isize {
- &mut **p //~ ERROR cannot infer
+ &mut **p //~ ERROR 16:5: 16:13: lifetime mismatch [E0623]
}
fn main() {
--- /dev/null
+// Copyright 2017 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.
+
+struct Foo {
+ field: i32,
+}
+
+fn foo2<'a>(a: &'a Foo, x: &i32) -> &'a i32 {
+ if true {
+ let p: &i32 = &a.field;
+ &*p
+ } else {
+ &*x
+ }
+}
+
+fn main() { }
--- /dev/null
+error[E0621]: explicit lifetime required in the type of `x`
+ --> $DIR/42701_one_named_and_one_anonymous.rs:20:9
+ |
+15 | fn foo2<'a>(a: &'a Foo, x: &i32) -> &'a i32 {
+ | - consider changing the type of `x` to `&'a i32`
+...
+20 | &*x
+ | ^^^ lifetime `'a` required
+
+error: aborting due to previous error
+
-error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'a` due to conflicting requirements
- --> $DIR/ex2c-push-inference-variable.rs:16:13
- |
-16 | let z = Ref { data: y.data };
- | ^^^
- |
-note: first, the lifetime cannot outlive the lifetime 'c as defined on the function body at 15:1...
- --> $DIR/ex2c-push-inference-variable.rs:15:1
- |
-15 | / fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
-16 | | let z = Ref { data: y.data };
-17 | | x.push(z);
-18 | | }
- | |_^
-note: ...so that reference does not outlive borrowed content
- --> $DIR/ex2c-push-inference-variable.rs:16:25
- |
-16 | let z = Ref { data: y.data };
- | ^^^^^^
-note: but, the lifetime must be valid for the lifetime 'b as defined on the function body at 15:1...
- --> $DIR/ex2c-push-inference-variable.rs:15:1
- |
-15 | / fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
-16 | | let z = Ref { data: y.data };
-17 | | x.push(z);
-18 | | }
- | |_^
-note: ...so that expression is assignable (expected Ref<'b, _>, found Ref<'_, _>)
+error[E0623]: lifetime mismatch
--> $DIR/ex2c-push-inference-variable.rs:17:12
|
+15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
+ | ------------ ------------ these two types are declared with different lifetimes...
+16 | let z = Ref { data: y.data };
17 | x.push(z);
- | ^
+ | ^ ...but data from `y` flows into `x` here
error: aborting due to previous error
-error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'a` due to conflicting requirements
- --> $DIR/ex2d-push-inference-variable-2.rs:17:13
- |
-17 | let b = Ref { data: y.data };
- | ^^^
- |
-note: first, the lifetime cannot outlive the lifetime 'c as defined on the function body at 15:1...
- --> $DIR/ex2d-push-inference-variable-2.rs:15:1
- |
-15 | / fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
-16 | | let a: &mut Vec<Ref<i32>> = x;
-17 | | let b = Ref { data: y.data };
-18 | | a.push(b);
-19 | | }
- | |_^
-note: ...so that reference does not outlive borrowed content
- --> $DIR/ex2d-push-inference-variable-2.rs:17:25
- |
-17 | let b = Ref { data: y.data };
- | ^^^^^^
-note: but, the lifetime must be valid for the lifetime 'b as defined on the function body at 15:1...
- --> $DIR/ex2d-push-inference-variable-2.rs:15:1
- |
-15 | / fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
-16 | | let a: &mut Vec<Ref<i32>> = x;
-17 | | let b = Ref { data: y.data };
-18 | | a.push(b);
-19 | | }
- | |_^
-note: ...so that expression is assignable (expected &mut std::vec::Vec<Ref<'_, i32>>, found &mut std::vec::Vec<Ref<'b, i32>>)
+error[E0623]: lifetime mismatch
--> $DIR/ex2d-push-inference-variable-2.rs:16:33
|
+15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
+ | ------------ ------------ these two types are declared with different lifetimes...
16 | let a: &mut Vec<Ref<i32>> = x;
- | ^
+ | ^ ...but data from `y` flows into `x` here
error: aborting due to previous error
-error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'a` due to conflicting requirements
- --> $DIR/ex2e-push-inference-variable-3.rs:17:13
- |
-17 | let b = Ref { data: y.data };
- | ^^^
- |
-note: first, the lifetime cannot outlive the lifetime 'c as defined on the function body at 15:1...
- --> $DIR/ex2e-push-inference-variable-3.rs:15:1
- |
-15 | / fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
-16 | | let a: &mut Vec<Ref<i32>> = x;
-17 | | let b = Ref { data: y.data };
-18 | | Vec::push(a, b);
-19 | | }
- | |_^
-note: ...so that reference does not outlive borrowed content
- --> $DIR/ex2e-push-inference-variable-3.rs:17:25
- |
-17 | let b = Ref { data: y.data };
- | ^^^^^^
-note: but, the lifetime must be valid for the lifetime 'b as defined on the function body at 15:1...
- --> $DIR/ex2e-push-inference-variable-3.rs:15:1
- |
-15 | / fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
-16 | | let a: &mut Vec<Ref<i32>> = x;
-17 | | let b = Ref { data: y.data };
-18 | | Vec::push(a, b);
-19 | | }
- | |_^
-note: ...so that expression is assignable (expected &mut std::vec::Vec<Ref<'_, i32>>, found &mut std::vec::Vec<Ref<'b, i32>>)
+error[E0623]: lifetime mismatch
--> $DIR/ex2e-push-inference-variable-3.rs:16:33
|
+15 | fn foo<'a, 'b, 'c>(x: &'a mut Vec<Ref<'b, i32>>, y: Ref<'c, i32>) {
+ | ------------ ------------ these two types are declared with different lifetimes...
16 | let a: &mut Vec<Ref<i32>> = x;
- | ^
+ | ^ ...but data from `y` flows into `x` here
error: aborting due to previous error
projects / rust.git / commitdiff