236 lines
11 KiB
Swift
236 lines
11 KiB
Swift
extension PureXML.Schema.XSDParser {
|
|
private struct ResolutionContext {
|
|
let check: ReferenceCheckContext
|
|
|
|
init(
|
|
types: Set<String>,
|
|
pools: [String: Set<String>],
|
|
bindings: [String: String],
|
|
targetNamespace: String?,
|
|
foreignPools: [String?: [String: Set<String>]],
|
|
chameleonNamespace: Bool,
|
|
) {
|
|
check = ReferenceCheckContext(
|
|
types: types,
|
|
pools: pools,
|
|
bindings: bindings,
|
|
targetNamespace: targetNamespace,
|
|
foreignPools: foreignPools,
|
|
chameleonNamespace: chameleonNamespace,
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Schema-validity findings for unresolvable references: every QName a schema
|
|
/// names (a `type`/`base`/`itemType`/`memberTypes` type, an `element`/
|
|
/// `attribute`/`group`/`attributeGroup` `ref`, an element `substitutionGroup`)
|
|
/// must resolve to a declared component or a built-in. The reference is matched
|
|
/// by local name, as the rest of the compiler resolves it.
|
|
///
|
|
/// Skipped when the document pulls in external definitions through
|
|
/// `import`/`include`/`redefine`: the default compile does not load them, so
|
|
/// the pools would be incomplete and a reference into them must not be flagged.
|
|
static func referenceFindings(
|
|
_ schema: XSDTree,
|
|
in context: PureXML.Schema.XSDContext,
|
|
elements: [String: PureXML.Schema.ElementType],
|
|
containers: [XSDTree],
|
|
) -> [PureXML.Schema.SchemaLocatedFinding] {
|
|
collectReferenceFindings(schema, in: context, elements: elements, containers: containers)
|
|
}
|
|
|
|
private static func collectReferenceFindings(
|
|
_ schema: XSDTree,
|
|
in context: PureXML.Schema.XSDContext,
|
|
elements: [String: PureXML.Schema.ElementType],
|
|
containers: [XSDTree],
|
|
) -> [PureXML.Schema.SchemaLocatedFinding] {
|
|
let xsdFindings = xsdNamespaceReferenceFindings(schema)
|
|
let simpleContentFindings = simpleContentBaseFindings(schema, in: context)
|
|
if skipsCrossDocumentRules(schema, compositionLoaded: context.compositionLoaded) {
|
|
return xsdFindings + simpleContentFindings
|
|
+ undeclaredNamespaceReferenceFindings(schema, containers: containers)
|
|
}
|
|
let types = referenceBuiltins.union(context.simpleTypes.keys).union(context.complexTypeNodes.keys)
|
|
let pools: [String: Set<String>] = [
|
|
"element": Set(elements.keys),
|
|
"attribute": Set(context.globalAttributes.keys),
|
|
"group": Set(context.groups.keys),
|
|
"attributeGroup": Set(context.attributeGroups.keys),
|
|
]
|
|
let targetNamespace = context.targetNamespace
|
|
let foreignPools = context.compositionLoaded
|
|
? foreignComponentPools(containers, mainTargetNamespace: targetNamespace)
|
|
: [:]
|
|
var findings: [PureXML.Schema.SchemaLocatedFinding] = []
|
|
let referenceSources: [(XSDTree, String?)]
|
|
if context.compositionLoaded {
|
|
let namespaceMap = resolveContainerNamespaces(containers, mainTargetNamespace: targetNamespace)
|
|
referenceSources = containers.compactMap { container -> (XSDTree, String?)? in
|
|
guard PureXML.Schema.XSDNode.localName(container) == "schema" else { return nil }
|
|
let index = containers.firstIndex(where: { $0 === container }) ?? containers.count - 1
|
|
let effectiveNamespace = namespaceMap[index] ?? targetNamespace
|
|
return (container, effectiveNamespace)
|
|
}
|
|
} else {
|
|
referenceSources = [(schema, targetNamespace)]
|
|
}
|
|
for (source, effectiveNamespace) in referenceSources {
|
|
let sourceBindings = PureXML.Schema.XSDNode.namespaceBindings(of: source)
|
|
let chameleonNamespace = PureXML.Schema.XSDNode.attribute(source, "targetNamespace") == nil
|
|
let resolutionContext = ResolutionContext(
|
|
types: types,
|
|
pools: pools,
|
|
bindings: sourceBindings,
|
|
targetNamespace: effectiveNamespace,
|
|
foreignPools: foreignPools,
|
|
chameleonNamespace: chameleonNamespace,
|
|
)
|
|
collectReferenceFindings(source, in: resolutionContext, inheritedBindings: sourceBindings, into: &findings)
|
|
}
|
|
var result = xsdFindings
|
|
result += simpleContentFindings
|
|
result += findings
|
|
result += redefineComponentExistenceFindings(containers)
|
|
result += importNamespaceFindings(context, containers)
|
|
return result
|
|
}
|
|
|
|
/// XSD 1.0 `src-redefine.6`/`7.2.1`/`7.2.2`: each component a `redefine` names
|
|
/// must have a same-kind component of that name in the redefined schema, and a
|
|
/// `redefine` may redefine a given component at most once. Runs only past the
|
|
/// cross-document skip guard above, so the redefined schema is loaded; a
|
|
/// redefinition whose name matches nothing in any non-`redefine` container (the
|
|
/// loaded targets and the root) names a component that does not exist, and a
|
|
/// name redefined twice in one `redefine` is a duplicate redefinition.
|
|
private static func redefineComponentExistenceFindings(_ containers: [XSDTree]) -> [PureXML.Schema.SchemaLocatedFinding] {
|
|
let kinds = ["complexType", "simpleType", "group", "attributeGroup"]
|
|
var defined: [String: Set<String>] = [:]
|
|
for container in containers where PureXML.Schema.XSDNode.localName(container) != "redefine" {
|
|
for kind in kinds {
|
|
for node in PureXML.Schema.XSDNode.children(container, named: kind) {
|
|
if let name = PureXML.Schema.XSDNode.attribute(node, "name") {
|
|
defined[kind, default: []].insert(name)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var findings: [PureXML.Schema.SchemaLocatedFinding] = []
|
|
for container in containers where PureXML.Schema.XSDNode.localName(container) == "redefine" {
|
|
var redefinedHere: [String: Set<String>] = [:]
|
|
for kind in kinds {
|
|
for node in PureXML.Schema.XSDNode.children(container, named: kind) {
|
|
guard let name = PureXML.Schema.XSDNode.attribute(node, "name") else { continue }
|
|
if !redefinedHere[kind, default: []].insert(name).inserted {
|
|
findings.append(PureXML.Schema.SchemaLocatedFinding(
|
|
reason: "a redefine redefines \(kind) '\(name)' more than once",
|
|
node: node,
|
|
))
|
|
} else if defined[kind]?.contains(name) != true {
|
|
findings.append(PureXML.Schema.SchemaLocatedFinding(
|
|
reason: "a redefine of \(kind) '\(name)' has no '\(name)' to redefine in the redefined schema",
|
|
node: node,
|
|
))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return findings
|
|
}
|
|
|
|
/// Whether cross-document schema-validity rules should stand down: an external
|
|
/// reference is declared but no external document was loaded through a
|
|
/// `schemaLoader`, so the merged component set is incomplete.
|
|
static func skipsCrossDocumentRules(_ schema: XSDTree, compositionLoaded: Bool) -> Bool {
|
|
hasExternalReference(schema) && !compositionLoaded
|
|
}
|
|
|
|
/// Whether the document declares an `import`, `include`, or `redefine`, so its
|
|
/// component pools may be completed by an external document the default compile
|
|
/// does not load.
|
|
static func hasExternalReference(_ schema: XSDTree) -> Bool {
|
|
var found = false
|
|
func walk(_ node: XSDTree) {
|
|
if isExternalDefinition(node) {
|
|
found = true
|
|
return
|
|
}
|
|
for child in PureXML.Schema.XSDNode.elementChildren(node) where !found {
|
|
walk(child)
|
|
}
|
|
}
|
|
walk(schema)
|
|
return found
|
|
}
|
|
|
|
/// Whether `node` is an `xs:import`/`xs:include`/`xs:redefine` (an XSD-namespace
|
|
/// element bringing in external definitions).
|
|
private static func isExternalDefinition(_ node: XSDTree) -> Bool {
|
|
guard node.name?.namespaceURI == xsdNamespace, let local = PureXML.Schema.XSDNode.localName(node) else {
|
|
return false
|
|
}
|
|
return local == "import" || local == "include" || local == "redefine"
|
|
}
|
|
|
|
private static func collectReferenceFindings(
|
|
_ node: XSDTree,
|
|
in resolutionContext: ResolutionContext,
|
|
inheritedBindings: [String: String],
|
|
into findings: inout [PureXML.Schema.SchemaLocatedFinding],
|
|
) {
|
|
let local = PureXML.Schema.XSDNode.localName(node)
|
|
if local == "appinfo" || local == "documentation" {
|
|
return
|
|
}
|
|
let bindings = mergedNamespaceBindings(on: node, inherited: inheritedBindings)
|
|
let nodeContext = ResolutionContext(
|
|
types: resolutionContext.check.types,
|
|
pools: resolutionContext.check.pools,
|
|
bindings: bindings,
|
|
targetNamespace: resolutionContext.check.targetNamespace,
|
|
foreignPools: resolutionContext.check.foreignPools,
|
|
chameleonNamespace: resolutionContext.check.chameleonNamespace,
|
|
)
|
|
if node.name?.namespaceURI == xsdNamespace, let local {
|
|
findings += referenceFindings(at: node, local: local, in: nodeContext)
|
|
}
|
|
for child in PureXML.Schema.XSDNode.elementChildren(node) {
|
|
collectReferenceFindings(child, in: resolutionContext, inheritedBindings: bindings, into: &findings)
|
|
}
|
|
}
|
|
|
|
private static func referenceFindings(
|
|
at node: XSDTree,
|
|
local: String,
|
|
in resolutionContext: ResolutionContext,
|
|
) -> [PureXML.Schema.SchemaLocatedFinding] {
|
|
var findings: [PureXML.Schema.SchemaLocatedFinding] = []
|
|
let context = resolutionContext.check
|
|
for attribute in ["type", "base", "itemType"] {
|
|
guard let qname = PureXML.Schema.XSDNode.attribute(node, attribute) else { continue }
|
|
if isUndeclaredReferenceType(qname, in: context) {
|
|
findings.append(PureXML.Schema.SchemaLocatedFinding(reason: "\(attribute) references undeclared type '\(qname)'", node: node))
|
|
}
|
|
}
|
|
if let members = PureXML.Schema.XSDNode.attribute(node, "memberTypes") {
|
|
for token in members.split(whereSeparator: \.isWhitespace) {
|
|
let qname = String(token)
|
|
if isUndeclaredReferenceType(qname, in: context) {
|
|
findings.append(PureXML.Schema.SchemaLocatedFinding(reason: "memberTypes references undeclared type '\(qname)'", node: node))
|
|
}
|
|
}
|
|
}
|
|
if let head = PureXML.Schema.XSDNode.attribute(node, "substitutionGroup") {
|
|
if isUndeclaredReferenceRef(head, poolName: "element", in: context) {
|
|
findings.append(PureXML.Schema.SchemaLocatedFinding(reason: "substitutionGroup references undeclared element '\(head)'", node: node))
|
|
}
|
|
}
|
|
if let reference = PureXML.Schema.XSDNode.attribute(node, "ref"), context.pools[local] != nil {
|
|
if isUndeclaredReferenceRef(reference, poolName: local, in: context) {
|
|
findings.append(PureXML.Schema.SchemaLocatedFinding(reason: "\(local) ref references undeclared '\(reference)'", node: node))
|
|
}
|
|
}
|
|
return findings
|
|
}
|
|
}
|