only added to linker

Author: John Bute

Sources/SWBCore/SpecImplementations/CommandLineToolSpec.swift

@@ -399,32 +399,8 @@ 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]? {
-        // 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
-        }
+        nil
     }
 
     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 isOutputAgnosticCCompilerArgument(argAsByteString, prevArgument: previousArg) {
+                } else if isOutputAgnosticCommandLineArgument(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 outputAgnosticCCompilerArguments = Set<ByteString>([
+    static let outputAgnosticCompilerArguments = Set<ByteString>([
         // https://clang.llvm.org/docs/UsersManual.html#formatting-of-diagnostics
         "-fshow-column",
         "-fno-show-column",
@@ -818,15 +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 outputAgnosticCCompilerArgumentPrefixes = Set<ByteString>([
+    static let outputAgnosticCompilerArgumentPrefixes = Set<ByteString>([
         // https://clang.llvm.org/docs/UsersManual.html#formatting-of-diagnostics
         "-fdiagnostics-format=",
         "-fdiagnostics-show-category=",
@@ -838,22 +838,22 @@ public class ClangCompilerSpec : CompilerSpec, SpecIdentifierType, GCCCompatible
         "-fbuild-session-timestamp=",
     ])
 
-    static let outputAgnosticCCompilerArgumentsWithValues = Set<ByteString>([
+    static let outputAgnosticCompilerArgumentsWithValues = Set<ByteString>([
         "-index-store-path",
         "-index-unit-output-path",
     ])
 
-    func isOutputAgnosticCCompilerArgument(_ argument: ByteString, prevArgument: ByteString?) -> Bool {
-        if ClangCompilerSpec.outputAgnosticCCompilerArguments.contains(argument) ||
-           ClangCompilerSpec.outputAgnosticCCompilerArgumentsWithValues.contains(argument) {
+    func isOutputAgnosticCommandLineArgument(_ argument: ByteString, prevArgument: ByteString?) -> Bool {
+        if ClangCompilerSpec.outputAgnosticCompilerArguments.contains(argument) ||
+            ClangCompilerSpec.outputAgnosticCompilerArgumentsWithValues.contains(argument) {
             return true
         }
 
-        if ClangCompilerSpec.outputAgnosticCCompilerArgumentPrefixes.first(where: { argument.hasPrefix($0) }) != nil {
+        if ClangCompilerSpec.outputAgnosticCompilerArgumentPrefixes.first(where: { argument.hasPrefix($0) }) != nil {
             return true
         }
 
-        if let prevArgument, ClangCompilerSpec.outputAgnosticCCompilerArgumentsWithValues.contains(prevArgument) {
+        if let prevArgument, ClangCompilerSpec.outputAgnosticCompilerArgumentsWithValues.contains(prevArgument) {
           return true
         }
 
@@ -869,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 isOutputAgnosticCCompilerArgument(arg, prevArgument: prevArg) {
+            if isOutputAgnosticCommandLineArgument(arg, prevArgument: prevArg) {
                 return nil
             }
             return arg

Sources/SWBCore/SpecImplementations/Tools/LinkerTools.swift

@@ -302,6 +302,29 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec
         return ["ld", "libtool"]
     }
 
+    static let outputAgnosticLinkerArguments = Set<ByteString>([
+        "-v"
+    ])
+
+    func isOutputAgnosticLinkerArgument(_ argument: ByteString, prevArgument: ByteString?) -> Bool {
+        if LdLinkerSpec.outputAgnosticLinkerArguments.contains(argument) {
+            return true
+        }
+
+        return false
+    }
+
+    public override func commandLineForSignature(for task: any ExecutableTask) -> [ByteString]? {
+        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 isOutputAgnosticLinkerArgument(arg, prevArgument: prevArg) {
+                return nil
+            }
+            return arg
+        }
+    }
+
     public func sparseSDKSearchPathArguments(_ cbc: CommandBuildContext) -> [String] {
         var specialArgs = [String]()
 

Sources/SWBCore/SpecImplementations/Tools/SwiftCompiler.swift

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