Swift Package IndexBuild Information
Failed to build Scout, reference master (374537), with Swift 6.2 (beta) for Linux on 20 Jun 2025 12:17:33 UTC.
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4609320-3":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.2-latest swift build --triple x86_64-unknown-linux-gnu 2>&1Build Log
========================================
RunAll
========================================
Builder version: 4.64.0
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/ABridoux/scout.git
Reference: master
Initialized empty Git repository in /host/spi-builder-workspace/.git/
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: git branch -m <name>
From https://github.com/ABridoux/scout
* branch master -> FETCH_HEAD
* [new branch] master -> origin/master
HEAD is now at 3745374 Merge pull request #273 from ABridoux/develop
Cloned https://github.com/ABridoux/scout.git
Revision (git rev-parse @):
37453749ef2d3e81a542cc9dacf0d8f636f848c1
SUCCESS checkout https://github.com/ABridoux/scout.git at master
========================================
Build
========================================
Selected platform: linux
Swift version: 6.2
Building package at path: $PWD
https://github.com/ABridoux/scout.git
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4609320-3":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.2-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-6.2-latest: Pulling from finestructure/spi-images
Digest: sha256:f81a7bd7aa87a0f81848d48c5bcc03f5f78deebd37fa5f9be9913077205d3687
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.2-latest
Fetching https://github.com/apple/swift-docc-plugin
Fetching https://github.com/ABridoux/BooleanExpressionEvaluation
Fetching https://github.com/swiftcsv/SwiftCSV
Fetching https://github.com/ABridoux/lux
Fetching https://github.com/jpsim/Yams.git
Fetching https://github.com/apple/swift-argument-parser
[1/541] Fetching booleanexpressionevaluation
[483/2082] Fetching booleanexpressionevaluation, lux
[653/4164] Fetching booleanexpressionevaluation, lux, swift-docc-plugin
[799/5944] Fetching booleanexpressionevaluation, lux, swift-docc-plugin, swiftcsv
[2683/16803] Fetching booleanexpressionevaluation, lux, swift-docc-plugin, swiftcsv, yams
Fetched https://github.com/ABridoux/BooleanExpressionEvaluation from cache (0.52s)
[7032/16262] Fetching lux, swift-docc-plugin, swiftcsv, yams
Fetching https://github.com/tadija/AEXML.git
[7033/31642] Fetching lux, swift-docc-plugin, swiftcsv, yams, swift-argument-parser
[27408/33769] Fetching lux, swift-docc-plugin, swiftcsv, yams, swift-argument-parser, aexml
Fetched https://github.com/tadija/AEXML.git from cache (1.24s)
Fetched https://github.com/swiftcsv/SwiftCSV from cache (1.79s)
Fetched https://github.com/apple/swift-docc-plugin from cache (1.79s)
Fetched https://github.com/apple/swift-argument-parser from cache (1.80s)
Fetched https://github.com/ABridoux/lux from cache (1.80s)
Fetched https://github.com/jpsim/Yams.git from cache (1.83s)
Computing version for https://github.com/ABridoux/BooleanExpressionEvaluation
Computed https://github.com/ABridoux/BooleanExpressionEvaluation at 2.0.1 (2.82s)
Computing version for https://github.com/tadija/AEXML.git
Computed https://github.com/tadija/AEXML.git at 4.7.0 (0.37s)
Computing version for https://github.com/jpsim/Yams.git
Computed https://github.com/jpsim/Yams.git at 4.0.6 (0.39s)
Computing version for https://github.com/apple/swift-docc-plugin
Computed https://github.com/apple/swift-docc-plugin at 1.4.4 (0.49s)
Fetching https://github.com/swiftlang/swift-docc-symbolkit
[1/3413] Fetching swift-docc-symbolkit
Fetched https://github.com/swiftlang/swift-docc-symbolkit from cache (0.35s)
Computing version for https://github.com/swiftlang/swift-docc-symbolkit
Computed https://github.com/swiftlang/swift-docc-symbolkit at 1.0.0 (0.81s)
Computing version for https://github.com/swiftcsv/SwiftCSV
Computed https://github.com/swiftcsv/SwiftCSV at 0.10.0 (0.37s)
Computing version for https://github.com/ABridoux/lux
Computed https://github.com/ABridoux/lux at 0.5.0 (0.37s)
Fetching https://github.com/scinfu/SwiftSoup.git
Fetching https://github.com/JohnSundell/Splash
[1/2167] Fetching splash
[2168/6083] Fetching splash, swiftsoup
Fetched https://github.com/JohnSundell/Splash from cache (0.30s)
[3916/3916] Fetching swiftsoup
Fetched https://github.com/scinfu/SwiftSoup.git from cache (0.40s)
Computing version for https://github.com/JohnSundell/Splash
Computed https://github.com/JohnSundell/Splash at 0.16.0 (0.83s)
Computing version for https://github.com/scinfu/SwiftSoup.git
Computed https://github.com/scinfu/SwiftSoup.git at 1.7.5 (2.37s)
Computing version for https://github.com/apple/swift-argument-parser
Computed https://github.com/apple/swift-argument-parser at 0.5.0 (0.43s)
Creating working copy for https://github.com/jpsim/Yams.git
Working copy of https://github.com/jpsim/Yams.git resolved at 4.0.6
Creating working copy for https://github.com/apple/swift-docc-plugin
Working copy of https://github.com/apple/swift-docc-plugin resolved at 1.4.4
Creating working copy for https://github.com/scinfu/SwiftSoup.git
Working copy of https://github.com/scinfu/SwiftSoup.git resolved at 1.7.5
Creating working copy for https://github.com/JohnSundell/Splash
Working copy of https://github.com/JohnSundell/Splash resolved at 0.16.0
Creating working copy for https://github.com/ABridoux/BooleanExpressionEvaluation
Working copy of https://github.com/ABridoux/BooleanExpressionEvaluation resolved at 2.0.1
Creating working copy for https://github.com/tadija/AEXML.git
Working copy of https://github.com/tadija/AEXML.git resolved at 4.7.0
Creating working copy for https://github.com/swiftcsv/SwiftCSV
Working copy of https://github.com/swiftcsv/SwiftCSV resolved at 0.10.0
Creating working copy for https://github.com/swiftlang/swift-docc-symbolkit
Working copy of https://github.com/swiftlang/swift-docc-symbolkit resolved at 1.0.0
Creating working copy for https://github.com/apple/swift-argument-parser
Working copy of https://github.com/apple/swift-argument-parser resolved at 0.5.0
Creating working copy for https://github.com/ABridoux/lux
Working copy of https://github.com/ABridoux/lux resolved at 0.5.0
[1/1] Compiling plugin Swift-DocC Preview
[2/2] Compiling plugin Swift-DocC
Building for debugging...
[2/38] Write sources
[7/38] Copying PrivacyInfo.xcprivacy
[8/38] Write sources
[16/38] Compiling writer.c
[17/38] Compiling reader.c
[18/38] Write swift-version-24593BA9C3E375BF.txt
[19/38] Compiling api.c
[20/38] Compiling parser.c
[21/95] Compiling emitter.c
[22/144] Compiling scanner.c
[24/166] Emitting module Parsing
[25/166] Compiling SwiftCSV String+Lines.swift
[26/167] Emitting module AEXML
[27/167] Compiling AEXML Builders.swift
[28/167] Emitting module ArgumentParserToolInfo
[29/167] Compiling ArgumentParserToolInfo ToolInfo.swift
[31/202] Compiling ArgumentParser Option.swift
[32/202] Compiling ArgumentParser OptionGroup.swift
[33/202] Compiling ArgumentParser CommandConfiguration.swift
[34/202] Compiling ArgumentParser EnumerableFlag.swift
[35/202] Compiling ArgumentParser ExpressibleByArgument.swift
[36/206] Compiling ArgumentParser BashCompletionsGenerator.swift
[37/206] Compiling ArgumentParser CompletionsGenerator.swift
[38/206] Compiling ArgumentParser FishCompletionsGenerator.swift
[39/206] Compiling ArgumentParser ZshCompletionsGenerator.swift
[40/206] Compiling ArgumentParser Argument.swift
[41/206] Compiling ArgumentParser ArgumentHelp.swift
[42/206] Compiling ArgumentParser CompletionKind.swift
[43/206] Compiling ArgumentParser Errors.swift
[44/206] Compiling ArgumentParser Flag.swift
[45/206] Compiling ArgumentParser NameSpecification.swift
[46/206] Emitting module ArgumentParser
[47/206] Compiling SwiftCSV resource_bundle_accessor.swift
[50/206] Compiling SwiftCSV Parser.swift
[51/206] Compiling SwiftCSV NamedCSVView.swift
[52/206] Compiling SwiftCSV Serializer.swift
[53/206] Compiling SwiftCSV ParsingState.swift
[56/207] Emitting module SwiftCSV
[59/208] Emitting module SwiftSoup
[81/216] Emitting module Yams
[86/216] Compiling ArgumentParser StringExtensions.swift
[87/216] Compiling ArgumentParser Tree.swift
[88/216] Compiling SwiftSoup SimpleDictionary.swift
[89/216] Compiling SwiftSoup StreamReader.swift
[90/216] Compiling SwiftSoup String.swift
[91/216] Compiling SwiftSoup StringBuilder.swift
[92/216] Compiling SwiftSoup StringUtil.swift
[93/216] Compiling SwiftSoup StructuralEvaluator.swift
[94/216] Compiling SwiftSoup SwiftSoup.swift
[95/216] Compiling SwiftSoup Tag.swift
[96/216] Compiling SwiftSoup TextNode.swift
[97/216] Compiling SwiftSoup Token.swift
[98/216] Compiling SwiftSoup TokenQueue.swift
[99/216] Compiling SwiftSoup Tokeniser.swift
[100/216] Compiling ArgumentParser ArgumentSet.swift
[101/216] Compiling ArgumentParser CommandParser.swift
[102/216] Compiling ArgumentParser InputOrigin.swift
[111/216] Emitting module Splash
[118/219] Compiling Parsing Parser.swift
[124/219] Wrapping AST for SwiftCSV for debugging
[126/219] Emitting module BooleanExpressionEvaluation
[129/219] Compiling ArgumentParser ParsableCommand.swift
[130/219] Compiling ArgumentParser ArgumentDecoder.swift
[131/219] Compiling ArgumentParser ArgumentDefinition.swift
[133/219] Compiling ArgumentParser ParsableArguments.swift
[134/219] Compiling ArgumentParser ParsableArgumentsValidation.swift
[135/219] Compiling AEXML Parser.swift
[136/219] Compiling AEXML Error.swift
[137/219] Compiling AEXML Options.swift
[141/219] Wrapping AST for ArgumentParserToolInfo for debugging
[143/219] Compiling ArgumentParser DumpHelpGenerator.swift
[144/219] Compiling ArgumentParser HelpCommand.swift
[145/219] Compiling ArgumentParser HelpGenerator.swift
[146/219] Compiling ArgumentParser MessageInfo.swift
[147/219] Compiling ArgumentParser UsageGenerator.swift
[148/219] Compiling ArgumentParser CollectionExtensions.swift
[149/219] Compiling ArgumentParser SequenceExtensions.swift
[150/219] Compiling Parsing Parser+Operators.swift
[151/219] Compiling Parsing Parser+Types.swift
[152/219] Compiling Parsing Character+Extensions.swift
[157/220] Compiling AEXML Document.swift
[158/220] Compiling AEXML Element.swift
[165/220] Compiling Splash Segment.swift
[166/220] Compiling Splash TokenType.swift
[167/220] Compiling Splash Tokenizer.swift
[168/220] Compiling ArgumentParser ParserError.swift
[169/220] Compiling ArgumentParser SplitArguments.swift
[184/221] Compiling BooleanExpressionEvaluation String+Extensions.swift
[185/222] Wrapping AST for Parsing for debugging
[186/222] Wrapping AST for AEXML for debugging
[187/222] Wrapping AST for BooleanExpressionEvaluation for debugging
[189/222] Compiling Yams YamlError.swift
[195/223] Wrapping AST for Yams for debugging
[205/252] Compiling Scout ExplorerXML+CSVExport.swift
[206/252] Compiling Scout ExplorerXML+CSVImport.swift
[207/252] Compiling Scout ExplorerXML+Delete.swift
[209/306] Wrapping AST for Splash for debugging
[210/306] Wrapping AST for ArgumentParser for debugging
error: emit-module command failed with exit code 1 (use -v to see invocation)
[212/306] Emitting module Scout
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
[213/317] Compiling Scout DataFormat.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[214/317] Compiling Scout Folding.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[215/317] Compiling Scout ScoutVersion.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[216/317] Compiling Scout ExplorerValue+Add.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[217/317] Compiling Scout ExplorerValue+Delete.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[218/317] Compiling Scout ExplorerValue+Get.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[219/317] Compiling Scout ExplorerValue+Set.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[220/317] Compiling Scout ExplorerValue+CSVExport.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[221/317] Compiling Scout ExplorerValue+CSVImport.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[222/317] Compiling Scout ExplorerValue.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[223/317] Compiling Scout ExplorerValue+Codable.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[224/317] Compiling Scout ExplorerValue+Convenience.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:30:54: error: reference to generic type 'CSV' requires arguments in <...>
28 | }
29 |
30 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerValue {
| `- error: reference to generic type 'CSV' requires arguments in <...>
31 | let rootTree = Tree.root()
32 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
42 | }
43 |
44 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerValue? {
| `- note: 'from(row:with:rootTree:)' declared here
45 | keysTrees.forEach { (key, tree) in
46 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerValue/CSV/ExplorerValue+CSVImport.swift:17:20: error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
15 | static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerValue {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| |- error: value of optional type 'ExplorerValue?' must be unwrapped to a value of type 'ExplorerValue'
| |- note: coalesce using '??' to provide a default when the optional value contains 'nil'
| `- note: force-unwrap using '!' to abort execution if the optional value contains 'nil'
18 | }
19 |
[225/317] Compiling Scout Optional+Extensions.swift
[226/317] Compiling Scout Slice+Etensions.swift
[227/317] Compiling Scout String+Extension.swift
[228/317] Compiling Scout String+Jaro-Winkler.swift
[229/317] Compiling Scout ExplorerError.swift
[230/317] Compiling Scout PathError.swift
[231/317] Compiling Scout Bounds+Bound.swift
[232/317] Compiling Scout Bounds+IntWrapper.swift
[233/317] Compiling Scout Bounds.swift
[234/317] Compiling Scout Path+Flattening.swift
[235/317] Compiling Scout Path+Miscellaneous.swift
[236/317] Compiling Scout PathElement.swift
[237/317] Compiling Scout PathElementRepresentable.swift
[238/317] Compiling Scout PathTree+ValueType.swift
[239/317] Compiling Scout PathTree.swift
[240/317] Compiling Scout CodablePathExplorer+Serialization.swift
[241/317] Compiling Scout CodablePathExplorer.swift
[242/317] Compiling Scout EquatablePathExplorer.swift
[243/318] Compiling Scout ExplorerValue+CustomStringConvertible.swift
[244/318] Compiling Scout ExplorerValue+ExpressibleBy.swift
[245/318] Compiling Scout ExplorerValue+Folded.swift
[246/318] Compiling Scout ExplorerValue+Helpers.swift
[247/318] Compiling Scout ExplorerValue+PathsListing.swift
[248/318] Compiling Scout CodableFormat.swift
[249/318] Compiling Scout CodableFormats+JsonDateIso8601.swift
[250/318] Compiling Scout CodableFormats+JsonDefault.swift
[251/318] Compiling Scout CodableFormats+Namespace.swift
[252/318] Compiling Scout CodableFormats+PlistDefault.swift
[253/318] Compiling Scout CodableFormats+YamlDefault.swift
[254/318] Compiling Scout ExplorerValueDecoder.swift
[255/318] Compiling Scout ExplorerXML.swift
[256/318] Compiling Scout AEXMLElement+Children.swift
[257/318] Compiling Scout AEXMLElement+Equal.swift
[258/318] Compiling Scout AEXMLElement+Group.swift
[259/318] Compiling Scout Array+Extensions.swift
[260/318] Compiling Scout CodingKey+Extensions.swift
[261/318] Compiling Scout Collection+Extensions.swift
[262/318] Compiling Scout Collection+Path.swift
[263/318] Compiling Scout Dictionary+Extensions.swift
[264/318] Compiling Scout Int+LastIndex.swift
[265/318] Compiling Scout NSRegularExpression+Extensions.swift
[266/318] Compiling Scout Path+StringConvertible.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
[267/318] Compiling Scout Path.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
[268/318] Compiling Scout PathElement+Convenience.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
[276/318] Compiling Scout PathExplorer+Convenience.swift
/host/spi-builder-workspace/Sources/Scout/Models/Path/Path+StringConvertible.swift:49:1: warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
47 |
48 | extension Path: CustomStringConvertible, CustomDebugStringConvertible {}
49 | extension Slice: CustomStringConvertible, CustomDebugStringConvertible where Base == Path {}
| |- warning: extension declares a conformance of imported type 'Slice' to imported protocols 'CustomStringConvertible', 'CustomDebugStringConvertible'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
| `- note: add '@retroactive' to silence this warning
50 |
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[280/318] Compiling Scout ExplorerXML+ExplorerValue.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[281/318] Compiling Scout ExplorerXML+Fold.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[282/318] Compiling Scout ExplorerXML+Get.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[283/318] Compiling Scout ExplorerXML+PathsListing.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[284/318] Compiling Scout ExplorerXML+Serialization.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[285/318] Compiling Scout ExplorerXML+Set.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[287/318] Compiling Scout ExplorerXML+SingleChildStrategy.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[288/318] Compiling Scout ExplorerXML+ValueSetter.swift
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:20:35: error: reference to generic type 'CSV' requires arguments in <...>
18 | }
19 |
20 | private static func from(csv: CSV, headers: Bool) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
21 | if headers {
22 | return try fromArrayOfDictionaries(csv: csv)
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:43:54: error: reference to generic type 'CSV' requires arguments in <...>
41 | }
42 |
43 | private static func fromArrayOfDictionaries(csv: CSV) throws -> ExplorerXML {
| `- error: reference to generic type 'CSV' requires arguments in <...>
44 | let rootTree = Tree.root(name: "element")
45 | let headers = try csv.header
/host/spi-builder-workspace/.build/checkouts/SwiftCSV/SwiftCSV/CSV.swift:66:12: note: generic type 'CSV' declared here
64 | /// For convenience, there's `EnumeratedCSV` to access fields in rows by their column index,
65 | /// and `NamedCSV` to access fields by their column names as defined in a header row.
66 | open class CSV<DataView : CSVView> {
| `- note: generic type 'CSV' declared here
67 |
68 | public let header: [String]
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:54: error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| `- error: cannot convert value of type 'Character' to expected argument type 'CSVDelimiter'
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:16:23: error: generic parameter 'DataView' could not be inferred
14 |
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
| |- error: generic parameter 'DataView' could not be inferred
| `- note: explicitly specify the generic arguments to fix this issue
17 | return try from(csv: csv, headers: hasHeaders)
18 | }
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: extra arguments at positions #1, #2 in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: extra arguments at positions #1, #2 in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
/host/spi-builder-workspace/Sources/Scout/ExplorerXML/ExplorerXML+CSVImport.swift:17:24: error: missing arguments for parameters 'row', 'with', 'rootTree' in call
15 | public static func fromCSV(string: String, separator: Character, hasHeaders: Bool) throws -> ExplorerXML {
16 | let csv = try CSV(string: string, delimiter: separator, loadColumns: hasHeaders)
17 | return try from(csv: csv, headers: hasHeaders)
| `- error: missing arguments for parameters 'row', 'with', 'rootTree' in call
18 | }
19 |
:
58 | }
59 |
60 | private static func from(row: [String: String], with keysTrees: [(key: String, path: Tree)], rootTree: Tree) throws -> ExplorerXML {
| `- note: 'from(row:with:rootTree:)' declared here
61 | keysTrees.forEach { (key, tree) in
62 | if let value = row[key] {
[288/318] Wrapping AST for SwiftSoup for debugging
[290/318] Compiling Scout PathExplorer+ExploreWithMemory.swift
[291/318] Compiling Scout PathExplorer+Helpers.swift
[292/318] Compiling Scout PathExplorer.swift
[293/318] Compiling Scout PathExplorers.swift
[294/318] Compiling Scout SerializablePathExplorer.swift
[295/318] Compiling Scout Path+Parsing.swift
[296/318] Compiling Scout PathsFilter+ExpressionPredicate.swift
[297/318] Compiling Scout PathsFilter+FunctionPredicate.swift
[298/318] Compiling Scout PathsFilter.swift
[299/318] Compiling Scout ValuePredicate.swift
[300/318] Compiling Scout ValueTarget.swift
[301/385] Emitting module Lux
[302/394] Compiling Lux Category.swift
[303/394] Compiling Lux Color.swift
[304/394] Compiling Lux InjectionType.swift
[305/394] Compiling Lux InjectorType.swift
[306/394] Compiling Lux RegexPattern.swift
[307/394] Compiling Lux TerminalModifier.swift
[308/394] Compiling Lux TextType.swift
[309/394] Compiling Lux ColorTheme.swift
[310/394] Compiling Lux DraculaPalette.swift
[311/394] Compiling Lux DataFormat.swift
[312/394] Compiling Lux Version.swift
[313/394] Compiling Lux Bool+KeyPath.swift
[314/394] Compiling Lux NSRegularExpression+Extensions.swift
[315/394] Compiling Lux String+Extensions.swift
[316/394] Compiling Lux StringProtocol+Extensions.swift
[317/394] Compiling Lux AttributedInjector.swift
[318/394] Compiling Lux BaseInjector.swift
[319/394] Compiling Lux FileInjectionService.swift
[320/394] Compiling Lux InjectionService.swift
[321/394] Compiling Lux JSONXcodeDefaultDelegate.swift
[322/394] Compiling Lux PlistXcodeDefaultDelegate.swift
[323/394] Compiling Lux SwiftXcodeDefaultDelegate.swift
[324/394] Compiling Lux XcodeLightPalette.swift
[325/394] Compiling Lux XcodeLightThemeInjectorDelegate.swift
[326/394] Compiling Lux XmlEnhancedXcodeDefaultDelegate.swift
[327/394] Compiling Lux XmlXcodeDefaultDelegate.swift
[328/394] Compiling Lux YAMLXcodeDefaultLightDelegate.swift
[329/394] Compiling Lux ZshXcodeLightDelegate.swift
[330/394] Compiling Lux YAMLCategory.swift
[331/394] Compiling Lux YAMLDelegate.swift
[332/394] Compiling Lux YAMLInjector.swift
[333/394] Compiling Lux ZshCategory.swift
[334/394] Compiling Lux ZshDelegate.swift
[335/394] Compiling Lux ZshInjector.swift
[336/394] Compiling Lux Appendable.swift
[337/394] Compiling Lux AttributedString.swift
[338/394] Compiling Lux CSSClass.swift
[339/394] Compiling Lux JSONXcodeDarkDelegate.swift
[340/394] Compiling Lux PlistXcodeDarkDelegate.swift
[341/394] Compiling Lux SwiftXcodeDarkDelegate.swift
[342/394] Compiling Lux XMLEnhancedXcodeDarkDelegate.swift
[343/394] Compiling Lux XcodeDarkPalette.swift
[344/394] Compiling Lux XcodeDarkThemeInjectorDelegate.swift
[345/394] Compiling Lux XmlXcodeDarkDelegate.swift
[346/394] Compiling Lux YAMLXcodeDarkDelegate.swift
[347/394] Compiling Lux ZshXcodeDarkDelegate.swift
[348/394] Compiling Lux DraculaThemeInjectorDelegate.swift
[349/394] Compiling Lux JSONDracula.swift
[350/394] Compiling Lux PlistDracula.swift
[351/394] Compiling Lux SwiftDracula.swift
[352/394] Compiling Lux XMLEnhancedDracula.swift
[353/394] Compiling Lux XmlDracula.swift
[354/394] Compiling Lux YAMLDracula.swift
[355/394] Compiling Lux ZshDracula.swift
[356/394] Compiling Lux ThemeInjectorDelegate.swift
[357/394] Compiling Lux InjectorDelegate.swift
[358/394] Compiling Lux TextInjector.swift
[359/394] Compiling Lux JSONCategory.swift
[360/394] Compiling Lux JSONDelegate.swift
[361/394] Compiling Lux JSONInjector.swift
[362/394] Compiling Lux PlistCategory.swift
[363/394] Compiling Lux PlistDelegate.swift
[364/394] Compiling Lux PlistInjector.swift
[365/394] Compiling Lux HTMLCustomCSSOutputFormat.swift
[366/394] Compiling Lux SwiftCategory.swift
[367/394] Compiling Lux SwiftDelegate.swift
[368/394] Compiling Lux SwiftInjector.swift
[369/394] Compiling Lux TerminalOutputFormat.swift
[370/394] Compiling Lux TokenType+SwiftCategory.swift
[371/394] Compiling Lux XMLEnhancedCategory.swift
[372/394] Compiling Lux XMLEnhancedDelegate.swift
[373/394] Compiling Lux XMLEnhancedInjector.swift
[374/394] Compiling Lux XMLCategory.swift
[375/394] Compiling Lux XMLDelegate.swift
[376/394] Compiling Lux XMLInjector.swift
[377/395] Wrapping AST for Lux for debugging
BUILD FAILURE 6.2 linux