Fix type lowering of ~Copyable and ~Escapable generics.

[atrick]

Factor AbstractionPattern::conformsToKnownProtocol and lower ~Escapable using the same logic as ~Copyable.

Adds support for conditionally Escapable enums.

Correctly sets the SILType::isTrivial flags for conditionally escapable structs and enums in environments (extensions) that provide an Escapable conformance, such as:

struct NE<E: ~Escapable> : ~Escapable {}

extension NE: Escapable {
  func foo() -> Self {
    // Self is both Escapable and trivial here.
    self
  }
}

Fixes rdar://125950218 ([nonescapable] support conditionally escapable enums)

[atrick]

@swift-ci test

[slavapestov]

struct NE<E: ~Escapable> : ~Escapable {}

extension NE: Escapable {
  func foo() -> Self {
    // Self is both Escapable and trivial here.
    self
  }
}

I don't see a test case that covers this specific situation from your PR description -- how can we observe the triviality of self here?

[atrick]

struct NE<E: ~Escapable> : ~Escapable {}

extension NE: Escapable {
  func foo() -> Self {
    // Self is both Escapable and trivial here.
    self
  }
}

I don't see a test case that covers this specific situation from your PR description -- how can we observe the triviality of self here?

Joe already wrote tests to check triviality. I reused those by adding ~Escapable

struct MyStruct<T: ~Copyable & ~Escapable>: ~Copyable & ~Escapable
enum MyEnum<T: ~Copyable & ~Escapable>: ~Copyable & ~Escapable

// CHECK-LABEL: sil{{.*}} @{{.*}}13trivialStruct
func trivialStruct() -> Int {
    // CHECK: [[ALLOC:%.*]] = alloc_stack $MyStruct<Trivial>
    // CHECK-NOT: destroy_addr [[ALLOC]] :
    // CHECK: dealloc_stack [[ALLOC]] :
     return MemoryLayout.size(ofValue: MyStruct(x: Trivial.a))
}
// CHECK-LABEL: sil{{.*}} @{{.*}}11trivialEnum
func trivialEnum() -> Int {
    // CHECK: [[ALLOC:%.*]] = alloc_stack $MyEnum<Trivial>
    // CHECK-NOT: destroy_addr [[ALLOC]] :
    // CHECK: dealloc_stack [[ALLOC]] :
     return MemoryLayout.size(ofValue: MyEnum.x(Trivial.a))
}

struct MyAssortment {
    var a: MyStruct<Trivial>
    var b: MyEnum<Trivial>
}

// CHECK-LABEL: sil{{.*}} @{{.*}}4frob
func frob(x: MyAssortment) -> Int {
    // CHECK: [[ALLOC:%.*]] = alloc_stack $MyAssortment
    // CHECK-NOT: destroy_addr [[ALLOC]] :
    // CHECK: dealloc_stack [[ALLOC]] :
    return MemoryLayout.size(ofValue: x)
}

This raises a good point that I was planning to bring up. We have a fair amount of complexity in AbstractionPattern to recognize inverse protocols. But any of that logic could be wrong and we'll never find out about it, at least for ~Escapabe, because the only effect is to set SILType::isTrivial in more cases. If we fail to set isTrivial, codegen is likely still correct and we'll never notice. None of the diagnostics exercise this logic, so it could be inconsistent.

[atrick]

@nate-chandler I can't remove the remaining uses of canBeEscapable yet because TypeConverter::visitAggregateLeaves recursively evaluates interface types. This may be as simple as mapping them into a context, but I don't understand this well enough to do it. So, for example:

struct Boxx<each T : _BitwiseCopyable> {
  var ts: (repeat each T)
}

Here, TypeConverter::verifyTrivialLowering is asked to evaluate the type of the ts member, which is a pack type with interface types:

(pack_expansion_type
  (pattern=pack_archetype_type address=0x150962278 conforms_to="Swift.(file)._BitwiseCopyable" name="each T"
    (interface_type=generic_type_param_type depth=0 index=0 decl="testbitwisecopyable.(file).Boxx.T@./testbitwisecopyable.swift:15:18" pack))
  (count=pack_archetype_type address=0x150962278 conforms_to="Swift.(file)._BitwiseCopyable" name="each T"
    (interface_type=generic_type_param_type depth=0 index=0 decl="testbitwisecopyable.(file).Boxx.T@./testbitwisecopyable.swift:15:18" pack)))

That's not going to work with any type system queries, including AbstractionPattern::isNoncopyable or, in this PR, AbstractionPattern::conformsToKnownProtocol.

[nate-chandler]

@atrick Okay, I will address this in a follow-up.

[atrick]

@jckarter I included a fix for AbstractionPattern::isNoncopyable in this PR.

@nate-chandler I included several unit tests involving BitwiseCopyable which, ultimately, should result in trivial lowering. But it's not high enough priority to debug right now, so I left TODOs, which we may want to track in a bug report.

[atrick]

@swift-ci test

[nate-chandler]

@atrick As a reminder, having conformance to BitwiseCopyable imply SIL trivial when appropriate (not always) is already tracked by rdar://123661042 and is not a correctness issue.

[atrick]

This is currently blocked on a segfault in stdlib/ArrayTraps.swift.gyb on iphonesimulator-x86_64 which I haven't been able to reproduce locally

[atrick]

This passes for me locally with the same build-script invocation as CI:
lit ./validation-test-iphonesimulator-x86_64 --filter stdlib/ArrayTraps.swift.gyb -a

[atrick]

@swift-ci test

[atrick]

@swift-ci smoke test windows