Merge pull request #357 from bytecodealliance/ydnar/issue356

wit/bindgen: improve WIT world matching, warn if ambiguous

Author: ydnar

CHANGELOG.md

@@ -13,6 +13,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 - [#306](https://github.com/bytecodealliance/go-modules/issues/306): do not emit incompatible version feature gates when serializing WIT. For example, if a world with version `0.1.0` *includes* a world from another package with a `@since(version = 0.2.0)` feature gate, then strip that feature gate when serializing to WIT if the version is greater than the world’s package version.
 - [#350](https://github.com/bytecodealliance/go-modules/issues/350): correctly align `record` size to the highest alignment of its fields, per [specification](https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#element-size).
 - [#352](https://github.com/bytecodealliance/go-modules/issues/352): do not use `tuple` types as data shape for `variant` or `result` types, as they may contain a `bool` or not be packed.
+- [#356](https://github.com/bytecodealliance/go-modules/issues/356): sort WIT packages topologically by dependency before matching WIT world when generating Go bindings. Warn if there is an ambiguous match.
 
 ## [v0.6.2] — 2025-03-16
 

wit/bindgen/generator.go

@@ -163,12 +163,39 @@ func newGenerator(res *wit.Resolve, opts ...Option) (*generator, error) {
 		g.opts.cmPackage = cmPackage
 	}
 	g.res = res
-	for _, g.world = range res.Worlds {
-		if g.world.Match(g.opts.world) {
-			break
-		}
-		// otherwise choose the last world
+
+	// Sort WIT packages topologically
+	packages := slices.Clone(res.Packages)
+	slices.SortFunc(packages, wit.ComparePackages)
+	slices.Reverse(packages)
+
+	// Select WIT world
+	var first *wit.World
+	for _, pkg := range packages {
+		pkg.Worlds.All()(func(_ string, w *wit.World) bool {
+			if first == nil {
+				first = w
+			}
+			if w.Match(g.opts.world) {
+				name := w.Package.Name
+				name.Extension = w.Name
+				if g.world == nil {
+					g.opts.logger.Infof("WIT world: %s", name.String())
+					g.world = w
+				} else {
+					g.opts.logger.Warnf("Warning: ambiguous WIT world: %s", name.String())
+				}
+			}
+			return true
+		})
+	}
+
+	// Fall back to first world
+	if g.world == nil {
+		g.world = first
 	}
+
+	// Instantiate a wasm-tools instance.
 	g.wasmTools, err = wasmtools.New(context.Background())
 	if err != nil {
 		return nil, err

wit/package.go

@@ -48,7 +48,13 @@ func (p *Package) dependsOn(dep Node) bool {
 	return done
 }
 
-func comparePackages(a, b *Package) int {
+// ComparePackages compares two WIT packages, based on dependence.
+// When used with [slices.SortFunc], this function will sort packages
+// based on their mutual dependence. Packages with fewer or no dependencies will sort last.
+// If package a depends on package b, this function returns 1.
+// If package b depends on package a, this function returns -1.
+// If package a == package b, this function returns 0.
+func ComparePackages(a, b *Package) int {
 	// fmt.Fprintln(os.Stderr, "comparing "+b.Name.String()+" to "+a.Name.String())
 	switch {
 	case a == b:

wit/wit.go

@@ -133,7 +133,7 @@ func (*Resolve) WITKind() string { return "resolve" }
 func (r *Resolve) WIT(ctx Node, _ string) string {
 	// Sort packages topologically by dependency
 	packages := slices.Clone(r.Packages)
-	slices.SortFunc(packages, comparePackages)
+	slices.SortFunc(packages, ComparePackages)
 	slices.Reverse(packages)
 
 	var b strings.Builder