public enum InvertedRange<Index: Comparable> {
    case beforeStart, afterEnd, all
    case prefix(upThrough: Index)
    case range(after: Index, upThrough: Index)
    case suffix(after: Index)
}

public protocol TransferableCollection: MutableCollection /*[[1]]*/ where /*[[2]]*/ Self.SubSequence: TransferableCollection {}

extension TransferableCollection /*[[3]]*/ {

    private func convertRange(_ range: InvertedRange<Index>) -> Range<Index>
    { /*...*/ }

    private func convertRange<R>(_ range: R) -> InvertedRange<Index> where R: RangeExpression, R.Bound == Index {
        let r = range.relative(to: self)
        switch (r.lowerBound, r.upperBound) {
        case (startIndex, endIndex): return .all
        case (startIndex, startIndex): return .beforeStart
        case (startIndex, let i): return .prefix(upThrough: index(before: i)) // ERROR HERE
        case (let i, endIndex): return .suffix(after: index(before: i)) // AND HERE
        case (endIndex, endIndex): return .afterEnd
        case (let s, let e): return .range(after: index(before: s), upThrough: index(before: e)) // AND HERE
        }
    }

}

where Self: BidirectionalCollection 

Self: BidirectionalCollection,

, BidirectionalCollection