Move BlockInfoCode to Bitstream

Author: CodaFi

Sources/TSCUtility/Bitstream.swift

@@ -147,6 +147,24 @@ extension Bitstream {
   }
 }
 
+extension Bitstream {
+    /// A `BlockInfoCode` enumerates the bits that occur in the metadata for
+    /// a block or record. Of these bits, only `setBID` is required. If
+    /// a name is given to a block or record with `blockName` or
+    /// `setRecordName`, debugging tools like `llvm-bcanalyzer` can be used to
+    /// introspect the structure of blocks and records in the bitstream file.
+    public enum BlockInfoCode: UInt8 {
+        /// Indicates which block ID is being described.
+        case setBID = 1
+        /// An optional element that records which bytes of the record are the
+        /// name of the block.
+        case blockName = 2
+        /// An optional element that records the record ID number and the bytes
+        /// for the name of the corresponding record.
+        case setRecordName = 3
+    }
+}
+
 extension Bitstream {
   /// A `BlockID` is a fixed-width field that occurs at the start of all blocks.
   ///

Sources/TSCUtility/BitstreamReader.swift

@@ -259,16 +259,16 @@ private struct BitstreamReader {
         }
 
         switch code {
-        case 1:
+        case UInt64(Bitstream.BlockInfoCode.setBID.rawValue):
           guard operands.count == 1 else { throw Error.invalidBlockInfoRecord(recordID: code) }
           currentBlockID = operands.first
-        case 2:
+        case UInt64(Bitstream.BlockInfoCode.blockName.rawValue):
           guard let blockID = currentBlockID else {
             throw Error.missingSETBID
           }
           if blockInfo[blockID] == nil { blockInfo[blockID] = BlockInfo() }
           blockInfo[blockID]!.name = String(bytes: operands.map { UInt8($0) }, encoding: .utf8) ?? "<invalid>"
-        case 3:
+        case UInt64(Bitstream.BlockInfoCode.setRecordName.rawValue):
           guard let blockID = currentBlockID else {
             throw Error.missingSETBID
           }

Sources/TSCUtility/BitstreamWriter.swift

@@ -8,8 +8,6 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
-import Foundation
-
 /// A `BitstreamWriter` is an object that is capable of emitting data in the
 /// [LLVM Bitstream](https://llvm.org/docs/BitCodeFormat.html#bitstream-format)
 /// format.
@@ -33,6 +31,7 @@ import Foundation
 ///
 /// Next, identify the kinds of records needed in the format and assign them
 /// unique, stable identifiers. For example:
+/// 
 /// ```
 /// enum DiagnosticRecordID: UInt8 {
 ///     case version        = 1
@@ -69,7 +68,7 @@ import Foundation
 ///     }
 ///
 ///     versionAbbrev = recordWriter.defineBlockInfoAbbreviation(.metadata, .init([
-///         .literalCode(RoundTripRecordID.version),
+///         .literalCode(DiagnosticRecordID.version),
 ///         .fixed(bitWidth: 32)
 ///     ]))
 ///
@@ -83,7 +82,7 @@ import Foundation
 /// ```
 /// recordWriter.writeBlock(.metadata, newAbbrevWidth: 3) {
 ///     recordWriter.writeRecord(versionAbbrev!) {
-///         $0.append(RoundTripRecordID.version)
+///         $0.append(DiagnosticRecordID.version)
 ///         $0.append(25 as UInt32)
 ///     }
 /// }
@@ -92,12 +91,6 @@ import Foundation
 /// The higher-level APIs will automatically ensure that `BitstreamWriter.data`
 /// is valid. Once serialization has completed, simply emit this data to a file.
 public final class BitstreamWriter {
-    public enum BlockInfoCode: UInt8 {
-        case setBID = 1
-        case blockName = 2
-        case setRecordName = 3
-    }
-
     /// The buffer of data being written to.
     private(set) public var data: [UInt8]
 
@@ -657,7 +650,7 @@ extension BitstreamWriter {
 
     private func `switch`(to blockID: Bitstream.BlockID) {
         if currentBlockID == blockID { return }
-        writeRecord(BlockInfoCode.setBID) {
+        writeRecord(Bitstream.BlockInfoCode.setBID) {
             $0.append(blockID)
         }
         currentBlockID = blockID

Tests/TSCUtilityTests/BitstreamTests.swift

@@ -387,7 +387,7 @@ final class BitstreamTests: XCTestCase {
     func testSimpleRecordWrite() {
         let recordWriter = BitstreamWriter()
         recordWriter.withSubBlock(.metadata, abbreviationBitWidth: 2) {
-            recordWriter.writeRecord(BitstreamWriter.BlockInfoCode.setRecordName) {
+            recordWriter.writeRecord(Bitstream.BlockInfoCode.setRecordName) {
                 $0.append(Bitstream.AbbreviationID.mockAbbreviation)
             }
         }
@@ -399,7 +399,7 @@ final class BitstreamTests: XCTestCase {
             UInt8(1), UInt8(0), UInt8(0), UInt8(0),
             // Still 32-bit aligned, now here's the record data
             UInt8(Bitstream.AbbreviationID.unabbreviatedRecord.rawValue)
-                | UInt8(BitstreamWriter.BlockInfoCode.setRecordName.rawValue << 2),
+                | UInt8(Bitstream.BlockInfoCode.setRecordName.rawValue << 2),
             UInt8(1), // record length of 1 - which is just the ID field
             UInt8(1), // record ID itself - which is 0b00001000 but we're
                       // 14 bits in by the time we get here and writing 6 bits,
@@ -409,19 +409,19 @@ final class BitstreamTests: XCTestCase {
     }
 
     func emitBlockID(_ id: Bitstream.BlockID, named name: String, to stream: BitstreamWriter) {
-        stream.writeRecord(BitstreamWriter.BlockInfoCode.setBID) {
+        stream.writeRecord(Bitstream.BlockInfoCode.setBID) {
             $0.append(id)
         }
 
-        stream.writeRecord(BitstreamWriter.BlockInfoCode.blockName) {
+        stream.writeRecord(Bitstream.BlockInfoCode.blockName) {
             $0.append(name)
         }
     }
 
     func emitRecordID<CodeType>(_ id: CodeType, named name: String, to stream: BitstreamWriter)
         where CodeType: RawRepresentable, CodeType.RawValue: UnsignedInteger & ExpressibleByIntegerLiteral
     {
-        stream.writeRecord(BitstreamWriter.BlockInfoCode.setRecordName) {
+        stream.writeRecord(Bitstream.BlockInfoCode.setRecordName) {
             $0.append(id)
             $0.append(name)
         }