From c4679acfd847fe419a4c27e8ab8efe9826460f80 Mon Sep 17 00:00:00 2001 From: Mihaela Mihaljevic Date: Mon, 15 Jun 2026 15:31:01 +0200 Subject: [PATCH] feat(schema): reject an all group extending a base with content (cos-all-limited.1.2) An xs:all group in a complexContent extension of a base that already has element content was accepted. The effective content model of such an extension is sequence(base content, extension content), which nests the all and violates the rule that an all group must be the whole content model. The base type is read from the compiled model: rejected only when the base resolves, in the schema's own target namespace, to a complex type with element-only or mixed content. An explicitly-empty base (an empty model group with mixed=false) has effectively empty content and may still be extended by an all (the all becomes the whole content); a simple-content, empty, foreign, or unresolved base is left alone. Checked for a self-contained schema. XSTS: invalid schemas accepted 411 to 403, no other bucket raised. --- CHANGELOG.md | 1 + Sources/Schema/ParticleRestriction.swift | 2 +- Sources/Schema/SchemaExtensionAllGroup.swift | 52 +++++++++++++++++ Sources/Schema/SchemaIDAttribute.swift | 1 + Tests/SchemaExtensionAllGroupTests.swift | 59 ++++++++++++++++++++ Tests/XSTSSuiteTests.swift | 2 +- docs/schema-validity-burndown.md | 2 +- 7 files changed, 116 insertions(+), 3 deletions(-) create mode 100644 Sources/Schema/SchemaExtensionAllGroup.swift create mode 100644 Tests/SchemaExtensionAllGroupTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index 731e6a9..0f4a011 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed +- An `xs:all` group may no longer appear in a `complexContent` extension of a base that already has element content (XSD 1.0 `cos-all-limited.1.2`, #170). The effective content model of such an extension is `sequence(base content, extension content)`, which nests the `all` and violates the rule that an `all` must be the whole content model. Detected from the compiled base type: rejected only when the base resolves (in the schema's own target namespace) to a complex type with element-only or mixed content. An explicitly-empty base (an empty model group with `mixed="false"`, whose content is effectively empty) may still be extended by an `all`, since the `all` becomes the whole content; a simple-content, empty, foreign, or unresolved base is left alone. Checked for a self-contained schema. XSTS: invalid schemas accepted 411 to 403, no other bucket raised. - A simple type whose `final` contains `list` (or `#all`) may no longer be used as a list `itemType`, and one whose `final` contains `union` (or `#all`) may no longer be a union `memberType` (XSD 1.0 simple-type `final`, #170). The restriction and extension directions were already enforced by `finalRespected`; the list and union directions were unchecked because `final="list"`/`"union"` is not modelled by the derivation-method set, so the `final` attribute is read directly. The reference is matched only when it resolves to the schema's own target namespace, so a list or union of a built-in (whose final is empty) is not confused with a user type of the same local name. Checked for a self-contained schema. XSTS: invalid schemas accepted 413 to 411, no other bucket raised. - A `whiteSpace` facet may only strengthen, never relax, its base type's effective whiteSpace (XSD Part 2 ยง4.3.6, #170). The order is `preserve` < `replace` < `collapse`, so a base fixed to `collapse` admits only `collapse`, and a `replace` base admits `replace` or `collapse`. A derivation that relaxes it (for example `whiteSpace="replace"` over a `collapse` base, or restricting `xs:token` to `replace`) was accepted and is now rejected. The base's effective whiteSpace is its own facet, falling back to its built-in intrinsic; the check is atomic-only and, when a base type's own whiteSpace has not yet resolved, can only under-detect, never reject a valid restriction. XSTS: invalid schemas accepted 422 to 413, no other bucket raised. - A top-level `xs:element` declaration may no longer carry `ref`, `form`, `minOccurs`, or `maxOccurs` (XSD 1.0 schema-for-schemas `topLevelElement`, #170). A global element is a declaration, never a particle or a reference, so those local-use attributes are invalid. The top-level-attribute applicability scan added earlier is generalized to cover both kinds; a local element particle inside a content model is unaffected. XSTS: invalid schemas accepted 424 to 422, no other bucket raised. diff --git a/Sources/Schema/ParticleRestriction.swift b/Sources/Schema/ParticleRestriction.swift index 7c1e6d8..5f11c46 100644 --- a/Sources/Schema/ParticleRestriction.swift +++ b/Sources/Schema/ParticleRestriction.swift @@ -172,7 +172,7 @@ extension PureXML.Schema { /// Whether a particle can never contribute a child element or wildcard: it /// has `maxOccurs=0`, or is a group all of whose members are content-free /// (an empty group included). Its only legal content is the empty sequence. - private static func contentFree(_ particle: Particle) -> Bool { + static func contentFree(_ particle: Particle) -> Bool { if particle.maxOccurs == 0 { return true } switch particle.term { case .element, .wildcard: diff --git a/Sources/Schema/SchemaExtensionAllGroup.swift b/Sources/Schema/SchemaExtensionAllGroup.swift new file mode 100644 index 0000000..d7c967a --- /dev/null +++ b/Sources/Schema/SchemaExtensionAllGroup.swift @@ -0,0 +1,52 @@ +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 !hasExternalReference(schema) else { return [] } + let bindings = context.namespaceBindings + var errors: [String] = [] + for content in descendants(schema, named: "complexContent") { + guard let ext = ExtAllNode.firstChild(content, named: "extension"), + extensionHasAllGroup(ext), + let base = ExtAllNode.attribute(ext, "base"), + ExtAllNode.referenceNamespace(base, bindings) == context.targetNamespace, + case let .complex(complex)? = types[ExtAllNode.stripPrefix(base)], + baseHasElementContent(complex.content) + else { continue } + errors.append("an 'all' group may not extend the type '\(ExtAllNode.stripPrefix(base))', which has its own content; an all group must be the whole content model") + } + return errors + } + + 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 (``) 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 + } + } +} diff --git a/Sources/Schema/SchemaIDAttribute.swift b/Sources/Schema/SchemaIDAttribute.swift index aaff692..9362b7b 100644 --- a/Sources/Schema/SchemaIDAttribute.swift +++ b/Sources/Schema/SchemaIDAttribute.swift @@ -71,5 +71,6 @@ extension PureXML.Schema.XSDParser { + idValueConstraintErrors(schema, context) + substitutionTypeErrors(schema, derivation, typeMaps.named) + userTypeValueConstraintErrors(schema, context, typeMaps.named) + + extensionAllGroupErrors(schema, context, typeMaps.named) } } diff --git a/Tests/SchemaExtensionAllGroupTests.swift b/Tests/SchemaExtensionAllGroupTests.swift new file mode 100644 index 0000000..bd3b6d3 --- /dev/null +++ b/Tests/SchemaExtensionAllGroupTests.swift @@ -0,0 +1,59 @@ +@testable import PureXML +import Testing + +@Suite("XSD all-group in extension (cos-all-limited.1.2 via extension)") +struct SchemaExtensionAllGroupTests { + private let xsd = "xmlns:xs=\"http://www.w3.org/2001/XMLSchema\"" + + private func compiles(_ body: String) -> Bool { + (try? PureXML.Schema.Document("\(body)")) != nil + } + + private func ext(base: String, content: String) -> String { + "" + + "\(content)" + + "" + } + + private let seqBase = "" + + "" + private let emptyBase = "" + private let allContent = "" + + @Test("An all group extending a base with content is rejected") + func test_allExtendingContentRejected() { + #expect(!compiles(seqBase + ext(base: "myType", content: allContent))) + } + + @Test("An all group extending an empty base compiles") + func test_allExtendingEmptyAccepted() { + #expect(compiles(emptyBase + ext(base: "emptyType", content: allContent))) + } + + @Test("A sequence extension of a content base compiles") + func test_sequenceExtensionAccepted() { + #expect(compiles(seqBase + ext(base: "myType", content: ""))) + } + + @Test("An all group as the whole content of a complex type compiles") + func test_allAsWholeContentAccepted() { + #expect(compiles("\(allContent)")) + } + + /// A base whose content is an explicit but empty model group (``) + /// has effectively empty content, so extending it with an `all` makes the `all` + /// the whole content model, which is valid (W3C Bug 6202). + @Test("An all group extending an explicitly-empty (non-mixed) base compiles") + func test_allExtendingExplicitEmptyAccepted() { + let base = "" + #expect(compiles(base + ext(base: "emptyGroup", content: allContent))) + } + + /// A mixed base, even with an empty particle, may not be extended by an `all` + /// (the resolution of W3C Bug 6202 keeps this invalid). + @Test("An all group extending a mixed empty base is rejected") + func test_allExtendingMixedEmptyRejected() { + let base = "" + #expect(!compiles(base + ext(base: "mixedEmpty", content: allContent))) + } +} diff --git a/Tests/XSTSSuiteTests.swift b/Tests/XSTSSuiteTests.swift index 7681e9a..4bd49a0 100644 --- a/Tests/XSTSSuiteTests.swift +++ b/Tests/XSTSSuiteTests.swift @@ -29,7 +29,7 @@ struct XSTSSuiteTests { /// XSTS` (debug is far slower and the corpus is large). Per-case deviations /// are written to /tmp/xsts-failures.txt for the burn-down. private let knownSchemaValidRejected = 1 - private let knownSchemaInvalidAccepted = 411 + private let knownSchemaInvalidAccepted = 403 private let knownInstanceValidRejected = 180 private let knownInstanceInvalidAccepted = 158 diff --git a/docs/schema-validity-burndown.md b/docs/schema-validity-burndown.md index 27ba76e..780a195 100644 --- a/docs/schema-validity-burndown.md +++ b/docs/schema-validity-burndown.md @@ -10,7 +10,7 @@ irreducible tail. Do not deviate to new features while this is open. | Bucket | Count | Reading | |---|---|---| | valid-schemas-rejected | **72 -> 4** | production target is 0: rejecting a correct schema is the most user-hostile defect (#148). Particle-restriction over-rejection fixed: pointless `maxOccurs=0` particles removed, content-free restriction of an EMPTY base, empty-derived emptiable-base, and (#163) the pairwise check over the normalized content model with occurrence subsumption applied only to same-kind pairings (cross-kind element/group, group/element, group/wildcard match occurrence inside, by effective total range / member). #164 resolved element-ref namespaces by prefix binding (the `particlesJj/Jk/Jm/Jn/Js`, `particlesQ/R` cluster, -28). Content-free (`maxOccurs=0`) derived groups and substitution-group declaration order closed `particlesW006`/`elemZ027_a`; the W3C MapAndSum rule (Sequence:Choice, #165) closed `particlesV003`. Remaining 1 (`particlesZ001`): a documented spec ambiguity (RecurseAsIfGroup; the reference rejects it), not a defect. | -| **invalid-schemas-accepted** | **2461 -> 411** | we rarely catch a bad one (facet, default/fixed value, particle-restriction name+type, id, structural content-model, UPA determinism, content order, identity-constraint XPath-subset, wildcard-namespace, final/block, simpleType content, group/wildcard and group/element cardinality, element-ref namespace, sequence/choice MapAndSum, circular type derivation, circular group/attributeGroup/substitution references, attribute-use uniqueness and single-ID, type-excludes-inline-type, ID-typed value-constraint exclusion, all-group reference placement, substitution-member type derivation, default/fixed mutual exclusion landed). | +| **invalid-schemas-accepted** | **2461 -> 403** | we rarely catch a bad one (facet, default/fixed value, particle-restriction name+type, id, structural content-model, UPA determinism, content order, identity-constraint XPath-subset, wildcard-namespace, final/block, simpleType content, group/wildcard and group/element cardinality, element-ref namespace, sequence/choice MapAndSum, circular type derivation, circular group/attributeGroup/substitution references, attribute-use uniqueness and single-ID, type-excludes-inline-type, ID-typed value-constraint exclusion, all-group reference placement, substitution-member type derivation, default/fixed mutual exclusion landed). | | valid-instances-rejected | **233 -> 180** | (instance side; #164's element-ref namespace fix is shared with instance validation, -34) | | invalid-instances-accepted | **160 -> 158** | (instance side; resolving an inline `` restriction base preserves list/union variety, so a `length` facet counts items and two more invalid instances are caught) |