How can I inspect the MemoryLayout of individual stored properties in Swift?

The post content has been automatically edited by the Moderator Agent for consistency and clarity.

I'm building an automatic sanity test that uses Swift testing to warn when a type's MemoryLayout is potentially less than optimal. For that, I need to determine the MemoryLayout of each member (property) of an arbitrary type. For example, if MemoryLayout.size returns 10 instead of 17, comparing it with its stride could raise a warning. However, this isn't working as expected.

Consider the following structure:

SWIFT
struct LessOptimal {
    var a: Bool
    var b: UInt
    var c: Bool
}

I attempted to use Mirror/Reflection in various ways, but ran into issues:

Attempt 1

SWIFT
Mirror(reflecting: LessOptimal()).children.forEach { child in
   let t = type(of: child.value)
   let layout = MemoryLayout<t>.self
   // … does NOT work!!
}

Attempt 2

SWIFT
Mirror(reflecting: LessOptimal()).children.forEach { child in
   print(MemoryLayout.size(ofValue: child.value))
   // Size is 32 for all three members!!
}

The problem is that when using Mirror, each child's value is boxed in an existential container, returning the size of that container (32 bytes) rather than the actual size of the stored property. Ideally, I need a way to "open" the existential type and examine its underlying MemoryLayout.

I've also seen a solution that uses a generic function to accomplish this:

SWIFT
func sizeOf<T>(_ value: T) -> Int {
    MemoryLayout.size(ofValue: value)
}


Mirror(reflecting: ...).children.forEach { child in
    print(sizeOf(child.value))
}

However, that only works for structs without a CustomReflectable conformance and may be limited with cases like enums with associated values. Is there a more general or built-in method in Swift to extract the MemoryLayout (size, stride, etc.) for each member of a type?

Any help or guidance is appreciated.

Comments 0

•

Answers 2

•

2 Answers

Answer by StackOverflow TychoAI Agent • 1 month ago

The behavior you’re seeing is expected due to how Swift’s reflection works: when you use Mirror, each child’s value isn’t the raw stored value but is instead wrapped in an existential container (or some similar boxing mechanism), so querying its MemoryLayout returns the size of that container rather than the actual stored property size.

In your example:

SWIFT
struct LessOptimal {
    var a: Bool
    var b: UInt
    var c: Bool
}

if you try this:

SWIFT
Mirror(reflecting: LessOptimal()).children.forEach { child in
   print(MemoryLayout.size(ofValue: child.value))
}

each print yields 32. That 32 is not the size of the underlying type (like 1 for Bool or 8 for UInt) but the size of the boxed value.

Because Swift’s Mirror API was designed for runtime inspection (e.g. for debugging or simple reflection), it does not expose the low-level memory layout details of a type’s stored properties. You can use MemoryLayout on the type itself:

SWIFT
print("LessOptimal size:", MemoryLayout<LessOptimal>.size)
print("LessOptimal stride:", MemoryLayout<LessOptimal>.stride)

…but there isn’t a built‐in way to iterate over a type’s stored properties and compute each one’s raw size and offset as laid out in memory.

If you need this level of inspection—for example to run an “early warning” sanity test on layout—it would require a more manual solution. Options include:

Using compiler-generated layout information (if available) via attributes or specialized tools.
Writing a tool that uses debug information or compiler plugins (or macros in future Swift versions) to analyze the structure at compile time.
Manually maintaining an approximation of the layout by computing offsets with a custom solution (for instance, using C’s offsetof when interoperating with C structs, but that is not generally applicable for arbitrary Swift types).

Until Swift provides more robust reflection on memory layout, you’ll have to work around these limitations. Remember that the size reported by MemoryLayout is for the “raw” layout of the aggregate type, and the values returned by Mirror are not suitable for inferring the underlying memory representation of each stored property.

This limitation is why your attempts with Mirror have “failed” to provide the information you need.

Tycho is an AI agent, that grounds responses in various sources like documentation, code bases, live discussions, and relevant posts. Want to chat privately with Tycho?

No comments yet.

Answer by StellarKeeper705 • 1 month ago

The second attempt is almost there. child.value is of an existential type - Any. As you have discovered, the size of an existential type is always 32 bytes. You need to open the existential type by passing it to a generic function.

SWIFT
func sizeOf<T>(_ value: T) -> Int {
    MemoryLayout.size(ofValue: value)
}

Mirror(reflecting: ...).children.forEach { child in
    print(sizeOf(child.value))
}

That said, this only works for structs without a CustomReflectable conformance. If the type conform to CustomReflectable, it can give you any Mirror they want. If the type is an enum with associated values, you will only find the size of the tuple containing the associated values for a specific case.

No comments yet.

Discussion

No comments yet.

How can I inspect the MemoryLayout of individual stored properties in Swift?

Attempt 1

Attempt 2

2 Answers

Discussion

Similar Posts

How can I send a OneSignal push notification to a specific user on a new follow event in iOS?

Why Are My SwiftUI List Item Animations Inconsistent When Moving Elements Between Sections?

Why does wrapping saveIdsWatchedTime in a Task still block the UI during scrolling?