wit, cmd/wit-bindgen-go: WIT tree shaking

This enables WIT tree-shaking by world or interface, as a precursor for Go package-level component metadata.

Author: ydnar

cmd/wit-bindgen-go/cmd/wit/wit.go

@@ -23,6 +23,14 @@ var Command = &cli.Command{
 			Config:   cli.StringConfig{TrimSpace: true},
 			Usage:    "WIT world to generate, otherwise generate all worlds",
 		},
+		&cli.StringFlag{
+			Name:     "interface",
+			Aliases:  []string{"i"},
+			Value:    "",
+			OnlyOnce: true,
+			Config:   cli.StringConfig{TrimSpace: true},
+			Usage:    "WIT interface to generate, otherwise generate all interfaces",
+		},
 	},
 	Action: action,
 }
@@ -32,19 +40,30 @@ func action(ctx context.Context, cmd *cli.Command) error {
 	if err != nil {
 		return err
 	}
+
 	res, err := witcli.LoadWIT(ctx, path, cmd.Reader, cmd.Bool("force-wit"))
 	if err != nil {
 		return err
 	}
+
 	var w *wit.World
-	world := cmd.String("world")
-	if world != "" {
+	if world := cmd.String("world"); world != "" {
 		w = findWorld(res, world)
 		if w == nil {
 			return fmt.Errorf("world %s not found", world)
 		}
 	}
-	fmt.Print(res.WIT(w, ""))
+
+	var i *wit.Interface
+	if face := cmd.String("interface"); face != "" {
+		i = findInterface(res, face)
+		if i == nil {
+			return fmt.Errorf("interface %s not found", face)
+		}
+	}
+
+	filter := wit.Filter(w, i)
+	fmt.Print(res.WIT(filter, ""))
 	return nil
 }
 
@@ -56,3 +75,12 @@ func findWorld(r *wit.Resolve, pattern string) *wit.World {
 	}
 	return nil
 }
+
+func findInterface(r *wit.Resolve, pattern string) *wit.Interface {
+	for _, i := range r.Interfaces {
+		if i.Match(pattern) {
+			return i
+		}
+	}
+	return nil
+}

internal/memoize/memoize.go

@@ -0,0 +1,16 @@
+package memoize
+
+// Function memoizes f, caching unique values of k.
+// Initial calls to the resulting function will call f(k), then cache and return v.
+// Subsequent calls will return the cached value for k.
+func Function[F func(K) V, K comparable, V any](f F) F {
+	m := make(map[K]V)
+	return func(k K) V {
+		if v, ok := m[k]; ok {
+			return v
+		}
+		v := f(k)
+		m[k] = v
+		return v
+	}
+}

wit/bindgen/generator.go

@@ -232,7 +232,7 @@ func (g *generator) defineWorld(w *wit.World) error {
 
 	// Write WIT file for this world
 	witFile := g.witFileFor(w)
-	witFile.WriteString(g.res.WIT(w, ""))
+	witFile.WriteString(g.res.WIT(wit.Filter(w, nil), ""))
 
 	// Write Go package docs
 	file := g.fileFor(w)

wit/docs.go

@@ -41,3 +41,8 @@
 // [WebAssembly Interface Type]: https://component-model.bytecodealliance.org/design/wit.html
 // [Component]: https://component-model.bytecodealliance.org/introduction.html
 package wit
+
+// Docs represent WIT documentation text extracted from comments.
+type Docs struct {
+	Contents string // may be empty
+}

wit/enum.go

@@ -0,0 +1,59 @@
+package wit
+
+// Enum represents a WIT [enum type], which is a [Variant] without associated data.
+// The equivalent in Go is a set of const identifiers declared with iota.
+// It implements the [Node], [ABI], and [TypeDefKind] interfaces.
+//
+// [enum type]: https://component-model.bytecodealliance.org/design/wit.html#enums
+type Enum struct {
+	_typeDefKind
+	Cases []EnumCase
+}
+
+// Despecialize despecializes [Enum] e into a [Variant] with no associated types.
+// See the [canonical ABI documentation] for more information.
+//
+// [canonical ABI documentation]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#despecialization
+func (e *Enum) Despecialize() TypeDefKind {
+	v := &Variant{
+		Cases: make([]Case, len(e.Cases)),
+	}
+	for i := range e.Cases {
+		v.Cases[i].Name = e.Cases[i].Name
+		v.Cases[i].Docs = e.Cases[i].Docs
+	}
+	return v
+}
+
+// Size returns the [ABI byte size] for [Enum] e, the smallest integer
+// type that can represent 0...len(e.Cases).
+// It is first [despecialized] into a [Variant] with no associated types, then sized.
+//
+// [ABI byte size]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#size
+// [despecialized]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#despecialization
+func (e *Enum) Size() uintptr {
+	return e.Despecialize().Size()
+}
+
+// Align returns the [ABI byte alignment] for [Enum] e.
+// It is first [despecialized] into a [Variant] with no associated types, then aligned.
+//
+// [ABI byte alignment]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#alignment
+// [despecialized]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#despecialization
+func (e *Enum) Align() uintptr {
+	return e.Despecialize().Align()
+}
+
+// Flat returns the [flattened] ABI representation of [Enum] e.
+//
+// [flattened]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#flattening
+func (v *Enum) Flat() []Type {
+	return Discriminant(len(v.Cases)).Flat()
+}
+
+// EnumCase represents a single case in an [Enum].
+// It implements the [Node] interface.
+type EnumCase struct {
+	Name string
+	Docs Docs
+}

wit/flags.go

@@ -0,0 +1,56 @@
+package wit
+
+// Flags represents a WIT [flags type], stored as a bitfield.
+// It implements the [Node], [ABI], and [TypeDefKind] interfaces.
+//
+// [flags type]: https://component-model.bytecodealliance.org/design/wit.html#flags
+type Flags struct {
+	_typeDefKind
+	Flags []Flag
+}
+
+// Size returns the [ABI byte size] of [Flags] f.
+//
+// [ABI byte size]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#size
+func (f *Flags) Size() uintptr {
+	n := len(f.Flags)
+	switch {
+	case n <= 8:
+		return 1
+	case n <= 16:
+		return 2
+	}
+	return 4 * uintptr((n+31)>>5)
+}
+
+// Align returns the [ABI byte alignment] of [Flags] f.
+//
+// [ABI byte alignment]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#alignment
+func (f *Flags) Align() uintptr {
+	n := len(f.Flags)
+	switch {
+	case n <= 8:
+		return 1
+	case n <= 16:
+		return 2
+	}
+	return 4
+}
+
+// Flat returns the [flattened] ABI representation of [Flags] f.
+//
+// [flattened]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#flattening
+func (f *Flags) Flat() []Type {
+	flat := make([]Type, (len(f.Flags)+31)>>5)
+	for i := range flat {
+		flat[i] = U32{}
+	}
+	return flat
+}
+
+// Flag represents a single flag value in a [Flags] type.
+// It implements the [Node] interface.
+type Flag struct {
+	Name string
+	Docs Docs
+}

wit/function.go

@@ -0,0 +1,184 @@
+package wit
+
+import (
+	"strings"
+)
+
+// Function represents a WIT [function].
+// Functions can be freestanding, methods, constructors or static.
+// It implements the [Node] and [WorldItem] interfaces.
+//
+// [function]: https://component-model.bytecodealliance.org/design/wit.html#functions
+type Function struct {
+	_worldItem
+	Name      string
+	Kind      FunctionKind
+	Params    []Param   // arguments to the function
+	Results   []Param   // a function can have a single anonymous result, or > 1 named results
+	Stability Stability // WIT @since or @unstable (nil if unknown)
+	Docs      Docs
+}
+
+// BaseName returns the base name of [Function] f.
+// For static functions, this returns the function name unchanged.
+// For constructors, this removes the [constructor] and type prefix.
+// For static functions, this removes the [static] and type prefix.
+// For methods, this removes the [method] and type prefix.
+// For special functions like [resource-drop], it will return a well-known value.
+func (f *Function) BaseName() string {
+	switch {
+	case strings.HasPrefix(f.Name, "[constructor]"):
+		return "constructor"
+	case strings.HasPrefix(f.Name, "[resource-new]"):
+		return "resource-new"
+	case strings.HasPrefix(f.Name, "[resource-rep]"):
+		return "resource-rep"
+	case strings.HasPrefix(f.Name, "[resource-drop]"):
+		return "resource-drop"
+	case strings.HasPrefix(f.Name, "[dtor]"):
+		return "destructor"
+	}
+	name, after, found := strings.Cut(f.Name, ".")
+	if found {
+		name = after
+	}
+	after, found = strings.CutPrefix(f.Name, "cabi_post_")
+	if found {
+		name = after + "-post-return"
+	}
+	return name
+}
+
+// Type returns the associated (self) [Type] for [Function] f, if f is a constructor, method, or static function.
+// If f is a freestanding function, this returns nil.
+func (f *Function) Type() Type {
+	switch kind := f.Kind.(type) {
+	case *Constructor:
+		return kind.Type
+	case *Static:
+		return kind.Type
+	case *Method:
+		return kind.Type
+	default:
+		return nil
+	}
+}
+
+// IsAdmin returns true if [Function] f is an administrative function in the Canonical ABI.
+func (f *Function) IsAdmin() bool {
+	switch {
+	// Imported
+	case f.IsStatic() && strings.HasPrefix(f.Name, "[resource-new]"):
+		return true
+	case f.IsMethod() && strings.HasPrefix(f.Name, "[resource-rep]"):
+		return true
+	case f.IsMethod() && strings.HasPrefix(f.Name, "[resource-drop]"):
+		return true
+
+	// Exported
+	case f.IsMethod() && strings.HasPrefix(f.Name, "[dtor]"):
+		return true
+	case strings.HasPrefix(f.Name, "cabi_post_"):
+		return true
+	}
+	return false
+}
+
+// IsFreestanding returns true if [Function] f is a freestanding function,
+// and not a constructor, method, or static function.
+func (f *Function) IsFreestanding() bool {
+	_, ok := f.Kind.(*Freestanding)
+	return ok
+}
+
+// IsConstructor returns true if [Function] f is a constructor.
+// To qualify, it must have a *[Constructor] Kind with a non-nil type.
+func (f *Function) IsConstructor() bool {
+	kind, ok := f.Kind.(*Constructor)
+	return ok && kind.Type != nil
+}
+
+// IsMethod returns true if [Function] f is a method.
+// To qualify, it must have a *[Method] Kind with a non-nil [Type] which matches borrow<t> of its first param.
+func (f *Function) IsMethod() bool {
+	if len(f.Params) == 0 {
+		return false
+	}
+	kind, ok := f.Kind.(*Method)
+	if !ok {
+		return false
+	}
+	t := f.Params[0].Type
+	h := KindOf[*Borrow](t)
+	return t == kind.Type || (h != nil && h.Type == kind.Type)
+}
+
+// IsStatic returns true if [Function] f is a static function.
+// To qualify, it must have a *[Static] Kind with a non-nil type.
+func (f *Function) IsStatic() bool {
+	kind, ok := f.Kind.(*Static)
+	return ok && kind.Type != nil
+}
+
+func (f *Function) dependsOn(dep Node) bool {
+	if dep == f {
+		return true
+	}
+	for _, p := range f.Params {
+		if DependsOn(p.Type, dep) {
+			return true
+		}
+	}
+	for _, r := range f.Results {
+		if DependsOn(r.Type, dep) {
+			return true
+		}
+	}
+	return false
+}
+
+func compareFunctions(a, b *Function) int {
+	return strings.Compare(a.Name, b.Name)
+}
+
+// Param represents a parameter to or the result of a [Function].
+// A Param can be unnamed.
+type Param struct {
+	Name string
+	Type Type
+}
+
+// FunctionKind represents the kind of a WIT [function], which can be one of
+// [Freestanding], [Method], [Static], or [Constructor].
+//
+// [function]: https://component-model.bytecodealliance.org/design/wit.html#functions
+type FunctionKind interface {
+	isFunctionKind()
+}
+
+// _functionKind is an embeddable type that conforms to the [FunctionKind] interface.
+type _functionKind struct{}
+
+func (_functionKind) isFunctionKind() {}
+
+// Freestanding represents a free-standing function that is not a method, static, or a constructor.
+type Freestanding struct{ _functionKind }
+
+// Method represents a function that is a method on its associated [Type].
+// The first argument to the function is self, an instance of [Type].
+type Method struct {
+	_functionKind
+	Type Type
+}
+
+// Static represents a function that is a static method of its associated [Type].
+type Static struct {
+	_functionKind
+	Type Type
+}
+
+// Constructor represents a function that is a constructor for its associated [Type].
+type Constructor struct {
+	_functionKind
+	Type Type
+}