     instance._kvcKeyPathStringPtr =
       kvcStringPtr.assumingMemoryBound(to: CChar.self)
   }
-
-  if instance._kvcKeyPathStringPtr == nil, isPureStruct {
+  if instance._kvcKeyPathStringPtr == nil, let offset = pureStructOffset {
     instance.assignOffsetToStorage(offset: Int(offset))
   }
   // If we can cache this instance as a shared instance, do so.

    let architectureSize = MemoryLayout<Int>.size
    if architectureSize == 8 {
      _kvcKeyPathStringPtr = UnsafePointer<CChar>(bitPattern: -offset - 1)
    } else {
      if offset == 0 {
        _kvcKeyPathStringPtr =
          UnsafePointer<CChar>(bitPattern: maximumOffsetOn32BitArchitecture + 1)
      } else if offset < maximumOffsetOn32BitArchitecture {
        _kvcKeyPathStringPtr = UnsafePointer<CChar>(bitPattern: offset)
      } else {
        _kvcKeyPathStringPtr = nil
      }
    }
  }

  // TODO: See if this can be @inlinable since it gets called on each
  // KeyPath access. It would mean _kvcKeyPathStringPtr would need
  // to be @usableFromInline. What effect would that have on ABI stability?
  func getOffsetFromStorage() -> Int? {
    let maximumOffsetOn32BitArchitecture = 4094
    guard let storage = _kvcKeyPathStringPtr else {

    
    let base = UnsafeRawPointer(Builtin.projectTailElems(self, Int32.self))
    return try f(KeyPathBuffer(base: base))
  }
  
  @usableFromInline // Exposed as public API by MemoryLayout<Root>.offset(of:)
