swift - 为什么嵌套的自捕获函数会干扰 isKnownUniquelyReferenced(_ :)?

Question

我试图在自定义集合中实现写时复制行为，这时我遇到了捕获 self 的嵌套函数的这种奇怪行为。

在下面的代码中，调用了isKnownUniquelyReferenced(_:)将始终返回 false，尽管在 甚至定义嵌套函数之前被调用:

class Foo {}

struct Bar {

    var foo = Foo()

    public mutating func bar() {

        print(isKnownUniquelyReferenced(&foo))

        func nestedFunc() {
            _ = self // capture self
        }
        nestedFunc()
    }
}

var b = Bar()
b.bar() // false ?!

到底为什么会这样，我能做些什么来解决它(假设 nestedFunc 实际上对 self 做了一些有用的事情)？

我知道 self 的捕获可能会干扰对 isKnownUniquelyReferenced(_:) 的调用——但肯定会在调用 时发生nestedFunc() 在这种情况下？

Answer 1

swift 3.1 更新

从 Xcode 8.3 beta 中可用的 Swift 3.1 开始，此问题已得到修复。 self在方法中根本不再装箱，因此 isKnownUniquelyReferenced(_:)返回 true正如预期的那样。

---

Swift 3.1 之前

我认为这是一个错误，并已提交错误报告 ( SR-3530 )。然而，我对这个问题的原因很感兴趣，所以进行了一些挖掘——这就是我的发现。

查看为 bar() 生成的规范 SIL方法(对于 -Onone 构建)显示 Swift 正在为 alloc_box 堆分配一个盒子( self )在方法的最开始——这样它就可以被nestedFunc()捕获.

// Bar.bar() -> ()
sil hidden @main.Bar.bar () -> () : $@convention(method) (@inout Bar) -> () {
// %0                                             // users: %10, %3
bb0(%0 : $*Bar):

  // create new heap-allocated box, and store self in it.
  // this is where the problem stems from – there are now two copies of the Bar instance, thus isKnownUniquelyReferenced will return false.
  %1 = alloc_box $Bar, var, name "self", argno 1, loc "main.swift":15:26, scope 9 // users: %11, %9, %7, %2
  %2 = project_box %1 : $@box Bar, loc "main.swift":15:26, scope 9 // users: %10, %5, %3
  copy_addr %0 to [initialization] %2 : $*Bar, scope 9 // id: %3

  // call isKnownUniquelyReferenced (I removed the print() function call as it generates a bunch of unrelated SIL).
  // function_ref isKnownUniquelyReferenced<A where ...> (inout A) -> Bool
  %4 = function_ref @Swift.isKnownUniquelyReferenced <A where A: Swift.AnyObject> (inout A) -> Swift.Bool : $@convention(thin) <τ_0_0 where τ_0_0 : AnyObject> (@inout τ_0_0) -> Bool, loc "main.swift":17:9, scope 10 // user: %6
  %5 = struct_element_addr %2 : $*Bar, #Bar.foo, loc "main.swift":17:35, scope 10 // user: %6
  %6 = apply %4<Foo>(%5) : $@convention(thin) <τ_0_0 where τ_0_0 : AnyObject> (@inout τ_0_0) -> Bool, loc "main.swift":17:39, scope 10

  // retain the heap-allocated box containing self, in preparation for applying nestedFunc() with it.
  // (as it's passed as an @owned parameter).
  strong_retain %1 : $@box Bar, loc "main.swift":27:9, scope 10 // id: %7

  // call the nested function with the box as the argument.
  // function_ref Bar.(bar() -> ()).(nestedFunc #1)() -> ()
  %8 = function_ref @main.Bar.(bar () -> ()).(nestedFunc #1) () -> () : $@convention(thin) (@owned @box Bar) -> (), loc "main.swift":27:9, scope 10 // user: %9
  %9 = apply %8(%1) : $@convention(thin) (@owned @box Bar) -> (), loc "main.swift":27:20, scope 10

  // once called, copy the contents of the box back to the address of the Bar instance that was passed into the method, and release the box.
  copy_addr %2 to %0 : $*Bar, scope 10            // id: %10
  strong_release %1 : $@box Bar, loc "main.swift":29:5, scope 10 // id: %11

  // so cute.
  %12 = tuple (), loc "main.swift":29:5, scope 10 // user: %13
  return %12 : $(), loc "main.swift":29:5, scope 10 // id: %13
}

^{( Full SIL here )}

由于这个装箱，现在有 两个 Bar 的副本bar() 中的实例方法，因此意味着 isKnownUniquelyReferenced(_:)将返回 false，因为有两个对 Foo 的引用实例。

据我所知，self 的拳击在方法的开头似乎是 mutating 优化的结果从复制输入复制输出的方法(self 在方法调用开始时被装箱，然后将突变应用于该盒子，然后在方法结束时写回被调用方)到按引用传递(这种优化发生在原始 SIL 和规范 SIL 之间。

用于创建 self 副本的同一个盒子现在使用方法内的变异来捕获self调用嵌套函数。我看不出为什么不应该在调用 nestedFunc() 之前创建捕获框，因为这是捕获 self 的合乎逻辑的位置(而不是在方法的开头)。

尽管无论如何，首先创建一个盒子是完全多余的，因为 nestedFunc()不会也不能逃脱。试图返回 nestedFunc()从该方法产生以下编译器错误:

Nested function cannot capture inout parameter and escape

所以它看起来真的只是一个尚未优化的极端情况。即使在 -O 构建中，尽管 Bar 的堆分配实例能够针对 foo 优化为堆栈分配属性，这仍然会导致对 Foo 的不必要的第二次引用实例。

---

解决方案

一个解决方案是只添加一个 inout self参数 nestedFunc() , 允许 self只是通过引用传递，而不是被捕获:

func nestedFunc(_ `self`: inout Bar) {
    _ = self // do something useful with self
}
// ...
nestedFunc(&self)

现在生成 SIL (-Onone):

// function_ref Bar.(bar() -> ()).(nestedFunc #1)(inout Bar) -> ()
%5 = function_ref @main.Bar.(bar () -> ()).(nestedFunc #1) (inout main.Bar) -> () : $@convention(thin) (@inout Bar) -> (), loc "main.swift":31:9, scope 10 // user: %6
%6 = apply %5(%0) : $@convention(thin) (@inout Bar) -> (), loc "main.swift":31:25, scope 10

此解决方案的优势在于它只是一种直接的按引用传递(因为 Bar 参数标记为 @inout )。因此，Bar 的实例只存在一个副本。 – 因此 isKnownUniquelyReferenced(_:)可以返回true。

另一种可能的解决方案，如果self未在 nestedFunc() 内发生突变, 就是通过 self按值，而不是引用。这可以通过本地闭包中的捕获列表来完成:

let nestedFunc = { [`self` = self] in // copy self into the closure.
    _ = self                          // the self inside the closure is immutable.
}
// ...
nestedFunc()

优点是你不需要显式传递任何东西到 nestedFunc()称呼。因为 Bar 的实例在创建闭包之前不会按值传递——它不会干扰对 isKnownUniquelyReferenced(_:) 的调用，假设调用先于闭包创建。