Merge branch 'master' into hs/fix-wip

Author: AvdLee

Sources/XCLogParser/activityparser/ActivityParser.swift

@@ -380,12 +380,27 @@ public class ActivityParser {
             }
 
             if className == "IDEFoundation.\(String(describing: IDEActivityLogSectionAttachment.self))" {
-                let jsonType = IDEActivityLogSectionAttachment.BuildOperationTaskMetrics.self
-                return try IDEActivityLogSectionAttachment(identifier: try parseAsString(token: iterator.next()),
-                                                           majorVersion: try parseAsInt(token: iterator.next()),
-                                                           minorVersion: try parseAsInt(token: iterator.next()),
-                                                           metrics: try parseAsJson(token: iterator.next(),
-                                                                                    type: jsonType))
+                let identifier = try parseAsString(token: iterator.next())
+                switch identifier.components(separatedBy: "ActivityLogSectionAttachment.").last {
+                case .some("TaskMetrics"):
+                    let jsonType = IDEActivityLogSectionAttachment.BuildOperationTaskMetrics.self
+                    return try IDEActivityLogSectionAttachment(identifier: identifier,
+                                                               majorVersion: try parseAsInt(token: iterator.next()),
+                                                               minorVersion: try parseAsInt(token: iterator.next()),
+                                                               metrics: try parseAsJson(token: iterator.next(),
+                                                                                         type: jsonType),
+                                                                backtrace: nil)
+                case .some("TaskBacktrace"):
+                    let jsonType = IDEActivityLogSectionAttachment.BuildOperationTaskBacktrace.self
+                    return try IDEActivityLogSectionAttachment(identifier: identifier,
+                                                               majorVersion: try parseAsInt(token: iterator.next()),
+                                                               minorVersion: try parseAsInt(token: iterator.next()),
+                                                               metrics: nil,
+                                                               backtrace: try parseAsJson(token: iterator.next(),
+                                                                                         type: jsonType))
+                default:
+                    throw XCLogParserError.parseError("Unexpected attachment identifier \(identifier)")
+                }
             }
             throw XCLogParserError.parseError("Unexpected className found parsing IDEConsoleItem \(className)")
     }

Sources/XCLogParser/activityparser/IDEActivityModel.swift

@@ -658,16 +658,115 @@ public class IDEActivityLogSectionAttachment: Encodable {
     public let majorVersion: UInt64
     public let minorVersion: UInt64
     public let metrics: BuildOperationTaskMetrics?
+    public let backtrace: BuildOperationTaskBacktrace?
 
     public init(
         identifier: String,
         majorVersion: UInt64,
         minorVersion: UInt64,
-        metrics: BuildOperationTaskMetrics?
+        metrics: BuildOperationTaskMetrics?,
+        backtrace: BuildOperationTaskBacktrace?
     ) throws {
         self.identifier = identifier
         self.majorVersion = majorVersion
         self.minorVersion = minorVersion
         self.metrics = metrics
+        self.backtrace = backtrace
+    }
+
+    public struct BuildOperationTaskBacktrace: Codable {
+        public let frames: [BuildOperationTaskBacktraceFrame]
+
+        public init(from decoder: any Decoder) throws {
+            let container = try decoder.singleValueContainer()
+            self.frames = try container.decode([BuildOperationTaskBacktraceFrame].self)
+        }
+
+        public func encode(to encoder: any Encoder) throws {
+            var container = encoder.singleValueContainer()
+            try container.encode(frames)
+        }
+    }
+
+    public struct BuildOperationTaskBacktraceFrame: Codable {
+        public let category: BuildOperationTaskBacktraceCategory
+        public let description: String
+    }
+
+    public enum BuildOperationTaskBacktraceCategory: String, Codable {
+        case ruleHadInvalidValue
+        case ruleSignatureChanged
+        case ruleNeverBuilt
+        case ruleInputRebuilt
+        case ruleForced
+        case dynamicTaskRegistration
+        case dynamicTaskRequest
+        case none
+
+        public init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: BuildOperationTaskBacktraceCategoryCodingKeys.self)
+
+            if container.contains(.ruleHadInvalidValue) {
+                self = .ruleHadInvalidValue
+            } else if container.contains(.ruleSignatureChanged) {
+                self = .ruleSignatureChanged
+            } else if container.contains(.ruleNeverBuilt) {
+                self = .ruleNeverBuilt
+            } else if container.contains(.ruleInputRebuilt) {
+                self = .ruleInputRebuilt
+            } else if container.contains(.ruleForced) {
+                self = .ruleForced
+            } else if container.contains(.dynamicTaskRegistration) {
+                self = .dynamicTaskRegistration
+            } else if container.contains(.dynamicTaskRequest) {
+                self = .dynamicTaskRequest
+            } else if container.contains(.none) {
+                self = .none
+            } else {
+                throw DecodingError.dataCorrupted(
+                    DecodingError.Context(
+                        codingPath: decoder.codingPath,
+                        debugDescription: "Unknown task backtrace category"
+                    )
+                )
+            }
+        }
+
+        public func encode(to encoder: Encoder) throws {
+            var container = encoder.container(keyedBy: BuildOperationTaskBacktraceCategoryCodingKeys.self)
+            switch self {
+            case .ruleHadInvalidValue:
+                try container.encode(EmptyObject(), forKey: .ruleHadInvalidValue)
+            case .ruleSignatureChanged:
+                try container.encode(EmptyObject(), forKey: .ruleSignatureChanged)
+            case .ruleNeverBuilt:
+                try container.encode(EmptyObject(), forKey: .ruleNeverBuilt)
+            case .ruleInputRebuilt:
+                try container.encode(EmptyObject(), forKey: .ruleInputRebuilt)
+            case .ruleForced:
+                try container.encode(EmptyObject(), forKey: .ruleForced)
+            case .dynamicTaskRegistration:
+                try container.encode(EmptyObject(), forKey: .dynamicTaskRegistration)
+            case .dynamicTaskRequest:
+                try container.encode(EmptyObject(), forKey: .dynamicTaskRequest)
+            case .none:
+                try container.encode(EmptyObject(), forKey: .none)
+            }
+        }
+    }
+
+    private enum BuildOperationTaskBacktraceCategoryCodingKeys: String, CodingKey {
+        case ruleHadInvalidValue
+        case ruleSignatureChanged
+        case ruleNeverBuilt
+        case ruleInputRebuilt
+        case ruleForced
+        case dynamicTaskRegistration
+        case dynamicTaskRequest
+        case none
+    }
+
+    private struct EmptyObject: Codable {
+        // Empty struct for objects with no properties
     }
 }

Sources/XCLogParser/commands/Version.swift

@@ -21,6 +21,6 @@ import Foundation
 
 public struct Version {
 
-    public static let current = "0.2.39"
+    public static let current = "0.2.43"
 
 }

Sources/XCLogParser/lexer/Index+Offset.swift

@@ -0,0 +1,30 @@
+// Copyright (c) 2019 Spotify AB.
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import Foundation
+
+extension String.Index {
+    init(compilerSafeOffset offset: Int, in string: String) {
+#if swift(>=5.0)
+        self = String.Index(utf16Offset: offset, in: string)
+#else
+        self = String.Index(encodedOffset: offset)
+#endif
+    }
+}

Sources/XCLogParser/lexer/Lexer.swift

@@ -23,7 +23,7 @@ public final class Lexer {
 
     static let SLFHeader = "SLF"
 
-    let typeDelimiters: CharacterSet
+    let typeDelimiters: Set<Character>
     let filePath: String
     var classNames = [String]()
     var userDirToRedact: String? {
@@ -38,7 +38,7 @@ public final class Lexer {
 
     public init(filePath: String) {
         self.filePath = filePath
-        self.typeDelimiters = CharacterSet(charactersIn: TokenType.all())
+        self.typeDelimiters = Set(TokenType.all())
         self.redactor = LexRedactor()
     }
 
@@ -53,15 +53,18 @@ public final class Lexer {
                          redacted: Bool,
                          withoutBuildSpecificInformation: Bool) throws -> [Token] {
         let scanner = Scanner(string: contents)
+
         guard scanSLFHeader(scanner: scanner) else {
             throw XCLogParserError.invalidLogHeader(filePath)
         }
+
         var tokens = [Token]()
         while !scanner.isAtEnd {
+
             guard let logTokens = scanSLFType(scanner: scanner,
                                               redacted: redacted,
                                               withoutBuildSpecificInformation: withoutBuildSpecificInformation),
-                logTokens.isEmpty == false else {
+                  logTokens.isEmpty == false else {
                 print(tokens)
                 throw XCLogParserError.invalidLine(scanner.approximateLine)
             }
@@ -71,20 +74,15 @@ public final class Lexer {
     }
 
     private func scanSLFHeader(scanner: Scanner) -> Bool {
-        #if os(Linux)
-        var format: String?
-        #else
-        var format: NSString?
-        #endif
-        return scanner.scanString(Lexer.SLFHeader, into: &format)
+        return scanner.scan(string: Lexer.SLFHeader)
     }
 
-    private func scanSLFType(scanner: Scanner, redacted: Bool, withoutBuildSpecificInformation: Bool) -> [Token]? {
+    private func scanSLFType(scanner: Scanner,
+                             redacted: Bool,
+                             withoutBuildSpecificInformation: Bool) -> [Token]? {
+        let payload = self.scanPayload(scanner: scanner)
 
-        guard let payload = scanPayload(scanner: scanner) else {
-            return nil
-        }
-        guard let tokenTypes = scanTypeDelimiter(scanner: scanner), tokenTypes.count > 0 else {
+        guard let tokenTypes = self.scanTypeDelimiter(scanner: scanner), tokenTypes.count > 0 else {
             return nil
         }
 
@@ -97,44 +95,30 @@ public final class Lexer {
         }
     }
 
-    private func scanPayload(scanner: Scanner) -> String? {
-        var payload: String = ""
-        #if os(Linux)
-        var char: String?
-        #else
-        var char: NSString?
-        #endif
+    private func scanPayload(scanner: Scanner) -> String {
         let hexChars = "abcdef0123456789"
-        while scanner.scanCharacters(from: CharacterSet(charactersIn: hexChars), into: &char),
-              let char = char as String? {
-            payload.append(char)
-        }
-        return payload
+        let characterSet = Set(hexChars)
+        return scanner.scanCharacters(from: characterSet) ?? ""
     }
 
     private func scanTypeDelimiter(scanner: Scanner) -> [TokenType]? {
-        #if os(Linux)
-        var delimiters: String?
-        #else
-        var delimiters: NSString?
-        #endif
-        if scanner.scanCharacters(from: typeDelimiters, into: &delimiters), let delimiters = delimiters {
-            let delimiters = String(delimiters)
-            if delimiters.count > 1 {
-                // if we found a string, we discard other type delimiters because there are part of the string
-                let tokenString = TokenType.string
-                if let char = delimiters.first, tokenString.rawValue == String(char) {
-                    scanner.scanLocation -= delimiters.count - 1
-                    return [tokenString]
-                }
-            }
-            // sometimes we found one or more nil list (-) next to the type delimiter
-            // in that case we'll return the delimiter and one or more `Token.null`
-            return delimiters.compactMap { character -> TokenType? in
-                TokenType(rawValue: String(character))
+        guard let delimiters = scanner.scanCharacters(from: self.typeDelimiters) else {
+            return nil
+        }
+
+        if delimiters.count > 1 {
+            // if we found a string, we discard other type delimiters because there are part of the string
+            let tokenString = TokenType.string
+            if let char = delimiters.first, tokenString.rawValue == String(char) {
+                scanner.moveOffset(by: -(delimiters.count - 1))
+                return [tokenString]
             }
         }
-        return nil
+        // sometimes we found one or more nil list (-) next to the type delimiter
+        // in that case we'll return the delimiter and one or more `Token.null`
+        return delimiters.compactMap { character -> TokenType? in
+            TokenType(rawValue: String(character))
+        }
     }
 
     private func scanToken(scanner: Scanner,
@@ -252,19 +236,12 @@ public final class Lexer {
                             scanner: Scanner,
                             redacted: Bool,
                             withoutBuildSpecificInformation: Bool) -> String? {
-        guard let value = Int(length) else {
+        guard let value = Int(length), let scannedResult = scanner.scan(count: value) else {
             print("error parsing string")
             return nil
         }
-        #if swift(>=5.0)
-        let start = String.Index(utf16Offset: scanner.scanLocation, in: scanner.string)
-        let end = String.Index(utf16Offset: scanner.scanLocation + value, in: scanner.string)
-        #else
-        let start = String.Index(encodedOffset: scanner.scanLocation)
-        let end = String.Index(encodedOffset: scanner.scanLocation + value)
-        #endif
-        scanner.scanLocation += value
-        var result = String(scanner.string[start..<end])
+
+        var result = scannedResult
         if redacted {
             result = redactor.redactUserDir(string: result)
         }
@@ -285,19 +262,18 @@ public final class Lexer {
     }
 }
 
-extension Scanner {
+private extension Scanner {
     var approximateLine: String {
-        let endCount = string.count - scanLocation > 21 ? scanLocation + 21 : string.count - scanLocation
-        #if swift(>=5.0)
-        let start = String.Index(utf16Offset: scanLocation, in: self.string)
-        let end = String.Index(utf16Offset: endCount, in: self.string)
-        #else
-        let start = String.Index(encodedOffset: scanLocation)
-        let end = String.Index(encodedOffset: endCount)
-        #endif
+        let currentLocation = self.offset
+        let contentSize = self.string.count
+
+        let start = String.Index(compilerSafeOffset: currentLocation, in: self.string)
+        let endCount = contentSize - currentLocation > 21 ? currentLocation + 21 : contentSize - currentLocation
+        let end = String.Index(compilerSafeOffset: endCount, in: self.string)
+
         if end <= start {
-            return String(string[start..<string.endIndex])
+            return String(self.string[start..<self.stringEndIndex])
         }
-        return String(string[start..<end])
+        return String(self.string[start..<end])
     }
 }