@shortlink-org/portolan 0.1.0 → 0.2.0

package/internal/wsdl/parse.go

@@ -1,920 +0,0 @@
-package wsdl
-
-import (
-	"encoding/xml"
-	"fmt"
-	"io"
-	"io/fs"
-	"net/url"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-)
-
-const (
-	soap11WSDL = "http://schemas.xmlsoap.org/wsdl/soap/"
-	soap12WSDL = "http://schemas.xmlsoap.org/wsdl/soap12/"
-	xsdNS      = "http://www.w3.org/2001/XMLSchema"
-)
-
-type qname struct {
-	ns    string
-	local string
-}
-
-type node struct {
-	name     xml.Name
-	attrs    []xml.Attr
-	ns       map[string]string
-	text     string
-	children []*node
-}
-
-func (n *node) attr(name string) string {
-	for _, attr := range n.attrs {
-		if attr.Name.Local == name && attr.Name.Space != "xmlns" {
-			return strings.TrimSpace(attr.Value)
-		}
-	}
-	return ""
-}
-
-func (n *node) child(name string) *node {
-	for _, child := range n.children {
-		if child.name.Local == name {
-			return child
-		}
-	}
-	return nil
-}
-
-func (n *node) childrenNamed(name string) []*node {
-	var out []*node
-	for _, child := range n.children {
-		if child.name.Local == name {
-			out = append(out, child)
-		}
-	}
-	return out
-}
-
-func (n *node) documentation() string {
-	doc := n.child("documentation")
-	if doc == nil {
-		annotation := n.child("annotation")
-		if annotation != nil {
-			doc = annotation.child("documentation")
-		}
-	}
-	if doc == nil {
-		return ""
-	}
-	return strings.Join(strings.Fields(doc.deepText()), " ")
-}
-
-func (n *node) deepText() string {
-	parts := []string{n.text}
-	for _, child := range n.children {
-		parts = append(parts, child.deepText())
-	}
-	return strings.Join(parts, " ")
-}
-
-func parseXML(reader io.Reader) (*node, error) {
-	decoder := xml.NewDecoder(reader)
-	rootNS := map[string]string{"xml": "http://www.w3.org/XML/1998/namespace"}
-	var root *node
-	var stack []*node
-	for {
-		token, err := decoder.Token()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return nil, err
-		}
-		switch value := token.(type) {
-		case xml.StartElement:
-			inScope := rootNS
-			if len(stack) > 0 {
-				inScope = stack[len(stack)-1].ns
-			}
-			namespaces := make(map[string]string, len(inScope)+2)
-			for prefix, namespace := range inScope {
-				namespaces[prefix] = namespace
-			}
-			for _, attr := range value.Attr {
-				switch {
-				case attr.Name.Space == "xmlns":
-					namespaces[attr.Name.Local] = attr.Value
-				case attr.Name.Space == "" && attr.Name.Local == "xmlns":
-					namespaces[""] = attr.Value
-				}
-			}
-			current := &node{name: value.Name, attrs: value.Attr, ns: namespaces}
-			if len(stack) == 0 {
-				root = current
-			} else {
-				parent := stack[len(stack)-1]
-				parent.children = append(parent.children, current)
-			}
-			stack = append(stack, current)
-		case xml.CharData:
-			if len(stack) > 0 {
-				stack[len(stack)-1].text += string(value)
-			}
-		case xml.EndElement:
-			if len(stack) > 0 {
-				stack = stack[:len(stack)-1]
-			}
-		}
-	}
-	if root == nil {
-		return nil, fmt.Errorf("empty XML document")
-	}
-	return root, nil
-}
-
-type document struct {
-	path string
-	root *node
-}
-
-type loader struct {
-	root     string
-	docs     map[string]*document
-	loaded   map[string]bool
-	adopted  map[string]map[string]bool
-	warnings []string
-}
-
-// Read loads one WSDL document and every local WSDL/XSD import or include it
-// reaches. spec is relative to root.
-func Read(root, spec string) (Result, error) {
-	absRoot, err := filepath.Abs(root)
-	if err != nil {
-		return Result{}, err
-	}
-	l := newLoader(absRoot)
-	path, err := l.localPath(absRoot, spec)
-	if err != nil {
-		return Result{}, err
-	}
-	if err := l.load(path, ""); err != nil {
-		return Result{}, err
-	}
-	result := l.result([]string{path}, true)
-	return result, nil
-}
-
-// Discover reads every WSDL in root. Imported interface-only documents are
-// used to complete their parent and are not emitted a second time.
-func Discover(root string) (Result, error) {
-	absRoot, err := filepath.Abs(root)
-	if err != nil {
-		return Result{}, err
-	}
-	var candidates []string
-	err = filepath.WalkDir(absRoot, func(path string, entry fs.DirEntry, walkErr error) error {
-		if walkErr != nil {
-			return walkErr
-		}
-		if entry.IsDir() {
-			if path != absRoot && (strings.HasPrefix(entry.Name(), ".") || entry.Name() == "node_modules") {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-		if strings.EqualFold(filepath.Ext(entry.Name()), ".wsdl") {
-			candidates = append(candidates, path)
-		}
-		return nil
-	})
-	if err != nil {
-		return Result{}, err
-	}
-	sort.Strings(candidates)
-	var roots []string
-	for _, path := range candidates {
-		file, openErr := os.Open(path)
-		if openErr != nil {
-			return Result{}, openErr
-		}
-		node, parseErr := parseXML(file)
-		_ = file.Close()
-		if parseErr != nil {
-			return Result{}, fmt.Errorf("%s: %w", path, parseErr)
-		}
-		if node.name.Local == "definitions" && len(node.childrenNamed("service")) > 0 {
-			roots = append(roots, path)
-		}
-	}
-	standalone := false
-	if len(roots) == 0 {
-		// Some repositories keep only the reusable portType document. It is
-		// still a useful contract when no service document exists to own it.
-		roots = candidates
-		standalone = true
-	}
-	combined := Result{}
-	for _, path := range roots {
-		l := newLoader(absRoot)
-		if err := l.load(path, ""); err != nil {
-			return Result{}, err
-		}
-		part := l.result([]string{path}, standalone)
-		combined.Contracts = append(combined.Contracts, part.Contracts...)
-		combined.Warnings = append(combined.Warnings, part.Warnings...)
-	}
-	combined.Contracts = uniqueContracts(combined.Contracts)
-	combined.Warnings = unique(combined.Warnings)
-	sort.Slice(combined.Contracts, func(i, j int) bool {
-		if combined.Contracts[i].Name != combined.Contracts[j].Name {
-			return combined.Contracts[i].Name < combined.Contracts[j].Name
-		}
-		return combined.Contracts[i].Source < combined.Contracts[j].Source
-	})
-	sort.Strings(combined.Warnings)
-	return combined, nil
-}
-
-func newLoader(root string) *loader {
-	return &loader{
-		root: root, docs: map[string]*document{}, loaded: map[string]bool{},
-		adopted: map[string]map[string]bool{},
-	}
-}
-
-func (l *loader) localPath(from, location string) (string, error) {
-	if strings.TrimSpace(location) == "" {
-		return "", fmt.Errorf("empty WSDL path")
-	}
-	if parsed, err := url.Parse(location); err == nil && parsed.Scheme != "" {
-		return "", fmt.Errorf("remote import %q is not read", location)
-	}
-	path := location
-	if !filepath.IsAbs(path) {
-		path = filepath.Join(from, filepath.FromSlash(path))
-	}
-	path, err := filepath.Abs(filepath.Clean(path))
-	if err != nil {
-		return "", err
-	}
-	rel, err := filepath.Rel(l.root, path)
-	if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
-		return "", fmt.Errorf("import %q leaves the input root", location)
-	}
-	return path, nil
-}
-
-func (l *loader) load(path, adoptedNS string) error {
-	key := path + "\x00" + adoptedNS
-	if l.loaded[key] {
-		return nil
-	}
-	l.loaded[key] = true
-	doc := l.docs[path]
-	if doc == nil {
-		file, err := os.Open(path)
-		if err != nil {
-			return err
-		}
-		root, parseErr := parseXML(file)
-		closeErr := file.Close()
-		if parseErr != nil {
-			return fmt.Errorf("%s: %w", path, parseErr)
-		}
-		if closeErr != nil {
-			return closeErr
-		}
-		doc = &document{path: path, root: root}
-		l.docs[path] = doc
-	}
-	if doc.root.name.Local == "schema" && doc.root.attr("targetNamespace") == "" && adoptedNS != "" {
-		if l.adopted[path] == nil {
-			l.adopted[path] = map[string]bool{}
-		}
-		l.adopted[path][adoptedNS] = true
-	}
-
-	for _, ref := range importReferences(doc.root, adoptedNS) {
-		imported, err := l.localPath(filepath.Dir(path), ref.location)
-		if err != nil {
-			rel, _ := filepath.Rel(l.root, path)
-			l.warnings = append(l.warnings, filepath.ToSlash(rel)+": "+err.Error())
-			continue
-		}
-		if err := l.load(imported, ref.adoptedNS); err != nil {
-			rel, _ := filepath.Rel(l.root, path)
-			l.warnings = append(l.warnings, filepath.ToSlash(rel)+": import "+ref.location+": "+err.Error())
-		}
-	}
-	return nil
-}
-
-type importReference struct {
-	location  string
-	adoptedNS string
-}
-
-func importReferences(root *node, inheritedNS string) []importReference {
-	var out []importReference
-	var walk func(*node, string)
-	walk = func(n *node, schemaNS string) {
-		if n.name.Local == "schema" {
-			schemaNS = first(n.attr("targetNamespace"), schemaNS)
-		}
-		if n.name.Local == "import" || n.name.Local == "include" || n.name.Local == "redefine" {
-			if location := first(n.attr("location"), n.attr("schemaLocation")); location != "" {
-				adopted := ""
-				if n.name.Local == "include" || n.name.Local == "redefine" {
-					adopted = schemaNS
-				}
-				out = append(out, importReference{location: location, adoptedNS: adopted})
-			}
-		}
-		for _, child := range n.children {
-			walk(child, schemaNS)
-		}
-	}
-	walk(root, inheritedNS)
-	seen := map[string]bool{}
-	var uniqueRefs []importReference
-	for _, ref := range out {
-		key := ref.location + "\x00" + ref.adoptedNS
-		if !seen[key] {
-			uniqueRefs = append(uniqueRefs, ref)
-			seen[key] = true
-		}
-	}
-	return uniqueRefs
-}
-
-type index struct {
-	messages     map[qname]*node
-	portTypes    map[qname]*node
-	bindings     map[qname]*node
-	elements     map[qname]*node
-	complexTypes map[qname]*node
-	namespace    map[*node]string
-}
-
-func (l *loader) buildIndex() index {
-	ix := index{
-		messages: map[qname]*node{}, portTypes: map[qname]*node{}, bindings: map[qname]*node{},
-		elements: map[qname]*node{}, complexTypes: map[qname]*node{}, namespace: map[*node]string{},
-	}
-	paths := make([]string, 0, len(l.docs))
-	for path := range l.docs {
-		paths = append(paths, path)
-	}
-	sort.Strings(paths)
-	for _, path := range paths {
-		root := l.docs[path].root
-		source := l.relative(path)
-		switch root.name.Local {
-		case "definitions":
-			ns := root.attr("targetNamespace")
-			ix.namespace[root] = ns
-			for _, child := range root.children {
-				switch child.name.Local {
-				case "message":
-					put(ix.messages, qname{ns, child.attr("name")}, child, &l.warnings, source)
-				case "portType", "interface":
-					put(ix.portTypes, qname{ns, child.attr("name")}, child, &l.warnings, source)
-				case "binding":
-					put(ix.bindings, qname{ns, child.attr("name")}, child, &l.warnings, source)
-				case "types":
-					for _, schema := range child.childrenNamed("schema") {
-						ix.addSchema(schema, source, "", &l.warnings)
-					}
-				}
-			}
-		case "schema":
-			namespaces := []string{root.attr("targetNamespace")}
-			if namespaces[0] == "" && len(l.adopted[path]) > 0 {
-				namespaces = namespaces[:0]
-				for namespace := range l.adopted[path] {
-					namespaces = append(namespaces, namespace)
-				}
-				sort.Strings(namespaces)
-			}
-			for _, namespace := range namespaces {
-				ix.addSchema(root, source, namespace, &l.warnings)
-			}
-		}
-	}
-	return ix
-}
-
-func (ix *index) addSchema(schema *node, path, adoptedNS string, warnings *[]string) {
-	ns := first(schema.attr("targetNamespace"), adoptedNS)
-	ix.namespace[schema] = ns
-	for _, child := range schema.children {
-		switch child.name.Local {
-		case "element":
-			put(ix.elements, qname{ns, child.attr("name")}, child, warnings, path)
-		case "complexType":
-			put(ix.complexTypes, qname{ns, child.attr("name")}, child, warnings, path)
-		}
-	}
-}
-
-func put(target map[qname]*node, key qname, value *node, warnings *[]string, path string) {
-	if key.local == "" {
-		return
-	}
-	if previous, exists := target[key]; exists && previous != value {
-		*warnings = append(*warnings, path+": duplicate declaration "+key.local+" in namespace "+key.ns)
-		return
-	}
-	target[key] = value
-}
-
-func (l *loader) result(rootPaths []string, includeStandalone bool) Result {
-	ix := l.buildIndex()
-	var contracts []Contract
-	for _, path := range rootPaths {
-		doc := l.docs[path]
-		if doc == nil || doc.root.name.Local != "definitions" {
-			continue
-		}
-		definitions := doc.root
-		namespace := definitions.attr("targetNamespace")
-		services := definitions.childrenNamed("service")
-		if len(services) == 0 && includeStandalone {
-			contract := Contract{Name: first(definitions.attr("name"), strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))), Namespace: namespace, Summary: definitions.documentation(), Source: l.relative(path)}
-			for _, portType := range definitions.childrenNamed("portType") {
-				contract.Interfaces = append(contract.Interfaces, ix.abstractInterface(portType))
-			}
-			if len(contract.Interfaces) > 0 {
-				contracts = append(contracts, contract)
-			}
-			continue
-		}
-		for _, service := range services {
-			contract := Contract{Name: first(service.attr("name"), definitions.attr("name")), Namespace: namespace, Summary: first(service.documentation(), definitions.documentation()), Source: l.relative(path)}
-			for _, port := range service.childrenNamed("port") {
-				if iface, ok := ix.boundInterface(port); ok {
-					contract.Interfaces = append(contract.Interfaces, iface)
-				} else {
-					l.warnings = append(l.warnings, l.relative(path)+": port "+first(port.attr("name"), "<unnamed>")+" refers to a binding or portType that is not available locally")
-				}
-			}
-			if len(contract.Interfaces) > 0 {
-				contracts = append(contracts, contract)
-			}
-		}
-	}
-	contracts = uniqueContracts(contracts)
-	for i := range contracts {
-		sort.Slice(contracts[i].Interfaces, func(a, b int) bool { return contracts[i].Interfaces[a].Name < contracts[i].Interfaces[b].Name })
-	}
-	sort.Slice(contracts, func(i, j int) bool {
-		if contracts[i].Name != contracts[j].Name {
-			return contracts[i].Name < contracts[j].Name
-		}
-		return contracts[i].Source < contracts[j].Source
-	})
-	l.warnings = summarizeDuplicateWarnings(l.warnings)
-	sort.Strings(l.warnings)
-	return Result{Contracts: contracts, Warnings: unique(l.warnings)}
-}
-
-func summarizeDuplicateWarnings(warnings []string) []string {
-	type group struct {
-		first string
-		count int
-	}
-	groups := map[string]*group{}
-	var out []string
-	for _, warning := range warnings {
-		const marker = ": duplicate declaration "
-		at := strings.Index(warning, marker)
-		if at < 0 {
-			out = append(out, warning)
-			continue
-		}
-		namespaceAt := strings.LastIndex(warning, " in namespace ")
-		if namespaceAt < 0 {
-			out = append(out, warning)
-			continue
-		}
-		namespace := warning[namespaceAt+len(" in namespace "):]
-		key := namespace
-		found := groups[key]
-		if found == nil {
-			found = &group{first: warning[:namespaceAt]}
-			groups[key] = found
-		}
-		found.count++
-	}
-	keys := make([]string, 0, len(groups))
-	for key := range groups {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-	for _, namespace := range keys {
-		found := groups[namespace]
-		out = append(out, fmt.Sprintf("%s; %d declarations share names in namespace %s; the first declaration is used", found.first, found.count, namespace))
-	}
-	return out
-}
-
-func (l *loader) relative(path string) string {
-	rel, err := filepath.Rel(l.root, path)
-	if err != nil {
-		return filepath.ToSlash(path)
-	}
-	return filepath.ToSlash(rel)
-}
-
-func (ix index) abstractInterface(portType *node) Interface {
-	iface := Interface{Name: portType.attr("name"), PortType: portType.attr("name")}
-	iface.Operations, iface.Messages = ix.operations(portType, nil)
-	return iface
-}
-
-func (ix index) boundInterface(port *node) (Interface, bool) {
-	bindingRef := resolveQName(port, port.attr("binding"), "")
-	binding := ix.lookup(ix.bindings, bindingRef)
-	if binding == nil {
-		return Interface{}, false
-	}
-	portTypeRef := resolveQName(binding, binding.attr("type"), bindingRef.ns)
-	portType := ix.lookup(ix.portTypes, portTypeRef)
-	if portType == nil {
-		return Interface{}, false
-	}
-	version, style := bindingSOAP(binding)
-	endpoint := ""
-	for _, child := range port.children {
-		if child.name.Local == "address" && (child.name.Space == soap11WSDL || child.name.Space == soap12WSDL || strings.Contains(child.name.Space, "soap")) {
-			endpoint = child.attr("location")
-			if child.name.Space == soap12WSDL {
-				version = "1.2"
-			} else if version == "" {
-				version = "1.1"
-			}
-		}
-	}
-	iface := Interface{Name: first(port.attr("name"), binding.attr("name")), Binding: binding.attr("name"), PortType: portType.attr("name"), Endpoint: endpoint, Version: version, Style: style}
-	iface.Operations, iface.Messages = ix.operations(portType, binding)
-	return iface, true
-}
-
-func bindingSOAP(binding *node) (version, style string) {
-	for _, child := range binding.children {
-		if child.name.Local != "binding" {
-			continue
-		}
-		if child.name.Space == soap12WSDL {
-			version = "1.2"
-		} else if child.name.Space == soap11WSDL || strings.Contains(child.name.Space, "soap") {
-			version = "1.1"
-		}
-		style = child.attr("style")
-	}
-	return version, style
-}
-
-func (ix index) operations(portType, binding *node) ([]Operation, []Message) {
-	bindingOps := map[string]*node{}
-	if binding != nil {
-		for _, operation := range binding.childrenNamed("operation") {
-			bindingOps[operation.attr("name")] = operation
-		}
-	}
-	var operations []Operation
-	messageRefs := map[qname]bool{}
-	for _, abstract := range portType.childrenNamed("operation") {
-		name := abstract.attr("name")
-		bound := bindingOps[name]
-		operation := Operation{Name: name, Doc: abstract.documentation()}
-		if input := abstract.child("input"); input != nil {
-			ref := resolveQName(input, input.attr("message"), "")
-			operation.Request = ref.local
-			messageRefs[ref] = ref.local != ""
-		}
-		if output := abstract.child("output"); output != nil {
-			ref := resolveQName(output, output.attr("message"), "")
-			operation.Response = ref.local
-			messageRefs[ref] = ref.local != ""
-		}
-		for _, fault := range abstract.childrenNamed("fault") {
-			ref := resolveQName(fault, fault.attr("message"), "")
-			faultName := first(fault.attr("name"), ref.local)
-			if faultName != "" {
-				operation.Faults = append(operation.Faults, faultName)
-			}
-			messageRefs[ref] = ref.local != ""
-		}
-		if bound != nil {
-			for _, child := range bound.children {
-				if child.name.Local == "operation" && (child.name.Space == soap11WSDL || child.name.Space == soap12WSDL || strings.Contains(child.name.Space, "soap")) {
-					operation.Action = first(child.attr("soapAction"), child.attr("soapActionURI"))
-				}
-			}
-			operation.Headers = bindingHeaders(bound)
-			if operation.Doc == "" {
-				operation.Doc = bound.documentation()
-			}
-		}
-		operation.Faults = unique(operation.Faults)
-		operations = append(operations, operation)
-	}
-	var messages []Message
-	seen := map[string]bool{}
-	var typeQueue []qname
-	refs := make([]qname, 0, len(messageRefs))
-	for ref, present := range messageRefs {
-		if present {
-			refs = append(refs, ref)
-		}
-	}
-	sort.Slice(refs, func(i, j int) bool { return qnameLess(refs[i], refs[j]) })
-	for _, ref := range refs {
-		message, reached := ix.message(ref)
-		if message.Name != "" && !seen[message.Name] {
-			messages = append(messages, message)
-			seen[message.Name] = true
-		}
-		typeQueue = append(typeQueue, reached...)
-	}
-	for len(typeQueue) > 0 {
-		ref := typeQueue[0]
-		typeQueue = typeQueue[1:]
-		if ref.local == "" || seen[ref.local] || builtin(ref) {
-			continue
-		}
-		complex := ix.lookup(ix.complexTypes, ref)
-		if complex == nil {
-			continue
-		}
-		fields, reached := ix.shape(complex, map[qname]bool{})
-		messages = append(messages, Message{Name: ref.local, Fields: fields})
-		seen[ref.local] = true
-		typeQueue = append(typeQueue, reached...)
-	}
-	sort.Slice(operations, func(i, j int) bool { return operations[i].Name < operations[j].Name })
-	sort.Slice(messages, func(i, j int) bool { return messages[i].Name < messages[j].Name })
-	return operations, messages
-}
-
-func bindingHeaders(operation *node) []string {
-	var headers []string
-	for _, direction := range []string{"input", "output"} {
-		container := operation.child(direction)
-		if container == nil {
-			continue
-		}
-		for _, child := range container.children {
-			if child.name.Local != "header" || !(child.name.Space == soap11WSDL || child.name.Space == soap12WSDL || strings.Contains(child.name.Space, "soap")) {
-				continue
-			}
-			message := resolveQName(child, child.attr("message"), "").local
-			header := first(child.attr("part"), message)
-			if message != "" && child.attr("part") != "" {
-				header = message + "." + child.attr("part")
-			}
-			if header != "" {
-				headers = append(headers, header)
-			}
-		}
-	}
-	return unique(headers)
-}
-
-func (ix index) message(ref qname) (Message, []qname) {
-	messageNode := ix.lookup(ix.messages, ref)
-	if messageNode == nil {
-		return Message{Name: ref.local}, nil
-	}
-	message := Message{Name: messageNode.attr("name")}
-	var reached []qname
-	parts := messageNode.childrenNamed("part")
-	for _, part := range parts {
-		if elementValue := part.attr("element"); elementValue != "" {
-			elementRef := resolveQName(part, elementValue, ref.ns)
-			element := ix.lookup(ix.elements, elementRef)
-			if element != nil && len(parts) == 1 {
-				fields, refs := ix.elementShape(element, elementRef.ns)
-				if len(fields) > 0 {
-					message.Fields = append(message.Fields, fields...)
-					reached = append(reached, refs...)
-					continue
-				}
-			}
-			typeName := elementRef.local
-			if element != nil && element.attr("type") != "" {
-				typeRef := resolveQName(element, element.attr("type"), elementRef.ns)
-				typeName = typeLabel(typeRef)
-				reached = append(reached, typeRef)
-			}
-			message.Fields = append(message.Fields, Field{Name: first(part.attr("name"), elementRef.local), Type: typeName, Doc: documentationOf(element)})
-			continue
-		}
-		typeRef := resolveQName(part, part.attr("type"), ref.ns)
-		message.Fields = append(message.Fields, Field{Name: first(part.attr("name"), "value"), Type: typeLabel(typeRef), Doc: part.documentation()})
-		reached = append(reached, typeRef)
-	}
-	return message, reached
-}
-
-func (ix index) elementShape(element *node, fallbackNS string) ([]Field, []qname) {
-	if inline := element.child("complexType"); inline != nil {
-		return ix.shape(inline, map[qname]bool{})
-	}
-	typeRef := resolveQName(element, element.attr("type"), fallbackNS)
-	if complex := ix.lookup(ix.complexTypes, typeRef); complex != nil {
-		fields, refs := ix.shape(complex, map[qname]bool{typeRef: true})
-		return fields, append(refs, typeRef)
-	}
-	return nil, []qname{typeRef}
-}
-
-func (ix index) shape(complex *node, resolving map[qname]bool) ([]Field, []qname) {
-	var fields []Field
-	var refs []qname
-	var walk func(*node)
-	walk = func(current *node) {
-		for _, child := range current.children {
-			switch child.name.Local {
-			case "extension", "restriction":
-				base := resolveQName(child, child.attr("base"), "")
-				if !builtin(base) && !resolving[base] {
-					if parent := ix.lookup(ix.complexTypes, base); parent != nil {
-						resolving[base] = true
-						parentFields, parentRefs := ix.shape(parent, resolving)
-						delete(resolving, base)
-						fields = append(fields, parentFields...)
-						refs = append(refs, parentRefs...)
-					}
-				}
-				walk(child)
-			case "sequence", "all", "choice", "complexContent", "simpleContent", "group":
-				walk(child)
-			case "element":
-				name := child.attr("name")
-				ref := resolveQName(child, child.attr("ref"), "")
-				if name == "" {
-					name = ref.local
-				}
-				typeRef := resolveQName(child, child.attr("type"), "")
-				if typeRef.local == "" && ref.local != "" {
-					if declared := ix.lookup(ix.elements, ref); declared != nil {
-						typeRef = resolveQName(declared, declared.attr("type"), ref.ns)
-						if name == "" {
-							name = declared.attr("name")
-						}
-					}
-				}
-				typeName := typeLabel(typeRef)
-				if inline := child.child("complexType"); inline != nil {
-					typeName = first(name, "object")
-				}
-				if typeName == "" {
-					typeName = "any"
-				}
-				if max := child.attr("maxOccurs"); max == "unbounded" || (max != "" && max != "1") {
-					typeName += "[]"
-				}
-				fields = append(fields, Field{Name: name, Type: typeName, Doc: child.documentation()})
-				refs = append(refs, typeRef)
-			case "attribute":
-				name := first(child.attr("name"), resolveQName(child, child.attr("ref"), "").local)
-				typeRef := resolveQName(child, child.attr("type"), "")
-				fields = append(fields, Field{Name: "@" + name, Type: first(typeLabel(typeRef), "string"), Doc: child.documentation()})
-				refs = append(refs, typeRef)
-			}
-		}
-	}
-	walk(complex)
-	return uniqueFields(fields), refs
-}
-
-func (ix index) lookup(values map[qname]*node, ref qname) *node {
-	if found := values[ref]; found != nil {
-		return found
-	}
-	if ref.local == "" {
-		return nil
-	}
-	var match *node
-	for key, value := range values {
-		if key.local != ref.local {
-			continue
-		}
-		if match != nil {
-			return nil
-		}
-		match = value
-	}
-	return match
-}
-
-func resolveQName(n *node, value, fallbackNS string) qname {
-	value = strings.TrimSpace(value)
-	if value == "" {
-		return qname{}
-	}
-	if prefix, local, ok := strings.Cut(value, ":"); ok {
-		return qname{ns: n.ns[prefix], local: local}
-	}
-	namespace := n.ns[""]
-	if namespace == "" || namespace == "http://schemas.xmlsoap.org/wsdl/" {
-		namespace = fallbackNS
-	}
-	return qname{ns: namespace, local: value}
-}
-
-func typeLabel(ref qname) string {
-	if ref.local == "" {
-		return ""
-	}
-	if ref.ns == xsdNS || strings.Contains(strings.ToLower(ref.ns), "xmlschema") {
-		switch strings.ToLower(ref.local) {
-		case "integer", "int", "long", "short", "byte", "nonnegativeinteger", "positiveinteger":
-			return "int"
-		case "decimal", "double", "float":
-			return "number"
-		case "boolean":
-			return "boolean"
-		case "datetime", "date", "time", "duration":
-			return strings.ToLower(ref.local)
-		case "base64binary", "hexbinary":
-			return "bytes"
-		case "anytype", "anysimpletype":
-			return "any"
-		default:
-			return "string"
-		}
-	}
-	return ref.local
-}
-
-func builtin(ref qname) bool {
-	return ref.local == "" || ref.ns == xsdNS || strings.Contains(strings.ToLower(ref.ns), "xmlschema")
-}
-
-func documentationOf(n *node) string {
-	if n == nil {
-		return ""
-	}
-	return n.documentation()
-}
-
-func uniqueContracts(in []Contract) []Contract {
-	seen := map[string]bool{}
-	var out []Contract
-	for _, contract := range in {
-		key := contract.Source + "\x00" + contract.Name
-		if !seen[key] {
-			out = append(out, contract)
-			seen[key] = true
-		}
-	}
-	return out
-}
-
-func uniqueFields(in []Field) []Field {
-	seen := map[string]bool{}
-	var out []Field
-	for _, field := range in {
-		if field.Name == "" || seen[field.Name] {
-			continue
-		}
-		seen[field.Name] = true
-		out = append(out, field)
-	}
-	return out
-}
-
-func qnameLess(left, right qname) bool {
-	if left.ns != right.ns {
-		return left.ns < right.ns
-	}
-	return left.local < right.local
-}
-
-func unique(in []string) []string {
-	seen := map[string]bool{}
-	var out []string
-	for _, value := range in {
-		if value != "" && !seen[value] {
-			seen[value] = true
-			out = append(out, value)
-		}
-	}
-	return out
-}
-
-func first(values ...string) string {
-	for _, value := range values {
-		if strings.TrimSpace(value) != "" {
-			return strings.TrimSpace(value)
-		}
-	}
-	return ""
-}