tools/src/tint/intrinsic/ast/ast.go - dawn.git - Git at Google

 // Copyright 2021 The Dawn & Tint Authors
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 //
 // 1. Redistributions of source code must retain the above copyright notice, this
 //    list of conditions and the following disclaimer.
 //
 // 2. Redistributions in binary form must reproduce the above copyright notice,
 //    this list of conditions and the following disclaimer in the documentation
 //    and/or other materials provided with the distribution.
 //
 // 3. Neither the name of the copyright holder nor the names of its
 //    contributors may be used to endorse or promote products derived from
 //    this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 // Package ast defines AST nodes that are produced by the Tint intrinsic
 // definition parser
 package ast

 import (
 	"fmt"
 	"strings"

 	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/tok"
 )

 // AST is the parsed syntax tree of the intrinsic definition file
 type AST struct {
 	Enums        []EnumDecl
 	Types        []TypeDecl
 	Matchers     []MatcherDecl
 	Builtins     []IntrinsicDecl
 	Constructors []IntrinsicDecl
 	Converters   []IntrinsicDecl
 	Operators    []IntrinsicDecl
 }

 func (a AST) String() string {
 	sb := strings.Builder{}
 	for _, e := range a.Enums {
 		fmt.Fprintf(&sb, "%v", e)
 		fmt.Fprintln(&sb)
 	}
 	for _, p := range a.Types {
 		fmt.Fprintf(&sb, "%v", p)
 		fmt.Fprintln(&sb)
 	}
 	for _, m := range a.Matchers {
 		fmt.Fprintf(&sb, "%v", m)
 		fmt.Fprintln(&sb)
 	}
 	for _, b := range a.Builtins {
 		fmt.Fprintf(&sb, "%v", b)
 		fmt.Fprintln(&sb)
 	}
 	for _, o := range a.Constructors {
 		fmt.Fprintf(&sb, "%v", o)
 		fmt.Fprintln(&sb)
 	}
 	for _, o := range a.Converters {
 		fmt.Fprintf(&sb, "%v", o)
 		fmt.Fprintln(&sb)
 	}
 	for _, o := range a.Operators {
 		fmt.Fprintf(&sb, "%v", o)
 		fmt.Fprintln(&sb)
 	}
 	return sb.String()
 }

 // EnumDecl describes an enumerator
 type EnumDecl struct {
 	Source  tok.Source
 	Name    string
 	Entries []EnumEntry
 }

 // Format implements the fmt.Formatter interface
 func (e EnumDecl) Format(w fmt.State, verb rune) {
 	fmt.Fprintf(w, "enum %v {\n", e.Name)
 	for _, e := range e.Entries {
 		fmt.Fprintf(w, "  %v\n", e)
 	}
 	fmt.Fprintf(w, "}\n")
 }

 // EnumEntry describes an entry in a enumerator
 type EnumEntry struct {
 	Source     tok.Source
 	Name       string
 	Attributes Attributes
 }

 // Format implements the fmt.Formatter interface
 func (e EnumEntry) Format(w fmt.State, verb rune) {
 	if len(e.Attributes) > 0 {
 		fmt.Fprintf(w, "%v %v", e.Attributes, e.Name)
 	} else {
 		fmt.Fprint(w, e.Name)
 	}
 }

 // MatcherDecl describes a matcher declaration
 type MatcherDecl struct {
 	Source  tok.Source
 	Name    string
 	Options MatcherOptions
 }

 // Format implements the fmt.Formatter interface
 func (m MatcherDecl) Format(w fmt.State, verb rune) {
 	fmt.Fprintf(w, "match %v", m.Name)
 	fmt.Fprintf(w, ": ")
 	m.Options.Format(w, verb)
 }

 // IntrinsicKind is either a Builtin, Operator, Initializer or Converter
 type IntrinsicKind string

 const (
 	// Builtin is a builtin function (max, fract, etc).
 	// Declared with 'fn'.
 	Builtin IntrinsicKind = "builtin"
 	// Operator is a unary or binary operator.
 	// Declared with 'op'.
 	Operator IntrinsicKind = "operator"
 	// Constructor is a value constructor function.
 	// Declared with 'init'.
 	Constructor IntrinsicKind = "constructor"
 	// Converter is a value conversion function.
 	// Declared with 'conv'.
 	Converter IntrinsicKind = "converter"
 )

 // IntrinsicDecl describes a builtin or operator declaration
 type IntrinsicDecl struct {
 	Source                 tok.Source
 	Kind                   IntrinsicKind
 	Name                   string
 	Attributes             Attributes
 	ImplicitTemplateParams []TemplateParam
 	ExplicitTemplateParams []TemplateParam
 	Parameters             Parameters
 	ReturnType             *TemplatedName
 }

 // Format implements the fmt.Formatter interface
 func (i IntrinsicDecl) Format(w fmt.State, verb rune) {
 	switch i.Kind {
 	case Builtin:
 		fmt.Fprintf(w, "fn ")
 	case Operator:
 		fmt.Fprintf(w, "op ")
 	case Constructor:
 		fmt.Fprintf(w, "ctor ")
 	case Converter:
 		fmt.Fprintf(w, "conv ")
 	}

 	fmt.Fprintf(w, "%v", i.Name)
 	if len(i.ExplicitTemplateParams) > 0 {
 		fmt.Fprintf(w, "<")
 		formatList(w, i.ExplicitTemplateParams)
 		fmt.Fprintf(w, ">")
 	}
 	if len(i.ImplicitTemplateParams) > 0 {
 		fmt.Fprintf(w, "[")
 		formatList(w, i.ImplicitTemplateParams)
 		fmt.Fprintf(w, "]")
 	}
 	i.Parameters.Format(w, verb)
 	if i.ReturnType != nil {
 		fmt.Fprintf(w, " -> ")
 		i.ReturnType.Format(w, verb)
 	}
 }

 // Parameters is a list of parameter
 type Parameters []Parameter

 // Format implements the fmt.Formatter interface
 func (l Parameters) Format(w fmt.State, verb rune) {
 	fmt.Fprintf(w, "(")
 	for i, p := range l {
 		if i > 0 {
 			fmt.Fprintf(w, ", ")
 		}
 		p.Attributes.Format(w, verb)
 		p.Format(w, verb)
 	}
 	fmt.Fprintf(w, ")")
 }

 // Parameter describes a single parameter of a function
 type Parameter struct {
 	Source     tok.Source
 	Attributes Attributes
 	Name       string // Optional
 	Type       TemplatedName
 }

 // Format implements the fmt.Formatter interface
 func (p Parameter) Format(w fmt.State, verb rune) {
 	if p.Name != "" {
 		fmt.Fprintf(w, "%v: ", p.Name)
 	}
 	p.Type.Format(w, verb)
 }

 // MatcherOptions is a list of TemplatedNames or MemberNames
 type MatcherOptions struct {
 	Types TemplatedNames
 	Enums MemberNames
 }

 // Format implements the fmt.Formatter interface
 func (o MatcherOptions) Format(w fmt.State, verb rune) {
 	for i, mo := range o.Types {
 		if i > 0 {
 			fmt.Fprintf(w, " | ")
 		}
 		mo.Format(w, verb)
 	}
 	for i, mo := range o.Enums {
 		if i > 0 {
 			fmt.Fprintf(w, " | ")
 		}
 		mo.Format(w, verb)
 	}
 }

 // TemplatedNames is a list of TemplatedName
 // Example:
 //
 //	a<b>, c<d, e>
 type TemplatedNames []TemplatedName

 // Format implements the fmt.Formatter interface
 func (l TemplatedNames) Format(w fmt.State, verb rune) {
 	formatList(w, l)
 }

 // TemplatedName is an identifier with optional templated arguments
 // Example:
 //
 //	vec<N, T>
 type TemplatedName struct {
 	Source       tok.Source
 	Name         string
 	TemplateArgs TemplatedNames
 }

 // Format implements the fmt.Formatter interface
 func (t TemplatedName) Format(w fmt.State, verb rune) {
 	fmt.Fprintf(w, "%v", t.Name)
 	if len(t.TemplateArgs) > 0 {
 		fmt.Fprintf(w, "<")
 		t.TemplateArgs.Format(w, verb)
 		fmt.Fprintf(w, ">")
 	}
 }

 // MemberNames is a list of MemberName
 // Example:
 //
 //	a.b, c.d
 type MemberNames []MemberName

 // Format implements the fmt.Formatter interface
 func (l MemberNames) Format(w fmt.State, verb rune) {
 	formatList(w, l)
 }

 // MemberName is two identifiers separated by a dot (Owner.Member)
 type MemberName struct {
 	Source tok.Source
 	Owner  string
 	Member string
 }

 // Format implements the fmt.Formatter interface
 func (t MemberName) Format(w fmt.State, verb rune) {
 	fmt.Fprintf(w, "%v.%v", t.Owner, t.Member)
 }

 // TypeDecl describes a type declaration
 type TypeDecl struct {
 	Source         tok.Source
 	Attributes     Attributes
 	Name           string
 	TemplateParams []TemplateParam
 }

 // Format implements the fmt.Formatter interface
 func (p TypeDecl) Format(w fmt.State, verb rune) {
 	if len(p.Attributes) > 0 {
 		p.Attributes.Format(w, verb)
 		fmt.Fprintf(w, " type %v", p.Name)
 	}
 	fmt.Fprintf(w, "type %v", p.Name)
 	if len(p.TemplateParams) > 0 {
 		fmt.Fprintf(w, "<")
 		formatList(w, p.TemplateParams)
 		fmt.Fprintf(w, ">")
 	}
 }

 // TemplateParam describes a template parameter with optional type
 // Example:
 //
 //	<Name>
 //	<Name: Type>
 type TemplateParam struct {
 	Source tok.Source
 	Name   string
 	Type   TemplatedName // Optional
 }

 // Format implements the fmt.Formatter interface
 func (t TemplateParam) Format(w fmt.State, verb rune) {
 	fmt.Fprintf(w, "%v", t.Name)
 	if t.Type.Name != "" {
 		fmt.Fprintf(w, " : ")
 		t.Type.Format(w, verb)
 	}
 }

 // Attributes is a list of Attribute
 // Example:
 //
 //	[[a(x), b(y)]]
 type Attributes []Attribute

 // Format implements the fmt.Formatter interface
 func (l Attributes) Format(w fmt.State, verb rune) {
 	for _, d := range l {
 		fmt.Fprint(w, "@")
 		d.Format(w, verb)
 		fmt.Fprint(w, " ")
 	}
 }

 // Take looks up the attribute with the given name. If the attribute is found
 // it is removed from the Attributes list and returned, otherwise nil is
 // returned and the Attributes are not altered.
 func (l *Attributes) Take(name string) *Attribute {
 	for i, a := range *l {
 		if a.Name == name {
 			*l = append((*l)[:i], (*l)[i+1:]...)
 			return &a
 		}
 	}
 	return nil
 }

 // Attribute describes a single attribute
 // Example:
 //
 //	@a(x)
 type Attribute struct {
 	Source tok.Source
 	Name   string
 	Values []any
 }

 // Format implements the fmt.Formatter interface
 func (d Attribute) Format(w fmt.State, verb rune) {
 	fmt.Fprintf(w, "%v", d.Name)
 	if len(d.Values) > 0 {
 		fmt.Fprintf(w, "(")
 		formatList(w, d.Values)
 		fmt.Fprintf(w, ")")
 	}
 }

 func formatList[T any](w fmt.State, list []T) {
 	for i, v := range list {
 		if i > 0 {
 			fmt.Fprint(w, ", ")
 		}
 		fmt.Fprintf(w, "%v", v)
 	}
 }
	// Copyright 2021 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	// Package ast defines AST nodes that are produced by the Tint intrinsic
	// definition parser
	package ast

	import (
	"fmt"
	"strings"

	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/tok"
	)

	// AST is the parsed syntax tree of the intrinsic definition file
	type AST struct {
	Enums []EnumDecl
	Types []TypeDecl
	Matchers []MatcherDecl
	Builtins []IntrinsicDecl
	Constructors []IntrinsicDecl
	Converters []IntrinsicDecl
	Operators []IntrinsicDecl
	}

	func (a AST) String() string {
	sb := strings.Builder{}
	for _, e := range a.Enums {
	fmt.Fprintf(&sb, "%v", e)
	fmt.Fprintln(&sb)
	}
	for _, p := range a.Types {
	fmt.Fprintf(&sb, "%v", p)
	fmt.Fprintln(&sb)
	}
	for _, m := range a.Matchers {
	fmt.Fprintf(&sb, "%v", m)
	fmt.Fprintln(&sb)
	}
	for _, b := range a.Builtins {
	fmt.Fprintf(&sb, "%v", b)
	fmt.Fprintln(&sb)
	}
	for _, o := range a.Constructors {
	fmt.Fprintf(&sb, "%v", o)
	fmt.Fprintln(&sb)
	}
	for _, o := range a.Converters {
	fmt.Fprintf(&sb, "%v", o)
	fmt.Fprintln(&sb)
	}
	for _, o := range a.Operators {
	fmt.Fprintf(&sb, "%v", o)
	fmt.Fprintln(&sb)
	}
	return sb.String()
	}

	// EnumDecl describes an enumerator
	type EnumDecl struct {
	Source tok.Source
	Name string
	Entries []EnumEntry
	}

	// Format implements the fmt.Formatter interface
	func (e EnumDecl) Format(w fmt.State, verb rune) {
	fmt.Fprintf(w, "enum %v {\n", e.Name)
	for _, e := range e.Entries {
	fmt.Fprintf(w, " %v\n", e)
	}
	fmt.Fprintf(w, "}\n")
	}

	// EnumEntry describes an entry in a enumerator
	type EnumEntry struct {
	Source tok.Source
	Name string
	Attributes Attributes
	}

	// Format implements the fmt.Formatter interface
	func (e EnumEntry) Format(w fmt.State, verb rune) {
	if len(e.Attributes) > 0 {
	fmt.Fprintf(w, "%v %v", e.Attributes, e.Name)
	} else {
	fmt.Fprint(w, e.Name)
	}
	}

	// MatcherDecl describes a matcher declaration
	type MatcherDecl struct {
	Source tok.Source
	Name string
	Options MatcherOptions
	}

	// Format implements the fmt.Formatter interface
	func (m MatcherDecl) Format(w fmt.State, verb rune) {
	fmt.Fprintf(w, "match %v", m.Name)
	fmt.Fprintf(w, ": ")
	m.Options.Format(w, verb)
	}

	// IntrinsicKind is either a Builtin, Operator, Initializer or Converter
	type IntrinsicKind string

	const (
	// Builtin is a builtin function (max, fract, etc).
	// Declared with 'fn'.
	Builtin IntrinsicKind = "builtin"
	// Operator is a unary or binary operator.
	// Declared with 'op'.
	Operator IntrinsicKind = "operator"
	// Constructor is a value constructor function.
	// Declared with 'init'.
	Constructor IntrinsicKind = "constructor"
	// Converter is a value conversion function.
	// Declared with 'conv'.
	Converter IntrinsicKind = "converter"
	)

	// IntrinsicDecl describes a builtin or operator declaration
	type IntrinsicDecl struct {
	Source tok.Source
	Kind IntrinsicKind
	Name string
	Attributes Attributes
	ImplicitTemplateParams []TemplateParam
	ExplicitTemplateParams []TemplateParam
	Parameters Parameters
	ReturnType *TemplatedName
	}

	// Format implements the fmt.Formatter interface
	func (i IntrinsicDecl) Format(w fmt.State, verb rune) {
	switch i.Kind {
	case Builtin:
	fmt.Fprintf(w, "fn ")
	case Operator:
	fmt.Fprintf(w, "op ")
	case Constructor:
	fmt.Fprintf(w, "ctor ")
	case Converter:
	fmt.Fprintf(w, "conv ")
	}

	fmt.Fprintf(w, "%v", i.Name)
	if len(i.ExplicitTemplateParams) > 0 {
	fmt.Fprintf(w, "<")
	formatList(w, i.ExplicitTemplateParams)
	fmt.Fprintf(w, ">")
	}
	if len(i.ImplicitTemplateParams) > 0 {
	fmt.Fprintf(w, "[")
	formatList(w, i.ImplicitTemplateParams)
	fmt.Fprintf(w, "]")
	}
	i.Parameters.Format(w, verb)
	if i.ReturnType != nil {
	fmt.Fprintf(w, " -> ")
	i.ReturnType.Format(w, verb)
	}
	}

	// Parameters is a list of parameter
	type Parameters []Parameter

	// Format implements the fmt.Formatter interface
	func (l Parameters) Format(w fmt.State, verb rune) {
	fmt.Fprintf(w, "(")
	for i, p := range l {
	if i > 0 {
	fmt.Fprintf(w, ", ")
	}
	p.Attributes.Format(w, verb)
	p.Format(w, verb)
	}
	fmt.Fprintf(w, ")")
	}

	// Parameter describes a single parameter of a function
	type Parameter struct {
	Source tok.Source
	Attributes Attributes
	Name string // Optional
	Type TemplatedName
	}

	// Format implements the fmt.Formatter interface
	func (p Parameter) Format(w fmt.State, verb rune) {
	if p.Name != "" {
	fmt.Fprintf(w, "%v: ", p.Name)
	}
	p.Type.Format(w, verb)
	}

	// MatcherOptions is a list of TemplatedNames or MemberNames
	type MatcherOptions struct {
	Types TemplatedNames
	Enums MemberNames
	}

	// Format implements the fmt.Formatter interface
	func (o MatcherOptions) Format(w fmt.State, verb rune) {
	for i, mo := range o.Types {
	if i > 0 {
	fmt.Fprintf(w, " \| ")
	}
	mo.Format(w, verb)
	}
	for i, mo := range o.Enums {
	if i > 0 {
	fmt.Fprintf(w, " \| ")
	}
	mo.Format(w, verb)
	}
	}

	// TemplatedNames is a list of TemplatedName
	// Example:
	//
	// a<b>, c<d, e>
	type TemplatedNames []TemplatedName

	// Format implements the fmt.Formatter interface
	func (l TemplatedNames) Format(w fmt.State, verb rune) {
	formatList(w, l)
	}

	// TemplatedName is an identifier with optional templated arguments
	// Example:
	//
	// vec<N, T>
	type TemplatedName struct {
	Source tok.Source
	Name string
	TemplateArgs TemplatedNames
	}

	// Format implements the fmt.Formatter interface
	func (t TemplatedName) Format(w fmt.State, verb rune) {
	fmt.Fprintf(w, "%v", t.Name)
	if len(t.TemplateArgs) > 0 {
	fmt.Fprintf(w, "<")
	t.TemplateArgs.Format(w, verb)
	fmt.Fprintf(w, ">")
	}
	}

	// MemberNames is a list of MemberName
	// Example:
	//
	// a.b, c.d
	type MemberNames []MemberName

	// Format implements the fmt.Formatter interface
	func (l MemberNames) Format(w fmt.State, verb rune) {
	formatList(w, l)
	}

	// MemberName is two identifiers separated by a dot (Owner.Member)
	type MemberName struct {
	Source tok.Source
	Owner string
	Member string
	}

	// Format implements the fmt.Formatter interface
	func (t MemberName) Format(w fmt.State, verb rune) {
	fmt.Fprintf(w, "%v.%v", t.Owner, t.Member)
	}

	// TypeDecl describes a type declaration
	type TypeDecl struct {
	Source tok.Source
	Attributes Attributes
	Name string
	TemplateParams []TemplateParam
	}

	// Format implements the fmt.Formatter interface
	func (p TypeDecl) Format(w fmt.State, verb rune) {
	if len(p.Attributes) > 0 {
	p.Attributes.Format(w, verb)
	fmt.Fprintf(w, " type %v", p.Name)
	}
	fmt.Fprintf(w, "type %v", p.Name)
	if len(p.TemplateParams) > 0 {
	fmt.Fprintf(w, "<")
	formatList(w, p.TemplateParams)
	fmt.Fprintf(w, ">")
	}
	}

	// TemplateParam describes a template parameter with optional type
	// Example:
	//
	// <Name>
	// <Name: Type>
	type TemplateParam struct {
	Source tok.Source
	Name string
	Type TemplatedName // Optional
	}

	// Format implements the fmt.Formatter interface
	func (t TemplateParam) Format(w fmt.State, verb rune) {
	fmt.Fprintf(w, "%v", t.Name)
	if t.Type.Name != "" {
	fmt.Fprintf(w, " : ")
	t.Type.Format(w, verb)
	}
	}

	// Attributes is a list of Attribute
	// Example:
	//
	// [[a(x), b(y)]]
	type Attributes []Attribute

	// Format implements the fmt.Formatter interface
	func (l Attributes) Format(w fmt.State, verb rune) {
	for _, d := range l {
	fmt.Fprint(w, "@")
	d.Format(w, verb)
	fmt.Fprint(w, " ")
	}
	}

	// Take looks up the attribute with the given name. If the attribute is found
	// it is removed from the Attributes list and returned, otherwise nil is
	// returned and the Attributes are not altered.
	func (l Attributes) Take(name string) Attribute {
	for i, a := range *l {
	if a.Name == name {
	l = append((l)[:i], (*l)[i+1:]...)
	return &a
	}
	}
	return nil
	}

	// Attribute describes a single attribute
	// Example:
	//
	// @a(x)
	type Attribute struct {
	Source tok.Source
	Name string
	Values []any
	}

	// Format implements the fmt.Formatter interface
	func (d Attribute) Format(w fmt.State, verb rune) {
	fmt.Fprintf(w, "%v", d.Name)
	if len(d.Values) > 0 {
	fmt.Fprintf(w, "(")
	formatList(w, d.Values)
	fmt.Fprintf(w, ")")
	}
	}

	func formatList[T any](w fmt.State, list []T) {
	for i, v := range list {
	if i > 0 {
	fmt.Fprint(w, ", ")
	}
	fmt.Fprintf(w, "%v", v)
	}
	}