func handle()

in Sources/Workspace/DefaultPluginScriptRunner.swift [397:470]
66 lines of code
16 McCabe index (conditional complexity)

        func handle(message: PluginToHostMessage) throws {
            dispatchPrecondition(condition: .onQueue(callbackQueue))
            switch message {
                
            case .emitDiagnostic(let severity, let message, let file, let line):
                let metadata: ObservabilityMetadata? = file.map {
                    var metadata = ObservabilityMetadata()
                    // FIXME: We should probably report some kind of protocol error if the path isn't valid.
                    metadata.fileLocation = try? .init(.init(validating: $0), line: line)
                    return metadata
                }
                let diagnostic: Basics.Diagnostic
                switch severity {
                case .error:
                    emittedAtLeastOneError = true
                    diagnostic = .error(message, metadata: metadata)
                case .warning:
                    diagnostic = .warning(message, metadata: metadata)
                case .remark:
                    diagnostic = .info(message, metadata: metadata)
                }
                delegate.pluginEmittedDiagnostic(diagnostic)
                
            case .defineBuildCommand(let config, let inputFiles, let outputFiles):
                delegate.pluginDefinedBuildCommand(
                    displayName: config.displayName,
                    executable: try AbsolutePath(validating: config.executable),
                    arguments: config.arguments,
                    environment: config.environment,
                    workingDirectory: try config.workingDirectory.map{ try AbsolutePath(validating: $0) },
                    inputFiles: try inputFiles.map{ try AbsolutePath(validating: $0) },
                    outputFiles: try outputFiles.map{ try AbsolutePath(validating: $0) })
                
            case .definePrebuildCommand(let config, let outputFilesDir):
                delegate.pluginDefinedPrebuildCommand(
                    displayName: config.displayName,
                    executable: try AbsolutePath(validating: config.executable),
                    arguments: config.arguments,
                    environment: config.environment,
                    workingDirectory: try config.workingDirectory.map{ try AbsolutePath(validating: $0) },
                    outputFilesDirectory: try AbsolutePath(validating: outputFilesDir))

            case .buildOperationRequest(let subset, let parameters):
                delegate.pluginRequestedBuildOperation(subset: subset, parameters: parameters) {
                    switch $0 {
                    case .success(let result):
                        outputQueue.async { try? outputHandle.writePluginMessage(.buildOperationResponse(result: result)) }
                    case .failure(let error):
                        outputQueue.async { try? outputHandle.writePluginMessage(.errorResponse(error: String(describing: error))) }
                    }
                }

            case .testOperationRequest(let subset, let parameters):
                delegate.pluginRequestedTestOperation(subset: subset, parameters: parameters) {
                    switch $0 {
                    case .success(let result):
                        outputQueue.async { try? outputHandle.writePluginMessage(.testOperationResponse(result: result)) }
                    case .failure(let error):
                        outputQueue.async { try? outputHandle.writePluginMessage(.errorResponse(error: String(describing: error))) }
                    }
                }

            case .symbolGraphRequest(let targetName, let options):
                // The plugin requested symbol graph information for a target. We ask the delegate and then send a response.
                delegate.pluginRequestedSymbolGraph(forTarget: targetName, options: options) {
                    switch $0 {
                    case .success(let result):
                        outputQueue.async { try? outputHandle.writePluginMessage(.symbolGraphResponse(result: result)) }
                    case .failure(let error):
                        outputQueue.async { try? outputHandle.writePluginMessage(.errorResponse(error: String(describing: error))) }
                    }
                }
            }
        }