There's a buggy SIL verifier check that was previously tautological,
and it turns out that it's violated, apparently harmlessly. Since it
was already doing nothing, I've commented it out temporarily while
I figure out the right way to fix SILGen to get the invariant right.
This value witness function takes an address of an enum value where the
payload has already been initialized, together with a case index, and
forms the enum value.
The formal behavior can be thought of as satisfying an identity in
relation to the existing two enum value witnesses. For any enum
value, the following is to leave the value unchanged:
tag = getEnumTag(value)
destructiveProjectEnumData(value)
destructiveInjectEnumData(value, tag)
This is the last missing piece for the inject_enum_addr SIL instruction
to handle resilient enums, allowing the implementation of an enum to be
decoupled from its uses. Also, it should be useful for dynamically
constructing enum cases with write reflection, once we get around to
doing such a thing.
The body of the value witness is emitted by a new emitStoreTag() method
on EnumImplStrategy. This is similar to the existing storeTag(), except
the case index is a value instead of a contant.
This is implemented as follows for the different enum strategies:
1) For enums consisting of a single case, this is trivial.
2) For enums where all cases are empty, stores the case index into the
payload area.
3) For enums with a single payload case, emits a call to a runtime
function. Note that for non-generic single payload enums, this could
be open-coded more efficiently, but the function still has the
correct behavior since it supports extra inhabitants and so on.
A follow-up patch will make this more efficient.
4) For multi-payload enums, there are two cases:
a) If one of the payloads is generic or resilient, the enum is
dynamically-sized, and a call to a runtime function is emitted.
b) If the entire enum is fixed-size, the value witness checks if
the case is empty or not.
If the case has a payload, the case index is swizzled into
spare bits of the payload, if any, with remaining bits going
into the extra tag area.
If the case is empty, the case index is swizzled into the
spare bits of the payload, the remaining bits of the payload,
and the extra tag area.
The implementations of emitStoreTag() duplicate existing logic in the
enum strategies, in particular case 4)b) is rather complicated.
Code cleanups are welcome here!
docs/archive/LangRef.html is flagged as unmaintained, but I didn't see
much else about optionals in the docs so why not update it now.
`emitPreconditionOptionalHasValue` had the switch logic moved from the
standard library to lib/SILGen/SILGenConvert.cpp back in 9c7417edc2
and there's no _preconditionOptionalHasValue intrinsic anymore. Updated
the comment in the headers to clarify.
While reading the documentation, I found out that the
`StringLiteralConvertible` and `_BuiltinStringLiteralConvertible`
protocols where not present anymore inside the `Policy.swift`
source code file. They are now defined inside the
`CompilerProtocols.swift` source code file.
This commit optimizes the images available in the
docs folder in order to save on bandwidth and
also decrease page loading time.
Images updated:
- docs/Array.png
- docs/ArrayBridge.png
- docs/ArrayCast.png
- docs/ArrayImplementation.png
- docs/ContiguousArray.png
- docs/Slice.png
