VWT functions and when to use them

[NSExceptional]

Echo's VWT exposes the following functions:

typealias P = UnsafeMutableRawPointer

/// Given a buffer an instance of the type in the source buffer, initialize
/// the destination buffer with a copy of the source.
public func initializeBufferWithCopyOfBuffer(_ dest: P, _ source: P)

/// Given an invalid instance of this type and a valid instance of this type,
/// copy the source instance into the destination.
public func initializeWithCopy(_ dest: P, _ source: P)

/// Given a valid instance of this type and another valid instance of this
/// type, copy the contents from the source into the destination.
public func assignWithCopy(_ dest: P, _ source: P)

/// Given an invalid instance of this type and a valid instance of this type,
/// initialize the destination by destroying the source instance.
public func initializeWithTake(_ dest: P, _ source: P)

/// Given a valid instance of this type and another valid instance of this
/// type, copy the contents from the source instance into the destination
/// while also destroying the source instance.
public func assignWithTake(_ dest: P, _ source: P)

Right now, my biggest source of confusion is the difference between assign and initialize. I understand the difference between copy and take, though whether I know which one to use at any given time is another question.

Consider the following scenario: I have a non-POD and I want to store it in space I've just allocated for an object, struct, or enum payload. I currently have a pointer to whatever instance it is I'm populating, and I have the value I want to store as Any. To actually store that value, I will have to extract it with AnyExistentialContainer.projectValue() and that is why I need to call one of these functions; because the references in that value won't be retained by the compiler when I do this.

Let's look at my helper function for constructing an instance of a struct, given a dictionary of key-value pairs:

extension StructMetadata {

    func createInstance(props: [String: Any] = [:]) -> Any{
        var box = AnyExistentialContainer(metadata: self)

        for (key, value) in props {
            let fieldType = self.fieldType(for: key)!
            if !fieldType.vwt.flags.isPOD {
                /* Use one of the above functions to perform the copy here */
            } else {
                // box.getValueBuffer() will automatically call
                // allocateBoxForExistential as needed
                self.set(value: value, forKey: key, pointer: box.getValueBuffer())
            }
        }
        
        return box.toAny // unsafeBitCast(box, to: Any.self)
    }
}

I have three questions:

1. Which function do I need to use for this scenario?
2. It is my understanding that if what I want to copy or initialize is a POD that I don't really need to use any of these functions; I can just do a plain-old memcpy() or equivalent operation, as in the else branch in my code above. Is that correct?
3. Are the following guesses about how each function works correct?
   • initializeBufferWithCopyOfBuffer: basically just memcpy; no retain operations
   • initializeWith____: since dest is invalid, no need to release the contents of dest
   • assignWith____: dest is valid, so the contents will be properly released
   • ______WithCopy: we will end up with two copies of the contents of source, so we must retain them
   • ______WithTake: we are just moving the contents of source, so we do not retain them

[Azoy]

The idea of the VWT functions is that they do the necessary retain/releases for us, so we don't need to do any of that. initialize will make an invalid destination valid, and assign will take a valid destination and make it a copy/will take the value from the source. The original value in destination before the assign will do whatever cleanup is required in the VWT function.

1. I would model your function like so:

extension StructMetadata {
    func createInstance(props: [String: Any] = [:]) -> Any {
        var box = AnyExistentialContainer(metadata: self)

        for (i, record) in descriptor.fields.records.enumerated() {
            guard let value = props[record.name] else {
                fatalError("Cannot initialize a struct without property")
            }

            var valueBox = container(for: value)
            vwt.initializeWithCopy(box.getValueBuffer() + fieldOffsets[i], valueBox.projectValue())
        }
        
        return box.toAny
    }
}

2. AFAIK yes, but it's still encouraged that you use the VWT function anyways for uniformity and safety.