Move "bytesLeft" precondition into closure of "4.2 performance workaround"

Author: tsolomko

Sources/ByteReader.swift

@@ -89,13 +89,14 @@ public class ByteReader {
      */
     public func bytes(count: Int) -> [UInt8] {
         precondition(count >= 0)
-        precondition(bytesLeft >= count)
         #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
             return { (data: Data, offset: inout Int) -> [UInt8] in
+                precondition(data.endIndex - offset >= count)
                 defer { offset += count }
                 return data[offset..<offset + count].toArray(type: UInt8.self, count: count)
             } (self.data, &self.offset)
         #else
+            precondition(bytesLeft >= count)
             defer { self.offset += count }
             return self.data[self.offset..<self.offset + count].toArray(type: UInt8.self, count: count)
         #endif
@@ -109,11 +110,11 @@ public class ByteReader {
      */
     public func int(fromBytes count: Int) -> Int {
         precondition(count >= 0)
-        precondition(bytesLeft >= count)
         // TODO: If uintX() could be force inlined or something in the future then probably it would make sense
         // to use them for `count` == 2, 4 or 8.
         #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
             return { (data: Data, offset: inout Int) -> Int in
+                precondition(data.endIndex - offset >= count)
                 var result = 0
                 for i in 0..<count {
                     result += Int(truncatingIfNeeded: data[offset]) << (8 * i)
@@ -122,6 +123,7 @@ public class ByteReader {
                 return result
             } (self.data, &self.offset)
         #else
+            precondition(bytesLeft >= count)
             var result = 0
             for i in 0..<count {
                 result += Int(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
@@ -137,13 +139,14 @@ public class ByteReader {
      - Precondition: There MUST be enough data left.
      */
     public func uint64() -> UInt64 {
-        precondition(bytesLeft >= 8)
         #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
             return { (data: Data, offset: inout Int) -> UInt64 in
+                precondition(data.endIndex - offset >= 8)
                 defer { offset += 8 }
                 return data[offset..<offset + 8].to(type: UInt64.self)
             } (self.data, &self.offset)
         #else
+            precondition(bytesLeft >= 8)
             defer { self.offset += 8 }
             return self.data[self.offset..<self.offset + 8].to(type: UInt64.self)
         #endif
@@ -160,9 +163,9 @@ public class ByteReader {
      */
     public func uint64(fromBytes count: Int) -> UInt64 {
         precondition(0...8 ~= count)
-        precondition(bytesLeft >= count)
         #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
             return { (data: Data, offset: inout Int) -> UInt64 in
+                precondition(data.endIndex - offset >= count)
                 var result = 0 as UInt64
                 for i in 0..<count {
                     result += UInt64(truncatingIfNeeded: data[offset]) << (8 * i)
@@ -171,6 +174,7 @@ public class ByteReader {
                 return result
             } (self.data, &self.offset)
         #else
+            precondition(bytesLeft >= count)
             var result = 0 as UInt64
             for i in 0..<count {
                 result += UInt64(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
@@ -186,13 +190,14 @@ public class ByteReader {
      - Precondition: There MUST be enough data left.
      */
     public func uint32() -> UInt32 {
-        precondition(bytesLeft >= 4)
         #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
             return { (data: Data, offset: inout Int) -> UInt32 in
+                precondition(data.endIndex - offset >= 4)
                 defer { offset += 4 }
                 return data[offset..<offset + 4].to(type: UInt32.self)
             } (self.data, &self.offset)
         #else
+            precondition(bytesLeft >= 4)
             defer { self.offset += 4 }
             return self.data[self.offset..<self.offset + 4].to(type: UInt32.self)
         #endif
@@ -209,9 +214,9 @@ public class ByteReader {
      */
     public func uint32(fromBytes count: Int) -> UInt32 {
         precondition(0...4 ~= count)
-        precondition(bytesLeft >= count)
         #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
             return { (data: Data, offset: inout Int) -> UInt32 in
+                precondition(data.endIndex - offset >= count)
                 var result = 0 as UInt32
                 for i in 0..<count {
                     result += UInt32(truncatingIfNeeded: data[offset]) << (8 * i)
@@ -220,6 +225,7 @@ public class ByteReader {
                 return result
             } (self.data, &self.offset)
         #else
+            precondition(bytesLeft >= count)
             var result = 0 as UInt32
             for i in 0..<count {
                 result += UInt32(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
@@ -235,13 +241,14 @@ public class ByteReader {
      - Precondition: There MUST be enough data left.
      */
     public func uint16() -> UInt16 {
-        precondition(bytesLeft >= 2)
         #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
             return { (data: Data, offset: inout Int) -> UInt16 in
+                precondition(data.endIndex - offset >= 2)
                 defer { offset += 2 }
                 return data[offset..<offset + 2].to(type: UInt16.self)
             } (self.data, &self.offset)
         #else
+            precondition(bytesLeft >= 2)
             defer { self.offset += 2 }
             return self.data[self.offset..<self.offset + 2].to(type: UInt16.self)
         #endif
@@ -258,9 +265,9 @@ public class ByteReader {
      */
     public func uint16(fromBytes count: Int) -> UInt16 {
         precondition(0...2 ~= count)
-        precondition(bytesLeft >= count)
         #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
             return { (data: Data, offset: inout Int) -> UInt16 in
+                precondition(data.endIndex - offset >= count)
                 var result = 0 as UInt16
                 for i in 0..<count {
                     result += UInt16(truncatingIfNeeded: data[offset]) << (8 * i)
@@ -269,6 +276,7 @@ public class ByteReader {
                 return result
             } (self.data, &self.offset)
         #else
+            precondition(bytesLeft >= count)
             var result = 0 as UInt16
             for i in 0..<count {
                 result += UInt16(truncatingIfNeeded: self.data[self.offset]) << (8 * i)