WasmParser: Turn init(LEB:) into top-level functions

Author: kateinoigakukun

Sources/WasmParser/LEB.swift

@@ -4,82 +4,78 @@ enum LEBError: Swift.Error, Equatable {
     case insufficientBytes
 }
 
-extension FixedWidthInteger where Self: UnsignedInteger {
-    @inline(__always)
-    init<Stream: ByteStream>(LEB stream: Stream) throws {
-        let firstByte = try stream.consumeAny()
-        var result: Self = Self(firstByte & 0b0111_1111)
-        if _fastPath(firstByte & 0b1000_0000 == 0) {
-            self = result
-            return
-        }
+@inline(__always)
+func decodeLEB128<IntType, Stream>(
+    stream: Stream
+) throws -> IntType where IntType: FixedWidthInteger, IntType: UnsignedInteger, Stream: ByteStream {
+    let firstByte = try stream.consumeAny()
+    var result: IntType = IntType(firstByte & 0b0111_1111)
+    if _fastPath(firstByte & 0b1000_0000 == 0) {
+        return result
+    }
 
-        var shift: UInt = 7
+    var shift: UInt = 7
 
-        while true {
-            let byte = try stream.consumeAny()
-            let slice = Self(byte & 0b0111_1111)
-            let nextShift = shift + 7
-            if nextShift >= Self.bitWidth, (byte >> (UInt(Self.bitWidth) - shift)) != 0 {
-                throw LEBError.integerRepresentationTooLong
-            }
-            result |= slice << shift
-            shift = nextShift
-
-            guard byte & 0b1000_0000 != 0 else { break }
+    while true {
+        let byte = try stream.consumeAny()
+        let slice = IntType(byte & 0b0111_1111)
+        let nextShift = shift + 7
+        if nextShift >= IntType.bitWidth, (byte >> (UInt(IntType.bitWidth) - shift)) != 0 {
+            throw LEBError.integerRepresentationTooLong
         }
+        result |= slice << shift
+        shift = nextShift
 
-        self = result
+        guard byte & 0b1000_0000 != 0 else { break }
     }
-}
 
-extension FixedWidthInteger where Self: SignedInteger {
-    @inline(__always)
-    init<Stream: ByteStream>(LEB stream: Stream) throws {
-        let firstByte = try stream.consumeAny()
-        var result: Self = Self(firstByte & 0b0111_1111)
-        if _fastPath(firstByte & 0b1000_0000 == 0) {
-            // Interpret Int${Self.bitWidth-1} as Int${Self.bitWidth}
-            self = (result << (Self.bitWidth - 7)) >> (Self.bitWidth - 7)
-            return
-        }
+    return result
+}
 
-        var shift: Self = 7
+func decodeLEB128<IntType, Stream>(
+    stream: Stream
+) throws -> IntType where IntType: FixedWidthInteger, IntType: RawSignedInteger, Stream: ByteStream {
+    let firstByte = try stream.consumeAny()
+    var result = IntType.Unsigned(firstByte & 0b0111_1111)
+    if _fastPath(firstByte & 0b1000_0000 == 0) {
+        // Interpret Int${Self.bitWidth-1} as Int${Self.bitWidth}
+        return (IntType(bitPattern: result) << (IntType.bitWidth - 7)) >> (IntType.bitWidth - 7)
+    }
 
-        var byte: UInt8
-        repeat {
-            byte = try stream.consumeAny()
+    var shift: IntType = 7
 
-            let slice = Self(byte & 0b0111_1111)
-            result |= slice << shift
+    var byte: UInt8
+    repeat {
+        byte = try stream.consumeAny()
 
-            // When we don't have enough bit width
-            if shift > (Self.bitWidth - 7) {
-                let remainingBitWidth = Self.bitWidth - Int(shift)
-                let continuationBit = (byte & 0b1000_0000) != 0
-                // When a next byte is expected
-                if continuationBit {
-                    throw LEBError.integerRepresentationTooLong
-                }
+        let slice = IntType.Unsigned(byte & 0b0111_1111)
+        result |= slice << shift
 
-                let signAndDiscardingBits = Int8(bitPattern: byte << 1) >> remainingBitWidth
-                // When meaningful bits are discarded
-                if signAndDiscardingBits != 0 && signAndDiscardingBits != -1 {
-                    throw LEBError.overflow
-                }
-                self = result
-                return
+        // When we don't have enough bit width
+        if shift > (IntType.bitWidth - 7) {
+            let remainingBitWidth = IntType.bitWidth - Int(shift)
+            let continuationBit = (byte & 0b1000_0000) != 0
+            // When a next byte is expected
+            if continuationBit {
+                throw LEBError.integerRepresentationTooLong
             }
 
-            shift += 7
-        } while byte & 0b1000_0000 != 0
-
-        // Sign flag is second high-order bit
-        if byte & 0b0100_0000 != 0 {
-            // Sign extend
-            result |= Self(~0) << shift
+            let signAndDiscardingBits = Int8(bitPattern: byte << 1) >> remainingBitWidth
+            // When meaningful bits are discarded
+            if signAndDiscardingBits != 0 && signAndDiscardingBits != -1 {
+                throw LEBError.overflow
+            }
+            return IntType(bitPattern: result)
         }
 
-        self = result
+        shift += 7
+    } while byte & 0b1000_0000 != 0
+
+    // Sign flag is second high-order bit
+    if byte & 0b0100_0000 != 0 {
+        // Sign extend
+        result |= IntType.Unsigned(bitPattern: ~0) << shift
     }
+
+    return IntType(bitPattern: result)
 }

Sources/WasmParser/Stream/FileHandleStream.swift

@@ -1,4 +1,4 @@
-import SystemPackage
+import struct SystemPackage.FileDescriptor
 
 public final class FileHandleStream: ByteStream {
     private(set) public var currentIndex: Int = 0

Sources/WasmParser/WasmParser.swift

@@ -1,4 +1,5 @@
-import SystemPackage
+import struct SystemPackage.FilePath
+import struct SystemPackage.FileDescriptor
 import WasmTypes
 
 #if os(Windows)
@@ -352,20 +353,12 @@ extension ByteStream {
     @inline(__always)
     @usableFromInline
     func parseUnsigned<T: RawUnsignedInteger>(_: T.Type = T.self) throws -> T {
-        return try T(LEB: self)
+        try decodeLEB128(stream: self)
     }
 
-    @inline(__always)
-    @usableFromInline
-    func parseSigned<T: FixedWidthInteger & SignedInteger>() throws -> T {
-        return try T(LEB: self)
-    }
-
-    @inline(__always)
     @usableFromInline
-    func parseInteger<T: RawUnsignedInteger>() throws -> T {
-        let signed: T.Signed = try parseSigned()
-        return signed.unsigned
+    func parseSigned<T: FixedWidthInteger & RawSignedInteger>() throws -> T {
+        try decodeLEB128(stream: self)
     }
 }
 
@@ -406,16 +399,10 @@ extension Parser {
         try stream.parseUnsigned(T.self)
     }
 
-    @inline(__always)
-    @inlinable
-    func parseSigned<T: FixedWidthInteger & SignedInteger>() throws -> T {
-        try stream.parseSigned()
-    }
-
-    @inline(__always)
     @inlinable
     func parseInteger<T: RawUnsignedInteger>() throws -> T {
-        try stream.parseInteger()
+        let signed: T.Signed = try stream.parseSigned()
+        return T(bitPattern: signed)
     }
 
     func parseName() throws -> String {

Sources/WasmParser/WasmTypes.swift

@@ -324,12 +324,6 @@ extension RawUnsignedInteger {
     }
 }
 
-extension RawSignedInteger {
-    var unsigned: Unsigned {
-        .init(bitPattern: self)
-    }
-}
-
 extension Instruction.Load {
     /// The alignment to the storage size of the memory access
     /// in log2 form.

Tests/WasmParserTests/LEBTests.swift

@@ -64,13 +64,13 @@ final class LEBTest: XCTestCase {
 extension FixedWidthInteger where Self: UnsignedInteger {
     fileprivate init(LEB bytes: [UInt8]) throws {
         let stream = StaticByteStream(bytes: bytes)
-        try self.init(LEB: stream)
+        self = try decodeLEB128(stream: stream)
     }
 }
 
-extension FixedWidthInteger where Self: SignedInteger {
+extension FixedWidthInteger where Self: RawSignedInteger {
     fileprivate init(LEB bytes: [UInt8]) throws {
         let stream = StaticByteStream(bytes: bytes)
-        try self.init(LEB: stream)
+        self = try decodeLEB128(stream: stream)
     }
 }