• 如果可能，寻找专门的 API。例如，可以使用 .entry() API 来实现 get_or_insert() 示例

  #![forbid(unsafe_code)]
  use ::std::{
      collections::HashMap,
  };
  
  fn get_or_insert (
      map: &'_ mut HashMap<u32, String>,
  ) -> &'_ String
  {
      map.entry(22).or_insert_with(|| String::from("hi"))
  }
  

  遗憾的是，现实是您并不总是可以随时使用这样的便利 API。

• 否则，您可以执行连续的非习惯性查找，以避免借用时间过长

  #![forbid(unsafe_code)]
  use ::std::{
      collections::HashMap,
  };
  
  fn get_or_insert (
      map: &'_ mut HashMap<u32, String>,
  ) -> &'_ String
  {
      // written like this to show the "transition path" from previous code
      let should_insert =
          if let Some(_discarded) = map.get(&22) {
              false
          } else {
              true
          }
      ;
      // but `should_insert` can obviously be shortened down to `map.get(&22).is_none()`
      // or, in this very instance, to `map.contains_key(&22).not()`.
      if should_insert {
          map.insert(22, String::from("hi"));
      }
      map.get(&22).unwrap() // or `&map[&22]`
  }
  

• 最后，关于“这种情况只发生在具体的命名生命周期”的问题，一个巧妙但麻烦的非 unsafe 的方法来规避限制是使用 CPS / 回调 / 作用域 API

  #![forbid(unsafe_code)]
  use ::std::{
      collections::HashMap,
  };
  
  fn with_get_or_insert<R> (
      map: &'_ mut HashMap<u32, String>,
      yield_:     impl FnOnce(
  /* -> */ &'_ String
                  ) -> R ) -> R
  {
      if let Some(v) = map.get(&22) {
          yield_(v)
      } else {
          map.insert(22, String::from("hi"));
          yield_(&map[&22])
      }
  }
  

虽然您应该首先尝试这些解决方案并看看它们如何适用于您的代码库，但有时它们不适用或与“一点 unsafe”相比过于麻烦。

在这种情况下，与所有已知的、被认为是安全的 unsafe 模式一样，理想的解决方案是将它分解成一个自己的小型且易于审查的 crate 或模块，然后使用因此公开的非 unsafe fn API 👌。

所以，回到那个“安全封装”的想法

1. 让我们找到一个已知的、被认为是合理的、在 Polonius 下被接受的借用检查器问题的规范实例；

2. 然后对其进行调整，使其可以作为大多数这些问题的通用工具进行重用。

如果我们仔细观察上面的借用检查器问题，我们可以看到有两个定义性的成分

• 一个显式的泛型生命周期参数（可能被省略）；
• 一个分支，其中一个分支基于那个借用返回，而另一个则不再关心它。

问题在于第二个分支应该能够重新获得在第一个分支中借用的东西的访问权，但当前的借用检查器拒绝了它。

这就是我们在正确的时刻撒一些正确位置的 unsafe，让“借用检查器看看别处”的时候。

因此，我们首先用伪代码给出（

fn polonius<'r, T> (
    borrow: &'r mut T,
    branch:
        impl // generic type to apply to all possible scopes.
        for<'any> // <- higher-order lifetime ensures the `&mut T` infected with it…
        FnOnce(&'any mut T)      // …can only escape the closure…
                    // vvvv        … through its return type and its return type only.
          -> Option< _<'any> > // <- The `Some` / `None` discriminant represents the branch info.
                  // ^^^^^^^
                  // some return type allowed to depend on `'any`.
                  // For instance, in the case of `get_or_insert`, this could
                  // have been `&'any String` (or `Option<&'any String>`).
                  // Bear with me for the moment and tolerate this pseudo-code.
    ,
) -> Result< // <- we "forward the branch", but with data attached to the fallback one (`Err(…)`).
        _<'r>, // <- "plot twist": `'any` above was `'r` !
        &'r mut T, // <- through Arcane Magic™ we get to transmute the `None` into an `Err(borrow)`
    >
{
    let tentative_borrow = &mut *borrow; // reborrow
    if let Some(dependent) = branch(tentative_borrow) {
        /* within this branch, the reborrow needs to last for `'r` */
        return Ok(dependent);
    }
    /* but within this branch, the reborrow needs to have ended: only Polonius supports that kind of logic */

    // give the borrow back
    Err(borrow) // <- without Polonius this is denied
}

此函数忽略伪代码中未指定泛型返回类型 _<'…>，确实代表了借用检查器问题的一个规范示例（如果没有 -Zpolonius，它将拒绝 Err(borrow) 行，表明 borrow 需要借用以供 'r 使用，并且 'r 的范围延伸到函数的任何结束处（借用检查器错误）。

而使用 -Zpolonius 时，它会被接受。

• 演示

神秘的魔法™

在此正确使用 unsafe，以缓解 -Zpolonius 缺少的不足，是将

let tentative_borrow = &mut *borrow; // reborrow

改为

let tentative_borrow = unsafe { &mut *(borrow as *mut _) }; // reborrow

其中 unsafe { &mut *(thing as *mut _) } 是执行 借用生命周期 扩展 的规范方法：该 &mut 借用的生命周期不再以任何方式与 'r 或 *borrow 绑定。

• 有些人可能会被诱惑使用 mem::transmute。虽然这确实有效，但它是一个更灵活的 API，在 unsafe 的情况下，这意味着它是一个更危险的 API。例如，使用 transmute 时，如果借用对象有自己的生命周期参数，这些参数也可能被擦除，而降级到指针再升级回引用的操作仅保证“擦除”借用的外部生命周期，而内部类型保持不变：这更安全。

借用检查器不再牵着我们的手，在重叠使用 borrow 和 tentative_borrow 方面（这将导致未定义行为）。现在必须由我们确保没有任何运行时路径可以导致这样的借用重叠。

确实如此，正如简单的分支所展示的

• 在 Some 分支中，dependent 仍然借用 tentative_borrow，因此，*borrow。但在此分支中，我们不再使用 borrow，并且在调用者体中也不使用，只要使用 dependent。实际上，在签名上，我们确实表明该 dependent 返回值，其类型为 _<'r>，是从 *borrow 借用的，因为那个 'r 名称的重复。

• 在 None 分支中，没有 dependent，并且不再使用 tentative_borrow，因此可以再次引用 borrow。

换句话说

虽然这是 unsafe，但 't 中确实存在 正确性。

为了额外的预防措施，这个crate甚至通过一个cfg-opt-out来保护对unsafe的使用，这样当使用-Zpolonius时，unsafe会被移除，同时函数的主体以及其签名都可以正常编译（这一点在CI中通过一个特殊的test得到了进一步强化）。

将其推广

Option<T<'_>>变成了PoloniusResult<T<'_>, U>

//! In pseudo-code:
fn polonius<'r, T, Ret : <'_>> (
    borrow: &'r mut T,
    branch: impl FnOnce(&'_ mut T) -> PoloniusResult<Ret<'_>, ()>,
) -> PoloniusResult<
        Ret<'r>,
        (), &'r mut T,
    >

// Real code!
use ::polonius_the_crab::{ForLt, PoloniusResult};

fn polonius<'input, T, Ret : ForLt> (
    borrow: &'input mut T,
    branch: impl for<'any> FnOnce(&'any mut T) -> PoloniusResult< Ret::Of<'any>, ()>,
) -> PoloniusResult<
        Ret::Of<'input>,
        (), &'input mut T,
    >
# { unimplemented!(); }

# use ::polonius_the_crab::ForLt;
#
/// Invalid code for our API:
/// It is not `StringRefNaïve` which is a type, but `StringRefNaïve<'smth>`
/// (notice the mandatory "early fed" generic lifetime parameter).
type StringRefNaïve<'any> = &'any String;

/// Correct code: make `StringRef` a fully-fledged stand-alone type!
type StringRef = ForLt!(<'any> = &'any String);

// Note: the macro supports lifetime elision, so as to be able to instead write:
type StringRef2 = ForLt!(&String); // Same type as `StringRef`!