E0623: Incorrect or ambiguous message

[vandenheuvel]

I encountered the following error:

error[E0623]: lifetime mismatch
  --> src/algorithm/simplex/branch_and_bound/logic.rs:47:73
   |
34 |       tableau: Tableau<'data_provider, NonArtificial, AdaptedMatrixProvider<'original_data, MP>, PR>,
   |                ------------------------------------------------------------------------------------- these two types are declared with different lifetimes...
...
47 |           let lower_provider: AdaptedMatrixProvider<'original_data, MP> = tableau.provider().clone_with_extra_bound(branch_variable,
   |  _________________________________________________________________________^
48 | |                                                                                                                   new_lower_bound,
49 | |                                                                                                                   BoundType::Lower);
   | |___________________________________________________________________________________________________________________________________^ ...but data from `tableau` flows into `tableau` here

Looking at line 47, this seems to be incorrect: data doesn't flow into tableau. Merely, another reference is created to a value which is also referenced by the existing tableau.

Moreover, it doesn't look like there are two types being pointed at by the compiler. The two types being referenced might be the outer and inner type though, but this is unclear and if this is the case, I think it requires change.

I tried to reproduce this issue on the playground, but was not successful. The full code can be found here. A slightly different state of the codebase, with a similar error, can be found here.

@estebank Looking at related issues, I thought that this might be relevant to you.

[stephaneyfx]

This looks like a somewhat faithful reduction of the problem (playground).

The problem seems to be relying on lifetime elision in the return type of Tableau::provider (which will pick the lifetime of &self AFAIK), causing a type mismatch on line 28 where the explicit type annotation does not match the return type. Uncommenting the lifetime in the code below makes the error go away.

#![allow(dead_code)]

struct Tableau<'a, MP> {
    provider: &'a MP,
}

impl<'adapted_matrix_provider, 'original_data, MP>
    Tableau<'adapted_matrix_provider, AdaptedMatrixProvider<'original_data, MP>>
{
    fn provider(&self) -> &'adapted_matrix_provider AdaptedMatrixProvider</*'original_data,*/ MP> {
        self.provider
    }
}

struct AdaptedMatrixProvider<'a, T> {
    original_problem: &'a T,
}

impl<'a, T> AdaptedMatrixProvider<'a, T> {
    fn clone_with_extra_bound(&self) -> Self {
        AdaptedMatrixProvider { original_problem: self.original_problem }
    }
}

fn create_and_solve_subproblems<'data_provider, 'original_data, MP>(
    tableau: Tableau<'data_provider, AdaptedMatrixProvider<'original_data, MP>>,
) {
    let _: AdaptedMatrixProvider<'original_data, MP> = tableau.provider().clone_with_extra_bound();
}

Error before uncommenting the lifetime:

error[E0623]: lifetime mismatch
  --> src/lib.rs:28:56
   |
26 |     tableau: Tableau<'data_provider, AdaptedMatrixProvider<'original_data, MP>>,
   |              ------------------------------------------------------------------ these two types are declared with different lifetimes...
27 | ) {
28 |     let _: AdaptedMatrixProvider<'original_data, MP> = tableau.provider().clone_with_extra_bound();
   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...but data from `tableau` flows into `tableau` here

error: aborting due to previous error

[vandenheuvel]

This indeed solved my original problem. @stephaneyfx thanks for your reproduction of the issue and solution.

[estebank]

Under mir borrowck we get another extra error that gives a bit more info but is still unclear:

$ rustc file.rs -Zborrowck=mir
error: lifetime may not live long enough
  --> file.rs:28:12
   |
25 | fn create_and_solve_subproblems<'data_provider, 'original_data, MP>(
   |                                 --------------  -------------- lifetime `'original_data` defined here
   |                                 |
   |                                 lifetime `'data_provider` defined here
...
28 |     let _: AdaptedMatrixProvider<'original_data, MP> = tableau.provider().clone_with_extra_bound();
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type annotation requires that `'data_provider` must outlive `'original_data`

error[E0597]: `tableau` does not live long enough
  --> file.rs:28:56
   |
25 | fn create_and_solve_subproblems<'data_provider, 'original_data, MP>(
   |                                                 -------------- lifetime `'original_data` defined here
...
28 |     let _: AdaptedMatrixProvider<'original_data, MP> = tableau.provider().clone_with_extra_bound();
   |            -----------------------------------------   ^^^^^^^ borrowed value does not live long enough
   |            |
   |            type annotation requires that `tableau` is borrowed for `'original_data`
29 | }
   | - `tableau` dropped here while still borrowed

error: aborting due to 2 previous errors

[BGR360]

Current output on the example above has only one error again. I then minimized it to the following equivalent code:

Playground

struct Foo<'a, A> {
    inner: &'a A,
}

struct Bar<'b, B> {
    inner: &'b B,
}

impl<'a, 'b, B> Foo<'a, Bar<'b, B>>
{
    fn inner(&self) -> &'a Bar</*'b,*/ B> {
        self.inner
    }
}

fn func<'a, 'b, B>(foo: Foo<'a, Bar<'b, B>>) {
    let _: &Bar<'b, B> = foo.inner();
}

error[E0623]: lifetime mismatch
  --> src/lib.rs:17:26
   |
16 | fn func<'a, 'b, B>(foo: Foo<'a, Bar<'b, B>>) {
   |                         ------------------- these two types are declared with different lifetimes...
17 |     let _: &Bar<'b, B> = foo.inner();
   |                          ^^^^^^^^^^^ ...but data from `foo` flows into `foo` here

[estebank]

Triage: we have two errors again:

error: lifetime may not live long enough
  --> src/lib.rs:28:12
   |
25 | fn create_and_solve_subproblems<'data_provider, 'original_data, MP>(
   |                                 --------------  -------------- lifetime `'original_data` defined here
   |                                 |
   |                                 lifetime `'data_provider` defined here
...
28 |     let _: AdaptedMatrixProvider<'original_data, MP> = tableau.provider().clone_with_extra_bound();
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type annotation requires that `'data_provider` must outlive `'original_data`
   |
   = help: consider adding the following bound: `'data_provider: 'original_data`

error[E0597]: `tableau` does not live long enough
  --> src/lib.rs:28:56
   |
25 | fn create_and_solve_subproblems<'data_provider, 'original_data, MP>(
   |                                                 -------------- lifetime `'original_data` defined here
...
28 |     let _: AdaptedMatrixProvider<'original_data, MP> = tableau.provider().clone_with_extra_bound();
   |            -----------------------------------------   ^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
   |            |
   |            type annotation requires that `tableau` is borrowed for `'original_data`
29 | }
   | - `tableau` dropped here while still borrowed

We don't point at line 10 still.

error: lifetime may not live long enough
  --> src/lib.rs:17:12
   |
16 | fn func<'a, 'b, B>(foo: Foo<'a, Bar<'b, B>>) {
   |         --  -- lifetime `'b` defined here
   |         |
   |         lifetime `'a` defined here
17 |     let _: &Bar<'b, B> = foo.inner();
   |            ^^^^^^^^^^^ type annotation requires that `'a` must outlive `'b`
   |
   = help: consider adding the following bound: `'a: 'b`

error[E0597]: `foo` does not live long enough
  --> src/lib.rs:17:26
   |
16 | fn func<'a, 'b, B>(foo: Foo<'a, Bar<'b, B>>) {
   |             -- lifetime `'b` defined here
17 |     let _: &Bar<'b, B> = foo.inner();
   |            -----------   ^^^^^^^^^^^ borrowed value does not live long enough
   |            |
   |            type annotation requires that `foo` is borrowed for `'b`
18 | }
   | - `foo` dropped here while still borrowed

I'm surprised that we don't even have a warning about referring to Bar without a lifetime.