Convert the seven checkers the complexExtensionBaseValid compile rule dispatches (the cos-ct-extends/src-ct content-derivation family) to located findings so each error attaches to its derivation node instead of the schema root (#169): a complexContent extension adding element content over a simpleContent base, a simpleContent restriction whose base is a built-in or user simple type, an unfaithful inline type in a simpleContent restriction, a complexContent base that is a simple type, a simpleContent extension whose base is xs:anyType, and a mismatched mixed setting on a complexContent extension each underline their extension/restriction node; an element carrying a default/fixed value over element-only or empty content underlines the element. Each predicate, iteration order, and reason string is unchanged; only the location each finding carries differs. The seven checkers had exactly one caller each (the dispatch), so each is renamed in place and the .unlocated wrap dropped. To keep the file under the 400-line limit, the seven functions and their two private helpers move to a new SchemaContentDerivation.swift; the shared extensionAddsElementContent helper, still used by the all-group checker that stays behind, becomes module-internal. Adds a located- diagnostics test per checker.
124 lines
7.4 KiB
Swift
124 lines
7.4 KiB
Swift
private typealias ExtAllNode = PureXML.Schema.XSDNode
|
|
|
|
extension PureXML.Schema.XSDParser {
|
|
/// XSD 1.0 `cos-all-limited.1.2` reached through extension: an `xs:all` group
|
|
/// must be the whole content model of a complex type. When a complex type
|
|
/// extends a base that already has element content, the effective content model
|
|
/// is `sequence(base content, extension content)`, so an `all` in the extension
|
|
/// is nested in that sequence and is invalid. Such schemas were accepted.
|
|
///
|
|
/// Detected from the compiled base type: the extension is rejected only when its
|
|
/// base resolves (in this schema's own target namespace) to a complex type whose
|
|
/// content is element-only or mixed. An empty base (extending it with an `all`
|
|
/// makes the `all` the whole content, which is valid), a simple-content base, or
|
|
/// an unresolved/foreign base is left alone. Checked for a self-contained schema.
|
|
static func extensionAllGroupErrors(_ schema: XSDTree, _ context: PureXML.Schema.XSDContext, _ types: [String: PureXML.Schema.ElementType]) -> [String] {
|
|
guard !skipsCrossDocumentRules(schema, compositionLoaded: context.compositionLoaded) else { return [] }
|
|
let bindings = context.namespaceBindings
|
|
var errors: [String] = []
|
|
for content in descendants(schema, named: "complexContent") {
|
|
guard let ext = ExtAllNode.firstChild(content, named: "extension"),
|
|
let base = ExtAllNode.attribute(ext, "base"),
|
|
ExtAllNode.referenceNamespace(base, bindings) == context.targetNamespace,
|
|
case let .complex(complex)? = types[ExtAllNode.stripPrefix(base)]
|
|
else { continue }
|
|
let baseName = ExtAllNode.stripPrefix(base)
|
|
// The extension itself adds an `all` group over a base that already has
|
|
// element content: the all would be nested in the extension sequence.
|
|
if extensionHasAllGroup(ext), baseHasElementContent(complex.content) {
|
|
errors.append("an 'all' group may not extend the type '\(baseName)', which has its own content; an all group must be the whole content model")
|
|
continue
|
|
}
|
|
// The base's own content IS an `all` group and the extension adds
|
|
// element content: the base's all is then nested in the sequence that
|
|
// joins base and extension content, which is forbidden (cos-all-limited).
|
|
if contentIsAllGroup(complex.content), extensionAddsElementContent(ext) {
|
|
errors.append("the type '\(baseName)' has an 'all' group as its whole content and may not be extended with element content")
|
|
}
|
|
}
|
|
return errors
|
|
}
|
|
|
|
/// Particle Valid (Restriction) for ANONYMOUS complex types: the named-type
|
|
/// rule (`restrictionsAreSubsets`) is keyed by type name and so never sees an
|
|
/// inline `complexType` that derives by `complexContent` restriction (the
|
|
/// common `<element><complexType><complexContent><restriction base="...">`
|
|
/// shape). This walks those, compiles each restricting type, resolves its base
|
|
/// in this schema's own target namespace, and runs the same subset check. Only a
|
|
/// self-contained schema is examined; the same `ParticleRestriction.violation`
|
|
/// used for named types keeps the false-positive profile identical.
|
|
static func anonymousRestrictionErrors(
|
|
_ schema: XSDTree,
|
|
_ context: PureXML.Schema.XSDContext,
|
|
_ types: [String: PureXML.Schema.ElementType],
|
|
_ derivation: [String: PureXML.Schema.TypeDerivation],
|
|
) -> [String] {
|
|
guard !skipsCrossDocumentRules(schema, compositionLoaded: context.compositionLoaded) else { return [] }
|
|
let bindings = context.namespaceBindings
|
|
var errors: [String] = []
|
|
for complexType in descendants(schema, named: "complexType") where ExtAllNode.attribute(complexType, "name") == nil {
|
|
guard let content = ExtAllNode.firstChild(complexType, named: "complexContent"),
|
|
let restriction = ExtAllNode.firstChild(content, named: "restriction"),
|
|
let baseRef = ExtAllNode.attribute(restriction, "base"),
|
|
ExtAllNode.referenceNamespace(baseRef, bindings) == context.targetNamespace,
|
|
case let .complex(base)? = types[ExtAllNode.stripPrefix(baseRef)]
|
|
else { continue }
|
|
let restricted = PureXML.Schema.XSDParser.complexType(complexType, context)
|
|
if let reason = PureXML.Schema.ParticleRestriction.violation(
|
|
restricted: restricted.content,
|
|
base: base.content,
|
|
types: types,
|
|
derivation: derivation,
|
|
) {
|
|
errors.append("an anonymous complex type is not a valid restriction of '\(ExtAllNode.stripPrefix(baseRef))': \(reason)")
|
|
}
|
|
}
|
|
return errors
|
|
}
|
|
|
|
/// Whether a content type's whole content model is a NON-EMPTY `all` group. An
|
|
/// empty `<all/>` contributes no content (the sibling rule treats extending
|
|
/// empty content as valid), so it is not flagged.
|
|
private static func contentIsAllGroup(_ content: PureXML.Schema.ContentType) -> Bool {
|
|
switch content {
|
|
case let .elementOnly(particle), let .mixed(particle):
|
|
guard case let .group(group) = particle.term, group.compositor == .all else { return false }
|
|
return !PureXML.Schema.ParticleRestriction.contentFree(particle)
|
|
case .empty, .simpleContent:
|
|
return false
|
|
}
|
|
}
|
|
|
|
/// Whether a `complexContent` extension adds element content: an `element` or
|
|
/// a wildcard `any` somewhere in its model group. An empty group (`<sequence/>`)
|
|
/// or an attribute-only extension adds no element content, so it keeps the
|
|
/// base's simple content and is not flagged. Shared with the content-derivation
|
|
/// checkers in `SchemaContentDerivation.swift`, so it is module-internal.
|
|
static func extensionAddsElementContent(_ extension: XSDTree) -> Bool {
|
|
let hasElement = descendants(`extension`, named: "element").contains { $0.name?.namespaceURI == xsdNamespace }
|
|
let hasWildcard = descendants(`extension`, named: "any").contains { $0.name?.namespaceURI == xsdNamespace }
|
|
return hasElement || hasWildcard
|
|
}
|
|
|
|
private static func extensionHasAllGroup(_ extension: XSDTree) -> Bool {
|
|
ExtAllNode.elementChildren(`extension`).contains { child in
|
|
child.name?.namespaceURI == xsdNamespace && ExtAllNode.localName(child) == "all"
|
|
}
|
|
}
|
|
|
|
/// Whether the base type's content would wrap an `all` extension in a sequence.
|
|
/// Mixed content always does (a mixed base, even with an empty particle, may not
|
|
/// be extended by an `all`, per the resolution of W3C Bug 6202). Element-only
|
|
/// content does only when its particle can actually contribute a child: an
|
|
/// explicit but empty model group (`<xs:sequence/>`) is effectively empty, and
|
|
/// extending empty content with an `all` makes the `all` the whole content,
|
|
/// which is valid. Empty and simple-content bases carry no element content.
|
|
private static func baseHasElementContent(_ content: PureXML.Schema.ContentType) -> Bool {
|
|
switch content {
|
|
case .mixed: true
|
|
case let .elementOnly(particle): !PureXML.Schema.ParticleRestriction.contentFree(particle)
|
|
case .empty, .simpleContent: false
|
|
}
|
|
}
|
|
}
|