From 4996d75879ab674d7bd908306cef27d699713a0f Mon Sep 17 00:00:00 2001 From: Mihaela Mihaljevic Date: Mon, 15 Jun 2026 11:41:26 +0200 Subject: [PATCH] fix(schema): an ID-derived attribute or element may not have a value constraint An attribute or element whose type is or derives from xs:ID may not carry a default or fixed value (a-props-correct.3 / e-props-correct.5). Such schemas were accepted. The check runs after named simple types are resolved, so a named user type derived from xs:ID is recognized (not just the built-in and inline forms). The type reference's namespace is resolved from its prefix: only an ID in the XSD namespace is the built-in, and a user type is ID only when it resolves to one whose base is xs:ID. An adversarial critic caught a namespace-blind over- rejection (a user type named ID, or an imported foo:ID, mistaken for the built-in); the namespace resolution fixes it, with a regression test. XSTS: invalid schemas accepted 489 to 481 (attZ013a/b, elemZ032a/b, valueconstraint01001m2/m3/m5/m6 now rejected), no other bucket raised. --- CHANGELOG.md | 1 + Sources/Schema/SchemaIDValueConstraint.swift | 65 ++++++++++++++++++++ Sources/Schema/XSDParser.swift | 2 +- Tests/SchemaIDValueConstraintTests.swift | 43 +++++++++++++ Tests/XSTSSuiteTests.swift | 2 +- docs/schema-validity-burndown.md | 2 +- 6 files changed, 112 insertions(+), 3 deletions(-) create mode 100644 Sources/Schema/SchemaIDValueConstraint.swift create mode 100644 Tests/SchemaIDValueConstraintTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index da4598b..8c91fe4 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 attribute or element whose type is or derives from `xs:ID` may no longer carry a `default` or `fixed` value constraint (XSD 1.0 `a-props-correct.3` / `e-props-correct.5`, #170). Such schemas were accepted. The check runs after named simple types resolve, so a named user type derived from `xs:ID` is recognized; the type reference's namespace is resolved from its prefix, so a user type named `ID` or an imported `foo:ID` is not mistaken for the built-in. XSTS: invalid schemas accepted 489 to 481, no other bucket raised. - A `type` attribute and an inline anonymous type definition are now mutually exclusive on an element or attribute (XSD 1.0 `src-element.3` / `src-attribute.3.1`, #170). An `` or `` carrying both a `type=` and an inline `` (or ``, for an element) is rejected; previously it was accepted. Only an inline type in the XSD namespace counts, so a foreign-namespace child that happens to be named `complexType`/`simpleType` is not mistaken for the component's own type. XSTS: invalid schemas accepted 495 to 489, no other bucket raised. - Attribute-use uniqueness and the single-ID rule are now enforced (XSD 1.0 `ct-props-correct.4` / `ag-props-correct.2` / `ct-props-correct.5`, #162). A complex type's or attribute group's attribute-use set (flattened through `attributeGroup` references) may not contain two distinct declarations with the same name and namespace, nor more than one attribute whose type is or derives from `xs:ID`. Declarations are deduplicated by the identity of their declaring node, so the same declaration reached by two paths (a diamond of attribute-group references) is one use, not a clash; names carry their resolved namespace, so a local attribute and a reference to a same-local-name attribute in an imported namespace do not collide. XSTS: invalid schemas accepted 505 to 495, no other bucket raised. Disclosed under-rejections: the set inherited through extension is not composed in, and a duplicate that requires an unprefixed reference in a schema with no default namespace is not detected. - Circular references among model groups, attribute groups, and substitution-group affiliations are now rejected (XSD 1.0 `mg-props-correct.2`, `ag-props-correct.3`, `e-props-correct.6`, #168). A model group may not contain itself, an attribute group may not reference itself transitively, and a substitution chain may not loop. The model-group check follows references only within a definition's own compositor tree, stopping at element and type boundaries: a group referenced inside an element's content is a recursive data structure (permitted), not the group containing itself. A reference is followed only when it resolves to the schema's own target namespace, and a group or attribute group redefined in `xs:redefine` (whose single self-reference is the legal redefinition) ends the chain. XSTS: invalid schemas accepted 516 to 505, no other bucket raised. A genuine cycle introduced across two redefined definitions is a disclosed under-rejection. diff --git a/Sources/Schema/SchemaIDValueConstraint.swift b/Sources/Schema/SchemaIDValueConstraint.swift new file mode 100644 index 0000000..1ba4d48 --- /dev/null +++ b/Sources/Schema/SchemaIDValueConstraint.swift @@ -0,0 +1,65 @@ +private typealias IDVNode = PureXML.Schema.XSDNode + +extension PureXML.Schema.XSDParser { + /// XSD 1.0 `a-props-correct.3` / `e-props-correct.5`: an attribute or element + /// declaration whose type is or derives from `xs:ID` must not carry a `default` + /// or `fixed` value constraint. Runs after named simple types are resolved, so a + /// named user type derived from `xs:ID` is recognized, not only the built-in and + /// inline forms. Only XSD-namespace declarations are checked; foreign content is + /// skipped. + static func idValueConstraintErrors(_ schema: XSDTree, _ context: PureXML.Schema.XSDContext) -> [String] { + var errors: [String] = [] + collectIDValueConstraintErrors(schema, context, into: &errors) + return errors + } + + private static func collectIDValueConstraintErrors(_ node: XSDTree, _ context: PureXML.Schema.XSDContext, into errors: inout [String]) { + let local = IDVNode.localName(node) + if local == "appinfo" || local == "documentation" { return } + if let error = idValueConstraintError(node, context) { + errors.append(error) + } + for child in IDVNode.elementChildren(node) { + collectIDValueConstraintErrors(child, context, into: &errors) + } + } + + private static func idValueConstraintError(_ node: XSDTree, _ context: PureXML.Schema.XSDContext) -> String? { + guard node.name?.namespaceURI == xsdNamespace, let kind = IDVNode.localName(node), + kind == "element" || kind == "attribute", + let name = IDVNode.attribute(node, "name"), + IDVNode.attribute(node, "default") != nil || IDVNode.attribute(node, "fixed") != nil, + isIDDerived(node, context) + else { return nil } + return "'\(kind)' '\(name)' must not have a default or fixed value because its type is derived from ID" + } + + /// Whether the declaration's type is or derives from `xs:ID`. A `type` attribute + /// is resolved by reference; an inline `simpleType` is ID only when it restricts + /// an ID-derived base (a list or union is not derived from ID). + private static func isIDDerived(_ node: XSDTree, _ context: PureXML.Schema.XSDContext) -> Bool { + if let typeName = IDVNode.attribute(node, "type") { + return typeReferenceIsID(typeName, context) + } + guard let inline = IDVNode.firstChild(node, named: "simpleType"), + let restriction = IDVNode.firstChild(inline, named: "restriction"), + let base = IDVNode.attribute(restriction, "base") + else { + return false + } + return typeReferenceIsID(base, context) + } + + /// Whether a type reference resolves to, or derives from, the built-in `xs:ID`. + /// The reference's namespace is resolved from its prefix: only an `ID` in the + /// XSD namespace is the built-in; a user type is ID only if it resolves to one + /// whose base is `xs:ID`; a foreign or unresolved reference is not ID. (Matching + /// by local name alone would mistake a user type named `ID`, or an imported + /// `foo:ID`, for the built-in.) + private static func typeReferenceIsID(_ typeName: String, _ context: PureXML.Schema.XSDContext) -> Bool { + if IDVNode.referenceNamespace(typeName, context.namespaceBindings) == xsdNamespace { + return IDVNode.stripPrefix(typeName) == "ID" + } + return context.simpleTypes[IDVNode.stripPrefix(typeName)]?.base == .id + } +} diff --git a/Sources/Schema/XSDParser.swift b/Sources/Schema/XSDParser.swift index 61606ac..4f30ecc 100644 --- a/Sources/Schema/XSDParser.swift +++ b/Sources/Schema/XSDParser.swift @@ -41,7 +41,7 @@ extension PureXML.Schema { let elements = globalElements(containers, context, into: &types) // Attribute-use uniqueness / single-ID run here, after `namedTypes` // populated `simpleTypes`, so a named user type derived from `xs:ID` counts. - for error in referenceErrors(schema, in: context, elements: elements) + attributeUseErrors(containers, context) { + for error in referenceErrors(schema, in: context, elements: elements) + attributeUseErrors(containers, context) + idValueConstraintErrors(schema, context) { context.diagnostics.report(error) } let (nillable, elementConstraints) = elementMetadata(containers) diff --git a/Tests/SchemaIDValueConstraintTests.swift b/Tests/SchemaIDValueConstraintTests.swift new file mode 100644 index 0000000..9e166ee --- /dev/null +++ b/Tests/SchemaIDValueConstraintTests.swift @@ -0,0 +1,43 @@ +@testable import PureXML +import Testing + +@Suite("XSD ID-typed declarations have no value constraint") +struct SchemaIDValueConstraintTests { + private func compiles(_ body: String) -> Bool { + (try? PureXML.Schema.Document("\(body)")) != nil + } + + @Test("An ID-typed attribute or element with a default or fixed value is rejected") + func test_idWithValueConstraintRejected() { + // Attribute of type xs:ID with a fixed value (a-props-correct.3). + #expect(!compiles("")) + // Element of type xs:ID with a default value (e-props-correct.5). + #expect(!compiles("")) + // A named user type derived from xs:ID is recognized (the check runs after + // named types resolve). + #expect(!compiles("" + + "")) + } + + @Test("An ID-typed declaration without a value constraint, or a value constraint on a non-ID type, compiles") + func test_acceptedCases() { + // ID type, no value constraint. + #expect(compiles("")) + #expect(compiles("")) + // A value constraint on a non-ID type is fine. + #expect(compiles("")) + #expect(compiles("")) + } + + @Test("A user type named ID (not xs:ID) with a value constraint is allowed") + func test_userTypeNamedIDNotBuiltin() { + // A user simpleType named ID in the target namespace, derived from string, is + // not the built-in xs:ID: a value constraint on it is legal. Resolving by + // local name alone would wrongly reject it. + let schema = "" + + "" + + "" + #expect((try? PureXML.Schema.Document(schema)) != nil) + } +} diff --git a/Tests/XSTSSuiteTests.swift b/Tests/XSTSSuiteTests.swift index 7860bca..6072b44 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 = 489 + private let knownSchemaInvalidAccepted = 481 private let knownInstanceValidRejected = 180 private let knownInstanceInvalidAccepted = 160 diff --git a/docs/schema-validity-burndown.md b/docs/schema-validity-burndown.md index 5b06e8a..f9143b4 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 -> 489** | 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 landed). | +| **invalid-schemas-accepted** | **2461 -> 481** | 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 landed). | | valid-instances-rejected | **233 -> 180** | (instance side; #164's element-ref namespace fix is shared with instance validation, -34) | | invalid-instances-accepted | 160 | |