tools/src/cmd/gen/main.go - dawn - Git at Google

 // Copyright 2021 The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // gen parses the <tint>/src/tint/intrinsics.def file, then scans the
 // project directory for '<file>.tmpl' files, to produce source code files.
 package main

 import (
 	"flag"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"math/rand"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"reflect"
 	"regexp"
 	"runtime"
 	"strconv"
 	"strings"
 	"text/template"
 	"time"
 	"unicode"

 	"dawn.googlesource.com/dawn/tools/src/container"
 	"dawn.googlesource.com/dawn/tools/src/fileutils"
 	"dawn.googlesource.com/dawn/tools/src/glob"
 	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/gen"
 	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/parser"
 	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/resolver"
 	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/sem"
 )

 const defProjectRelPath = "src/tint/intrinsics.def"

 func main() {
 	if err := run(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 }

 func showUsage() {
 	fmt.Println(`
 gen generates the templated code for the Tint compiler

 gen scans the project directory for '<file>.tmpl' files, to produce source code
 files.

 If the templates use the 'IntrinsicTable' function then gen will parse and
 resolve the <tint>/src/tint/intrinsics.def file.

 usage:
   gen

 optional flags:`)
 	flag.PrintDefaults()
 	fmt.Println(``)
 	os.Exit(1)
 }

 func run() error {
 	projectRoot := fileutils.ProjectRoot()

 	// Find clang-format
 	clangFormatPath := findClangFormat(projectRoot)
 	if clangFormatPath == "" {
 		return fmt.Errorf("cannot find clang-format in <dawn>/buildtools nor PATH")
 	}

 	// Recursively find all the template files in the <tint>/src directory
 	files, err := glob.Scan(projectRoot, glob.MustParseConfig(`{
 		"paths": [{"include": [
 			"src/tint/**.tmpl",
 			"test/tint/**.tmpl"
 		]}]
 	}`))
 	if err != nil {
 		return err
 	}

 	cache := &genCache{}

 	// For each template file...
 	for _, relTmplPath := range files {
 		// Make tmplPath absolute
 		tmplPath := filepath.Join(projectRoot, relTmplPath)

 		// Read the template file
 		tmpl, err := ioutil.ReadFile(tmplPath)
 		if err != nil {
 			return fmt.Errorf("failed to open '%v': %w", tmplPath, err)
 		}

 		// Create or update the file at relpath if the file content has changed,
 		// preserving the copyright year in the header.
 		// relpath is a path relative to the template
 		writeFile := func(relpath, body string) error {
 			abspath := filepath.Join(filepath.Dir(tmplPath), relpath)

 			copyrightYear := time.Now().Year()

 			// Load the old file
 			existing, err := ioutil.ReadFile(abspath)
 			if err == nil {
 				// Look for the existing copyright year
 				if match := copyrightRegex.FindStringSubmatch(string(existing)); len(match) == 2 {
 					if year, err := strconv.Atoi(match[1]); err == nil {
 						copyrightYear = year
 					}
 				}
 			}

 			// Write the common file header
 			sb := strings.Builder{}
 			sb.WriteString(fmt.Sprintf(header, copyrightYear, filepath.ToSlash(relTmplPath)))
 			sb.WriteString(body)
 			content := sb.String()
 			return writeFileIfChanged(abspath, content, string(existing))
 		}

 		// Write the content generated using the template and semantic info
 		sb := strings.Builder{}
 		if err := generate(string(tmpl), cache, &sb, writeFile); err != nil {
 			return fmt.Errorf("while processing '%v': %w", tmplPath, err)
 		}

 		if body := sb.String(); body != "" {
 			_, tmplFileName := filepath.Split(tmplPath)
 			outFileName := strings.TrimSuffix(tmplFileName, ".tmpl")

 			switch filepath.Ext(outFileName) {
 			case ".cc", ".h", ".inl":
 				body, err = clangFormat(body, clangFormatPath)
 				if err != nil {
 					return err
 				}
 			}

 			if err := writeFile(outFileName, body); err != nil {
 				return err
 			}
 		}
 	}

 	return nil
 }

 // Cache for objects that are expensive to build, and can be reused between templates.
 type genCache struct {
 	cached struct {
 		sem            *sem.Sem            // lazily built by sem()
 		intrinsicTable *gen.IntrinsicTable // lazily built by intrinsicTable()
 		permuter       *gen.Permuter       // lazily built by permute()
 	}
 }

 // sem lazily parses and resolves the intrinsic.def file, returning the semantic info.
 func (g *genCache) sem() (*sem.Sem, error) {
 	if g.cached.sem == nil {
 		// Load the builtins definition file
 		defPath := filepath.Join(fileutils.ProjectRoot(), defProjectRelPath)

 		defSource, err := ioutil.ReadFile(defPath)
 		if err != nil {
 			return nil, err
 		}

 		// Parse the definition file to produce an AST
 		ast, err := parser.Parse(string(defSource), defProjectRelPath)
 		if err != nil {
 			return nil, err
 		}

 		// Resolve the AST to produce the semantic info
 		sem, err := resolver.Resolve(ast)
 		if err != nil {
 			return nil, err
 		}

 		g.cached.sem = sem
 	}
 	return g.cached.sem, nil
 }

 // intrinsicTable lazily calls and returns the result of buildIntrinsicTable(),
 // caching the result for repeated calls.
 func (g *genCache) intrinsicTable() (*gen.IntrinsicTable, error) {
 	if g.cached.intrinsicTable == nil {
 		sem, err := g.sem()
 		if err != nil {
 			return nil, err
 		}
 		g.cached.intrinsicTable, err = gen.BuildIntrinsicTable(sem)
 		if err != nil {
 			return nil, err
 		}
 	}
 	return g.cached.intrinsicTable, nil
 }

 // permute lazily calls buildPermuter(), caching the result for repeated
 // calls, then passes the argument to Permutator.Permute()
 func (g *genCache) permute(overload *sem.Overload) ([]gen.Permutation, error) {
 	if g.cached.permuter == nil {
 		sem, err := g.sem()
 		if err != nil {
 			return nil, err
 		}
 		g.cached.permuter, err = gen.NewPermuter(sem)
 		if err != nil {
 			return nil, err
 		}
 	}
 	return g.cached.permuter.Permute(overload)
 }

 // writes content to path if the file has changed
 func writeFileIfChanged(path, newContent, oldContent string) error {
 	if oldContent == newContent {
 		return nil // Not changed
 	}
 	if err := os.MkdirAll(filepath.Dir(path), 0777); err != nil {
 		return fmt.Errorf("failed to create directory for '%v': %w", path, err)
 	}
 	if err := ioutil.WriteFile(path, []byte(newContent), 0666); err != nil {
 		return fmt.Errorf("failed to write file '%v': %w", path, err)
 	}
 	return nil
 }

 var copyrightRegex = regexp.MustCompile(`// Copyright (\d+) The`)

 const header = `// Copyright %v The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 ////////////////////////////////////////////////////////////////////////////////
 // File generated by tools/src/cmd/gen
 // using the template:
 //   %v
 //
 // Do not modify this file directly
 ////////////////////////////////////////////////////////////////////////////////

 `

 type generator struct {
 	template  *template.Template
 	cache     *genCache
 	writeFile WriteFile
 	rnd       *rand.Rand
 }

 // WriteFile is a function that Generate() may call to emit a new file from a
 // template.
 // relpath is the relative path from the currently executing template.
 // content is the file content to write.
 type WriteFile func(relpath, content string) error

 // generate executes the template tmpl, writing the output to w.
 // See https://golang.org/pkg/text/template/ for documentation on the template
 // syntax.
 func generate(tmpl string, cache *genCache, w io.Writer, writeFile WriteFile) error {
 	g := generator{
 		template:  template.New("<template>"),
 		cache:     cache,
 		writeFile: writeFile,
 		rnd:       rand.New(rand.NewSource(4561123)),
 	}
 	if err := g.bindAndParse(g.template, tmpl); err != nil {
 		return err
 	}
 	return g.template.Execute(w, nil)
 }

 func (g *generator) bindAndParse(t *template.Template, text string) error {
 	_, err := t.Funcs(map[string]interface{}{
 		"Map":                   newMap,
 		"Iterate":               iterate,
 		"Title":                 strings.Title,
 		"PascalCase":            pascalCase,
 		"SplitDisplayName":      gen.SplitDisplayName,
 		"HasPrefix":             strings.HasPrefix,
 		"HasSuffix":             strings.HasSuffix,
 		"TrimPrefix":            strings.TrimPrefix,
 		"TrimSuffix":            strings.TrimSuffix,
 		"TrimLeft":              strings.TrimLeft,
 		"TrimRight":             strings.TrimRight,
 		"Split":                 strings.Split,
 		"Scramble":              g.scramble,
 		"IsEnumEntry":           is(sem.EnumEntry{}),
 		"IsEnumMatcher":         is(sem.EnumMatcher{}),
 		"IsFQN":                 is(sem.FullyQualifiedName{}),
 		"IsInt":                 is(1),
 		"IsTemplateEnumParam":   is(sem.TemplateEnumParam{}),
 		"IsTemplateNumberParam": is(sem.TemplateNumberParam{}),
 		"IsTemplateTypeParam":   is(sem.TemplateTypeParam{}),
 		"IsType":                is(sem.Type{}),
 		"ElementType":           gen.ElementType,
 		"DeepestElementType":    gen.DeepestElementType,
 		"IsAbstract":            gen.IsAbstract,
 		"IsDeclarable":          gen.IsDeclarable,
 		"OverloadUsesF16":       gen.OverloadUsesF16,
 		"IsFirstIn":             isFirstIn,
 		"IsLastIn":              isLastIn,
 		"Sem":                   g.cache.sem,
 		"IntrinsicTable":        g.cache.intrinsicTable,
 		"Permute":               g.cache.permute,
 		"Eval":                  g.eval,
 		"Import":                g.importTmpl,
 		"WriteFile":             func(relpath, content string) (string, error) { return "", g.writeFile(relpath, content) },
 	}).Option("missingkey=error").Parse(text)
 	return err
 }

 // eval executes the sub-template with the given name and argument, returning
 // the generated output
 func (g *generator) eval(template string, args ...interface{}) (string, error) {
 	target := g.template.Lookup(template)
 	if target == nil {
 		return "", fmt.Errorf("template '%v' not found", template)
 	}
 	sb := strings.Builder{}

 	var err error
 	if len(args) == 1 {
 		err = target.Execute(&sb, args[0])
 	} else {
 		m := newMap()
 		if len(args)%2 != 0 {
 			return "", fmt.Errorf("Eval expects a single argument or list name-value pairs")
 		}
 		for i := 0; i < len(args); i += 2 {
 			name, ok := args[i].(string)
 			if !ok {
 				return "", fmt.Errorf("Eval argument %v is not a string", i)
 			}
 			m.Put(name, args[i+1])
 		}
 		err = target.Execute(&sb, m)
 	}

 	if err != nil {
 		return "", fmt.Errorf("while evaluating '%v': %v", template, err)
 	}
 	return sb.String(), nil
 }

 // importTmpl parses the template at the given project-relative path, merging
 // the template definitions into the global namespace.
 // Note: The body of the template is not executed.
 func (g *generator) importTmpl(path string) (string, error) {
 	if strings.Contains(path, "..") {
 		return "", fmt.Errorf("import path must not contain '..'")
 	}
 	path = filepath.Join(fileutils.ProjectRoot(), path)
 	data, err := ioutil.ReadFile(path)
 	if err != nil {
 		return "", fmt.Errorf("failed to open '%v': %w", path, err)
 	}
 	t := g.template.New("")
 	if err := g.bindAndParse(t, string(data)); err != nil {
 		return "", fmt.Errorf("failed to parse '%v': %w", path, err)
 	}
 	return "", nil
 }

 // scramble randomly modifies the input string so that it is no longer equal to
 // any of the strings in 'avoid'.
 func (g *generator) scramble(str string, avoid container.Set[string]) (string, error) {
 	bytes := []byte(str)
 	passes := g.rnd.Intn(5) + 1

 	const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"

 	char := func() byte { return chars[g.rnd.Intn(len(chars))] }
 	replace := func(at int) { bytes[at] = char() }
 	delete := func(at int) { bytes = append(bytes[:at], bytes[at+1:]...) }
 	insert := func(at int) { bytes = append(append(bytes[:at], char()), bytes[at:]...) }

 	for i := 0; i < passes || avoid.Contains(string(bytes)); i++ {
 		if len(bytes) > 0 {
 			at := g.rnd.Intn(len(bytes))
 			switch g.rnd.Intn(3) {
 			case 0:
 				replace(at)
 			case 1:
 				delete(at)
 			case 2:
 				insert(at)
 			}
 		} else {
 			insert(0)
 		}
 	}
 	return string(bytes), nil
 }

 // Map is a simple generic key-value map, which can be used in the template
 type Map map[interface{}]interface{}

 func newMap() Map { return Map{} }

 // Put adds the key-value pair into the map.
 // Put always returns an empty string so nothing is printed in the template.
 func (m Map) Put(key, value interface{}) string {
 	m[key] = value
 	return ""
 }

 // Get looks up and returns the value with the given key. If the map does not
 // contain the given key, then nil is returned.
 func (m Map) Get(key interface{}) interface{} {
 	return m[key]
 }

 // is returns a function that returns true if the value passed to the function
 // matches the type of 'ty'.
 func is(ty interface{}) func(interface{}) bool {
 	rty := reflect.TypeOf(ty)
 	return func(v interface{}) bool {
 		ty := reflect.TypeOf(v)
 		return ty == rty || ty == reflect.PtrTo(rty)
 	}
 }

 // isFirstIn returns true if v is the first element of the given slice.
 func isFirstIn(v, slice interface{}) bool {
 	s := reflect.ValueOf(slice)
 	count := s.Len()
 	if count == 0 {
 		return false
 	}
 	return s.Index(0).Interface() == v
 }

 // isFirstIn returns true if v is the last element of the given slice.
 func isLastIn(v, slice interface{}) bool {
 	s := reflect.ValueOf(slice)
 	count := s.Len()
 	if count == 0 {
 		return false
 	}
 	return s.Index(count-1).Interface() == v
 }

 // iterate returns a slice of length 'n', with each element equal to its index.
 // Useful for: {{- range Iterate $n -}}<this will be looped $n times>{{end}}
 func iterate(n int) []int {
 	out := make([]int, n)
 	for i := range out {
 		out[i] = i
 	}
 	return out
 }

 // pascalCase returns the snake-case string s transformed into 'PascalCase',
 // Rules:
 // * The first letter of the string is capitalized
 // * Characters following an underscore or number are capitalized
 // * Underscores are removed from the returned string
 // See: https://en.wikipedia.org/wiki/Camel_case
 func pascalCase(s string) string {
 	b := strings.Builder{}
 	upper := true
 	for _, r := range s {
 		if r == '_' {
 			upper = true
 			continue
 		}
 		if upper {
 			b.WriteRune(unicode.ToUpper(r))
 			upper = false
 		} else {
 			b.WriteRune(r)
 		}
 		if unicode.IsNumber(r) {
 			upper = true
 		}
 	}
 	return b.String()
 }

 // Invokes the clang-format executable at 'exe' to format the file content 'in'.
 // Returns the formatted file.
 func clangFormat(in, exe string) (string, error) {
 	cmd := exec.Command(exe)
 	cmd.Stdin = strings.NewReader(in)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		return "", fmt.Errorf("clang-format failed:\n%v\n%v", string(out), err)
 	}
 	return string(out), nil
 }

 // Looks for clang-format in the 'buildtools' directory, falling back to PATH
 func findClangFormat(projectRoot string) string {
 	var path string
 	switch runtime.GOOS {
 	case "linux":
 		path = filepath.Join(projectRoot, "buildtools/linux64/clang-format")
 	case "darwin":
 		path = filepath.Join(projectRoot, "buildtools/mac/clang-format")
 	case "windows":
 		path = filepath.Join(projectRoot, "buildtools/win/clang-format.exe")
 	}
 	if fileutils.IsExe(path) {
 		return path
 	}
 	var err error
 	path, err = exec.LookPath("clang-format")
 	if err == nil {
 		return path
 	}
 	return ""
 }
	// Copyright 2021 The Tint Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	// gen parses the <tint>/src/tint/intrinsics.def file, then scans the
	// project directory for '<file>.tmpl' files, to produce source code files.
	package main

	import (
	"flag"
	"fmt"
	"io"
	"io/ioutil"
	"math/rand"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"text/template"
	"time"
	"unicode"

	"dawn.googlesource.com/dawn/tools/src/container"
	"dawn.googlesource.com/dawn/tools/src/fileutils"
	"dawn.googlesource.com/dawn/tools/src/glob"
	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/gen"
	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/parser"
	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/resolver"
	"dawn.googlesource.com/dawn/tools/src/tint/intrinsic/sem"
	)

	const defProjectRelPath = "src/tint/intrinsics.def"

	func main() {
	if err := run(); err != nil {
	fmt.Println(err)
	os.Exit(1)
	}
	}

	func showUsage() {
	fmt.Println(`
	gen generates the templated code for the Tint compiler

	gen scans the project directory for '<file>.tmpl' files, to produce source code
	files.

	If the templates use the 'IntrinsicTable' function then gen will parse and
	resolve the <tint>/src/tint/intrinsics.def file.

	usage:
	gen

	optional flags:`)
	flag.PrintDefaults()
	fmt.Println(``)
	os.Exit(1)
	}

	func run() error {
	projectRoot := fileutils.ProjectRoot()

	// Find clang-format
	clangFormatPath := findClangFormat(projectRoot)
	if clangFormatPath == "" {
	return fmt.Errorf("cannot find clang-format in <dawn>/buildtools nor PATH")
	}

	// Recursively find all the template files in the <tint>/src directory
	files, err := glob.Scan(projectRoot, glob.MustParseConfig(`{
	"paths": [{"include": [
	"src/tint/**.tmpl",
	"test/tint/**.tmpl"
	]}]
	}`))
	if err != nil {
	return err
	}

	cache := &genCache{}

	// For each template file...
	for _, relTmplPath := range files {
	// Make tmplPath absolute
	tmplPath := filepath.Join(projectRoot, relTmplPath)

	// Read the template file
	tmpl, err := ioutil.ReadFile(tmplPath)
	if err != nil {
	return fmt.Errorf("failed to open '%v': %w", tmplPath, err)
	}

	// Create or update the file at relpath if the file content has changed,
	// preserving the copyright year in the header.
	// relpath is a path relative to the template
	writeFile := func(relpath, body string) error {
	abspath := filepath.Join(filepath.Dir(tmplPath), relpath)

	copyrightYear := time.Now().Year()

	// Load the old file
	existing, err := ioutil.ReadFile(abspath)
	if err == nil {
	// Look for the existing copyright year
	if match := copyrightRegex.FindStringSubmatch(string(existing)); len(match) == 2 {
	if year, err := strconv.Atoi(match[1]); err == nil {
	copyrightYear = year
	}
	}
	}

	// Write the common file header
	sb := strings.Builder{}
	sb.WriteString(fmt.Sprintf(header, copyrightYear, filepath.ToSlash(relTmplPath)))
	sb.WriteString(body)
	content := sb.String()
	return writeFileIfChanged(abspath, content, string(existing))
	}

	// Write the content generated using the template and semantic info
	sb := strings.Builder{}
	if err := generate(string(tmpl), cache, &sb, writeFile); err != nil {
	return fmt.Errorf("while processing '%v': %w", tmplPath, err)
	}

	if body := sb.String(); body != "" {
	_, tmplFileName := filepath.Split(tmplPath)
	outFileName := strings.TrimSuffix(tmplFileName, ".tmpl")

	switch filepath.Ext(outFileName) {
	case ".cc", ".h", ".inl":
	body, err = clangFormat(body, clangFormatPath)
	if err != nil {
	return err
	}
	}

	if err := writeFile(outFileName, body); err != nil {
	return err
	}
	}
	}

	return nil
	}

	// Cache for objects that are expensive to build, and can be reused between templates.
	type genCache struct {
	cached struct {
	sem *sem.Sem // lazily built by sem()
	intrinsicTable *gen.IntrinsicTable // lazily built by intrinsicTable()
	permuter *gen.Permuter // lazily built by permute()
	}
	}

	// sem lazily parses and resolves the intrinsic.def file, returning the semantic info.
	func (g genCache) sem() (sem.Sem, error) {
	if g.cached.sem == nil {
	// Load the builtins definition file
	defPath := filepath.Join(fileutils.ProjectRoot(), defProjectRelPath)

	defSource, err := ioutil.ReadFile(defPath)
	if err != nil {
	return nil, err
	}

	// Parse the definition file to produce an AST
	ast, err := parser.Parse(string(defSource), defProjectRelPath)
	if err != nil {
	return nil, err
	}

	// Resolve the AST to produce the semantic info
	sem, err := resolver.Resolve(ast)
	if err != nil {
	return nil, err
	}

	g.cached.sem = sem
	}
	return g.cached.sem, nil
	}

	// intrinsicTable lazily calls and returns the result of buildIntrinsicTable(),
	// caching the result for repeated calls.
	func (g genCache) intrinsicTable() (gen.IntrinsicTable, error) {
	if g.cached.intrinsicTable == nil {
	sem, err := g.sem()
	if err != nil {
	return nil, err
	}
	g.cached.intrinsicTable, err = gen.BuildIntrinsicTable(sem)
	if err != nil {
	return nil, err
	}
	}
	return g.cached.intrinsicTable, nil
	}

	// permute lazily calls buildPermuter(), caching the result for repeated
	// calls, then passes the argument to Permutator.Permute()
	func (g genCache) permute(overload sem.Overload) ([]gen.Permutation, error) {
	if g.cached.permuter == nil {
	sem, err := g.sem()
	if err != nil {
	return nil, err
	}
	g.cached.permuter, err = gen.NewPermuter(sem)
	if err != nil {
	return nil, err
	}
	}
	return g.cached.permuter.Permute(overload)
	}

	// writes content to path if the file has changed
	func writeFileIfChanged(path, newContent, oldContent string) error {
	if oldContent == newContent {
	return nil // Not changed
	}
	if err := os.MkdirAll(filepath.Dir(path), 0777); err != nil {
	return fmt.Errorf("failed to create directory for '%v': %w", path, err)
	}
	if err := ioutil.WriteFile(path, []byte(newContent), 0666); err != nil {
	return fmt.Errorf("failed to write file '%v': %w", path, err)
	}
	return nil
	}

	var copyrightRegex = regexp.MustCompile(`// Copyright (\d+) The`)

	const header = `// Copyright %v The Tint Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	////////////////////////////////////////////////////////////////////////////////
	// File generated by tools/src/cmd/gen
	// using the template:
	// %v
	//
	// Do not modify this file directly
	////////////////////////////////////////////////////////////////////////////////

	`

	type generator struct {
	template *template.Template
	cache *genCache
	writeFile WriteFile
	rnd *rand.Rand
	}

	// WriteFile is a function that Generate() may call to emit a new file from a
	// template.
	// relpath is the relative path from the currently executing template.
	// content is the file content to write.
	type WriteFile func(relpath, content string) error

	// generate executes the template tmpl, writing the output to w.
	// See https://golang.org/pkg/text/template/ for documentation on the template
	// syntax.
	func generate(tmpl string, cache *genCache, w io.Writer, writeFile WriteFile) error {
	g := generator{
	template: template.New("<template>"),
	cache: cache,
	writeFile: writeFile,
	rnd: rand.New(rand.NewSource(4561123)),
	}
	if err := g.bindAndParse(g.template, tmpl); err != nil {
	return err
	}
	return g.template.Execute(w, nil)
	}

	func (g generator) bindAndParse(t template.Template, text string) error {
	_, err := t.Funcs(map[string]interface{}{
	"Map": newMap,
	"Iterate": iterate,
	"Title": strings.Title,
	"PascalCase": pascalCase,
	"SplitDisplayName": gen.SplitDisplayName,
	"HasPrefix": strings.HasPrefix,
	"HasSuffix": strings.HasSuffix,
	"TrimPrefix": strings.TrimPrefix,
	"TrimSuffix": strings.TrimSuffix,
	"TrimLeft": strings.TrimLeft,
	"TrimRight": strings.TrimRight,
	"Split": strings.Split,
	"Scramble": g.scramble,
	"IsEnumEntry": is(sem.EnumEntry{}),
	"IsEnumMatcher": is(sem.EnumMatcher{}),
	"IsFQN": is(sem.FullyQualifiedName{}),
	"IsInt": is(1),
	"IsTemplateEnumParam": is(sem.TemplateEnumParam{}),
	"IsTemplateNumberParam": is(sem.TemplateNumberParam{}),
	"IsTemplateTypeParam": is(sem.TemplateTypeParam{}),
	"IsType": is(sem.Type{}),
	"ElementType": gen.ElementType,
	"DeepestElementType": gen.DeepestElementType,
	"IsAbstract": gen.IsAbstract,
	"IsDeclarable": gen.IsDeclarable,
	"OverloadUsesF16": gen.OverloadUsesF16,
	"IsFirstIn": isFirstIn,
	"IsLastIn": isLastIn,
	"Sem": g.cache.sem,
	"IntrinsicTable": g.cache.intrinsicTable,
	"Permute": g.cache.permute,
	"Eval": g.eval,
	"Import": g.importTmpl,
	"WriteFile": func(relpath, content string) (string, error) { return "", g.writeFile(relpath, content) },
	}).Option("missingkey=error").Parse(text)
	return err
	}

	// eval executes the sub-template with the given name and argument, returning
	// the generated output
	func (g *generator) eval(template string, args ...interface{}) (string, error) {
	target := g.template.Lookup(template)
	if target == nil {
	return "", fmt.Errorf("template '%v' not found", template)
	}
	sb := strings.Builder{}

	var err error
	if len(args) == 1 {
	err = target.Execute(&sb, args[0])
	} else {
	m := newMap()
	if len(args)%2 != 0 {
	return "", fmt.Errorf("Eval expects a single argument or list name-value pairs")
	}
	for i := 0; i < len(args); i += 2 {
	name, ok := args[i].(string)
	if !ok {
	return "", fmt.Errorf("Eval argument %v is not a string", i)
	}
	m.Put(name, args[i+1])
	}
	err = target.Execute(&sb, m)
	}

	if err != nil {
	return "", fmt.Errorf("while evaluating '%v': %v", template, err)
	}
	return sb.String(), nil
	}

	// importTmpl parses the template at the given project-relative path, merging
	// the template definitions into the global namespace.
	// Note: The body of the template is not executed.
	func (g *generator) importTmpl(path string) (string, error) {
	if strings.Contains(path, "..") {
	return "", fmt.Errorf("import path must not contain '..'")
	}
	path = filepath.Join(fileutils.ProjectRoot(), path)
	data, err := ioutil.ReadFile(path)
	if err != nil {
	return "", fmt.Errorf("failed to open '%v': %w", path, err)
	}
	t := g.template.New("")
	if err := g.bindAndParse(t, string(data)); err != nil {
	return "", fmt.Errorf("failed to parse '%v': %w", path, err)
	}
	return "", nil
	}

	// scramble randomly modifies the input string so that it is no longer equal to
	// any of the strings in 'avoid'.
	func (g *generator) scramble(str string, avoid container.Set[string]) (string, error) {
	bytes := []byte(str)
	passes := g.rnd.Intn(5) + 1

	const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"

	char := func() byte { return chars[g.rnd.Intn(len(chars))] }
	replace := func(at int) { bytes[at] = char() }
	delete := func(at int) { bytes = append(bytes[:at], bytes[at+1:]...) }
	insert := func(at int) { bytes = append(append(bytes[:at], char()), bytes[at:]...) }

	for i := 0; i < passes \|\| avoid.Contains(string(bytes)); i++ {
	if len(bytes) > 0 {
	at := g.rnd.Intn(len(bytes))
	switch g.rnd.Intn(3) {
	case 0:
	replace(at)
	case 1:
	delete(at)
	case 2:
	insert(at)
	}
	} else {
	insert(0)
	}
	}
	return string(bytes), nil
	}

	// Map is a simple generic key-value map, which can be used in the template
	type Map map[interface{}]interface{}

	func newMap() Map { return Map{} }

	// Put adds the key-value pair into the map.
	// Put always returns an empty string so nothing is printed in the template.
	func (m Map) Put(key, value interface{}) string {
	m[key] = value
	return ""
	}

	// Get looks up and returns the value with the given key. If the map does not
	// contain the given key, then nil is returned.
	func (m Map) Get(key interface{}) interface{} {
	return m[key]
	}

	// is returns a function that returns true if the value passed to the function
	// matches the type of 'ty'.
	func is(ty interface{}) func(interface{}) bool {
	rty := reflect.TypeOf(ty)
	return func(v interface{}) bool {
	ty := reflect.TypeOf(v)
	return ty == rty \|\| ty == reflect.PtrTo(rty)
	}
	}

	// isFirstIn returns true if v is the first element of the given slice.
	func isFirstIn(v, slice interface{}) bool {
	s := reflect.ValueOf(slice)
	count := s.Len()
	if count == 0 {
	return false
	}
	return s.Index(0).Interface() == v
	}

	// isFirstIn returns true if v is the last element of the given slice.
	func isLastIn(v, slice interface{}) bool {
	s := reflect.ValueOf(slice)
	count := s.Len()
	if count == 0 {
	return false
	}
	return s.Index(count-1).Interface() == v
	}

	// iterate returns a slice of length 'n', with each element equal to its index.
	// Useful for: {{- range Iterate $n -}}<this will be looped $n times>{{end}}
	func iterate(n int) []int {
	out := make([]int, n)
	for i := range out {
	out[i] = i
	}
	return out
	}

	// pascalCase returns the snake-case string s transformed into 'PascalCase',
	// Rules:
	// * The first letter of the string is capitalized
	// * Characters following an underscore or number are capitalized
	// * Underscores are removed from the returned string
	// See: https://en.wikipedia.org/wiki/Camel_case
	func pascalCase(s string) string {
	b := strings.Builder{}
	upper := true
	for _, r := range s {
	if r == '_' {
	upper = true
	continue
	}
	if upper {
	b.WriteRune(unicode.ToUpper(r))
	upper = false
	} else {
	b.WriteRune(r)
	}
	if unicode.IsNumber(r) {
	upper = true
	}
	}
	return b.String()
	}

	// Invokes the clang-format executable at 'exe' to format the file content 'in'.
	// Returns the formatted file.
	func clangFormat(in, exe string) (string, error) {
	cmd := exec.Command(exe)
	cmd.Stdin = strings.NewReader(in)
	out, err := cmd.CombinedOutput()
	if err != nil {
	return "", fmt.Errorf("clang-format failed:\n%v\n%v", string(out), err)
	}
	return string(out), nil
	}

	// Looks for clang-format in the 'buildtools' directory, falling back to PATH
	func findClangFormat(projectRoot string) string {
	var path string
	switch runtime.GOOS {
	case "linux":
	path = filepath.Join(projectRoot, "buildtools/linux64/clang-format")
	case "darwin":
	path = filepath.Join(projectRoot, "buildtools/mac/clang-format")
	case "windows":
	path = filepath.Join(projectRoot, "buildtools/win/clang-format.exe")
	}
	if fileutils.IsExe(path) {
	return path
	}
	var err error
	path, err = exec.LookPath("clang-format")
	if err == nil {
	return path
	}
	return ""
	}