A flow mapping entry may begin with its `:` indicator for an empty key
(`{ : value }`) or carry only properties before the `:` (`{ !!str : value }`).
Both resolve to a null key, but parseFlowMappingPair required a node before
the `:` and raised "expected a YAML node".
Emit a null key in that position instead, mirroring the empty-value handling
already present after the `:`. The change consumes the key's properties first
so a property-only key keeps its tag or anchor, and is confined to flow
mapping key position, where a null key is unambiguously valid; an entry with
no `:` at all (`{ a, }`) still errors.
Raises yaml-test-suite parse-level to 297/333 (89.2%) and value-level to
174/192, with the should-error rejection rate unchanged (no invalid document
newly accepted). 422 tests pass.
132 lines
5.4 KiB
Swift
132 lines
5.4 KiB
Swift
extension PureYAML.Parsing.TokenEventParser {
|
|
mutating func parseFlowSequence(
|
|
properties: PureYAML.Parsing.NodeProperties,
|
|
) throws -> PureYAML.Parsing.NodeResult {
|
|
let start = try expect("flow sequence start") { kind in
|
|
if case .flowSequenceStart = kind {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
let startMark = properties.mark ?? start.mark
|
|
var endMark = start.endMark
|
|
try emit(.sequenceStart(
|
|
anchor: properties.anchor,
|
|
tag: properties.tag,
|
|
style: .flow,
|
|
mark: startMark,
|
|
))
|
|
var hasEntry = false
|
|
while cursor.current != nil {
|
|
if case .flowSequenceEnd = cursor.current?.kind {
|
|
let end = try expect("flow sequence end") { kind in
|
|
if case .flowSequenceEnd = kind {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
endMark = end.endMark
|
|
try emit(.sequenceEnd(mark: endMark))
|
|
return PureYAML.Parsing.NodeResult(kind: .sequence, endMark: endMark)
|
|
}
|
|
if case .flowEntry = cursor.current?.kind {
|
|
// A comma separates entries, so one must precede it: a leading or repeated comma
|
|
// is an empty entry, which is not allowed. A single trailing comma before the
|
|
// closing bracket is fine, since the close is handled above regardless of `hasEntry`.
|
|
guard hasEntry else {
|
|
throw unexpectedToken(expected: "flow sequence entry or flow sequence end")
|
|
}
|
|
hasEntry = false
|
|
_ = try cursor.advance()
|
|
continue
|
|
}
|
|
endMark = try parseNode().endMark
|
|
hasEntry = true
|
|
if cursor.current?.kind.isFlowTerminator == false {
|
|
throw unexpectedToken(expected: "flow entry or flow sequence end")
|
|
}
|
|
}
|
|
throw unexpectedToken(expected: "flow sequence end")
|
|
}
|
|
|
|
mutating func parseFlowMapping(
|
|
properties: PureYAML.Parsing.NodeProperties,
|
|
) throws -> PureYAML.Parsing.NodeResult {
|
|
let start = try expect("flow mapping start") { kind in
|
|
if case .flowMappingStart = kind {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
let startMark = properties.mark ?? start.mark
|
|
var endMark = start.endMark
|
|
try emit(.mappingStart(
|
|
anchor: properties.anchor,
|
|
tag: properties.tag,
|
|
style: .flow,
|
|
mark: startMark,
|
|
))
|
|
var hasEntry = false
|
|
while cursor.current != nil {
|
|
if case .flowMappingEnd = cursor.current?.kind {
|
|
let end = try expect("flow mapping end") { kind in
|
|
if case .flowMappingEnd = kind {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
endMark = end.endMark
|
|
try emit(.mappingEnd(mark: endMark))
|
|
return PureYAML.Parsing.NodeResult(kind: .mapping, endMark: endMark)
|
|
}
|
|
if case .flowEntry = cursor.current?.kind {
|
|
// As in a flow sequence, a comma separates entries and so requires one before it;
|
|
// a leading or repeated comma is an empty entry. A trailing comma is fine.
|
|
guard hasEntry else {
|
|
throw unexpectedToken(expected: "flow mapping entry or flow mapping end")
|
|
}
|
|
hasEntry = false
|
|
_ = try cursor.advance()
|
|
continue
|
|
}
|
|
endMark = try parseFlowMappingPair().endMark
|
|
hasEntry = true
|
|
if cursor.current?.kind.isFlowTerminator == false {
|
|
throw unexpectedToken(expected: "flow entry or flow mapping end")
|
|
}
|
|
}
|
|
throw unexpectedToken(expected: "flow mapping end")
|
|
}
|
|
|
|
mutating func parseFlowMappingPair() throws -> PureYAML.Parsing.NodeResult {
|
|
if cursor.current?.kind.isMappingKey == true {
|
|
return try parseMappingPair()
|
|
}
|
|
|
|
// A flow mapping key may be empty (`{ : v }`) or carry only properties (`{ !!str : v }`):
|
|
// both resolve to a null key, so emit one rather than requiring a node before the `:`. This is
|
|
// valid only in flow mapping key position, so the empty-node allowance stays local here.
|
|
let keyProperties = try consumeProperties()
|
|
if case .mappingValue = cursor.current?.kind {
|
|
let mark = keyProperties.mark ?? cursor.current?.mark ?? .start
|
|
try emit(.scalar(value: "", anchor: keyProperties.anchor, tag: keyProperties.tag, style: .plain, mark: mark))
|
|
} else {
|
|
_ = try parseNode(properties: keyProperties)
|
|
}
|
|
let valueIndicator = try expect("mapping value") { kind in
|
|
if case .mappingValue = kind {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
let properties = try consumeProperties()
|
|
guard properties != .none || cursor.current?.kind.isFlowTerminator == false else {
|
|
let mark = valueIndicator.endMark
|
|
try emit(.scalar(value: "", anchor: nil, tag: nil, style: .plain, mark: mark))
|
|
return PureYAML.Parsing.NodeResult(kind: .scalar, endMark: mark)
|
|
}
|
|
return try parseNode(properties: properties)
|
|
}
|
|
}
|