Compiler fails to prevent accessing protocol extension members on consumed values

[rayx]

Description

After a value is consumed, it's still possible to access protocol extension members on it. This happens for both protocol required members and non-required members, as long as they are not shadowed by struct's own implemenations.

Reproduction

My original example:

func test() {
    let values = [1, 2, 3]
    var newValues = consume values
    newValues.append(4)
    
    //print(values.count) // this doesn't compile (as expected)
    //print(values[0]) // this doesn't compile (as expected)
    print(values.first!) // output: 1
    print(values.last!) // output: 3
}

User CrystDragon in Swift forums identified the general pattern to reproduce it:

protocol P {
    func bar() 
}
extension P {
    func bar() {}
    func baz() {}
}

struct A: P {
    let x: String = ""

    func foo() {}
}

func test() {
    let a = A()
    _ = consume a

    a.foo() // error, as expected
    a.bar() // no error, not as expected
    a.baz() // no error, not as expected
}

Expected behavior

Compile should produce error

Environment

$ swift --version
Swift version 6.2-dev (LLVM 5fbc818cf26c90b, Swift 2e18973)
Target: x86_64-unknown-linux-gnu
Build config: +assertions

Additional information

Just in case some people might think P.bar() works because P has no data requirement, compiler fails to generate diagnostic for the following code too.

protocol P {
    var x: String { get }
    func bar()
}

extension P {
    func bar() { print(x) }
}

struct A: P {
    let x: String = ""
}

func test() {
    let a = A()
    _ = consume a

    a.bar() // no error, not as expected
}

[jamieQ]

in case it helps, here are a few more variations involving global generic functions:

func consumeValue<V>(_ v: consuming V) { _ = consume v }
func borrowValue<V>(_ v: borrowing V) { _ = v }
func useValue<V>(_ v: V) { _ = v }

func consumeA(_ a: consuming A) { _ = consume a }
func borrowA(_ a: borrowing A) { _ = a }
func useA(_ a: A) { _ = a }

struct A {
    var prop = ""
}

func testLocalBindingUseAfterConsumeGenerics() {
    let a = A()
    _ = consume a
    // 👇 replacing the `_ = consume a` with this will cause no error
    // but if they are both present, the second consume will error
    // consumeValue(a)
    borrowValue(a)
    useValue(a)
}

func testLocalBindingUseAfterConsumeNoGenericFns() {
    let a = A() // error: 'a' used after consume
    _ = consume a   // note: consumed here

    // without the generic indirection, these all error:
    consumeA(a) // note: used here
    borrowA(a)  // note: used here
    useA(a)     // note: used here
}

func testParameterBinding(_ a: consuming A) { // error: 'a' used after consume
    _ = consume a   // note: consumed here
    // consumeValue(a) // consuming like this will also cause an error
    borrowValue(a)  // note: used here
    useValue(a)
}

[xwu]

Tagged with “regression” because the original example is correctly diagnosed in Swift 6.1 and earlier, though users point out that others are not, so possibly there are multiple issues here.

[tbkka]

I see why you find this surprising, but it is actually correct.

consumeValue(a) consumes the value that was passed to it. Since A is copyable, the caller is free to make extra copies as needed. In this case, when you use a after consumeValue(a), the compiler will make a copy and pass that to consumeValue() in order to allow your code to function.

_ = consume a is a special case that always forcibly ends the lifetime of a. That blocks the compiler from inserting a copy to satisfy later uses.

If you play with making A : ~Copyable, you'll see the behavior you expect, since that also blocks the compiler from inserting copies. You can also experiment with inout arguments. When calling a function with an inout parameter, the compiler also avoids making a copy because the purpose of such a function call is precisely to mutate the passed-in value.

[jamieQ]

@tbkka per the 'move function' evolution document:

consume ends the lifetime of a specific local let, local var, or function parameter, and enforces this by causing the compiler to emit a diagnostic upon any use after the consume.

in this case:

func testLocalBindingUseAfterConsumeGenerics() {
    let a = A()
    _ = consume a
    // 👇 replacing the `_ = consume a` with this will cause no error
    // but if they are both present, the second consume will error
    // consumeValue(a)
    borrowValue(a)
    useValue(a)
}

how are the calls to borrowValue() and useValue() not 'uses after the consume'?

[xwu]

@tbkka The original reported case is legitimate, afaict, and is a regression. To be concrete, the following compiles in 6.2 but not 6.1, and I am not sure why the language semantics would have changed in 6.2:

func test() {
    let values = [1, 2, 3]
    var newValues = consume values
    newValues.append(4)
    print(values.first!)
}

Swift 6.1 produces the expected diagnostic, which is now missing from nightlies or dev snapshot builds:

error: 'values' used after consume
1 | func test() {
2 |     let values = [1, 2, 3]
  |                  `- error: 'values' used after consume
3 |     var newValues = consume values
  |                     `- note: consumed here
4 |     newValues.append(4)
5 |     print(values.first!)
  |                  `- note: used here
6 | }

[jamieQ]

after looking into it a bit, it seems the regression may be due to the SILGen for some function calls having changed from producing a copy SIL instruction in the caller to a store_borrow in more recent compilers (well, in 6.2 at least – godbolt). the pass that is supposed to diagnose use after consume appears to possibly not handle store_borrow instructions at all (see this comment), and so it seems it fails to report these.

@tbkka i'm still wondering if you could confirm whether this behavior is erroneous, if you have a moment – thanks!