Fix C++ warnings incorrectly classified as errors

.gitignore

@@ -14,3 +14,4 @@ DerivedData/
 
 # Xcode 11
 .swiftpm/
+RealTests/

Sources/XCLogParser/commands/CommandHandler.swift

@@ -71,6 +71,17 @@
         let reporterOutput = ReporterOutputFactory.makeReporterOutput(path: options.outputPath)
         let logReporter = options.reporter.makeLogReporter()
         try logReporter.report(build: buildSteps, output: reporterOutput, rootOutput: options.rootOutput)
+
+        // Exit with appropriate code based on build status
+        if shouldExitWithFailureCode(buildSteps: buildSteps) {
+            exit(1)
+        }
+    }
+
+    private func shouldExitWithFailureCode(buildSteps: BuildStep) -> Bool {
+        // Check if the main build failed
+        let buildStatus = buildSteps.buildStatus.lowercased()
+        return buildStatus.contains("failed") || buildStatus.contains("error")
     }
 
 }

Sources/XCLogParser/parser/BuildStep.swift

@@ -98,6 +98,8 @@ public enum DetailStepType: String, Encodable {
             return .cCompilation
         case Prefix("CompileSwift "):
             return .swiftCompilation
+        case Prefix("SwiftCompile "):
+            return .swiftCompilation
         case Prefix("Ld "):
             return .linker
         case Prefix("PhaseScriptExecution "):

Sources/XCLogParser/parser/Notice+Parser.swift

@@ -31,7 +31,8 @@
     /// - returns: An Array of `Notice`
     public static func parseFromLogSection(_ logSection: IDEActivityLogSection,
                                            forType type: DetailStepType,
-                                           truncLargeIssues: Bool)
+                                           truncLargeIssues: Bool,
+                                           isSubsection: Bool = false)
         -> [Notice] {
         var logSection = logSection
         if truncLargeIssues && logSection.messages.count > 100 {
@@ -60,7 +61,9 @@
             // Special case, Interface builder warning can only be spotted by checking the whole text of the
             // log section
             let noticeTypeTitle = message.categoryIdent.isEmpty ? logSection.text : message.categoryIdent
-            if var notice = Notice(withType: NoticeType.fromTitle(noticeTypeTitle),
+            let initialType = NoticeType.fromTitleAndSeverity(noticeTypeTitle, severity: message.severity)
+
+            if var notice = Notice(withType: initialType,
                                    logMessage: message,
                                    detail: logSection.text) {
                 // Add the right details to Swift errors
@@ -73,8 +76,8 @@
                         var errorLocation = notice.documentURL.replacingOccurrences(of: "file://", with: "")
                         errorLocation += ":\(notice.startingLineNumber):\(notice.startingColumnNumber):"
                         // do not report error in a file that it does not belong to (we'll ended
-                        // up having duplicated errors)
-                        if !logSection.location.documentURLString.isEmpty
+                        // up having duplicated errors) - but only for main sections, not subsections
+                        if !isSubsection && !logSection.location.documentURLString.isEmpty
                             && logSection.location.documentURLString != notice.documentURL {
                             return nil
                         }
@@ -164,8 +167,17 @@
         }
         return zip(logSection.messages, clangFlags)
             .compactMap { (message, warningFlag) -> Notice? in
-                // If the warning is treated as error, we marked the issue as error
-                let type: NoticeType = warningFlag.contains("-Werror") ? .clangError : .clangWarning
+                // Determine type based on both flags and severity
+                var type: NoticeType
+                if warningFlag.contains("-Werror") {
+                    type = .clangError
+                } else {
+                    // Use severity to determine if this should be treated as error or warning
+                    // Severity 2+ = error (treated as error by compiler)
+                    // Severity 1 = warning
+                    type = message.severity >= 2 ? .clangError : .clangWarning
+                }
+
                 let notice = Notice(withType: type, logMessage: message, clangFlag: warningFlag)
 
                 if let notice = notice,

Sources/XCLogParser/parser/NoticeType.swift

@@ -94,8 +94,48 @@
             return .swiftError
         case Suffix("failed with a nonzero exit code"):
             return .failedCommandError
+        case "No-usage":
+            return .swiftWarning
         default:
             return .note
         }
     }
+
+    /// Returns a NoticeType based on both categoryIdent title and severity level
+    /// This method handles ambiguous categories that can be either warnings or errors
+    /// Severity levels: 0 = note, 1 = warning, 2+ = error (treated as error by compiler)
+    public static func fromTitleAndSeverity(_ title: String, severity: Int) -> NoticeType? {
+        // First get the initial type from title
+        guard let initialType = fromTitle(title) else {
+            return nil
+        }
+
+        // Use severity to override type classification when needed
+        switch severity {
+        case 0:
+            return .note
+        case 1:
+            switch initialType {
+            case .clangError:
+                return .clangWarning
+            case .swiftError:
+                return .swiftWarning
+            default:
+                return initialType
+            }
+        case 2...:
+            switch initialType {
+            case .clangWarning, .projectWarning:
+                return .clangError
+            case .swiftWarning:
+                return .swiftError
+            case .note:
+                return .error
+            default:
+                return initialType
+            }
+        default:
+            return initialType
+        }
+    }
 }

Sources/XCLogParser/parser/ParserBuildSteps.swift

@@ -98,6 +98,31 @@
         self.truncLargeIssues = truncLargeIssues
     }
 
+    /// Collects all warnings and errors from a BuildStep tree and deduplicates them
+    /// - parameter buildStep: The root BuildStep to collect notices from
+    /// - returns: A tuple of (warnings, errors) arrays with duplicates removed
+    private func collectAndDeduplicateNotices(from buildStep: BuildStep) -> ([Notice], [Notice]) {
+        var allWarnings: [Notice] = []
+        var allErrors: [Notice] = []
+
+        func collectNotices(from step: BuildStep) {
+            if let warnings = step.warnings {
+                allWarnings.append(contentsOf: warnings)
+            }
+            if let errors = step.errors {
+                allErrors.append(contentsOf: errors)
+            }
+
+            for subStep in step.subSteps {
+                collectNotices(from: subStep)
+            }
+        }
+
+        collectNotices(from: buildStep)
+
+        return (allWarnings.removingDuplicates(), allErrors.removingDuplicates())
+    }
+
     /// Parses the content from an Xcode log into a `BuildStep`
     /// - parameter activityLog: An `IDEActivityLog`
     /// - returns: A `BuildStep` with the parsed content from the log.
@@ -106,8 +131,12 @@
         buildStatus = BuildStatusSanitizer.sanitize(originalStatus: activityLog.mainSection.localizedResultString)
         let mainSectionWithTargets = activityLog.mainSection.groupedByTarget()
         var mainBuildStep = try parseLogSection(logSection: mainSectionWithTargets, type: .main, parentSection: nil)
-        mainBuildStep.errorCount = totalErrors
-        mainBuildStep.warningCount = totalWarnings
+
+        // Collect and deduplicate all warnings and errors from the entire build tree
+        let (deduplicatedWarnings, deduplicatedErrors) = collectAndDeduplicateNotices(from: mainBuildStep)
+        mainBuildStep.errorCount = deduplicatedErrors.count
+        mainBuildStep.warningCount = deduplicatedWarnings.count
+
         mainBuildStep = decorateWithSwiftcTimes(mainBuildStep)
         return mainBuildStep
     }
@@ -131,7 +160,41 @@
                 targetErrors = 0
                 targetWarnings = 0
             }
-            let notices = parseWarningsAndErrorsFromLogSection(logSection, forType: detailType)
+            var notices = parseWarningsAndErrorsFromLogSection(logSection, forType: detailType)
+
+
+            // For Swift compilations and other compilation types, also check subsections for errors/warnings
+            // Also ensure Swift file-level compilations are processed correctly
+            if (detailType == .swiftCompilation || detailType == .cCompilation || detailType == .other) && !logSection.subSections.isEmpty {
+                // Initialize notices if nil
+                if notices == nil {
+                    notices = ["warnings": [], "errors": [], "notes": []]
+                }
+
+                for subSection in logSection.subSections {
+                    if let subNotices = parseWarningsAndErrorsFromLogSectionAsSubsection(subSection, forType: detailType) {
+                        // Merge subsection notices with parent section notices
+                        if let parentWarnings = notices?["warnings"], let subWarnings = subNotices["warnings"] {
+                            notices?["warnings"] = parentWarnings + subWarnings
+                        } else if let subWarnings = subNotices["warnings"] {
+                            notices?["warnings"] = subWarnings
+                        }
+
+                        if let parentErrors = notices?["errors"], let subErrors = subNotices["errors"] {
+                            notices?["errors"] = parentErrors + subErrors
+                        } else if let subErrors = subNotices["errors"] {
+                            notices?["errors"] = subErrors
+                        }
+
+                        if let parentNotes = notices?["notes"], let subNotes = subNotices["notes"] {
+                            notices?["notes"] = parentNotes + subNotes
+                        } else if let subNotes = subNotices["notes"] {
+                            notices?["notes"] = subNotes
+                        }
+                    }
+                }
+            }
+
             let warnings: [Notice]? = notices?["warnings"]
             let errors: [Notice]? = notices?["errors"]
             let notes: [Notice]? = notices?["notes"]
@@ -146,6 +209,7 @@
                 totalWarnings += warnings.count
                 targetWarnings += warnings.count
             }
+
             var step = BuildStep(type: type,
                                  machineName: machineName,
                                  buildIdentifier: self.buildIdentifier,
@@ -310,6 +374,14 @@
                 "errors": notices.getErrors(),
                 "notes": notices.getNotes()]
     }
+
+    private func parseWarningsAndErrorsFromLogSectionAsSubsection(_ logSection: IDEActivityLogSection, forType type: DetailStepType)
+        -> [String: [Notice]]? {
+        let notices = Notice.parseFromLogSection(logSection, forType: type, truncLargeIssues: truncLargeIssues, isSubsection: true)
+        return ["warnings": notices.getWarnings(),
+                "errors": notices.getErrors(),
+                "notes": notices.getNotes()]
+    }
 
     private func decorateWithSwiftcTimes(_ mainStep: BuildStep) -> BuildStep {
         swiftCompilerParser.parse()
@@ -395,4 +467,4 @@
                          andCompilationDuration: lastStep.compilationEndTimestamp - app.startTimestamp)
     }
 
 }