refactored to add verbosity flag to output agnostic flags for clang ld and swift

Author: John Bute

Sources/SWBCore/BuildParameters.swift

@@ -191,7 +191,7 @@ public struct BuildParameters: Hashable, SerializableCodable, Sendable {
         try container.encodeIfPresent(activeRunDestination, forKey: .activeRunDestination)
         try container.encodeIfPresent(activeArchitecture, forKey: .activeArchitecture)
         try container.encodeIfPresent(arena, forKey: .arena)
-        try container.encode(filterOverrides(overrides), forKey: .overrides)
+        try container.encode(overrides, forKey: .overrides)
         try container.encode(commandLineOverrides, forKey: .commandLineOverrides)
         try container.encodeIfPresent(commandLineConfigOverridesPath, forKey: .commandLineConfigOverridesPath)
         try container.encode(commandLineConfigOverrides, forKey: .commandLineConfigOverrides)
@@ -228,7 +228,7 @@ public struct BuildParameters: Hashable, SerializableCodable, Sendable {
         hasher.combine(activeRunDestination)
         hasher.combine(activeArchitecture)
         hasher.combine(arena)
-        hasher.combine(filterOverrides(overrides))
+        hasher.combine(overrides)
         hasher.combine(commandLineOverrides)
         hasher.combine(commandLineConfigOverridesPath)
         hasher.combine(commandLineConfigOverrides)
@@ -237,15 +237,6 @@ public struct BuildParameters: Hashable, SerializableCodable, Sendable {
         hasher.combine(toolchainOverride)
         return hasher.finalize()
     }
-
-    private func filterOverrides(_ overrides: [String: String]) -> [String: String] {
-        overrides.mapValues { value in
-            // Remove -v flag from the value to avoid rebuild
-            value.split(separator: " ")
-                .filter { $0 != "-v" }
-                .joined(separator: " ")
-        }
-    }
 }
 
 extension BuildParameters {

Sources/SWBCore/SpecImplementations/CommandLineToolSpec.swift

@@ -399,8 +399,32 @@ open class CommandLineToolSpec : PropertyDomainSpec, SpecType, TaskTypeDescripti
         return false
     }
 
+    static let outputAgnosticCompilerArguments = Set<ByteString>([
+        "-v"
+    ])
+
+    func isOutputAgnosticCommandLineArgument(_ argument: ByteString, prevArgument: ByteString?) -> Bool {
+        if CommandLineToolSpec.outputAgnosticCompilerArguments.contains(argument) {
+            return true
+        }
+
+        return false
+    }
     public func commandLineForSignature(for task: any ExecutableTask) -> [ByteString]? {
-        return nil
+        // TODO: We should probably allow the specs themselves to mark options
+        // as output agnostic, rather than always postprocessing the command
+        // line. In some cases we will have to postprocess, because of settings
+        // like OTHER_SWIFT_FLAGS where the user can't possibly add this
+        // metadata to the values, but those settings be handled on a
+        // case-by-case basis.
+        return task.commandLine.indices.compactMap { index in
+            let arg = task.commandLine[index].asByteString
+            let prevArg = index > task.commandLine.startIndex ? task.commandLine[index - 1].asByteString : nil
+            if isOutputAgnosticCommandLineArgument(arg, prevArgument: prevArg) {
+                return nil
+            }
+            return arg
+        }
     }
 
     static func parseCommandLineTemplate(_ parser: SpecParser, _ components: [String]) -> [CommandLineTemplateArg] {

Sources/SWBCore/SpecImplementations/Tools/CCompiler.swift

@@ -733,7 +733,7 @@ public class ClangCompilerSpec : CompilerSpec, SpecIdentifierType, GCCCompatible
                 } else if ClangSourceFileIndexingInfo.skippedArgsWithoutValues.contains(argAsByteString) || arg.starts(with: "-fbuild-session-file=") {
                     // Relevant to indexing, so exclude arg from response file.
                     regularCommandLine.append(arg)
-                } else if isOutputAgnosticCommandLineArgument(argAsByteString, prevArgument: previousArg) {
+                } else if isOutputAgnosticCCompilerArgument(argAsByteString, prevArgument: previousArg) {
                     // Output agnostic, so exclude from response file.
                     regularCommandLine.append(arg)
                 } else if precompNeutralFlagPatterns.map({ $0.matches(arg) }).reduce(false, { $0 || $1 }) && !(previousArg ?? "").hasPrefix("-X") {
@@ -797,7 +797,7 @@ public class ClangCompilerSpec : CompilerSpec, SpecIdentifierType, GCCCompatible
         return fileType
     }
 
-    static let outputAgnosticCompilerArguments = Set<ByteString>([
+    static let outputAgnosticCCompilerArguments = Set<ByteString>([
         // https://clang.llvm.org/docs/UsersManual.html#formatting-of-diagnostics
         "-fshow-column",
         "-fno-show-column",
@@ -818,14 +818,15 @@ public class ClangCompilerSpec : CompilerSpec, SpecIdentifierType, GCCCompatible
         "-fdiagnostics-parseable-fixits",
         "-fno-elide-type",
         "-fdiagnostics-show-template-tree",
+        "-v",
 
         // https://clang.llvm.org/docs/ClangCommandLineReference.html
         "-fdiagnostics-show-note-include-stack",
         "-fno-diagnostics-show-note-include-stack",
         "-fmodules-validate-once-per-build-session",
     ])
 
-    static let outputAgnosticCompilerArgumentPrefixes = Set<ByteString>([
+    static let outputAgnosticCCompilerArgumentPrefixes = Set<ByteString>([
         // https://clang.llvm.org/docs/UsersManual.html#formatting-of-diagnostics
         "-fdiagnostics-format=",
         "-fdiagnostics-show-category=",
@@ -837,22 +838,22 @@ public class ClangCompilerSpec : CompilerSpec, SpecIdentifierType, GCCCompatible
         "-fbuild-session-timestamp=",
     ])
 
-    static let outputAgnosticCompilerArgumentsWithValues = Set<ByteString>([
+    static let outputAgnosticCCompilerArgumentsWithValues = Set<ByteString>([
         "-index-store-path",
         "-index-unit-output-path",
     ])
 
-    func isOutputAgnosticCommandLineArgument(_ argument: ByteString, prevArgument: ByteString?) -> Bool {
-        if ClangCompilerSpec.outputAgnosticCompilerArguments.contains(argument) ||
-           ClangCompilerSpec.outputAgnosticCompilerArgumentsWithValues.contains(argument) {
+    func isOutputAgnosticCCompilerArgument(_ argument: ByteString, prevArgument: ByteString?) -> Bool {
+        if ClangCompilerSpec.outputAgnosticCCompilerArguments.contains(argument) ||
+           ClangCompilerSpec.outputAgnosticCCompilerArgumentsWithValues.contains(argument) {
             return true
         }
 
-        if ClangCompilerSpec.outputAgnosticCompilerArgumentPrefixes.first(where: { argument.hasPrefix($0) }) != nil {
+        if ClangCompilerSpec.outputAgnosticCCompilerArgumentPrefixes.first(where: { argument.hasPrefix($0) }) != nil {
             return true
         }
 
-        if let prevArgument, ClangCompilerSpec.outputAgnosticCompilerArgumentsWithValues.contains(prevArgument) {
+        if let prevArgument, ClangCompilerSpec.outputAgnosticCCompilerArgumentsWithValues.contains(prevArgument) {
           return true
         }
 
@@ -868,7 +869,7 @@ public class ClangCompilerSpec : CompilerSpec, SpecIdentifierType, GCCCompatible
         return task.commandLine.indices.compactMap { index in
             let arg = task.commandLine[index].asByteString
             let prevArg = index > task.commandLine.startIndex ? task.commandLine[index - 1].asByteString : nil
-            if isOutputAgnosticCommandLineArgument(arg, prevArgument: prevArg) {
+            if isOutputAgnosticCCompilerArgument(arg, prevArgument: prevArg) {
                 return nil
             }
             return arg

Sources/SWBCore/SpecImplementations/Tools/SwiftCompiler.swift

@@ -1184,17 +1184,22 @@ public final class SwiftCompilerSpec : CompilerSpec, SpecIdentifierType, SwiftDi
         case invalid
     }
 
-    static let outputAgnosticCompilerArgumentsWithValues = Set<ByteString>([
+    static let outputAgnosticSwiftCompilerArguments = Set<ByteString>([
+        "-v"
+    ])
+
+    static let outputAgnosticSwiftCompilerArgumentsWithValues = Set<ByteString>([
         "-index-store-path",
         "-index-unit-output-path",
     ])
 
-    func isOutputAgnosticCommandLineArgument(_ argument: ByteString, prevArgument: ByteString?) -> Bool {
-        if SwiftCompilerSpec.outputAgnosticCompilerArgumentsWithValues.contains(argument) {
+    func isOutputAgnosticSwiftCompilerArgument(_ argument: ByteString, prevArgument: ByteString?) -> Bool {
+        if SwiftCompilerSpec.outputAgnosticSwiftCompilerArguments.contains(argument) ||
+            SwiftCompilerSpec.outputAgnosticSwiftCompilerArgumentsWithValues.contains(argument) {
             return true
         }
 
-        if let prevArgument, SwiftCompilerSpec.outputAgnosticCompilerArgumentsWithValues.contains(prevArgument) {
+        if let prevArgument, SwiftCompilerSpec.outputAgnosticSwiftCompilerArgumentsWithValues.contains(prevArgument) {
             return true
         }
 
@@ -1211,7 +1216,7 @@ public final class SwiftCompilerSpec : CompilerSpec, SpecIdentifierType, SwiftDi
         return task.commandLine.indices.compactMap { index in
             let arg = task.commandLine[index].asByteString
             let prevArg = index > task.commandLine.startIndex ? task.commandLine[index - 1].asByteString : nil
-            if isOutputAgnosticCommandLineArgument(arg, prevArgument: prevArg) {
+            if isOutputAgnosticSwiftCompilerArgument(arg, prevArgument: prevArg) {
                 return nil
             }
             return arg