The protocol witness tables aren't compatible; they chain by reference rather than putting one inside the other.

@belkadan ah thanks! In other words, we need the allocation+copy in this case as what will need to happen is really (in pseudo-code)

foo(arrayOfSubPWTs.map { $0.superPWT })

Or do you see any way of not doing that? In theory, it'd be possible to see that this is a unique reference to the array and replace the PWTs in-place rather than alloc+copy but I don't know enough to judge if that's possible or not.

We don't really consider related protocols to have related representations today, but I suppose they could. They're all "existential box + witness table reference".

That said, you're calling this thing in a loop, which means it has to keep the original array around anyway to do the conversion again. You'd only get the optimization in the "last use" case.

yes, @belkadan, you're right. I put it in a loop so I can dtrace it easier 🙂. But I guess this program might be a better test case?

import Darwin

protocol Super {}

protocol Sub: Super {}

struct Foo: Sub {}

@inline(never)
func foo(_ supers: [Super]) {
}

@inline(never)
func CHECK_ALLOCATIONS_HERE(_ things: [Sub]) {
    foo(things)
}

CHECK_ALLOCATIONS_HERE([Foo(), Foo(), Foo(), Foo()]) // prime it

close(0xcafe) // just a dummy for the dtrace script
CHECK_ALLOCATIONS_HERE([Foo(), Foo(), Foo(), Foo(), Foo()])
close(0xdead) // just a dummy for the dtrace script

which results in

$ swiftc -O test.swift && sudo dtrace -n 'syscall::close:entry / pid == $target && arg0 == 0xcafe / { printf("go"); running = 1; } pid$target::malloc:entry / running == 1 / { @malloc_calls[ustack()] = count(); } syscall::close:entry / pid == $target && arg0 == 0xdead / { running = 0; } ::END { printa(@malloc_calls); }' -c ./test
dtrace: description 'syscall::close:entry ' matched 7 probes
dtrace: pid 91538 has exited
CPU     ID                    FUNCTION:NAME
  2    164                      close:entry go
  0      2                             :END 

              libsystem_malloc.dylib`malloc
              libswiftCore.dylib`swift_slowAlloc+0x19
              libswiftCore.dylib`_swift_allocObject_(swift::TargetHeapMetadata<swift::InProcess> const*, unsigned long, unsigned long)+0x14
              test`specialized ContiguousArray.reserveCapacity(_:)+0xc3
              test`specialized _arrayForceCast<A, B>(_:)+0x39
              test`CHECK_ALLOCATIONS_HERE(_:)+0x17
              test`main+0x18b
              libdyld.dylib`start+0x1
              test`0x1
                1

so as expected, it doesn't apply that optimisation and allocates.

@swift-ci create

Drive by comment that the way to fix this is to remove this implicit conversion completely.