Home

Types

• ContextDescriptorKind: A discriminator to determine what type of context a descriptor is.
• FieldDescriptor.Kind: A discriminator to determine what type of context this field descriptor is describing.
• GenericParameterKind: A discriminator to determine what type of parameter a generic parameter is.
• GenericRequirementKind: A discriminator to determine what kind of requirement a generic requirement is.
• GenericRequirementLayoutKind: A discriminator to determine what layout a layout requirement has.
• MethodDescriptor.Kind: A discriminator to indicate what kind of method a method descriptor is.
• ProtocolRequirement.Kind: A discriminator to determine what kind of protocol requirement this is.
• ReferenceStorageKind: A discriminator to determine what kind of reference storage modifier a field is.
• MetadataInitializationKind: A discriminator to determine what kind of initialization this metadata goes through, if any.
• TypeReferenceKind: The type of reference this is to some type.
• GenericPackKind: The kind of generic argument pack described by a pack-shape descriptor.
• GenericValueType: The representation of a value generic parameter.
• ExtendedExistentialTypeShape.SpecialKind: The existential value representation selected by its shape.
• FunctionMetadata.DifferentiabilityKind: The automatic-differentiation kind encoded in function metadata.
• MetadataKind: A discriminator that determines what type of metadata this is.
• MetadataState: The public and current state of a metadata record.
• SpecialProtocol: A discriminator to determine the special protocolness of an existential.
• FunctionConvention: A discriminator to determine what calling convention a function has.
• ValueOwnership: A discriminator to determine what the ownership rules are (currently) for a function parameter.
• PackLifetime: The allocation lifetime encoded in a runtime metadata or witness-table pack pointer.
• GenericArgument: One word in a generic metadata argument layout.
• JobKind: A schedulable Swift-concurrency job kind.
• JobPriority: A Swift-concurrency job priority.
• TaskStatusRecordKind: A kind of dynamic task-status record.
• TaskOptionRecordKind: A kind of record passed while creating an asynchronous task.
• ContinuationStatus: The lifecycle state of an async continuation.
• KeyPathComponentHeader.Kind: Component representations defined by the Swift key-path ABI.
• KeyPathComponentHeader.StoredOffsetKind: Physical storage forms for a stored-property offset.
• KeyPathComponentHeader.OptionalOperation: Optional operations encoded by optional key-path components.
• KeyPathComponentHeader.ComputedPropertyKind: Access forms for computed key-path components.
• KeyPathComponentHeader.ComputedIdentifierKind: Identifier representations for computed key-path components.
• KeyPathComponentHeader.ComputedIdentifierResolution: Identifier resolution states for computed key-path components.
• KnownMetadata
• KnownMetadata.Builtin
• AnonymousDescriptor: An anonymous descriptor describes a context which is anonymous, like a function or a private declaration will have an anonymous parent context.
• ClassDescriptor: A class descriptor that descibes some class context.
• VTableDescriptorHeader: Structure that helps in determining where the vtable for a class is within the type metadata and how many vtable entries there are.
• MethodDescriptor: Structure that describes a class or protocol method.
• OverrideTableHeader: Structure that tells the number of method override entries in a class descriptor.
• MethodOverrideDescriptor: A method override descriptor describes the method being overriden from what class.
• DefaultOverrideTableHeader: Header for a table of default method override records.
• MethodDefaultOverrideDescriptor: A default method override inherited by subclasses that do not provide an implementation of their own.
• MetadataBounds: Bounds for metadata objects.
• AnonymousDescriptor.Flags: The specific flags that describe an anonymous descriptor.
• ContextDescriptorFlags: The flags which describe a context descriptor.
• FieldRecord.Flags: The flags which describe a field record.
• GenericMetadataPattern.Flags: Flags that describe this generic metadata pattern.
• GenericParameterDescriptor: The flags that describe a generic parameter.
• GenericRequirementDescriptor.Flags: The flags that describe a generic requirement.
• MethodDescriptor.Flags: Flags that describe a method descriptor.
• ProtocolDescriptor.Flags: The flags that describe a protocol descriptor.
• ProtocolRequirement.Flags: The flags that describe a protocol requirement.
• TypeContextDescriptorFlags: The flags which describe a type's context descriptor.
• ExtraClassDescriptorFlags: Extra flags stored in a class descriptor when it has a resilient superclass.
• EnumDescriptor: An enum descriptor that describes some enum context.
• ExtensionDescriptor: An extension descriptor that describes some extension context.
• FieldDescriptor: A special descriptor that describes a type's fields.
• FieldRecord: A record that describes a single stored property or an enum case.
• GenericContext: A generic context describes the generic information about some generic context.
• GenericContextDescriptorFlags: Flags describing modern generic-context trailing records.
• GenericPackShapeHeader: Header preceding a generic context's pack-shape descriptors.
• GenericPackShapeDescriptor: Describes one metadata or witness-table pack and its shape equivalence class.
• GenericValueHeader: Header preceding the descriptors for value generic parameters.
• GenericValueDescriptor: Describes one value generic parameter.
• GenericRequirementDescriptor: This descriptor describes any generic requirement in either a generic context or in a protocol's requirement signature.
• TypeGenericContext: A type generic context is an extension of a generic context for contexts that define some type in Swift. Currently that includes structs, classes, and enums. While protocols do define a type, they aren't considered type contexts.
• GenericMetadataPattern: An instantiation pattern for metadata.
• GenericValueMetadataPattern: A typed generic-metadata pattern for structs and enums.
• GenericClassMetadataPattern: A typed generic-metadata pattern for classes.
• GenericMetadataPartialPattern: A compact relative copy pattern embedded in a typed generic metadata pattern.
• ModuleDescriptor: A module descriptor that describes some Swift module.
• OpaqueDescriptor: Represents a descriptor for an opaque type.
• ProtocolDescriptor: A protocol descriptor that describes some protocol context.
• ProtocolRequirement: A protocol requirement that is defined in some protocol.
• StructDescriptor: A struct descriptor that describes some structure context.
• ForeignMetadataInitialization: Structure that contains the completion function for initializing singleton foreign metadata.
• SingletonMetadataInitialization: Structure that contains information needed to perform initialization of singleton value metadata.
• ResilientClassMetadataPattern: The allocation pattern used by a non-generic class with resilient ancestry.
• TypeImportInfo: Importer-provided identity data for a nominal type.
• ClassMetadata: The metadata structure that represents a class type in Swift.
• EnumMetadata: The metadata structure that represents an enum type in Swift.
• EnumValueWitnessTable: The value witness table for enums that have enum specific value witness functions.
• ExistentialMetadata: The metadata structure that represents some existential type, mainly protocols, in Swift.
• ExtendedExistentialMetadata: Metadata for a constrained existential such as any Collection<Int>.
• ExtendedExistentialTypeShape: The shape of a constrained existential type.
• ExtendedExistentialTypeShape.Flags: Flags for an extended existential shape.
• NonUniqueExtendedExistentialTypeShape: A compiler-emitted constrained-existential shape that the Swift runtime uniquifies before it creates metadata.
• GenericSignatureHeader: Header shared by a constrained existential's generic signatures.
• FixedArrayMetadata: Metadata for a Builtin.FixedArray type.
• ForeignReferenceTypeMetadata: Metadata for an imported non-Swift, non-Objective-C reference type.
• ForeignClassMetadata: The metadata structure that represents a foreign reference counted object from another language that Swift observes.
• FunctionMetadata: The metadata structure that represents a function type in Swift.
• ExtendedFunctionTypeFlags: Extended flags carried by some function types beyond FunctionMetadata.Flags.
• InvertibleProtocolSet: A set of invertible protocol requirements carried by a function type.
• HeapGenericLocalVariableMetadata: The metadata structure that represents generic boxes that are instantiated at runtime.
• HeapLocalVariableMetadata: The metadata structure that represents local variables that are heap allocated.
• UnknownMetadata: A metadata record whose enumerated kind is newer than Echo understands, or a runtime-private non-type record. Its raw word remains available through rawKind; type-only operations deliberately precondition-fail.
• MetadataAccessFunction: The Metadata Access Function is a special function within every type context descriptor that instantiates metadata of that type.
• MetadataRequest: A metadata request is a "request" to a runtime function that returns some metadata in some state, either blocking until the runtime can produce said metadata, or non-blocking returning an abstract metadata record.
• MetadataResponse: A metadata response is the return type for some runtime functions that either produce metadata or check it.
• MetadataTrailingFlags: Flags stored after the trailing data of a statically-specialized generic value metadata record.
• ClassMetadata.Flags: The flags that describe some class metadata.
• ExistentialMetadata.Flags: The flags that describe some existential metadata.
• FunctionMetadata.Flags: The flags that describe some function metadata.
• FunctionMetadata.ParamFlags: The flags that represent some function parameter.
• ValueWitnessTable.Flags: The flags that describe some value witness table.
• MetatypeMetadata: The metadata structure that represents a metatype wrapping some instance type.
• ObjCClassWrapperMetadata: The metadata structure that represents an Objective-C class that wasn't Swift compiled.
• OpaqueMetadata: The metadata structure that represents some opaque type in Swift. An opaque type might include a private structure, or perhaps some metadata for the various Builtin types in Swift.
• StructMetadata: The metadata structure that represents a struct type in Swift.
• TupleMetadata: The metadata structure that represents a tuple type in Swift.
• TupleMetadata.Element: The structure that represents a tuple element in some tuple metadata.
• MetadataPack: A runtime pack of type metadata used by variadic generic expansions.
• WitnessTablePack: A runtime pack of protocol witness tables used by variadic generic expansions.
• ValueWitnessTable: The value witness table is a table of function pointers that describe how to properly copy, destroy, etc. memory for a given type. It also contains type layout information about the type including size, stride, and alignment.
• TaskCreateFlags: Flags supplied when the runtime creates an asynchronous task.
• JobFlags: Flags stored on a schedulable job.
• TaskGroupFlags: Flags for a Swift task group.
• TaskStatusRecordFlags: Flags stored at the start of a task-status record.
• TaskOptionRecordFlags: Flags stored at the start of a task-creation option record.
• AsyncContinuationFlags: Flags supplied when initializing an async continuation.
• ConformanceDescriptor: A structure that helps describe a particular conformance in Swift. Information includes what type is being conformed to what protocol, some flags like if the conformance is retroactive, has conditional requirements, etc.
• ResilientWitness: A requirement and implementation pair in a resilient witness pattern.
• GenericWitnessTable: Instantiation layout information for a generic witness table.
• GlobalActorReference: The type and conformance used to isolate a conformance to a global actor.
• AnyExistentialContainer: An any existential container holds the necessary information for any value with type Any. I.e. the type erased type.
• ExistentialContainer: An existential container is a type in Swift that contains some struct or class with information of what the type it's containing is, and the witness tables needed that the existential (protocol) is.
• DualExistentialContainer: An existential container is a type in Swift that contains some struct or class with information of what the type it's containing is, and the witness tables needed that the existential (protocol) is. Dual supports an existential that is composed of two protocols. E.g. X & Y
• BoxPair: A box pair is the pair of heap object + value within said heap object. When you allocate a new box, you're given a pointer to the heap object along with a pointer to the value inside the heap object.
• HeapObject: Some object whose value is being stored on the heap and is being reference counted by the Swift runtime.
• DynamicReplacementScope: A scope containing the dynamic replacements an image registers together.
• DynamicReplacementDescriptor: One function replacement recorded in a dynamic replacement scope.
• DynamicReplacementKey: The dynamic-replacement key for one function or accessor.
• DynamicReplacementChainEntry: An entry in a dynamic replacement chain.
• OpaqueTypeReplacement: A replacement of one opaque (some) type descriptor by another.
• AccessibleFunction: A function record that the Swift runtime can locate by its mangled name.
• AccessibleFunctionFlags: Flags stored in an accessible-function record.
• GenericEnvironment: The generic signature data associated with an accessible function.
• GenericEnvironmentFlags: Flags stored in a generic-environment descriptor.
• KeyPathComponentHeader: The 32-bit header at the start of a Swift key-path component.
• ConformanceDescriptor.Flags: The flags that describe a conformance to a protocol for a type.
• WitnessTable: In its simpliest form, a witness table is simply a table of function pointers that fulfill the requirements a protocol imposes. Witness tables instruct exactly how a type conforms to a protocol and the functions needed to satisy a protocol requirement.
• RelativeWitnessTable: A protocol witness table whose entries use relative pointers.

Protocols

• ContextDescriptor: A context descriptor describes any entity in Swift that contains other types or contexts.
• TypeContextDescriptor: A type context descriptor is a context descriptor who defines some new type. This includes structs, classes, and enums. Protocols also define a new type, but aren't considered type context descriptors.
• ExistentialTypeMetadata: Common metadata surface for legacy and constrained existential types.
• Metadata: Metadata refers to the Swift metadata records in a given binary. All metadata records include a value witness table, which describe how to properly copy, destroy, etc. the memory of a type, along with a given "kind".
• TypeMetadata: Type metadata refers to those metadata records who declare a new type in Swift. Said metadata records only refer to structs, classes, and enums.

Global Typealiases

• ParameterOwnership: The ownership convention of a function parameter.

Global Functions

• reflect(_:​): The main entry point to grab type metadata from some metatype.
• reflect(_:​): The main entry point to grab type metadata from some instance.
• reflectClass(_:​): The main entry point to grab a class's metadata from some metatype that represents a class.
• reflectClass(_:​): The main entry point to grab a class's metadata from some instance.
• reflectEnum(_:​): The main entry point to grab an enum's metadata from some metatype that represents a enum.
• reflectEnum(_:​): The main entry point to grab a enum's metadata from some instance.
• reflectStruct(_:​): The main entry point to grab a struct's metadata from some metatype that represents a struct.
• reflectStruct(_:​): The main entry point to grab a struct's metadata from some instance.
• container(for:​): Given an Any value, return the container that represents the value.
• swift_allocBox(for:​)
• swift_allocBox(for:​)
• swift_allocObject(for:​size:​alignment:​): Allocates a new reference counted class instance.
• swift_getTypeName(for:​qualified:​): Gets the types name, either qualified (full name representation), or non qualified (just the type name).
• swift_getTypeName(for:​qualified:​): Gets the types name, either qualified (full name representation), or non qualified (just the type name).
• swift_conformsToProtocol(type:​protocol:​): Checks whether the type conforms to the given protocol.
• swift_conformsToProtocol(metadata:​protocol:​): Checks whether the type conforms to the given protocol.
• registerProtocols(section:​size:​)
• registerProtocolConformances(section:​size:​)
• findConformance(to:​): Finds a conformance descriptor for a given protocol by scanning all registered conformances in the binary.
• findConformance(toProtocolNamed:​): Finds a conformance descriptor for a protocol with the given name.
• registerTypeMetadata(section:​size:​)
• registerDynamicReplacementScopes(section:​size:​)
• registerOpaqueTypeReplacements(section:​size:​)
• registerAccessibleFunctions(section:​size:​)
• lookupSection(_:​segment:​section:​do:​)

Global Variables

• ptr: Backing existential metatype metadata pointer.
• instanceType: The existential instance type that this metatype wraps.
• instanceMetadata: The metadata for the existential instance type that this metatype wraps.
• flags: The flags specific to existential metadata.
• protocols: The list of all protocols this program has loaded.
• types: The list of all protocols this program has loaded.
• dynamicReplacementScopes: Dynamic-replacement scopes registered by the images currently loaded into this process. The scopes are read-only views; replacement activation remains the Swift runtime's responsibility.
• opaqueTypeReplacements: Opaque-type (some) descriptor replacements registered by loaded images.
• accessibleFunctions: Functions that Swift has made available for runtime lookup by mangled name.