Add project path information to errors & warnings from linker.

rdar://157313332

Author: brooke-callahan

Sources/SWBCore/ProjectModel/Workspace.swift

@@ -262,6 +262,24 @@ public final class Workspace: ProjectModelItem, PIFObject, ReferenceLookupContex
         return project
     }
 
+    public static func projectPath(for target: Target, workspace: Workspace) -> Path {
+        let project = workspace.project(for: target)
+        return project.xcodeprojPath
+    }
+
+    public static func projectLocation(for configuredTarget: ConfiguredTarget?, workspaceContext: WorkspaceContext?) -> Diagnostic.Location {
+        let location: Diagnostic.Location
+        if let target = configuredTarget?.target,
+           let workspace = workspaceContext?.workspace {
+            let path = self.projectPath(for: target, workspace: workspace)
+            location = Diagnostic.Location.path(path, fileLocation: nil)
+        }
+        else {
+            location = .unknown
+        }
+        return location
+    }
+
     /// Find the projects with the given name.
     public func projects(named name: String) -> [Project] {
         return projectsByName[name] ?? []

Sources/SWBCore/SpecImplementations/CommandLineToolSpec.swift

@@ -1463,7 +1463,7 @@ open class GenericOutputParser : TaskOutputParser {
     public let toolBasenames: Set<String>
 
     /// Buffered output that has not yet been parsed (parsing is line-by-line, so we buffer incomplete lines until we receive more output).
-    private var unparsedBytes: ArraySlice<UInt8> = []
+    internal var unparsedBytes: ArraySlice<UInt8> = []
 
     /// The Diagnostic that is being constructed, possibly across multiple lines of input.
     private var inProgressDiagnostic: Diagnostic?

Sources/SWBCore/SpecImplementations/LinkerSpec.swift

@@ -144,7 +144,7 @@ open class LinkerSpec : CommandLineToolSpec, @unchecked Sendable {
     }
 
     /// Custom entry point for constructing linker tasks.
-    public func constructLinkerTasks(_ cbc: CommandBuildContext, _ delegate: any TaskGenerationDelegate, libraries: [LibrarySpecifier], usedTools: [CommandLineToolSpec: Set<FileTypeSpec>]) async {
+    public func constructLinkerTasks(_ cbc: CommandBuildContext, _ delegate: any TaskGenerationDelegate, libraries: [LibrarySpecifier], usedTools: [CommandLineToolSpec: Set<FileTypeSpec>], workspaceContext: WorkspaceContext) async {
         /// Delegate to the generic machinery.
         await delegate.createTask(type: self, ruleInfo: defaultRuleInfo(cbc, delegate), commandLine: commandLineFromTemplate(cbc, delegate, optionContext: discoveredCommandLineToolSpecInfo(cbc.producer, cbc.scope, delegate)).map(\.asString), environment: environmentFromSpec(cbc, delegate), workingDirectory: cbc.producer.defaultWorkingDirectory, inputs: cbc.inputs.map({ $0.absolutePath }), outputs: [cbc.output], action: createTaskAction(cbc, delegate), execDescription: resolveExecutionDescription(cbc, delegate), enableSandboxing: enableSandboxing)
     }

Sources/SWBCore/SpecImplementations/Tools/LinkerTools.swift

@@ -176,6 +176,60 @@ public struct DiscoveredLdLinkerToolSpecInfo: DiscoveredCommandLineToolSpecInfo
     /// Maximum number of undefined symbols to emit.  Might be configurable in the future.
     let undefinedSymbolCountLimit = 100
 
+    override public func write(bytes: ByteString) {
+
+        // Split the buffer into slices separated by newlines.  The last slice represents the partial last line (there always is one, even if it's empty).
+        var lines = bytes.split(separator: UInt8(ascii: "\n"), maxSplits: .max, omittingEmptySubsequences: false)
+
+        // Any unparsed bytes belong to the first line. We don't want to run `split` over these because it can lead to accidentally quadratic behavior if write is called many times per line.
+        lines[0] = unparsedBytes + lines[0]
+        
+        let linesToParse = lines.dropLast()
+
+        if let target = self.task.forTarget?.target {
+            // Linker errors and warnings take more effort to get actionable information out of build logs than those for source files. This is because the linker does not have the path to the project or target name so they are not included in the message.
+            //
+            // Prepend the path to the project and target name to any error or warning lines.
+            // Example input:
+            // ld: warning: linking with (/System/Library/Frameworks/CoreAudio.framework/Versions/A/CoreAudio) but not using any symbols from it
+            // Example output:
+            // /Path/To/ProjectFolder/ProjectName.xcodeproj: TargetName: ld: warning: linking with (/System/Library/Frameworks/CoreAudio.framework/Versions/A/CoreAudio) but not using any symbols from it
+
+            let workspace = self.workspaceContext.workspace
+            let projectPath = Workspace.projectPath(for: target, workspace: workspace)
+            let targetName = target.name
+
+            let processedLines: [ByteString] = linesToParse.map { lineBytes in
+                let lineString = String(decoding: lineBytes, as: Unicode.UTF8.self)
+                if lineString.contains(": error:")
+                    || lineString.contains(": warning:") {
+                    
+                    let issueString = "\(projectPath.str): \(targetName): \(lineString)"
+                    return ByteString(encodingAsUTF8: issueString)
+                }
+                return ByteString(lineBytes)
+            }
+            
+            // Forward the bytes
+            let processedBytes = ByteString(processedLines.joined(separator: ByteString("\n")))
+            delegate.emitOutput(processedBytes)
+        }
+        else {
+            // Forward the bytes
+            let processedBytes = ByteString(linesToParse.joined(separator: ByteString("\n")))
+            delegate.emitOutput(processedBytes)
+        }
+        
+        // Parse any complete lines of output.
+        for line in linesToParse {
+            parseLine(line)
+        }
+        
+        // Track the last, incomplete line to as the unparsed bytes.
+        unparsedBytes = lines.last ?? []
+    }
+
+    @discardableResult
     override func parseLine<S: Collection>(_ lineBytes: S) -> Bool where S.Element == UInt8 {
 
         // Create a string that we can examine.  Use the non-failable constructor, so that we are robust against potentially invalid UTF-8.
@@ -190,11 +244,13 @@ public struct DiscoveredLdLinkerToolSpecInfo: DiscoveredCommandLineToolSpecInfo
             }
             else if let match = LdLinkerOutputParser.problemMessageRegEx.firstMatch(in: lineString), match[3].hasPrefix("symbol(s) not found") {
                 // It's time to emit all the symbols.  We emit each as a separate message.
+                let projectLocation = Workspace.projectLocation(for: self.task.forTarget, workspaceContext: self.workspaceContext)
+
                 for symbol in undefinedSymbols.prefix(undefinedSymbolCountLimit) {
-                    delegate.diagnosticsEngine.emit(Diagnostic(behavior: .error, location: .unknown, data: DiagnosticData("Undefined symbol: \(symbol)"), appendToOutputStream: false))
+                    delegate.diagnosticsEngine.emit(Diagnostic(behavior: .error, location: projectLocation, data: DiagnosticData("Undefined symbol: \(symbol)"), appendToOutputStream: false))
                 }
                 if undefinedSymbols.count > undefinedSymbolCountLimit {
-                    delegate.diagnosticsEngine.emit(Diagnostic(behavior: .note, location: .unknown, data: DiagnosticData("(\(undefinedSymbols.count - undefinedSymbolCountLimit) additional undefined symbols are shown in the transcript"), appendToOutputStream: false))
+                    delegate.diagnosticsEngine.emit(Diagnostic(behavior: .note, location: projectLocation, data: DiagnosticData("(\(undefinedSymbols.count - undefinedSymbolCountLimit) additional undefined symbols are shown in the transcript"), appendToOutputStream: false))
                 }
                 collectingUndefinedSymbols = false
                 undefinedSymbols = []
@@ -213,7 +269,8 @@ public struct DiscoveredLdLinkerToolSpecInfo: DiscoveredCommandLineToolSpecInfo
             let severity = match[2].isEmpty ? "error" : match[2]
             let behavior = Diagnostic.Behavior(name: severity) ?? .note
             let message = match[3].prefix(1).localizedCapitalized + match[3].dropFirst()
-            let diagnostic = Diagnostic(behavior: behavior, location: .unknown, data: DiagnosticData(message), appendToOutputStream: false)
+            let projectLocation = Workspace.projectLocation(for: self.task.forTarget, workspaceContext: self.workspaceContext)
+            let diagnostic = Diagnostic(behavior: behavior, location: projectLocation, data: DiagnosticData(message), appendToOutputStream: false)
             delegate.diagnosticsEngine.emit(diagnostic)
         }
         return true
@@ -320,7 +377,7 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec
         }
     }
 
-    override public func constructLinkerTasks(_ cbc: CommandBuildContext, _ delegate: any TaskGenerationDelegate, libraries: [LibrarySpecifier], usedTools: [CommandLineToolSpec: Set<FileTypeSpec>]) async {
+    override public func constructLinkerTasks(_ cbc: CommandBuildContext, _ delegate: any TaskGenerationDelegate, libraries: [LibrarySpecifier], usedTools: [CommandLineToolSpec: Set<FileTypeSpec>], workspaceContext: WorkspaceContext) async {
         let resolvedLinkerDriver = Self.resolveLinkerDriver(cbc, usedTools: usedTools)
         let linkerDriverLookup: ((MacroDeclaration) -> MacroStringExpression?) = { macro in
             switch macro {
@@ -672,7 +729,7 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec
         await inputs.append(contentsOf: additionalInputDependencies(cbc, delegate, optionContext: discoveredCommandLineToolSpecInfo(cbc.producer, cbc.scope, delegate), lookup: lookup).map(delegate.createNode))
 
         // Add dependencies for any arguments indicating a file path.
-        Self.addAdditionalDependenciesFromCommandLine(cbc, commandLine, environment, &inputs, &outputs, delegate)
+        Self.addAdditionalDependenciesFromCommandLine(cbc, commandLine, environment, &inputs, &outputs, delegate, workspaceContext: workspaceContext)
 
         let architecture = cbc.scope.evaluate(BuiltinMacros.arch)
         let buildVariant = cbc.scope.evaluate(BuiltinMacros.variant)
@@ -721,15 +778,16 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec
         delegate.createTask(type: self, dependencyData: dependencyInfo, payload: payload, ruleInfo: defaultRuleInfo(cbc, delegate), commandLine: commandLine, environment: environment, workingDirectory: cbc.producer.defaultWorkingDirectory, inputs: inputs + otherInputs, outputs: outputs, action: delegate.taskActionCreationDelegate.createDeferredExecutionTaskActionIfRequested(userPreferences: cbc.producer.userPreferences), execDescription: resolveExecutionDescription(cbc, delegate), enableSandboxing: enableSandboxing)
     }
 
-    public static func addAdditionalDependenciesFromCommandLine(_ cbc: CommandBuildContext, _ commandLine: [String], _ environment: EnvironmentBindings, _ inputs: inout [any PlannedNode], _ outputs: inout [any PlannedNode], _ delegate: any TaskGenerationDelegate) {
+    public static func addAdditionalDependenciesFromCommandLine(_ cbc: CommandBuildContext, _ commandLine: [String], _ environment: EnvironmentBindings, _ inputs: inout [any PlannedNode], _ outputs: inout [any PlannedNode], _ delegate: any TaskGenerationDelegate, workspaceContext: WorkspaceContext) {
         guard cbc.scope.evaluate(BuiltinMacros._DISCOVER_COMMAND_LINE_LINKER_INPUTS) else {
             return
         }
 
         enumerateLinkerCommandLine(arguments: commandLine, handleWl: cbc.scope.evaluate(BuiltinMacros._DISCOVER_COMMAND_LINE_LINKER_INPUTS_INCLUDE_WL)) { arg, value in
             func emitDependencyDiagnostic(type: String, node: PlannedPathNode) {
                 if delegate.userPreferences.enableDebugActivityLogs {
-                    delegate.note("Added \(type) dependency '\(node.path.str)' from command line argument \(arg)", location: .unknown)
+                    let projectLocation = Workspace.projectLocation(for: cbc.producer.configuredTarget, workspaceContext: workspaceContext)
+                    delegate.note("Added \(type) dependency '\(node.path.str)' from command line argument \(arg)", location: projectLocation)
                 }
             }
 
@@ -1592,7 +1650,7 @@ public final class LibtoolLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @u
         return delegate.taskActionCreationDelegate.createLinkerTaskAction(expandResponseFiles: !useResponseFile)
     }
 
-    override public func constructLinkerTasks(_ cbc: CommandBuildContext, _ delegate: any TaskGenerationDelegate, libraries: [LibrarySpecifier], usedTools: [CommandLineToolSpec: Set<FileTypeSpec>]) async {
+    override public func constructLinkerTasks(_ cbc: CommandBuildContext, _ delegate: any TaskGenerationDelegate, libraries: [LibrarySpecifier], usedTools: [CommandLineToolSpec: Set<FileTypeSpec>], workspaceContext: WorkspaceContext) async {
         var inputPaths = cbc.inputs.map({ $0.absolutePath })
         var specialArgs = [String]()
 

Sources/SWBTaskConstruction/TaskProducers/BuildPhaseTaskProducers/SourcesTaskProducer.swift

@@ -979,8 +979,10 @@ package final class SourcesTaskProducer: FilesBasedBuildPhaseTaskProducerBase, F
                         let linkerInputs = linkerInputNodes.map { FileToBuild(context: context, absolutePath: $0.path) }
                         let actualOutput = outputPreviewDylib ?? output
                         let actualCommandOrderingOutputs = !commandOrderingOutputsPreviewDylib.isEmpty ? commandOrderingOutputsPreviewDylib : commandOrderingOutputs
+                        let workspaceContext = context.workspaceContext
 
-                        await linkerSpec.constructLinkerTasks(CommandBuildContext(producer: context, scope: scope, inputs: linkerInputs, output: actualOutput, commandOrderingInputs: additionalLinkerOrderingInputs, commandOrderingOutputs: actualCommandOrderingOutputs), delegate, libraries: librariesToLink, usedTools: usedTools)
+                        // In SourcesTaskProducer.swift, modify the call:
+                        await linkerSpec.constructLinkerTasks(CommandBuildContext(producer: context, scope: scope, inputs: linkerInputs, output: actualOutput, commandOrderingInputs: additionalLinkerOrderingInputs, commandOrderingOutputs: actualCommandOrderingOutputs), delegate, libraries: librariesToLink, usedTools: usedTools, workspaceContext: workspaceContext)
                     }
 
                     if let outputPreviewDylib, let outputPreviewBlankInjectionDylib {