原文链接：https://doc.rust-lang.org/nomicon/lifetime-mismatch.html

生命周期的局限

考虑下面的代码：

  1. struct Foo;
  3. impl Foo {
  4.     fn mutate_and_share(&mut self) -> &Self {&*self}
  5.     fn share(&self) {}
  6. }
  8. fn main() {
  9.     let mut foo = Foo;
  10.     let loan = foo.mutate_and_share();
  11.     foo.share();
  12. }

你可能觉得它能成功编译。我们调用mutate_and_share，临时可变地借用foo，但接下来返回一个共享引用。因为调用foo.share()时没有可变的引用了，所以我们认为可以正常调用。

但是当我们尝试编译它：

  1. <anon>:11:5: 11:8 error: cannot borrow `foo` as immutable because it is also borrowed as mutable
  2. <anon>:11     foo.share();
  3.               ^~~
  4. <anon>:10:16: 10:19 note: previous borrow of `foo` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `foo` until the borrow ends
  5. <anon>:10     let loan = foo.mutate_and_share();
  6.                          ^~~
  7. <anon>:12:2: 12:2 note: previous borrow ends here
  8. <anon>:8 fn main() {
  9. <anon>:9     let mut foo = Foo;
  10. <anon>:10     let loan = foo.mutate_and_share();
  11. <anon>:11     foo.share();
  12. <anon>:12 }
  13.           ^

发生了什么呢？嗯……我们遇到了和上一章的示例2相同的错误。我们去掉语法糖，会得到这样的代码:

  1. struct Foo;
  3. impl Foo {
  4.     fn mutate_and_share<'a>(&'a mut self) -> &'a Self { &'a *self }
  5.     fn share<'a>(&'a self) {}
  6. }
  8. fn main() {
  9.     'b: {
  10.         let mut foo: Foo = Foo;
  11.         'c: {
  12.             let loan: &'c Foo = Foo::mutate_and_share::<'c>(&'c mut foo);
  13.             'd: {
  14.                 Foo::share::<'d>(&'d foo);
  15.             }
  16.         }
  17.     }
  18. }

生命周期系统强行把&mut foo的生命周期扩展到’c，以和loan的生命周期以及mutate_and_share的签名匹配。接下来我们调用share，Rust认为我们在给&'c mut foo创建别名，于是拒绝了我们。

这段程序显然完全符合引用的语义，但是我们的生命周期系统过于粗糙，无法对它进行正确的分析。

接下来，还有什么普遍的问题吗？关于SEME区域的，大概吧？