Refactor idlgen for better testing

Slightly refactors //tools/src/cmd/idlgen/main.go to better accommodate
future testing. Changes include:

* Making showUsage return an error instead of calling os.Exit
* Making run not rely on global flag state
* Updating parsing code to read and parse a file instead of relying on
  ParseFiles, as that circumvents the filesystem dependency injection

All of these changes should be functional no-ops outside of tests.

Bug: 344014313
Change-Id: I7c22c1437b337df1714adab0f9e50fc2ec828527
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/282877
Reviewed-by: dan sinclair <dsinclair@chromium.org>
Commit-Queue: dan sinclair <dsinclair@chromium.org>
Auto-Submit: Brian Sheedy <bsheedy@google.com>

Author: bsheedy-work

tools/src/cmd/idlgen/main.go

@@ -46,34 +46,37 @@ import (
 )
 
 func main() {
-	if err := run(oswrapper.GetRealOSWrapper()); err != nil {
+	if err := run(os.Args[1:], oswrapper.GetRealOSWrapper()); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 }
 
-func showUsage() {
-	fmt.Println(`
+func showUsage() error {
+	return fmt.Errorf(`
 idlgen is a tool used to generate code from WebIDL files and a golang
 template file
 
 Usage:
   idlgen --template=<template-path> --output=<output-path> <idl-file> [<idl-file>...]`)
-	os.Exit(1)
 }
 
-func run(osWrapper oswrapper.OSWrapper) error {
+func run(args []string, osWrapper oswrapper.OSWrapper) error {
 	var templatePath string
 	var outputPath string
-	flag.StringVar(&templatePath, "template", "", "the template file run with the parsed WebIDL files")
-	flag.StringVar(&outputPath, "output", "", "the output file")
-	flag.Parse()
 
-	idlFiles := flag.Args()
+	flagSet := flag.NewFlagSet("idlgen", flag.ContinueOnError)
+	flagSet.StringVar(&templatePath, "template", "", "the template file run with the parsed WebIDL files")
+	flagSet.StringVar(&outputPath, "output", "", "the output file")
+	if err := flagSet.Parse(args); err != nil {
+		return err
+	}
+
+	idlFiles := flagSet.Args()
 
 	// Check all required arguments are provided
 	if templatePath == "" || outputPath == "" || len(idlFiles) == 0 {
-		showUsage()
+		return showUsage()
 	}
 
 	// Open up the output file
@@ -118,7 +121,10 @@ func run(osWrapper oswrapper.OSWrapper) error {
 	}
 
 	// Initialize the generator
-	g := generator{t: template.New(templatePath)}
+	g := generator{
+		t:         template.New(templatePath),
+		osWrapper: osWrapper,
+	}
 	g.workingDir = filepath.Dir(templatePath)
 	g.funcs = map[string]interface{}{
 		// Functions exposed to the template
@@ -446,6 +452,8 @@ type generator struct {
 	funcs map[string]interface{}
 	// dependency-sorted declarations
 	declarations declarations
+	// osWrapper for file operations
+	osWrapper oswrapper.OSWrapper
 }
 
 // eval executes the sub-template with the given name and arguments, returning
@@ -494,13 +502,25 @@ func (g *generator) lookup(name string) ast.Decl {
 // include loads the template with the given path, importing the declarations
 // into the scope of the current template.
 func (g *generator) include(path string) (string, error) {
-	t, err := g.t.
+	// The file is read and manually parsed instead of using Template.ParseFiles
+	// since ParseFiles circumvents our filesystem dependency injection.
+	fullPath := filepath.Join(g.workingDir, path)
+	content, err := g.osWrapper.ReadFile(fullPath)
+	if err != nil {
+		return "", err
+	}
+
+	// ParseFiles uses the basename of the file as the template name.
+	basename := filepath.Base(path)
+	t := g.t.New(basename).
 		Option("missingkey=invalid").
-		Funcs(g.funcs).
-		ParseFiles(filepath.Join(g.workingDir, path))
+		Funcs(g.funcs)
+
+	t, err = t.Parse(string(content))
 	if err != nil {
 		return "", err
 	}
+
 	g.t.AddParseTree(path, t.Tree)
 	return "", nil
 }