gorenameをライブラリとして使う #golang

$ go get -u golang.org/x/tools/cmd/gorename

$ gorename -help
gorename: precise type-safe renaming of identifiers in Go source code.

Usage:

 gorename (-from <spec> | -offset <file>:#<byte-offset>) -to <name> [-force]

You must specify the object (named entity) to rename using the -offset
or -from flag.  Exactly one must be specified.

Flags:

-offset    specifies the filename and byte offset of an identifier to rename.
           This form is intended for use by text editors.

-from      specifies the object to rename using a query notation;
           This form is intended for interactive use at the command line.
           A legal -from query has one of the following forms:

  "encoding/json".Decoder.Decode        method of package-level named type
  (*"encoding/json".Decoder).Decode     ditto, alternative syntax
  "encoding/json".Decoder.buf           field of package-level named struct type
  "encoding/json".HTMLEscape            package member (const, func, var, type)
  "encoding/json".Decoder.Decode::x     local object x within a method
  "encoding/json".HTMLEscape::x         local object x within a function
  "encoding/json"::x                    object x anywhere within a package
  json.go::x                            object x within file json.go

           Double-quotes must be escaped when writing a shell command.
           Quotes may be omitted for single-segment import paths such as "fmt".

           For methods, the parens and '*' on the receiver type are both
           optional.

           It is an error if one of the ::x queries matches multiple
           objects.

-to        the new name.

-force     causes the renaming to proceed even if conflicts were reported.
           The resulting program may be ill-formed, or experience a change
           in behaviour.

           WARNING: this flag may even cause the renaming tool to crash.
           (In due course this bug will be fixed by moving certain
           analyses into the type-checker.)

-d         display diffs instead of rewriting files

-v         enables verbose logging.

gorename automatically computes the set of packages that might be
affected.  For a local renaming, this is just the package specified by
-from or -offset, but for a potentially exported name, gorename scans
the workspace ($GOROOT and $GOPATH).

gorename rejects renamings of concrete methods that would change the
assignability relation between types and interfaces.  If the interface
change was intentional, initiate the renaming at the interface method.

gorename rejects any renaming that would create a conflict at the point
of declaration, or a reference conflict (ambiguity or shadowing), or
anything else that could cause the resulting program not to compile.


Examples:

$ gorename -offset file.go:#123 -to foo

  Rename the object whose identifier is at byte offset 123 within file file.go.

$ gorename -from '"bytes".Buffer.Len' -to Size

  Rename the "Len" method of the *bytes.Buffer type to "Size".

---- TODO ----
...

$ gorename -h
Usage of gorename:
  -d    display diffs instead of rewriting files
  -diffcmd string
        diff command invoked when using -d (default "diff")
  -force
        proceed, even if conflicts were reported
  -from string
        identifier to be renamed; see -help for formats
  -help
        show usage message
  -offset string
        file and byte offset of identifier to be renamed, e.g. 'file.go:#123'.  For use by editors.
  -tags build tags
        a list of build tags to consider satisfied during the build. For more information about build tags, see the description of build constraints in the documentation for the go/build package (default <tagsFlag>)
  -to string
        new name for identifier
  -v    print verbose information

$ gorename -from '"bytes".Buffer.Len' -to Size

$ gorename -offset file.go:#123 -to foo

rename.Main(&build.Default, *offsetFlag, *fromFlag, *toFlag)

$ go get -u golang.org/x/tools/refactor/rename

func Main(ctxt *build.Context, offsetFlag, fromFlag, to string) error

type Context struct {
        GOARCH      string // target architecture
        GOOS        string // target operating system
        GOROOT      string // Go root
        GOPATH      string // Go path
        CgoEnabled  bool   // whether cgo can be used
        UseAllFiles bool   // use files regardless of +build lines, file names
        Compiler    string // compiler to assume when computing target paths

        // The build and release tags specify build constraints
        // that should be considered satisfied when processing +build lines.
        // Clients creating a new context may customize BuildTags, which
        // defaults to empty, but it is usually an error to customize ReleaseTags,
        // which defaults to the list of Go releases the current release is compatible with.
        // In addition to the BuildTags and ReleaseTags, build constraints
        // consider the values of GOARCH and GOOS as satisfied tags.
        BuildTags   []string
        ReleaseTags []string

        // The install suffix specifies a suffix to use in the name of the installation
        // directory. By default it is empty, but custom builds that need to keep
        // their outputs separate can set InstallSuffix to do so. For example, when
        // using the race detector, the go command uses InstallSuffix = "race", so
        // that on a Linux/386 system, packages are written to a directory named
        // "linux_386_race" instead of the usual "linux_386".
        InstallSuffix string

        // JoinPath joins the sequence of path fragments into a single path.
        // If JoinPath is nil, Import uses filepath.Join.
        JoinPath func(elem ...string) string

        // SplitPathList splits the path list into a slice of individual paths.
        // If SplitPathList is nil, Import uses filepath.SplitList.
        SplitPathList func(list string) []string

        // IsAbsPath reports whether path is an absolute path.
        // If IsAbsPath is nil, Import uses filepath.IsAbs.
        IsAbsPath func(path string) bool

        // IsDir reports whether the path names a directory.
        // If IsDir is nil, Import calls os.Stat and uses the result's IsDir method.
        IsDir func(path string) bool

        // HasSubdir reports whether dir is a subdirectory of
        // (perhaps multiple levels below) root.
        // If so, HasSubdir sets rel to a slash-separated path that
        // can be joined to root to produce a path equivalent to dir.
        // If HasSubdir is nil, Import uses an implementation built on
        // filepath.EvalSymlinks.
        HasSubdir func(root, dir string) (rel string, ok bool)

        // ReadDir returns a slice of os.FileInfo, sorted by Name,
        // describing the content of the named directory.
        // If ReadDir is nil, Import uses ioutil.ReadDir.
        ReadDir func(dir string) ([]os.FileInfo, error)

        // OpenFile opens a file (not a directory) for reading.
        // If OpenFile is nil, Import uses os.Open.
        OpenFile func(path string) (io.ReadCloser, error)
}

package main

import (
	"fmt"
	"go/ast"
	"go/build"
	"go/parser"
	"go/token"
	"path/filepath"
	"strings"

	"golang.org/x/tools/refactor/rename"
)

func main() {
	pkg, err := build.Import("fuga", ".", build.IgnoreVendor)
	if err != nil {
		fmt.Println("Error:", err)
	}

	for _, filename := range pkg.GoFiles {
		if err := renameID(filepath.Join(pkg.Dir, filename)); err != nil {
			fmt.Println("Error:", err)
		}
	}
}

func renameID(filename string) error {
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filename, nil, parser.AllErrors)
	if err != nil {
		return err
	}

	type renameParam struct {
		offset string
		to     string
	}

	var renameParams []*renameParam
	for _, decl := range f.Decls {
		genDecl, isGenDecl := decl.(*ast.GenDecl)
		if !isGenDecl {
			continue
		}

		for _, spec := range genDecl.Specs {
			typeSpec, isType := spec.(*ast.TypeSpec)
			if !isType {
				continue
			}

			structType, isStruct := typeSpec.Type.(*ast.StructType)
			if !isStruct {
				continue
			}

			for _, fi := range structType.Fields.List {
				for _, fn := range fi.Names {
					if strings.HasSuffix(fn.Name, "Id") {
						renameParams = append(renameParams, &renameParam{
							offset: fmt.Sprintf("%s:#%d", filename, fn.Pos()),
							to:     fn.Name[:len(fn.Name)-1] + "D", // Id -> ID
						})
					}
				}
			}
		}
	}

	fmt.Println(filename)
	for _, p := range renameParams {
		fmt.Println(p.offset, "->", p.to)
		if err := rename.Main(&build.Default, p.offset, "", p.to); err != nil {
			return err
		}
	}

	return nil
}

$ tree $GOPATH/src/fuga
$GOPATH/src/fuga
└── fuga.go
$ cat $GOPATH/src/fuga/fuga.go
package fuga

type Hoge struct {
        hogeId         int
        fugaId, piyoId int
}

$ go run rename.go
$GOPATH/fuga.go
$GOPATH/fuga.go:#35 -> hogeID
Renamed 1 occurrence in 1 file in 1 package.
$GOPATH/fuga.go:#55 -> fugaID
Renamed 1 occurrence in 1 file in 1 package.
$GOPATH/fuga.go:#63 -> piyoID
Renamed 1 occurrence in 1 file in 1 package.
$ cat $GOPATH/src/fuga/fuga.go
package fuga

type Hoge struct {
        hogeID         int
        fugaID, piyoID int
}