Add deserialization for the Swift/Clang serialized diagnostics (.dia) format

owenv · owenv · commit 08bd94f11a65 · 2020-09-01T22:41:08.000-07:00
diff --git a/Sources/TSCUtility/CMakeLists.txt b/Sources/TSCUtility/CMakeLists.txt
@@ -10,6 +10,8 @@ add_library(TSCUtility
   Archiver.swift
   ArgumentParser.swift
   ArgumentParserShellCompletion.swift
+  Bits.swift
+  Bitstream.swift
   BuildFlags.swift
   CollectionExtensions.swift
   Diagnostics.swift
@@ -28,6 +30,7 @@ add_library(TSCUtility
   Platform.swift
   PolymorphicCodable.swift
   ProgressAnimation.swift
+  SerializedDiagnostics.swift
   SQLite.swift
   SimplePersistence.swift
   StringExtensions.swift
diff --git a/Sources/TSCUtility/SerializedDiagnostics.swift b/Sources/TSCUtility/SerializedDiagnostics.swift
@@ -1,8 +1,232 @@
-//
-//  SerializedDiagnostics.swift
-//  swift-tools-support-core
-//
-//  Created by Owen Voorhees on 9/1/20.
-//
+/*
+ This source file is part of the Swift.org open source project
 
+ Copyright (c) 2020 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
 import Foundation
+
+/// Represents diagnostics serialized in a .dia file by the Swift compiler or Clang.
+public struct SerializedDiagnostics {
+  public enum Error: Swift.Error {
+    case badMagic
+    case unexpectedTopLevelRecord
+    case unknownBlock
+    case malformedRecord
+    case noMetadataBlock
+    case unexpectedSubblock
+    case unexpectedRecord
+    case missingInformation
+  }
+
+  private enum BlockID: UInt64 {
+    case metadata = 8
+    case diagnostic = 9
+  }
+
+  private enum RecordID: UInt64 {
+    case version = 1
+    case diagnosticInfo = 2
+    case sourceRange = 3
+    case flag = 4
+    case category = 5
+    case filename = 6
+    case fixit = 7
+  }
+
+  /// The serialized diagnostics format version number.
+  public var versionNumber: Int
+  /// Serialized diagnostics.
+  public var diagnostics: [Diagnostic]
+
+  public init(data: Data) throws {
+    let bitcode = try Bitcode(data: data)
+
+    guard bitcode.signature == .init(string: "DIAG") else { throw Error.badMagic }
+
+    var diagnostics: [Diagnostic] = []
+    var versionNumber: Int? = nil
+    var filenameMap = [UInt64: String]()
+    var flagMap = [UInt64: String]()
+    var categoryMap = [UInt64: String]()
+
+    for element in bitcode.elements {
+      guard case let .block(block) = element else { throw Error.unexpectedTopLevelRecord }
+      switch BlockID(rawValue: block.id) {
+      case .metadata:
+        guard block.elements.count == 1,
+              case let .record(versionRecord) = block.elements[0],
+              versionRecord.id == RecordID.version.rawValue,
+              versionRecord.fields.count == 1 else {
+          throw Error.malformedRecord
+        }
+        versionNumber = Int(versionRecord.fields[0])
+      case .diagnostic:
+        diagnostics.append(try Diagnostic(block: block,
+                                          filenameMap: &filenameMap,
+                                          flagMap: &flagMap,
+                                          categoryMap: &categoryMap))
+      case nil:
+        throw Error.unknownBlock
+      }
+    }
+
+    guard let version = versionNumber else { throw Error.noMetadataBlock }
+    self.versionNumber = version
+    self.diagnostics = diagnostics
+  }
+}
+
+extension SerializedDiagnostics {
+  public struct Diagnostic {
+
+    public enum Level: UInt64 {
+      case ignored, note, warning, error, fatal, remark
+    }
+    /// The diagnostic message text.
+    public var text: String
+    /// The level the diagnostic was emitted at.
+    public var level: Level
+    /// The location the diagnostic was emitted at in the source file.
+    public var location: SourceLocation
+    /// The diagnostic category. Currently only Clang emits this.
+    public var category: String?
+    /// The corresponding diagnostic command-line flag. Currently only Clang emits this.
+    public var flag: String?
+    /// Ranges in the source file associated with the diagnostic.
+    public var ranges: [(SourceLocation, SourceLocation)]
+    /// Fix-its associated with the diagnostic.
+    public var fixIts: [FixIt]
+
+    fileprivate init(block: BitcodeElement.Block,
+                     filenameMap: inout [UInt64: String],
+                     flagMap: inout [UInt64: String],
+                     categoryMap: inout [UInt64: String]) throws {
+      var text: String? = nil
+      var level: Level? = nil
+      var location: SourceLocation? = nil
+      var category: String? = nil
+      var flag: String? = nil
+      var ranges: [(SourceLocation, SourceLocation)] = []
+      var fixIts: [FixIt] = []
+
+      for element in block.elements {
+        guard case let .record(record) = element else {
+          throw Error.unexpectedSubblock
+        }
+
+        switch SerializedDiagnostics.RecordID(rawValue: record.id) {
+        case .diagnosticInfo:
+          guard record.fields.count == 8,
+                case .blob(let diagnosticBlob) = record.payload
+          else { throw Error.malformedRecord }
+
+          text = String(data: diagnosticBlob, encoding: .utf8)
+          level = Level(rawValue: record.fields[0])
+          location = try SourceLocation(fields: record.fields[1...4],
+                                        filenameMap: filenameMap)
+          category = categoryMap[record.fields[5]]
+          flag = flagMap[record.fields[6]]
+
+        case .sourceRange:
+          guard record.fields.count == 8 else { throw Error.malformedRecord }
+
+          let start = try SourceLocation(fields: record.fields[0...3],
+                                         filenameMap: filenameMap)
+          let end = try SourceLocation(fields: record.fields[4...7],
+                                       filenameMap: filenameMap)
+          ranges.append((start, end))
+
+        case .flag:
+          guard record.fields.count == 2,
+                case .blob(let flagBlob) = record.payload,
+                let flagText = String(data: flagBlob, encoding: .utf8)
+          else { throw Error.malformedRecord }
+
+          let diagnosticID = record.fields[0]
+          flagMap[diagnosticID] = flagText
+
+        case .category:
+          guard record.fields.count == 2,
+                case .blob(let categoryBlob) = record.payload,
+                let categoryText = String(data: categoryBlob, encoding: .utf8)
+          else { throw Error.malformedRecord }
+
+          let categoryID = record.fields[0]
+          categoryMap[categoryID] = categoryText
+
+        case .filename:
+          guard record.fields.count == 4,
+                case .blob(let filenameBlob) = record.payload,
+                let filenameText = String(data: filenameBlob, encoding: .utf8)
+          else { throw Error.malformedRecord }
+
+          let filenameID = record.fields[0]
+          // record.fields[1] and record.fields[2] are no longer used.
+          filenameMap[filenameID] = filenameText
+
+        case .fixit:
+          guard record.fields.count == 9,
+                case .blob(let fixItBlob) = record.payload,
+                let fixItText = String(data: fixItBlob, encoding: .utf8)
+          else { throw Error.malformedRecord }
+
+          let start = try SourceLocation(fields: record.fields[0...3],
+                                         filenameMap: filenameMap)
+          let end = try SourceLocation(fields: record.fields[4...7],
+                                       filenameMap: filenameMap)
+          fixIts.append(FixIt(start: start, end: end, text: fixItText))
+
+        case .version, nil:
+          throw Error.unexpectedRecord
+        }
+      }
+
+      do {
+        guard let text = text, let level = level, let location = location else {
+          throw Error.missingInformation
+        }
+        self.text = text
+        self.level = level
+        self.location = location
+        self.category = category
+        self.flag = flag
+        self.fixIts = fixIts
+        self.ranges = ranges
+      }
+    }
+  }
+
+  public struct SourceLocation: Equatable {
+    /// The filename associated with the diagnostic.
+    public var filename: String
+    public var line: UInt64
+    public var column: UInt64
+    /// The byte offset in the source file of the diagnostic. Currently, only
+    /// Clang includes this, it is set to 0 by Swift.
+    public var offset: UInt64
+
+    fileprivate init(fields: ArraySlice<UInt64>,
+                     filenameMap: [UInt64: String]) throws {
+      guard let name = filenameMap[fields[fields.startIndex]] else {
+        throw Error.missingInformation
+      }
+      self.filename = name
+      self.line = fields[fields.startIndex + 1]
+      self.column = fields[fields.startIndex + 2]
+      self.offset = fields[fields.startIndex + 3]
+    }
+  }
+
+  public struct FixIt {
+    /// Start location.
+    public var start: SourceLocation
+    /// End location.
+    public var end: SourceLocation
+    /// Fix-it replacement text.
+    public var text: String
+  }
+}
diff --git a/Tests/TSCUtilityTests/SerializedDiagnosticsTests.swift b/Tests/TSCUtilityTests/SerializedDiagnosticsTests.swift
@@ -1,8 +1,85 @@
-//
-//  File.swift
-//  
-//
-//  Created by Owen Voorhees on 9/1/20.
-//
+/*
+ This source file is part of the Swift.org open source project
 
+ Copyright (c) 2020 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+import XCTest
 import Foundation
+import TSCBasic
+import TSCUtility
+
+final class SerializedDiagnosticsTests: XCTestCase {
+  func testReadSwiftSerializedDiags() throws {
+    let serializedDiagnosticsPath = AbsolutePath(#file).parentDirectory
+        .appending(components: "Inputs", "serialized.dia")
+    let contents = try localFileSystem.readFileContents(serializedDiagnosticsPath)
+    let serializedDiags = try SerializedDiagnostics(data: Data(contents.contents))
+
+    XCTAssertEqual(serializedDiags.versionNumber, 1)
+    XCTAssertEqual(serializedDiags.diagnostics.count, 17)
+
+    let one = serializedDiags.diagnostics[5]
+    XCTAssertEqual(one.text, "expected ',' separator")
+    XCTAssertEqual(one.level, .error)
+    XCTAssertTrue(one.location.filename.hasSuffix("/StoreSearchCoordinator.swift"))
+    XCTAssertEqual(one.location.line, 21)
+    XCTAssertEqual(one.location.column, 69)
+    XCTAssertEqual(one.location.offset, 0)
+    XCTAssertNil(one.category)
+    XCTAssertNil(one.flag)
+    XCTAssertEqual(one.ranges.count, 0)
+    XCTAssertEqual(one.fixIts.count, 1)
+    XCTAssertEqual(one.fixIts[0].text, ",")
+    XCTAssertEqual(one.fixIts[0].start, one.fixIts[0].end)
+    XCTAssertTrue(one.fixIts[0].start.filename.hasSuffix("/StoreSearchCoordinator.swift"))
+    XCTAssertEqual(one.fixIts[0].start.line, 21)
+    XCTAssertEqual(one.fixIts[0].start.column, 69)
+    XCTAssertEqual(one.fixIts[0].start.offset, 0)
+
+    let two = serializedDiags.diagnostics[16]
+    XCTAssertEqual(two.text, "use of unresolved identifier 'DispatchQueue'")
+    XCTAssertEqual(two.level, .error)
+    XCTAssertTrue(two.location.filename.hasSuffix("/Observable.swift"))
+    XCTAssertEqual(two.location.line, 34)
+    XCTAssertEqual(two.location.column, 13)
+    XCTAssertEqual(two.location.offset, 0)
+    XCTAssertNil(two.category)
+    XCTAssertNil(two.flag)
+    XCTAssertEqual(two.ranges.count, 1)
+    XCTAssertTrue(two.ranges[0].0.filename.hasSuffix("/Observable.swift"))
+    XCTAssertEqual(two.ranges[0].0.line, 34)
+    XCTAssertEqual(two.ranges[0].0.column, 13)
+    XCTAssertEqual(two.ranges[0].0.offset, 0)
+    XCTAssertTrue(two.ranges[0].1.filename.hasSuffix("/Observable.swift"))
+    XCTAssertEqual(two.ranges[0].1.line, 34)
+    XCTAssertEqual(two.ranges[0].1.column, 26)
+    XCTAssertEqual(two.ranges[0].1.offset, 0)
+    XCTAssertEqual(two.fixIts.count, 0)
+  }
+
+  func testReadClangSerializedDiags() throws {
+    let serializedDiagnosticsPath = AbsolutePath(#file).parentDirectory
+        .appending(components: "Inputs", "clang.dia")
+    let contents = try localFileSystem.readFileContents(serializedDiagnosticsPath)
+    let serializedDiags = try SerializedDiagnostics(data: Data(contents.contents))
+
+    XCTAssertEqual(serializedDiags.versionNumber, 1)
+    XCTAssertEqual(serializedDiags.diagnostics.count, 4)
+
+    let one = serializedDiags.diagnostics[1]
+    XCTAssertEqual(one.text, "values of type 'NSInteger' should not be used as format arguments; add an explicit cast to 'long' instead")
+    XCTAssertEqual(one.level, .warning)
+    XCTAssertEqual(one.location.line, 252)
+    XCTAssertEqual(one.location.column, 137)
+    XCTAssertEqual(one.location.offset, 10046)
+    XCTAssertEqual(one.category, "Format String Issue")
+    XCTAssertEqual(one.flag, "format")
+    XCTAssertEqual(one.ranges.count, 4)
+    XCTAssertEqual(one.fixIts.count, 2)
+  }
+}
