     let mirror = Mirror(reflecting: unwrapType(item))
     let description = mirror.description
     let offsetOfFirstBracketForMirrorDescriptionOfTuple = 11
-    let idx = description.index(description.startIndex, offsetBy: offsetOfFirstBracketForMirrorDescriptionOfTuple)
+    let idx = description.index(description.startIndex,
+                offsetBy: offsetOfFirstBracketForMirrorDescriptionOfTuple)
     if description[idx] == "(" {
       return true
     }
     return false
   }
     
-    // TODO: Merge the functionality of _computeOffsetForPureStructKeypath,
-    // _recalculateOffsetForPureStructKeyPath() and _storedInlineOffset.
-
-    // If this keypath traverses structs only, it'll have a predictable memory layout.
-    // We can then jump to the value directly in _projectReadOnly().
-    internal func _computeOffsetForPureStructKeypath() {
-      _pureStructValueOffset = 0
-      var isPureStruct = true
-      var exitEarly = false
-      defer {
-        _isPureStructKeyPath = isPureStruct
-      }
-      withBuffer {
-        var buffer = $0
-        if buffer.data.isEmpty {
-          if isClass(Self._rootAndValueType.root) {
-            isPureStruct = false
-          }
-        } else {
-          while !exitEarly {
-            let (rawComponent, optNextType) = buffer.next()
-            if isTuple(optNextType as Any) {
-              isPureStruct = false
-              break
-            }
-            switch rawComponent.header.kind {
-            case .struct:
-              _pureStructValueOffset += rawComponent._structOrClassOffset
-            case .class, .computed, .optionalChain, .optionalForce, .optionalWrap, .external:
-              isPureStruct = false
-              exitEarly = true
-            }
-            if optNextType == nil {
-              break
-            }
-          }
-        }
-      }
-    }
-
-    // Recalculates the offset in the case where one pure struct keypath is appended to another.
-    internal func _recalculateOffsetForPureStructKeyPath() {
-      _pureStructValueOffset = 0
-      withBuffer {
-        var buffer = $0
-        while true {
-          let (rawComponent, optNextType) = buffer.next()
-          switch rawComponent.header.kind {
-          case .struct:
-            _pureStructValueOffset += rawComponent._structOrClassOffset
-          case .class, .computed, .optionalChain, .optionalForce, .optionalWrap, .external:
-            return
-          }
-          if optNextType == nil {
-            break
-          }
-        }
-      }
-    }
-
     @usableFromInline // Exposed as public API by MemoryLayout<Root>.offset(of:)
     internal var _storedInlineOffset: Int? {
       return withBuffer {

                                                mutable: mutable,
                                                inlineOffset: value)
        pushDest(header)
      case .outOfLine(let offset):
        let header = RawKeyPathComponent.Header(storedWithOutOfLineOffset: kind,
                                                mutable: mutable)

                                   setter: UnsafeRawPointer?,
                                   arguments: KeyPathPatternComputedArguments?,
                                   externalArgs: UnsafeBufferPointer<Int32>?) {
    isPureStruct.append(false)
    let previous = updatePreviousComponentAddr()
    let settable = setter != nil
    // A nonmutating settable property can end the reference prefix.
