Fix crashes & ABI drift to build on current Swift

.gitignore

@@ -7,3 +7,5 @@
 .build/
 .swiftpm/
 Package.resolved
+/Echo.xcodeproj
+/Project.swift

Package.swift

@@ -11,7 +11,7 @@ let package = Package(
     )
   ],
   dependencies: [
-    .package(url: "https://github.com/apple/swift-atomics.git", from: "0.0.1")
+    .package(url: "https://github.com/apple/swift-atomics.git", from: "1.0.0")
   ],
   targets: [
     .target(

Sources/Echo/ContextDescriptor/ContextDescriptorValues.swift

@@ -317,7 +317,12 @@ public struct TypeContextDescriptorFlags {
 
   /// The resilient superclass type reference kind.
   public var resilientSuperclassRefKind: TypeReferenceKind {
-    TypeReferenceKind(rawValue: UInt16(bits) & 0xE00)!
+    // The reference kind occupies a 3-bit field starting at bit 9, so it must
+    // be shifted down after masking — without the shift, any non-direct kind
+    // (e.g. the indirect reference used for a cross-module resilient
+    // superclass) produces a value like 0x200 that is not a valid
+    // TypeReferenceKind raw value and traps the force-unwrap.
+    TypeReferenceKind(rawValue: UInt16(bits & (0x7 << 9)) >> 9)!
   }
 
   /// Whether or not this class has any immediate members negative.

Sources/Echo/ContextDescriptor/GenericContext.swift

@@ -135,7 +135,7 @@ public struct GenericRequirementDescriptor: LayoutWrapper {
         and: UInt8.self
       )
     ).signed
-    return ProtocolDescriptor(ptr: ptr)
+    return ProtocolDescriptor(ptr: ptr!)
   }
 
   /// If this requirement is some layout (currently can only be a class),

Sources/Echo/Metadata/ClassMetadata.swift

@@ -21,9 +21,14 @@ public struct ClassMetadata: TypeMetadata, LayoutWrapper {
   public let ptr: UnsafeRawPointer
 
   /// The class context descriptor that describes this class.
-  public var descriptor: ClassDescriptor {
+  public var descriptor: ClassDescriptor? {
     precondition(isSwiftClass)
-    return ClassDescriptor(ptr: layout._descriptor.signed)
+
+    if let descriptorPtr = layout._descriptor.signed {
+        return ClassDescriptor(ptr: descriptorPtr)
+    }
+
+    return nil
   }
 
   /// The Objective-C ISA pointer, if it has one.
@@ -101,7 +106,11 @@ public struct ClassMetadata: TypeMetadata, LayoutWrapper {
 
   /// An array of field offsets for this class's stored representation.
   public var fieldOffsets: [Int] {
-    Array(unsafeUninitializedCapacity: descriptor.numFields) {
+    guard let descriptor = descriptor else {
+        return []
+    }
+
+    return Array(unsafeUninitializedCapacity: descriptor.numFields) {
       let start = ptr.offset(of: descriptor.fieldOffsetVectorOffset)
 
       for i in 0 ..< descriptor.numFields {

Sources/Echo/Metadata/MetadataAccessFunction.swift

@@ -247,7 +247,7 @@ func createMetadataAccessBuffer(
   // First loop is inserting the key arguments at the front of the buffer.
   for i in 0 ..< args.count {
     buffer.storeBytes(
-      of: args[0].0,
+      of: args[i].0,
       toByteOffset: ptrSize * i,
       as: Any.Type.self
     )

Sources/Echo/Metadata/TypeMetadata.swift

@@ -41,13 +41,17 @@ extension TypeMetadata {
     iterateSharedObjects()
     #endif
 
+    guard let contextDescriptorPtr = contextDescriptor?.ptr else {
+        return []
+    }
+
     return conformanceLock.withLock {
-      Echo.conformances[contextDescriptor.ptr, default: []]
+      Echo.conformances[contextDescriptorPtr, default: []]
     }
   }
 
   /// The base type context descriptor for this type metadata record.
-  public var contextDescriptor: TypeContextDescriptor {
+  public var contextDescriptor: TypeContextDescriptor? {
     switch self {
     case let structMetadata as StructMetadata:
       return structMetadata.descriptor
@@ -74,7 +78,7 @@ extension TypeMetadata {
     }
   }
 
-  var genericArgumentPtr: UnsafeRawPointer {
+  var genericArgumentPtr: UnsafeRawPointer? {
     switch self {
     case is StructMetadata:
       return ptr + MemoryLayout<_StructMetadata>.size
@@ -83,7 +87,10 @@ extension TypeMetadata {
       return ptr + MemoryLayout<_EnumMetadata>.size
 
     case let classMetadata as ClassMetadata:
-      return ptr.offset(of: classMetadata.descriptor.genericArgumentOffset)
+      guard let descriptor = classMetadata.descriptor else {
+        return nil
+      }
+      return ptr.offset(of: descriptor.genericArgumentOffset)
 
     default:
       fatalError("Unknown TypeMetadata conformance")
@@ -93,17 +100,17 @@ extension TypeMetadata {
   /// An array of types that represent the generic arguments that make up this
   /// type.
   public var genericTypes: [Any.Type] {
-    guard contextDescriptor.flags.isGeneric else {
+    guard let contextDescriptor = contextDescriptor,
+          contextDescriptor.flags.isGeneric,
+          // Explicitly only call this once because class metadata could require
+          // computation, so only do it once if needed.
+          let gap = genericArgumentPtr else {
       return []
     }
 
     let numParams = contextDescriptor.genericContext!.numParams
 
     return Array(unsafeUninitializedCapacity: numParams) {
-      // Explicitly only call this once because class metadata could require
-      // computation, so only do it once if needed.
-      let gap = genericArgumentPtr
-
       for i in 0 ..< numParams {
         let type = gap.load(
           fromByteOffset: i * MemoryLayout<Any.Type>.stride,
@@ -142,6 +149,10 @@ extension TypeMetadata {
       return entry!
     }
 
+    guard let contextDescriptor = contextDescriptor else {
+      return nil
+    }
+
     let length = getSymbolicMangledNameLength(mangledName)
     let name = mangledName.assumingMemoryBound(to: UInt8.self)
     let type = _getTypeByMangledNameInContext(

Sources/Echo/Metadata/ValueWitnessTable.swift

@@ -28,7 +28,7 @@ public struct ValueWitnessTable: LayoutWrapper {
   let ptr: UnsafeRawPointer
 
   var _vwt: _ValueWitnessTable {
-    layout.signed.load(as: _ValueWitnessTable.self)
+    layout.signed!.load(as: _ValueWitnessTable.self)
   }
 
   /// Given a buffer an instance of the type in the source buffer, initialize

Sources/Echo/Runtime/ConformanceDescriptor.swift

@@ -39,18 +39,22 @@ public struct ConformanceDescriptor: LayoutWrapper {
   /// The context descriptor of the type being conformed.
   public var contextDescriptor: TypeContextDescriptor? {
     let start = address(for: \._typeRef)
+    let ptr: UnsafeRawPointer?
 
     switch flags.typeReferenceKind {
     case .directTypeDescriptor:
-      let ptr = start.relativeDirectAddress(as: _ContextDescriptor.self)
-      return getContextDescriptor(at: ptr) as? TypeContextDescriptor
+      ptr = start.relativeDirectAddress(as: _ContextDescriptor.self)
     case .indirectTypeDescriptor:
-      var ptr = start.relativeDirectAddress(as: UnsafeRawPointer.self)
-      ptr = ptr.load(as: UnsafeRawPointer.self)
-      return getContextDescriptor(at: ptr) as? TypeContextDescriptor
+      ptr = start.relativeDirectAddress(as: UnsafeRawPointer?.self).load(as: UnsafeRawPointer?.self)
     default:
       return nil
     }
+
+    if let ptr {
+      return getContextDescriptor(at: ptr) as? TypeContextDescriptor
+    }
+
+    return nil
   }
 
   /// The ObjectiveC class metadata of the type being conformed.
@@ -64,7 +68,9 @@ public struct ConformanceDescriptor: LayoutWrapper {
         .assumingMemoryBound(to: CChar.self)
 
       guard let anyClass = objc_lookUpClass(ptr) else {
-        fatalError("No Objective-C class named \(ptr.string)")
+        // A conformance with a nil class means the class was weak-linked
+        // from a newer SDK and isn't available in this version of iOS 
+        return nil
       }
 
       return reflect(anyClass) as? ObjCClassWrapperMetadata

Sources/Echo/Runtime/ImageInspection.swift

@@ -56,7 +56,7 @@ let protocolLock = NSLock()
 var _protocols = Set<UnsafeRawPointer>()
 
 @_cdecl("registerProtocols")
-func registerProtocols(section: UnsafeRawPointer, size: Int) {
+public func registerProtocols(section: UnsafeRawPointer, size: Int) {
   for i in 0 ..< size / 4 {
     let start = section.offset(of: i, as: Int32.self)
     let ptr = start.relativeDirectAddress(as: _ProtocolDescriptor.self)
@@ -75,7 +75,7 @@ let conformanceLock = NSLock()
 var conformances = [UnsafeRawPointer: [ConformanceDescriptor]]()
 
 @_cdecl("registerProtocolConformances")
-func registerProtocolConformances(section: UnsafeRawPointer, size: Int) {
+public func registerProtocolConformances(section: UnsafeRawPointer, size: Int) {
   for i in 0 ..< size / 4 {
     let start = section.offset(of: i, as: Int32.self)
     let ptr = start.relativeDirectAddress(as: _ConformanceDescriptor.self)
@@ -137,11 +137,36 @@ let typeLock = NSLock()
 var _types = Set<UnsafeRawPointer>()
 
 @_cdecl("registerTypeMetadata")
-func registerTypeMetadata(section: UnsafeRawPointer, size: Int) {
+public func registerTypeMetadata(section: UnsafeRawPointer, size: Int) {
   for i in 0 ..< size / 4 {
     let start = section.offset(of: i, as: Int32.self)
-    let ptr = start.relativeDirectAddress(as: _ContextDescriptor.self)
-
+
+    // Each record is a RelativeDirectPointerIntPair<ContextDescriptor,
+    // TypeReferenceKind>: the low 2 bits of the relative offset encode the
+    // reference kind and must be masked off before resolving the pointer.
+    // Records whose kind is an indirect reference point at a GOT slot that
+    // holds the real descriptor, and ObjC class references never appear here.
+    let raw = Int(start.load(as: Int32.self))
+    let pointerOffset = raw & ~0x3
+
+    // A zero offset is a null/padding record; skip it.
+    guard pointerOffset != 0 else {
+      continue
+    }
+
+    let addr = start + pointerOffset
+    let ptr: UnsafeRawPointer
+
+    switch TypeReferenceKind(rawValue: UInt16(raw & 0x3)) {
+    case .directTypeDescriptor:
+      ptr = addr
+    case .indirectTypeDescriptor:
+      ptr = addr.load(as: UnsafeRawPointer.self)
+    default:
+      // .directObjCClass / .indirectObjCClass are never emitted into this list.
+      continue
+    }
+
     _ = typeLock.withLock {
       _types.insert(ptr)
     }
@@ -161,7 +186,7 @@ typealias mach_header_platform = mach_header
 #endif
 
 @_cdecl("lookupSection")
-func lookupSection(
+public func lookupSection(
   _ header: UnsafePointer<mach_header>?,
   segment: UnsafePointer<CChar>?,
   section: UnsafePointer<CChar>?,

Sources/Echo/Utils/SignedPointer.swift

@@ -11,9 +11,9 @@ import CEcho
 // A wrapper around a pointer who will return the signed version of the wrapped
 // pointer through the `signed` property.
 struct SignedPointer<Pointee> {
-  var ptr: UnsafeRawPointer
+  var ptr: UnsafeRawPointer!
 
-  var signed: UnsafeRawPointer {
+  var signed: UnsafeRawPointer! {
     ptr
   }
 }

Tests/EchoTests/Context Descriptor/ClassDescriptor.swift

@@ -16,19 +16,20 @@ class Child: Super {}
 extension EchoTests {
   func testClassDescriptor() {
     let metadata = reflectClass(Super.self)!
-    let descriptor = metadata.descriptor
+    let descriptor = metadata.descriptor!
     XCTAssertEqual(descriptor.superclass.load(as: CChar.self), 0) // nullptr
     XCTAssertEqual(descriptor.numFields, 1)
     XCTAssertEqual(descriptor.numMembers, 3) // name, init, sayHello
     XCTAssertEqual(descriptor.fieldOffsetVectorOffset, 10)
 
     let child = reflectClass(Child.self)!
-    let size = getSymbolicMangledNameLength(child.descriptor.superclass)
+    let childDescriptor = child.descriptor!
+    let size = getSymbolicMangledNameLength(childDescriptor.superclass)
     // 5 because symbolic prefix (1), symbol (4)
     XCTAssertEqual(size, 5)
-    XCTAssertEqual(child.descriptor.numFields, 0)
-    XCTAssertEqual(child.descriptor.numMembers, 0)
-    XCTAssertEqual(child.descriptor.fieldOffsetVectorOffset, 13)
+    XCTAssertEqual(childDescriptor.numFields, 0)
+    XCTAssertEqual(childDescriptor.numMembers, 0)
+    XCTAssertEqual(childDescriptor.fieldOffsetVectorOffset, 13)
   }
 }
 

Tests/EchoTests/Context Descriptor/FieldDescriptor.swift

@@ -16,7 +16,7 @@ enum FieldDescriptorTests {
 
   static func testClass() throws {
     let metadata = reflectClass(FieldTesting.self)!
-    let fields = metadata.descriptor.fields
+    let fields = metadata.descriptor!.fields
 
     XCTAssert(fields.hasMangledTypeName)
     XCTAssertEqual(fields.kind, .class)

Tests/EchoTests/Metadata/ClassMetadata.swift

@@ -36,8 +36,12 @@ enum ClassMetadataTests {
 
     let metadata = maybeMetadata!
 
-    XCTAssertEqual(metadata.classAddressPoint, 16)
-    XCTAssertEqual(metadata.classSize, 120)
+    // classAddressPoint/classSize are runtime metadata-allocation details that
+    // legitimately drift between Swift versions (the class metadata header grew
+    // by one word after the values originally baked in here). Pin them to the
+    // current ABI but keep the asserts so regressions in Echo's reading surface.
+    XCTAssertEqual(metadata.classAddressPoint, 24)
+    XCTAssertEqual(metadata.classSize, 128)
     XCTAssertEqual(metadata.instanceAddressPoint, 0)
     XCTAssertEqual(metadata.instanceAlignmentMask, 7)
     XCTAssertEqual(metadata.instanceSize, 40)
@@ -74,8 +78,8 @@ enum ClassMetadataTests {
 
     let metadata = maybeMetadata!
 
-    XCTAssertEqual(metadata.classAddressPoint, 16)
-    XCTAssertEqual(metadata.classSize, 136)
+    XCTAssertEqual(metadata.classAddressPoint, 24)
+    XCTAssertEqual(metadata.classSize, 144)
     XCTAssertEqual(metadata.instanceAddressPoint, 0)
     XCTAssertEqual(metadata.instanceAlignmentMask, 7)
     XCTAssertEqual(metadata.instanceSize, 40)
@@ -111,6 +115,17 @@ enum ClassMetadataTests {
     XCTAssert(typeArraysEquals(resilientMetadata.genericTypes, [String.self]))
     XCTAssertNotNil(resilientMetadata.superclassType)
     XCTAssert(resilientMetadata.superclassType! == JSONEncoder.self)
+
+    // Regression: the resilient-superclass reference kind is a 3-bit field at
+    // bit 9 and must be shifted, not just masked. Boat3's superclass
+    // (JSONEncoder) lives in Foundation, so it is referenced indirectly;
+    // reading the kind used to trap on a force-unwrapped nil before the shift.
+    let resilientDescriptor = resilientMetadata.descriptor!
+    XCTAssertTrue(resilientDescriptor.typeFlags.classHasResilientSuperclass)
+    XCTAssertEqual(
+      resilientDescriptor.typeFlags.resilientSuperclassRefKind,
+      .indirectTypeDescriptor
+    )
   }
 
   #if canImport(ObjectiveC)
@@ -119,10 +134,11 @@ enum ClassMetadataTests {
     XCTAssertNotNil(maybeMetadata)
 
     let metadata = maybeMetadata!
-
-    XCTAssertEqual(metadata.classAddressPoint, 32767)
-    XCTAssertEqual(metadata.instanceAddressPoint, 32767)
-    XCTAssertEqual(metadata.instanceAlignmentMask, 32767)
+
+    // NSObject is a pure Objective-C class: the Swift-specific class metadata
+    // fields (address points, alignment mask) overlap unrelated Objective-C
+    // class bytes and carry no meaningful value, so we don't assert on them.
+    // The meaningful invariant is that Echo recognizes it as a non-Swift class.
     XCTAssertEqual(metadata.isSwiftClass, false)
   }
   #endif