--- /dev/null
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package rename contains the implementation of the 'gorename' command
+// whose main function is in golang.org/x/tools/cmd/gorename.
+// See the Usage constant for the command documentation.
+package rename // import "golang.org/x/tools/refactor/rename"
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "go/ast"
+ "go/build"
+ "go/format"
+ "go/parser"
+ "go/token"
+ "go/types"
+ "io"
+ "io/ioutil"
+ "log"
+ "os"
+ "os/exec"
+ "path"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+
+ "golang.org/x/tools/go/loader"
+ "golang.org/x/tools/go/types/typeutil"
+ "golang.org/x/tools/refactor/importgraph"
+ "golang.org/x/tools/refactor/satisfy"
+)
+
+const Usage = `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 ----
+
+// Correctness:
+// - handle dot imports correctly
+// - document limitations (reflection, 'implements' algorithm).
+// - sketch a proof of exhaustiveness.
+
+// Features:
+// - support running on packages specified as *.go files on the command line
+// - support running on programs containing errors (loader.Config.AllowErrors)
+// - allow users to specify a scope other than "global" (to avoid being
+// stuck by neglected packages in $GOPATH that don't build).
+// - support renaming the package clause (no object)
+// - support renaming an import path (no ident or object)
+// (requires filesystem + SCM updates).
+// - detect and reject edits to autogenerated files (cgo, protobufs)
+// and optionally $GOROOT packages.
+// - report all conflicts, or at least all qualitatively distinct ones.
+// Sometimes we stop to avoid redundancy, but
+// it may give a disproportionate sense of safety in -force mode.
+// - support renaming all instances of a pattern, e.g.
+// all receiver vars of a given type,
+// all local variables of a given type,
+// all PkgNames for a given package.
+// - emit JSON output for other editors and tools.
+
+var (
+ // Force enables patching of the source files even if conflicts were reported.
+ // The resulting program may be ill-formed.
+ // It may even cause gorename to crash. TODO(adonovan): fix that.
+ Force bool
+
+ // Diff causes the tool to display diffs instead of rewriting files.
+ Diff bool
+
+ // DiffCmd specifies the diff command used by the -d feature.
+ // (The command must accept a -u flag and two filename arguments.)
+ DiffCmd = "diff"
+
+ // ConflictError is returned by Main when it aborts the renaming due to conflicts.
+ // (It is distinguished because the interesting errors are the conflicts themselves.)
+ ConflictError = errors.New("renaming aborted due to conflicts")
+
+ // Verbose enables extra logging.
+ Verbose bool
+)
+
+var stdout io.Writer = os.Stdout
+
+type renamer struct {
+ iprog *loader.Program
+ objsToUpdate map[types.Object]bool
+ hadConflicts bool
+ from, to string
+ satisfyConstraints map[satisfy.Constraint]bool
+ packages map[*types.Package]*loader.PackageInfo // subset of iprog.AllPackages to inspect
+ msets typeutil.MethodSetCache
+ changeMethods bool
+}
+
+var reportError = func(posn token.Position, message string) {
+ fmt.Fprintf(os.Stderr, "%s: %s\n", posn, message)
+}
+
+// importName renames imports of fromPath within the package specified by info.
+// If fromName is not empty, importName renames only imports as fromName.
+// If the renaming would lead to a conflict, the file is left unchanged.
+func importName(iprog *loader.Program, info *loader.PackageInfo, fromPath, fromName, to string) error {
+ if fromName == to {
+ return nil // no-op (e.g. rename x/foo to y/foo)
+ }
+ for _, f := range info.Files {
+ var from types.Object
+ for _, imp := range f.Imports {
+ importPath, _ := strconv.Unquote(imp.Path.Value)
+ importName := path.Base(importPath)
+ if imp.Name != nil {
+ importName = imp.Name.Name
+ }
+ if importPath == fromPath && (fromName == "" || importName == fromName) {
+ from = info.Implicits[imp]
+ break
+ }
+ }
+ if from == nil {
+ continue
+ }
+ r := renamer{
+ iprog: iprog,
+ objsToUpdate: make(map[types.Object]bool),
+ to: to,
+ packages: map[*types.Package]*loader.PackageInfo{info.Pkg: info},
+ }
+ r.check(from)
+ if r.hadConflicts {
+ reportError(iprog.Fset.Position(f.Imports[0].Pos()),
+ "skipping update of this file")
+ continue // ignore errors; leave the existing name
+ }
+ if err := r.update(); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func Main(ctxt *build.Context, offsetFlag, fromFlag, to string) error {
+ // -- Parse the -from or -offset specifier ----------------------------
+
+ if (offsetFlag == "") == (fromFlag == "") {
+ return fmt.Errorf("exactly one of the -from and -offset flags must be specified")
+ }
+
+ if !isValidIdentifier(to) {
+ return fmt.Errorf("-to %q: not a valid identifier", to)
+ }
+
+ if Diff {
+ defer func(saved func(string, []byte) error) { writeFile = saved }(writeFile)
+ writeFile = diff
+ }
+
+ var spec *spec
+ var err error
+ if fromFlag != "" {
+ spec, err = parseFromFlag(ctxt, fromFlag)
+ } else {
+ spec, err = parseOffsetFlag(ctxt, offsetFlag)
+ }
+ if err != nil {
+ return err
+ }
+
+ if spec.fromName == to {
+ return fmt.Errorf("the old and new names are the same: %s", to)
+ }
+
+ // -- Load the program consisting of the initial package -------------
+
+ iprog, err := loadProgram(ctxt, map[string]bool{spec.pkg: true})
+ if err != nil {
+ return err
+ }
+
+ fromObjects, err := findFromObjects(iprog, spec)
+ if err != nil {
+ return err
+ }
+
+ // -- Load a larger program, for global renamings ---------------------
+
+ if requiresGlobalRename(fromObjects, to) {
+ // For a local refactoring, we needn't load more
+ // packages, but if the renaming affects the package's
+ // API, we we must load all packages that depend on the
+ // package defining the object, plus their tests.
+
+ if Verbose {
+ log.Print("Potentially global renaming; scanning workspace...")
+ }
+
+ // Scan the workspace and build the import graph.
+ _, rev, errors := importgraph.Build(ctxt)
+ if len(errors) > 0 {
+ // With a large GOPATH tree, errors are inevitable.
+ // Report them but proceed.
+ fmt.Fprintf(os.Stderr, "While scanning Go workspace:\n")
+ for path, err := range errors {
+ fmt.Fprintf(os.Stderr, "Package %q: %s.\n", path, err)
+ }
+ }
+
+ // Enumerate the set of potentially affected packages.
+ affectedPackages := make(map[string]bool)
+ for _, obj := range fromObjects {
+ // External test packages are never imported,
+ // so they will never appear in the graph.
+ for path := range rev.Search(obj.Pkg().Path()) {
+ affectedPackages[path] = true
+ }
+ }
+
+ // TODO(adonovan): allow the user to specify the scope,
+ // or -ignore patterns? Computing the scope when we
+ // don't (yet) support inputs containing errors can make
+ // the tool rather brittle.
+
+ // Re-load the larger program.
+ iprog, err = loadProgram(ctxt, affectedPackages)
+ if err != nil {
+ return err
+ }
+
+ fromObjects, err = findFromObjects(iprog, spec)
+ if err != nil {
+ return err
+ }
+ }
+
+ // -- Do the renaming -------------------------------------------------
+
+ r := renamer{
+ iprog: iprog,
+ objsToUpdate: make(map[types.Object]bool),
+ from: spec.fromName,
+ to: to,
+ packages: make(map[*types.Package]*loader.PackageInfo),
+ }
+
+ // A renaming initiated at an interface method indicates the
+ // intention to rename abstract and concrete methods as needed
+ // to preserve assignability.
+ for _, obj := range fromObjects {
+ if obj, ok := obj.(*types.Func); ok {
+ recv := obj.Type().(*types.Signature).Recv()
+ if recv != nil && isInterface(recv.Type().Underlying()) {
+ r.changeMethods = true
+ break
+ }
+ }
+ }
+
+ // Only the initially imported packages (iprog.Imported) and
+ // their external tests (iprog.Created) should be inspected or
+ // modified, as only they have type-checked functions bodies.
+ // The rest are just dependencies, needed only for package-level
+ // type information.
+ for _, info := range iprog.Imported {
+ r.packages[info.Pkg] = info
+ }
+ for _, info := range iprog.Created { // (tests)
+ r.packages[info.Pkg] = info
+ }
+
+ for _, from := range fromObjects {
+ r.check(from)
+ }
+ if r.hadConflicts && !Force {
+ return ConflictError
+ }
+ return r.update()
+}
+
+// loadProgram loads the specified set of packages (plus their tests)
+// and all their dependencies, from source, through the specified build
+// context. Only packages in pkgs will have their functions bodies typechecked.
+func loadProgram(ctxt *build.Context, pkgs map[string]bool) (*loader.Program, error) {
+ conf := loader.Config{
+ Build: ctxt,
+ ParserMode: parser.ParseComments,
+
+ // TODO(adonovan): enable this. Requires making a lot of code more robust!
+ AllowErrors: false,
+ }
+ // Optimization: don't type-check the bodies of functions in our
+ // dependencies, since we only need exported package members.
+ conf.TypeCheckFuncBodies = func(p string) bool {
+ return pkgs[p] || pkgs[strings.TrimSuffix(p, "_test")]
+ }
+
+ if Verbose {
+ var list []string
+ for pkg := range pkgs {
+ list = append(list, pkg)
+ }
+ sort.Strings(list)
+ for _, pkg := range list {
+ log.Printf("Loading package: %s", pkg)
+ }
+ }
+
+ for pkg := range pkgs {
+ conf.ImportWithTests(pkg)
+ }
+
+ // Ideally we would just return conf.Load() here, but go/types
+ // reports certain "soft" errors that gc does not (Go issue 14596).
+ // As a workaround, we set AllowErrors=true and then duplicate
+ // the loader's error checking but allow soft errors.
+ // It would be nice if the loader API permitted "AllowErrors: soft".
+ conf.AllowErrors = true
+ prog, err := conf.Load()
+ if err != nil {
+ return nil, err
+ }
+
+ var errpkgs []string
+ // Report hard errors in indirectly imported packages.
+ for _, info := range prog.AllPackages {
+ if containsHardErrors(info.Errors) {
+ errpkgs = append(errpkgs, info.Pkg.Path())
+ }
+ }
+ if errpkgs != nil {
+ var more string
+ if len(errpkgs) > 3 {
+ more = fmt.Sprintf(" and %d more", len(errpkgs)-3)
+ errpkgs = errpkgs[:3]
+ }
+ return nil, fmt.Errorf("couldn't load packages due to errors: %s%s",
+ strings.Join(errpkgs, ", "), more)
+ }
+ return prog, nil
+}
+
+func containsHardErrors(errors []error) bool {
+ for _, err := range errors {
+ if err, ok := err.(types.Error); ok && err.Soft {
+ continue
+ }
+ return true
+ }
+ return false
+}
+
+// requiresGlobalRename reports whether this renaming could potentially
+// affect other packages in the Go workspace.
+func requiresGlobalRename(fromObjects []types.Object, to string) bool {
+ var tfm bool
+ for _, from := range fromObjects {
+ if from.Exported() {
+ return true
+ }
+ switch objectKind(from) {
+ case "type", "field", "method":
+ tfm = true
+ }
+ }
+ if ast.IsExported(to) && tfm {
+ // A global renaming may be necessary even if we're
+ // exporting a previous unexported name, since if it's
+ // the name of a type, field or method, this could
+ // change selections in other packages.
+ // (We include "type" in this list because a type
+ // used as an embedded struct field entails a field
+ // renaming.)
+ return true
+ }
+ return false
+}
+
+// update updates the input files.
+func (r *renamer) update() error {
+ // We use token.File, not filename, since a file may appear to
+ // belong to multiple packages and be parsed more than once.
+ // token.File captures this distinction; filename does not.
+
+ var nidents int
+ var filesToUpdate = make(map[*token.File]bool)
+ docRegexp := regexp.MustCompile(`\b` + r.from + `\b`)
+ for _, info := range r.packages {
+ // Mutate the ASTs and note the filenames.
+ for id, obj := range info.Defs {
+ if r.objsToUpdate[obj] {
+ nidents++
+ id.Name = r.to
+ filesToUpdate[r.iprog.Fset.File(id.Pos())] = true
+ // Perform the rename in doc comments too.
+ if doc := r.docComment(id); doc != nil {
+ for _, comment := range doc.List {
+ comment.Text = docRegexp.ReplaceAllString(comment.Text, r.to)
+ }
+ }
+ }
+ }
+
+ for id, obj := range info.Uses {
+ if r.objsToUpdate[obj] {
+ nidents++
+ id.Name = r.to
+ filesToUpdate[r.iprog.Fset.File(id.Pos())] = true
+ }
+ }
+ }
+
+ // Renaming not supported if cgo files are affected.
+ var generatedFileNames []string
+ for _, info := range r.packages {
+ for _, f := range info.Files {
+ tokenFile := r.iprog.Fset.File(f.Pos())
+ if filesToUpdate[tokenFile] && generated(f, tokenFile) {
+ generatedFileNames = append(generatedFileNames, tokenFile.Name())
+ }
+ }
+ }
+ if !Force && len(generatedFileNames) > 0 {
+ return fmt.Errorf("refusing to modify generated file%s containing DO NOT EDIT marker: %v", plural(len(generatedFileNames)), generatedFileNames)
+ }
+
+ // Write affected files.
+ var nerrs, npkgs int
+ for _, info := range r.packages {
+ first := true
+ for _, f := range info.Files {
+ tokenFile := r.iprog.Fset.File(f.Pos())
+ if filesToUpdate[tokenFile] {
+ if first {
+ npkgs++
+ first = false
+ if Verbose {
+ log.Printf("Updating package %s", info.Pkg.Path())
+ }
+ }
+
+ filename := tokenFile.Name()
+ var buf bytes.Buffer
+ if err := format.Node(&buf, r.iprog.Fset, f); err != nil {
+ log.Printf("failed to pretty-print syntax tree: %v", err)
+ nerrs++
+ continue
+ }
+ if err := writeFile(filename, buf.Bytes()); err != nil {
+ log.Print(err)
+ nerrs++
+ }
+ }
+ }
+ }
+ if !Diff {
+ fmt.Printf("Renamed %d occurrence%s in %d file%s in %d package%s.\n",
+ nidents, plural(nidents),
+ len(filesToUpdate), plural(len(filesToUpdate)),
+ npkgs, plural(npkgs))
+ }
+ if nerrs > 0 {
+ return fmt.Errorf("failed to rewrite %d file%s", nerrs, plural(nerrs))
+ }
+ return nil
+}
+
+// docComment returns the doc for an identifier.
+func (r *renamer) docComment(id *ast.Ident) *ast.CommentGroup {
+ _, nodes, _ := r.iprog.PathEnclosingInterval(id.Pos(), id.End())
+ for _, node := range nodes {
+ switch decl := node.(type) {
+ case *ast.FuncDecl:
+ return decl.Doc
+ case *ast.Field:
+ return decl.Doc
+ case *ast.GenDecl:
+ return decl.Doc
+ // For {Type,Value}Spec, if the doc on the spec is absent,
+ // search for the enclosing GenDecl
+ case *ast.TypeSpec:
+ if decl.Doc != nil {
+ return decl.Doc
+ }
+ case *ast.ValueSpec:
+ if decl.Doc != nil {
+ return decl.Doc
+ }
+ case *ast.Ident:
+ default:
+ return nil
+ }
+ }
+ return nil
+}
+
+func plural(n int) string {
+ if n != 1 {
+ return "s"
+ }
+ return ""
+}
+
+// writeFile is a seam for testing and for the -d flag.
+var writeFile = reallyWriteFile
+
+func reallyWriteFile(filename string, content []byte) error {
+ return ioutil.WriteFile(filename, content, 0644)
+}
+
+func diff(filename string, content []byte) error {
+ renamed := fmt.Sprintf("%s.%d.renamed", filename, os.Getpid())
+ if err := ioutil.WriteFile(renamed, content, 0644); err != nil {
+ return err
+ }
+ defer os.Remove(renamed)
+
+ diff, err := exec.Command(DiffCmd, "-u", filename, renamed).CombinedOutput()
+ if len(diff) > 0 {
+ // diff exits with a non-zero status when the files don't match.
+ // Ignore that failure as long as we get output.
+ stdout.Write(diff)
+ return nil
+ }
+ if err != nil {
+ return fmt.Errorf("computing diff: %v", err)
+ }
+ return nil
+}
projects / dotfiles / .git / blobdiff