feat(depinject): codegen part 1 (imports & idents) (#12557)

## Description

Ref #12556 

To make things easier I've starting splitting up #12469 into smaller PRs.

This first PR for codegen adds basic infrastructure for:
* adding package imports
* creating new var names (`*ast.Ident`) without conflicts

Other PRs will add the actual codegen functionality.



---

### Author Checklist

*All items are required. Please add a note to the item if the item is not applicable and
please add links to any relevant follow up issues.*

I have...

- [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title
- [ ] added `!` to the type prefix if API or client breaking change
- [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting))
- [ ] provided a link to the relevant issue or specification
- [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules)
- [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing)
- [ ] added a changelog entry to `CHANGELOG.md`
- [ ] included comments for [documenting Go code](https://blog.golang.org/godoc)
- [ ] updated the relevant documentation or specification
- [ ] reviewed "Files changed" and left comments if necessary
- [ ] confirmed all CI checks have passed

### Reviewers Checklist

*All items are required. Please add a note if the item is not applicable and please add
your handle next to the items reviewed if you only reviewed selected items.*

I have...

- [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title
- [ ] confirmed `!` in the type prefix if API or client breaking change
- [ ] confirmed all author checklist items have been addressed 
- [ ] reviewed state machine logic
- [ ] reviewed API design and naming
- [ ] reviewed documentation is accurate
- [ ] reviewed tests and test coverage
- [ ] manually tested (if applicable)

depinject/internal/codegen/file.go

@@ -0,0 +1,90 @@
+package codegen
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"strconv"
+)
+
+// FileGen is a utility for generating/patching golang file ASTs.
+type FileGen struct {
+	File           *ast.File
+	idents         map[string]bool
+	codegenPkgPath string
+	pkgImportMap   map[string]*importInfo
+}
+
+// NewFileGen creates a new FileGen instance from a file AST with the provided package path.
+func NewFileGen(file *ast.File, codegenPkgPath string) (*FileGen, error) {
+	g := &FileGen{
+		File:           file,
+		idents:         map[string]bool{},
+		codegenPkgPath: codegenPkgPath,
+		pkgImportMap:   map[string]*importInfo{},
+	}
+
+	// add all go keywords to reserved idents
+	for i := token.Token(0); i <= token.TILDE; i++ {
+		name := i.String()
+		if token.IsKeyword(name) {
+			g.idents[name] = true
+		}
+	}
+
+	// add all top-level decl idents
+	for _, decl := range file.Decls {
+		switch decl := decl.(type) {
+		case *ast.FuncDecl:
+			g.idents[decl.Name.Name] = true
+		case *ast.GenDecl:
+			for _, spec := range decl.Specs {
+				switch spec := spec.(type) {
+				case *ast.TypeSpec:
+					g.idents[spec.Name.Name] = true
+				case *ast.ValueSpec:
+					for _, name := range spec.Names {
+						g.idents[name.Name] = true
+					}
+				}
+			}
+		}
+	}
+
+	for _, spec := range file.Imports {
+		pkgPath, err := strconv.Unquote(spec.Path.Value)
+		if err != nil {
+			return nil, err
+		}
+
+		var info *importInfo
+		if spec.Name != nil {
+			name := spec.Name.Name
+			if name == "." {
+				return nil, fmt.Errorf(". package imports are not allowed")
+			}
+
+			info = &importInfo{importPrefix: name, ImportSpec: spec}
+		} else {
+			prefix := defaultPkgPrefix(pkgPath)
+			info = &importInfo{importPrefix: prefix, ImportSpec: spec}
+		}
+		g.pkgImportMap[pkgPath] = info
+		g.idents[info.importPrefix] = true
+	}
+
+	return g, nil
+}
+
+// PatchFuncDecl returns a FuncGen instance for the function declaration with the given name or returns nil.
+func (g *FileGen) PatchFuncDecl(name string) *FuncGen {
+	for _, decl := range g.File.Decls {
+		funcDecl, ok := decl.(*ast.FuncDecl)
+		if ok {
+			if funcDecl.Name.Name == name {
+				return newFuncGen(g, funcDecl)
+			}
+		}
+	}
+	return nil
+}

depinject/internal/codegen/func.go

@@ -0,0 +1,31 @@
+package codegen
+
+import (
+	"go/ast"
+)
+
+// FuncGen is a utility for generating/patching golang function declaration ASTs.
+type FuncGen struct {
+	*FileGen
+	Func *ast.FuncDecl
+}
+
+func newFuncGen(fileGen *FileGen, f *ast.FuncDecl) *FuncGen {
+	g := &FuncGen{FileGen: fileGen, Func: f}
+
+	// reserve param idents
+	for _, field := range f.Type.Params.List {
+		for _, name := range field.Names {
+			g.idents[name.Name] = true
+		}
+	}
+
+	// reserve result
+	for _, field := range f.Type.Results.List {
+		for _, name := range field.Names {
+			g.idents[name.Name] = true
+		}
+	}
+
+	return g
+}

depinject/internal/codegen/ident.go

@@ -0,0 +1,29 @@
+package codegen
+
+import (
+	"fmt"
+	"go/ast"
+)
+
+// CreateIdent creates a new ident that doesn't conflict with reserved symbols,
+// top-level declarations and other defined idents. Idents are unique across
+// the whole file as it is assumed that codegen usually happens on one function
+// per file.
+func (g *FileGen) CreateIdent(namePrefix string) *ast.Ident {
+	return ast.NewIdent(g.doCreateIdent(namePrefix))
+}
+
+func (g *FileGen) doCreateIdent(namePrefix string) string {
+	v := namePrefix
+	i := 2
+	for {
+		_, ok := g.idents[v]
+		if !ok {
+			g.idents[v] = true
+			return v
+		}
+
+		v = fmt.Sprintf("%s%d", namePrefix, i)
+		i++
+	}
+}

depinject/internal/codegen/ident_test.go

@@ -0,0 +1,48 @@
+package codegen
+
+import (
+	"go/parser"
+	"go/token"
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestReservedIdents(t *testing.T) {
+	const src = `
+package mypkg
+
+import "example.com/bar"
+
+type MyInt int
+
+var myVar int
+
+func Build(a, a2 int, b string) (c int, err error) {}
+`
+	file, err := parser.ParseFile(token.NewFileSet(), "", src, 0)
+	assert.NilError(t, err)
+
+	fileGen, err := NewFileGen(file, "example.com/mypkg")
+	assert.NilError(t, err)
+	funcGen := fileGen.PatchFuncDecl("Build")
+	assert.Assert(t, funcGen != nil)
+
+	// go keywords get a suffix
+	assert.Equal(t, "type2", funcGen.CreateIdent("type").Name)
+	assert.Equal(t, "package2", funcGen.CreateIdent("package").Name)
+	assert.Equal(t, "goto2", funcGen.CreateIdent("goto").Name)
+
+	// import name prefixes get suffixes
+	assert.Equal(t, "bar2", funcGen.CreateIdent("bar").Name)
+
+	// top-level decl names get prefixes
+	assert.Equal(t, "MyInt2", funcGen.CreateIdent("MyInt").Name)
+	assert.Equal(t, "myVar2", funcGen.CreateIdent("myVar").Name)
+
+	// param and result names get suffixes at func level
+	assert.Equal(t, "a3", funcGen.CreateIdent("a").Name)
+	assert.Equal(t, "b2", funcGen.CreateIdent("b").Name)
+	assert.Equal(t, "c2", funcGen.CreateIdent("c").Name)
+	assert.Equal(t, "err2", funcGen.CreateIdent("err").Name)
+}

depinject/internal/codegen/import.go

@@ -0,0 +1,48 @@
+package codegen
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"strings"
+)
+
+type importInfo struct {
+	*ast.ImportSpec
+	importPrefix string
+}
+
+// AddOrGetImport adds a new import for the provided pkgPath (if needed) and
+// returns the unique import prefix for that path.
+func (g *FileGen) AddOrGetImport(pkgPath string) (importPrefix string) {
+	if pkgPath == "" || pkgPath == g.codegenPkgPath {
+		return ""
+	}
+
+	if i, ok := g.pkgImportMap[pkgPath]; ok {
+		return i.importPrefix
+	}
+
+	imp := &ast.ImportSpec{
+		Path: &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", pkgPath)},
+	}
+
+	defaultPrefix := defaultPkgPrefix(pkgPath)
+	importPrefix = g.doCreateIdent(defaultPrefix)
+
+	if importPrefix != defaultPrefix {
+		imp.Name = ast.NewIdent(importPrefix)
+	}
+	g.File.Imports = append(g.File.Imports, imp)
+	g.pkgImportMap[pkgPath] = &importInfo{
+		ImportSpec:   imp,
+		importPrefix: importPrefix,
+	}
+	g.idents[importPrefix] = true
+	return importPrefix
+}
+
+func defaultPkgPrefix(pkgPath string) string {
+	pkgParts := strings.Split(pkgPath, "/")
+	return pkgParts[len(pkgParts)-1]
+}

depinject/internal/codegen/import_test.go

@@ -0,0 +1,60 @@
+package codegen
+
+import (
+	"go/parser"
+	"go/token"
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestImport(t *testing.T) {
+	const badFileSrc = `
+package mypkg
+
+import . "example.com/foo"
+`
+
+	badFile, err := parser.ParseFile(token.NewFileSet(), "", badFileSrc, 0)
+	assert.NilError(t, err)
+
+	_, err = NewFileGen(badFile, "example.com/mypkg")
+	assert.ErrorContains(t, err, ".")
+
+	const goodFileSrc = `
+package mypkg
+
+import "example.com/foo"
+import abc "example.com/bar"
+`
+
+	goodFile, err := parser.ParseFile(token.NewFileSet(), "", goodFileSrc, 0)
+	assert.NilError(t, err)
+	assert.Equal(t, 2, len(goodFile.Imports))
+
+	fgen, err := NewFileGen(goodFile, "example.com/mypkg")
+	assert.NilError(t, err)
+
+	// self import is ""
+	assert.Equal(t, "", fgen.AddOrGetImport("example.com/mypkg"))
+
+	// bar import is abc, no new import was added
+	assert.Equal(t, "abc", fgen.AddOrGetImport("example.com/bar"))
+	assert.Equal(t, 2, len(goodFile.Imports))
+
+	// foo import is foo, no new import is added
+	assert.Equal(t, "foo", fgen.AddOrGetImport("example.com/foo"))
+	assert.Equal(t, 2, len(goodFile.Imports))
+
+	// baz import is baz, a new import is added
+	assert.Equal(t, "baz", fgen.AddOrGetImport("example.com/baz"))
+	assert.Equal(t, 3, len(goodFile.Imports))
+
+	// another foo import is foo2, a new import is added
+	assert.Equal(t, "foo2", fgen.AddOrGetImport("example2.com/foo"))
+	assert.Equal(t, 4, len(goodFile.Imports))
+
+	// another baz import is baz2, a new import is added
+	assert.Equal(t, "baz2", fgen.AddOrGetImport("example.com/foo/baz"))
+	assert.Equal(t, 5, len(goodFile.Imports))
+}