refactor/rename/spec.go - tools - Git at Google

 // 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

 // This file contains logic related to specifying a renaming: parsing of
 // the flags as a form of query, and finding the object(s) it denotes.
 // See Usage for flag details.

 import (
 	"bytes"
 	"fmt"
 	"go/ast"
 	"go/build"
 	"go/parser"
 	"go/token"
 	"go/types"
 	"log"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"

 	"golang.org/x/tools/go/buildutil"
 	"golang.org/x/tools/go/loader"
 	"golang.org/x/tools/internal/typesinternal"
 )

 // A spec specifies an entity to rename.
 //
 // It is populated from an -offset flag or -from query;
 // see Usage for the allowed -from query forms.
 type spec struct {
 	// pkg is the package containing the position
 	// specified by the -from or -offset flag.
 	// If filename == "", our search for the 'from' entity
 	// is restricted to this package.
 	pkg string

 	// The original name of the entity being renamed.
 	// If the query had a ::from component, this is that;
 	// otherwise it's the last segment, e.g.
 	//   (encoding/json.Decoder).from
 	//   encoding/json.from
 	fromName string

 	// -- The remaining fields are private to this file.  All are optional. --

 	// The query's ::x suffix, if any.
 	searchFor string

 	// e.g. "Decoder" in "(encoding/json.Decoder).fieldOrMethod"
 	//                or "encoding/json.Decoder
 	pkgMember string

 	// e.g. fieldOrMethod in "(encoding/json.Decoder).fieldOrMethod"
 	typeMember string

 	// Restricts the query to this file.
 	// Implied by -from="file.go::x" and -offset flags.
 	filename string

 	// Byte offset of the 'from' identifier within the file named 'filename'.
 	// -offset mode only.
 	offset int
 }

 // parseFromFlag interprets the "-from" flag value as a renaming specification.
 // See Usage in rename.go for valid formats.
 func parseFromFlag(ctxt *build.Context, fromFlag string) (*spec, error) {
 	var spec spec
 	var main string // sans "::x" suffix
 	switch parts := strings.Split(fromFlag, "::"); len(parts) {
 	case 1:
 		main = parts[0]
 	case 2:
 		main = parts[0]
 		spec.searchFor = parts[1]
 		if parts[1] == "" {
 			// error
 		}
 	default:
 		return nil, fmt.Errorf("-from %q: invalid identifier specification (see -help for formats)", fromFlag)
 	}

 	if strings.HasSuffix(main, ".go") {
 		// main is "filename.go"
 		if spec.searchFor == "" {
 			return nil, fmt.Errorf("-from: filename %q must have a ::name suffix", main)
 		}
 		spec.filename = main
 		if !buildutil.FileExists(ctxt, spec.filename) {
 			return nil, fmt.Errorf("no such file: %s", spec.filename)
 		}

 		bp, err := buildutil.ContainingPackage(ctxt, wd, spec.filename)
 		if err != nil {
 			return nil, err
 		}
 		spec.pkg = bp.ImportPath

 	} else {
 		// main is one of:
 		//  "importpath"
 		//  "importpath".member
 		//  (*"importpath".type).fieldormethod           (parens and star optional)
 		if err := parseObjectSpec(&spec, main); err != nil {
 			return nil, err
 		}
 	}

 	if spec.searchFor != "" {
 		spec.fromName = spec.searchFor
 	}

 	cwd, err := os.Getwd()
 	if err != nil {
 		return nil, err
 	}

 	// Sanitize the package.
 	bp, err := ctxt.Import(spec.pkg, cwd, build.FindOnly)
 	if err != nil {
 		return nil, fmt.Errorf("can't find package %q", spec.pkg)
 	}
 	spec.pkg = bp.ImportPath

 	if !isValidIdentifier(spec.fromName) {
 		return nil, fmt.Errorf("-from: invalid identifier %q", spec.fromName)
 	}

 	if Verbose {
 		log.Printf("-from spec: %+v", spec)
 	}

 	return &spec, nil
 }

 // parseObjectSpec parses main as one of the non-filename forms of
 // object specification.
 func parseObjectSpec(spec *spec, main string) error {
 	// Parse main as a Go expression, albeit a strange one.
 	e, _ := parser.ParseExpr(main)

 	if pkg := parseImportPath(e); pkg != "" {
 		// e.g. bytes or "encoding/json": a package
 		spec.pkg = pkg
 		if spec.searchFor == "" {
 			return fmt.Errorf("-from %q: package import path %q must have a ::name suffix",
 				main, main)
 		}
 		return nil
 	}

 	if e, ok := e.(*ast.SelectorExpr); ok {
 		x := unparen(e.X)

 		// Strip off star constructor, if any.
 		if star, ok := x.(*ast.StarExpr); ok {
 			x = star.X
 		}

 		if pkg := parseImportPath(x); pkg != "" {
 			// package member e.g. "encoding/json".HTMLEscape
 			spec.pkg = pkg              // e.g. "encoding/json"
 			spec.pkgMember = e.Sel.Name // e.g. "HTMLEscape"
 			spec.fromName = e.Sel.Name
 			return nil
 		}

 		if x, ok := x.(*ast.SelectorExpr); ok {
 			// field/method of type e.g. ("encoding/json".Decoder).Decode
 			y := unparen(x.X)
 			if pkg := parseImportPath(y); pkg != "" {
 				spec.pkg = pkg               // e.g. "encoding/json"
 				spec.pkgMember = x.Sel.Name  // e.g. "Decoder"
 				spec.typeMember = e.Sel.Name // e.g. "Decode"
 				spec.fromName = e.Sel.Name
 				return nil
 			}
 		}
 	}

 	return fmt.Errorf("-from %q: invalid expression", main)
 }

 // parseImportPath returns the import path of the package denoted by e.
 // Any import path may be represented as a string literal;
 // single-segment import paths (e.g. "bytes") may also be represented as
 // ast.Ident.  parseImportPath returns "" for all other expressions.
 func parseImportPath(e ast.Expr) string {
 	switch e := e.(type) {
 	case *ast.Ident:
 		return e.Name // e.g. bytes

 	case *ast.BasicLit:
 		if e.Kind == token.STRING {
 			pkgname, _ := strconv.Unquote(e.Value)
 			return pkgname // e.g. "encoding/json"
 		}
 	}
 	return ""
 }

 // parseOffsetFlag interprets the "-offset" flag value as a renaming specification.
 func parseOffsetFlag(ctxt *build.Context, offsetFlag string) (*spec, error) {
 	var spec spec
 	// Validate -offset, e.g. file.go:#123
 	parts := strings.Split(offsetFlag, ":#")
 	if len(parts) != 2 {
 		return nil, fmt.Errorf("-offset %q: invalid offset specification", offsetFlag)
 	}

 	spec.filename = parts[0]
 	if !buildutil.FileExists(ctxt, spec.filename) {
 		return nil, fmt.Errorf("no such file: %s", spec.filename)
 	}

 	bp, err := buildutil.ContainingPackage(ctxt, wd, spec.filename)
 	if err != nil {
 		return nil, err
 	}
 	spec.pkg = bp.ImportPath

 	for _, r := range parts[1] {
 		if !isDigit(r) {
 			return nil, fmt.Errorf("-offset %q: non-numeric offset", offsetFlag)
 		}
 	}
 	spec.offset, err = strconv.Atoi(parts[1])
 	if err != nil {
 		return nil, fmt.Errorf("-offset %q: non-numeric offset", offsetFlag)
 	}

 	// Parse the file and check there's an identifier at that offset.
 	fset := token.NewFileSet()
 	f, err := buildutil.ParseFile(fset, ctxt, nil, wd, spec.filename, parser.ParseComments)
 	if err != nil {
 		return nil, fmt.Errorf("-offset %q: cannot parse file: %s", offsetFlag, err)
 	}

 	id := identAtOffset(fset, f, spec.offset)
 	if id == nil {
 		return nil, fmt.Errorf("-offset %q: no identifier at this position", offsetFlag)
 	}

 	spec.fromName = id.Name

 	return &spec, nil
 }

 var wd = func() string {
 	wd, err := os.Getwd()
 	if err != nil {
 		panic("cannot get working directory: " + err.Error())
 	}
 	return wd
 }()

 // For source trees built with 'go build', the -from or -offset
 // spec identifies exactly one initial 'from' object to rename ,
 // but certain proprietary build systems allow a single file to
 // appear in multiple packages (e.g. the test package contains a
 // copy of its library), so there may be multiple objects for
 // the same source entity.

 func findFromObjects(iprog *loader.Program, spec *spec) ([]types.Object, error) {
 	if spec.filename != "" {
 		return findFromObjectsInFile(iprog, spec)
 	}

 	// Search for objects defined in specified package.

 	// TODO(adonovan): the iprog.ImportMap has an entry {"main": ...}
 	// for main packages, even though that's not an import path.
 	// Seems like a bug.
 	//
 	// pkg := iprog.ImportMap[spec.pkg]
 	// if pkg == nil {
 	// 	return fmt.Errorf("cannot find package %s", spec.pkg) // can't happen?
 	// }
 	// info := iprog.AllPackages[pkg]

 	// Workaround: lookup by value.
 	var info *loader.PackageInfo
 	var pkg *types.Package
 	for pkg, info = range iprog.AllPackages {
 		if pkg.Path() == spec.pkg {
 			break
 		}
 	}
 	if info == nil {
 		return nil, fmt.Errorf("package %q was not loaded", spec.pkg)
 	}

 	objects, err := findObjects(info, spec)
 	if err != nil {
 		return nil, err
 	}
 	if len(objects) > 1 {
 		// ambiguous "*" scope query
 		return nil, ambiguityError(iprog.Fset, objects)
 	}
 	return objects, nil
 }

 func findFromObjectsInFile(iprog *loader.Program, spec *spec) ([]types.Object, error) {
 	var fromObjects []types.Object
 	for _, info := range iprog.AllPackages {
 		// restrict to specified filename
 		// NB: under certain proprietary build systems, a given
 		// filename may appear in multiple packages.
 		for _, f := range info.Files {
 			thisFile := iprog.Fset.File(f.Pos())
 			if !sameFile(thisFile.Name(), spec.filename) {
 				continue
 			}
 			// This package contains the query file.

 			if spec.offset != 0 {
 				// We cannot refactor generated files since position information is invalidated.
 				if generated(f, thisFile) {
 					return nil, fmt.Errorf("cannot rename identifiers in generated file containing DO NOT EDIT marker: %s", thisFile.Name())
 				}

 				// Search for a specific ident by file/offset.
 				id := identAtOffset(iprog.Fset, f, spec.offset)
 				if id == nil {
 					// can't happen?
 					return nil, fmt.Errorf("identifier not found")
 				}
 				obj := info.Uses[id]
 				if obj == nil {
 					obj = info.Defs[id]
 					if obj == nil {
 						// Ident without Object.

 						// Package clause?
 						pos := thisFile.Pos(spec.offset)
 						_, path, _ := iprog.PathEnclosingInterval(pos, pos)
 						if len(path) == 2 { // [Ident File]
 							// TODO(adonovan): support this case.
 							return nil, fmt.Errorf("cannot rename %q: renaming package clauses is not yet supported",
 								path[1].(*ast.File).Name.Name)
 						}

 						// Implicit y in "switch y := x.(type) {"?
 						if obj := typeSwitchVar(&info.Info, path); obj != nil {
 							return []types.Object{obj}, nil
 						}

 						// Probably a type error.
 						return nil, fmt.Errorf("cannot find object for %q", id.Name)
 					}
 				}
 				if obj.Pkg() == nil {
 					return nil, fmt.Errorf("cannot rename predeclared identifiers (%s)", obj)

 				}

 				fromObjects = append(fromObjects, obj)
 			} else {
 				// do a package-wide query
 				objects, err := findObjects(info, spec)
 				if err != nil {
 					return nil, err
 				}

 				// filter results: only objects defined in thisFile
 				var filtered []types.Object
 				for _, obj := range objects {
 					if iprog.Fset.File(obj.Pos()) == thisFile {
 						filtered = append(filtered, obj)
 					}
 				}
 				if len(filtered) == 0 {
 					return nil, fmt.Errorf("no object %q declared in file %s",
 						spec.fromName, spec.filename)
 				} else if len(filtered) > 1 {
 					return nil, ambiguityError(iprog.Fset, filtered)
 				}
 				fromObjects = append(fromObjects, filtered[0])
 			}
 			break
 		}
 	}
 	if len(fromObjects) == 0 {
 		// can't happen?
 		return nil, fmt.Errorf("file %s was not part of the loaded program", spec.filename)
 	}
 	return fromObjects, nil
 }

 func typeSwitchVar(info *types.Info, path []ast.Node) types.Object {
 	if len(path) > 3 {
 		// [Ident AssignStmt TypeSwitchStmt...]
 		if sw, ok := path[2].(*ast.TypeSwitchStmt); ok {
 			// choose the first case.
 			if len(sw.Body.List) > 0 {
 				obj := info.Implicits[sw.Body.List[0].(*ast.CaseClause)]
 				if obj != nil {
 					return obj
 				}
 			}
 		}
 	}
 	return nil
 }

 // On success, findObjects returns the list of objects named
 // spec.fromName matching the spec.  On success, the result has exactly
 // one element unless spec.searchFor!="", in which case it has at least one
 // element.
 func findObjects(info *loader.PackageInfo, spec *spec) ([]types.Object, error) {
 	if spec.pkgMember == "" {
 		if spec.searchFor == "" {
 			panic(spec)
 		}
 		objects := searchDefs(&info.Info, spec.searchFor)
 		if objects == nil {
 			return nil, fmt.Errorf("no object %q declared in package %q",
 				spec.searchFor, info.Pkg.Path())
 		}
 		return objects, nil
 	}

 	pkgMember := info.Pkg.Scope().Lookup(spec.pkgMember)
 	if pkgMember == nil {
 		return nil, fmt.Errorf("package %q has no member %q",
 			info.Pkg.Path(), spec.pkgMember)
 	}

 	var searchFunc *types.Func
 	if spec.typeMember == "" {
 		// package member
 		if spec.searchFor == "" {
 			return []types.Object{pkgMember}, nil
 		}

 		// Search within pkgMember, which must be a function.
 		searchFunc, _ = pkgMember.(*types.Func)
 		if searchFunc == nil {
 			return nil, fmt.Errorf("cannot search for %q within %s %q",
 				spec.searchFor, objectKind(pkgMember), pkgMember)
 		}
 	} else {
 		// field/method of type
 		// e.g. (encoding/json.Decoder).Decode
 		// or ::x within it.

 		tName, _ := pkgMember.(*types.TypeName)
 		if tName == nil {
 			return nil, fmt.Errorf("%s.%s is a %s, not a type",
 				info.Pkg.Path(), pkgMember.Name(), objectKind(pkgMember))
 		}

 		// search within named type.
 		obj, _, _ := types.LookupFieldOrMethod(tName.Type(), true, info.Pkg, spec.typeMember)
 		if obj == nil {
 			return nil, fmt.Errorf("cannot find field or method %q of %s.%s",
 				spec.typeMember, info.Pkg.Path(), tName.Name())
 		}

 		if spec.searchFor == "" {
 			// If it is an embedded field, return the type of the field.
 			if v, ok := obj.(*types.Var); ok && v.Anonymous() {
 				if t, ok := typesinternal.Unpointer(v.Type()).(hasTypeName); ok {
 					return []types.Object{t.Obj()}, nil
 				}
 			}
 			return []types.Object{obj}, nil
 		}

 		searchFunc, _ = obj.(*types.Func)
 		if searchFunc == nil {
 			return nil, fmt.Errorf("cannot search for local name %q within %s (%s.%s).%s; need a function",
 				spec.searchFor, objectKind(obj), info.Pkg.Path(), tName.Name(),
 				obj.Name())
 		}
 		if types.IsInterface(tName.Type()) {
 			return nil, fmt.Errorf("cannot search for local name %q within abstract method (%s.%s).%s",
 				spec.searchFor, info.Pkg.Path(), tName.Name(), searchFunc.Name())
 		}
 	}

 	// -- search within function or method --

 	decl := funcDecl(info, searchFunc)
 	if decl == nil {
 		return nil, fmt.Errorf("cannot find syntax for %s", searchFunc) // can't happen?
 	}

 	var objects []types.Object
 	for _, obj := range searchDefs(&info.Info, spec.searchFor) {
 		// We use positions, not scopes, to determine whether
 		// the obj is within searchFunc.  This is clumsy, but the
 		// alternative, using the types.Scope tree, doesn't
 		// account for non-lexical objects like fields and
 		// interface methods.
 		if decl.Pos() <= obj.Pos() && obj.Pos() < decl.End() && obj != searchFunc {
 			objects = append(objects, obj)
 		}
 	}
 	if objects == nil {
 		return nil, fmt.Errorf("no local definition of %q within %s",
 			spec.searchFor, searchFunc)
 	}
 	return objects, nil
 }

 func funcDecl(info *loader.PackageInfo, fn *types.Func) *ast.FuncDecl {
 	for _, f := range info.Files {
 		for _, d := range f.Decls {
 			if d, ok := d.(*ast.FuncDecl); ok && info.Defs[d.Name] == fn {
 				return d
 			}
 		}
 	}
 	return nil
 }

 func searchDefs(info *types.Info, name string) []types.Object {
 	var objects []types.Object
 	for id, obj := range info.Defs {
 		if obj == nil {
 			// e.g. blank ident.
 			// TODO(adonovan): but also implicit y in
 			//    switch y := x.(type)
 			// Needs some thought.
 			continue
 		}
 		if id.Name == name {
 			objects = append(objects, obj)
 		}
 	}
 	return objects
 }

 func identAtOffset(fset *token.FileSet, f *ast.File, offset int) *ast.Ident {
 	var found *ast.Ident
 	ast.Inspect(f, func(n ast.Node) bool {
 		if id, ok := n.(*ast.Ident); ok {
 			idpos := fset.Position(id.Pos()).Offset
 			if idpos <= offset && offset < idpos+len(id.Name) {
 				found = id
 			}
 		}
 		return found == nil // keep traversing only until found
 	})
 	return found
 }

 // ambiguityError returns an error describing an ambiguous "*" scope query.
 func ambiguityError(fset *token.FileSet, objects []types.Object) error {
 	var buf bytes.Buffer
 	for i, obj := range objects {
 		if i > 0 {
 			buf.WriteString(", ")
 		}
 		posn := fset.Position(obj.Pos())
 		fmt.Fprintf(&buf, "%s at %s:%d:%d",
 			objectKind(obj), filepath.Base(posn.Filename), posn.Line, posn.Column)
 	}
 	return fmt.Errorf("ambiguous specifier %s matches %s",
 		objects[0].Name(), buf.String())
 }

 // Matches cgo generated comment as well as the proposed standard:
 //
 //	https://golang.org/s/generatedcode
 var generatedRx = regexp.MustCompile(`// .*DO NOT EDIT\.?`)

 // generated reports whether ast.File is a generated file.
 func generated(f *ast.File, tokenFile *token.File) bool {

 	// Iterate over the comments in the file
 	for _, commentGroup := range f.Comments {
 		for _, comment := range commentGroup.List {
 			if matched := generatedRx.MatchString(comment.Text); matched {
 				// Check if comment is at the beginning of the line in source
 				if pos := tokenFile.Position(comment.Slash); pos.Column == 1 {
 					return true
 				}
 			}
 		}
 	}
 	return false
 }
	// 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

	// This file contains logic related to specifying a renaming: parsing of
	// the flags as a form of query, and finding the object(s) it denotes.
	// See Usage for flag details.

	import (
	"bytes"
	"fmt"
	"go/ast"
	"go/build"
	"go/parser"
	"go/token"
	"go/types"
	"log"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"

	"golang.org/x/tools/go/buildutil"
	"golang.org/x/tools/go/loader"
	"golang.org/x/tools/internal/typesinternal"
	)

	// A spec specifies an entity to rename.
	//
	// It is populated from an -offset flag or -from query;
	// see Usage for the allowed -from query forms.
	type spec struct {
	// pkg is the package containing the position
	// specified by the -from or -offset flag.
	// If filename == "", our search for the 'from' entity
	// is restricted to this package.
	pkg string

	// The original name of the entity being renamed.
	// If the query had a ::from component, this is that;
	// otherwise it's the last segment, e.g.
	// (encoding/json.Decoder).from
	// encoding/json.from
	fromName string

	// -- The remaining fields are private to this file. All are optional. --

	// The query's ::x suffix, if any.
	searchFor string

	// e.g. "Decoder" in "(encoding/json.Decoder).fieldOrMethod"
	// or "encoding/json.Decoder
	pkgMember string

	// e.g. fieldOrMethod in "(encoding/json.Decoder).fieldOrMethod"
	typeMember string

	// Restricts the query to this file.
	// Implied by -from="file.go::x" and -offset flags.
	filename string

	// Byte offset of the 'from' identifier within the file named 'filename'.
	// -offset mode only.
	offset int
	}

	// parseFromFlag interprets the "-from" flag value as a renaming specification.
	// See Usage in rename.go for valid formats.
	func parseFromFlag(ctxt build.Context, fromFlag string) (spec, error) {
	var spec spec
	var main string // sans "::x" suffix
	switch parts := strings.Split(fromFlag, "::"); len(parts) {
	case 1:
	main = parts[0]
	case 2:
	main = parts[0]
	spec.searchFor = parts[1]
	if parts[1] == "" {
	// error
	}
	default:
	return nil, fmt.Errorf("-from %q: invalid identifier specification (see -help for formats)", fromFlag)
	}

	if strings.HasSuffix(main, ".go") {
	// main is "filename.go"
	if spec.searchFor == "" {
	return nil, fmt.Errorf("-from: filename %q must have a ::name suffix", main)
	}
	spec.filename = main
	if !buildutil.FileExists(ctxt, spec.filename) {
	return nil, fmt.Errorf("no such file: %s", spec.filename)
	}

	bp, err := buildutil.ContainingPackage(ctxt, wd, spec.filename)
	if err != nil {
	return nil, err
	}
	spec.pkg = bp.ImportPath

	} else {
	// main is one of:
	// "importpath"
	// "importpath".member
	// (*"importpath".type).fieldormethod (parens and star optional)
	if err := parseObjectSpec(&spec, main); err != nil {
	return nil, err
	}
	}

	if spec.searchFor != "" {
	spec.fromName = spec.searchFor
	}

	cwd, err := os.Getwd()
	if err != nil {
	return nil, err
	}

	// Sanitize the package.
	bp, err := ctxt.Import(spec.pkg, cwd, build.FindOnly)
	if err != nil {
	return nil, fmt.Errorf("can't find package %q", spec.pkg)
	}
	spec.pkg = bp.ImportPath

	if !isValidIdentifier(spec.fromName) {
	return nil, fmt.Errorf("-from: invalid identifier %q", spec.fromName)
	}

	if Verbose {
	log.Printf("-from spec: %+v", spec)
	}

	return &spec, nil
	}

	// parseObjectSpec parses main as one of the non-filename forms of
	// object specification.
	func parseObjectSpec(spec *spec, main string) error {
	// Parse main as a Go expression, albeit a strange one.
	e, _ := parser.ParseExpr(main)

	if pkg := parseImportPath(e); pkg != "" {
	// e.g. bytes or "encoding/json": a package
	spec.pkg = pkg
	if spec.searchFor == "" {
	return fmt.Errorf("-from %q: package import path %q must have a ::name suffix",
	main, main)
	}
	return nil
	}

	if e, ok := e.(*ast.SelectorExpr); ok {
	x := unparen(e.X)

	// Strip off star constructor, if any.
	if star, ok := x.(*ast.StarExpr); ok {
	x = star.X
	}

	if pkg := parseImportPath(x); pkg != "" {
	// package member e.g. "encoding/json".HTMLEscape
	spec.pkg = pkg // e.g. "encoding/json"
	spec.pkgMember = e.Sel.Name // e.g. "HTMLEscape"
	spec.fromName = e.Sel.Name
	return nil
	}

	if x, ok := x.(*ast.SelectorExpr); ok {
	// field/method of type e.g. ("encoding/json".Decoder).Decode
	y := unparen(x.X)
	if pkg := parseImportPath(y); pkg != "" {
	spec.pkg = pkg // e.g. "encoding/json"
	spec.pkgMember = x.Sel.Name // e.g. "Decoder"
	spec.typeMember = e.Sel.Name // e.g. "Decode"
	spec.fromName = e.Sel.Name
	return nil
	}
	}
	}

	return fmt.Errorf("-from %q: invalid expression", main)
	}

	// parseImportPath returns the import path of the package denoted by e.
	// Any import path may be represented as a string literal;
	// single-segment import paths (e.g. "bytes") may also be represented as
	// ast.Ident. parseImportPath returns "" for all other expressions.
	func parseImportPath(e ast.Expr) string {
	switch e := e.(type) {
	case *ast.Ident:
	return e.Name // e.g. bytes

	case *ast.BasicLit:
	if e.Kind == token.STRING {
	pkgname, _ := strconv.Unquote(e.Value)
	return pkgname // e.g. "encoding/json"
	}
	}
	return ""
	}

	// parseOffsetFlag interprets the "-offset" flag value as a renaming specification.
	func parseOffsetFlag(ctxt build.Context, offsetFlag string) (spec, error) {
	var spec spec
	// Validate -offset, e.g. file.go:#123
	parts := strings.Split(offsetFlag, ":#")
	if len(parts) != 2 {
	return nil, fmt.Errorf("-offset %q: invalid offset specification", offsetFlag)
	}

	spec.filename = parts[0]
	if !buildutil.FileExists(ctxt, spec.filename) {
	return nil, fmt.Errorf("no such file: %s", spec.filename)
	}

	bp, err := buildutil.ContainingPackage(ctxt, wd, spec.filename)
	if err != nil {
	return nil, err
	}
	spec.pkg = bp.ImportPath

	for _, r := range parts[1] {
	if !isDigit(r) {
	return nil, fmt.Errorf("-offset %q: non-numeric offset", offsetFlag)
	}
	}
	spec.offset, err = strconv.Atoi(parts[1])
	if err != nil {
	return nil, fmt.Errorf("-offset %q: non-numeric offset", offsetFlag)
	}

	// Parse the file and check there's an identifier at that offset.
	fset := token.NewFileSet()
	f, err := buildutil.ParseFile(fset, ctxt, nil, wd, spec.filename, parser.ParseComments)
	if err != nil {
	return nil, fmt.Errorf("-offset %q: cannot parse file: %s", offsetFlag, err)
	}

	id := identAtOffset(fset, f, spec.offset)
	if id == nil {
	return nil, fmt.Errorf("-offset %q: no identifier at this position", offsetFlag)
	}

	spec.fromName = id.Name

	return &spec, nil
	}

	var wd = func() string {
	wd, err := os.Getwd()
	if err != nil {
	panic("cannot get working directory: " + err.Error())
	}
	return wd
	}()

	// For source trees built with 'go build', the -from or -offset
	// spec identifies exactly one initial 'from' object to rename ,
	// but certain proprietary build systems allow a single file to
	// appear in multiple packages (e.g. the test package contains a
	// copy of its library), so there may be multiple objects for
	// the same source entity.

	func findFromObjects(iprog loader.Program, spec spec) ([]types.Object, error) {
	if spec.filename != "" {
	return findFromObjectsInFile(iprog, spec)
	}

	// Search for objects defined in specified package.

	// TODO(adonovan): the iprog.ImportMap has an entry {"main": ...}
	// for main packages, even though that's not an import path.
	// Seems like a bug.
	//
	// pkg := iprog.ImportMap[spec.pkg]
	// if pkg == nil {
	// return fmt.Errorf("cannot find package %s", spec.pkg) // can't happen?
	// }
	// info := iprog.AllPackages[pkg]

	// Workaround: lookup by value.
	var info *loader.PackageInfo
	var pkg *types.Package
	for pkg, info = range iprog.AllPackages {
	if pkg.Path() == spec.pkg {
	break
	}
	}
	if info == nil {
	return nil, fmt.Errorf("package %q was not loaded", spec.pkg)
	}

	objects, err := findObjects(info, spec)
	if err != nil {
	return nil, err
	}
	if len(objects) > 1 {
	// ambiguous "*" scope query
	return nil, ambiguityError(iprog.Fset, objects)
	}
	return objects, nil
	}

	func findFromObjectsInFile(iprog loader.Program, spec spec) ([]types.Object, error) {
	var fromObjects []types.Object
	for _, info := range iprog.AllPackages {
	// restrict to specified filename
	// NB: under certain proprietary build systems, a given
	// filename may appear in multiple packages.
	for _, f := range info.Files {
	thisFile := iprog.Fset.File(f.Pos())
	if !sameFile(thisFile.Name(), spec.filename) {
	continue
	}
	// This package contains the query file.

	if spec.offset != 0 {
	// We cannot refactor generated files since position information is invalidated.
	if generated(f, thisFile) {
	return nil, fmt.Errorf("cannot rename identifiers in generated file containing DO NOT EDIT marker: %s", thisFile.Name())
	}

	// Search for a specific ident by file/offset.
	id := identAtOffset(iprog.Fset, f, spec.offset)
	if id == nil {
	// can't happen?
	return nil, fmt.Errorf("identifier not found")
	}
	obj := info.Uses[id]
	if obj == nil {
	obj = info.Defs[id]
	if obj == nil {
	// Ident without Object.

	// Package clause?
	pos := thisFile.Pos(spec.offset)
	_, path, _ := iprog.PathEnclosingInterval(pos, pos)
	if len(path) == 2 { // [Ident File]
	// TODO(adonovan): support this case.
	return nil, fmt.Errorf("cannot rename %q: renaming package clauses is not yet supported",
	path[1].(*ast.File).Name.Name)
	}

	// Implicit y in "switch y := x.(type) {"?
	if obj := typeSwitchVar(&info.Info, path); obj != nil {
	return []types.Object{obj}, nil
	}

	// Probably a type error.
	return nil, fmt.Errorf("cannot find object for %q", id.Name)
	}
	}
	if obj.Pkg() == nil {
	return nil, fmt.Errorf("cannot rename predeclared identifiers (%s)", obj)

	}

	fromObjects = append(fromObjects, obj)
	} else {
	// do a package-wide query
	objects, err := findObjects(info, spec)
	if err != nil {
	return nil, err
	}

	// filter results: only objects defined in thisFile
	var filtered []types.Object
	for _, obj := range objects {
	if iprog.Fset.File(obj.Pos()) == thisFile {
	filtered = append(filtered, obj)
	}
	}
	if len(filtered) == 0 {
	return nil, fmt.Errorf("no object %q declared in file %s",
	spec.fromName, spec.filename)
	} else if len(filtered) > 1 {
	return nil, ambiguityError(iprog.Fset, filtered)
	}
	fromObjects = append(fromObjects, filtered[0])
	}
	break
	}
	}
	if len(fromObjects) == 0 {
	// can't happen?
	return nil, fmt.Errorf("file %s was not part of the loaded program", spec.filename)
	}
	return fromObjects, nil
	}

	func typeSwitchVar(info *types.Info, path []ast.Node) types.Object {
	if len(path) > 3 {
	// [Ident AssignStmt TypeSwitchStmt...]
	if sw, ok := path[2].(*ast.TypeSwitchStmt); ok {
	// choose the first case.
	if len(sw.Body.List) > 0 {
	obj := info.Implicits[sw.Body.List[0].(*ast.CaseClause)]
	if obj != nil {
	return obj
	}
	}
	}
	}
	return nil
	}

	// On success, findObjects returns the list of objects named
	// spec.fromName matching the spec. On success, the result has exactly
	// one element unless spec.searchFor!="", in which case it has at least one
	// element.
	func findObjects(info loader.PackageInfo, spec spec) ([]types.Object, error) {
	if spec.pkgMember == "" {
	if spec.searchFor == "" {
	panic(spec)
	}
	objects := searchDefs(&info.Info, spec.searchFor)
	if objects == nil {
	return nil, fmt.Errorf("no object %q declared in package %q",
	spec.searchFor, info.Pkg.Path())
	}
	return objects, nil
	}

	pkgMember := info.Pkg.Scope().Lookup(spec.pkgMember)
	if pkgMember == nil {
	return nil, fmt.Errorf("package %q has no member %q",
	info.Pkg.Path(), spec.pkgMember)
	}

	var searchFunc *types.Func
	if spec.typeMember == "" {
	// package member
	if spec.searchFor == "" {
	return []types.Object{pkgMember}, nil
	}

	// Search within pkgMember, which must be a function.
	searchFunc, _ = pkgMember.(*types.Func)
	if searchFunc == nil {
	return nil, fmt.Errorf("cannot search for %q within %s %q",
	spec.searchFor, objectKind(pkgMember), pkgMember)
	}
	} else {
	// field/method of type
	// e.g. (encoding/json.Decoder).Decode
	// or ::x within it.

	tName, _ := pkgMember.(*types.TypeName)
	if tName == nil {
	return nil, fmt.Errorf("%s.%s is a %s, not a type",
	info.Pkg.Path(), pkgMember.Name(), objectKind(pkgMember))
	}

	// search within named type.
	obj, _, _ := types.LookupFieldOrMethod(tName.Type(), true, info.Pkg, spec.typeMember)
	if obj == nil {
	return nil, fmt.Errorf("cannot find field or method %q of %s.%s",
	spec.typeMember, info.Pkg.Path(), tName.Name())
	}

	if spec.searchFor == "" {
	// If it is an embedded field, return the type of the field.
	if v, ok := obj.(*types.Var); ok && v.Anonymous() {
	if t, ok := typesinternal.Unpointer(v.Type()).(hasTypeName); ok {
	return []types.Object{t.Obj()}, nil
	}
	}
	return []types.Object{obj}, nil
	}

	searchFunc, _ = obj.(*types.Func)
	if searchFunc == nil {
	return nil, fmt.Errorf("cannot search for local name %q within %s (%s.%s).%s; need a function",
	spec.searchFor, objectKind(obj), info.Pkg.Path(), tName.Name(),
	obj.Name())
	}
	if types.IsInterface(tName.Type()) {
	return nil, fmt.Errorf("cannot search for local name %q within abstract method (%s.%s).%s",
	spec.searchFor, info.Pkg.Path(), tName.Name(), searchFunc.Name())
	}
	}

	// -- search within function or method --

	decl := funcDecl(info, searchFunc)
	if decl == nil {
	return nil, fmt.Errorf("cannot find syntax for %s", searchFunc) // can't happen?
	}

	var objects []types.Object
	for _, obj := range searchDefs(&info.Info, spec.searchFor) {
	// We use positions, not scopes, to determine whether
	// the obj is within searchFunc. This is clumsy, but the
	// alternative, using the types.Scope tree, doesn't
	// account for non-lexical objects like fields and
	// interface methods.
	if decl.Pos() <= obj.Pos() && obj.Pos() < decl.End() && obj != searchFunc {
	objects = append(objects, obj)
	}
	}
	if objects == nil {
	return nil, fmt.Errorf("no local definition of %q within %s",
	spec.searchFor, searchFunc)
	}
	return objects, nil
	}

	func funcDecl(info loader.PackageInfo, fn types.Func) *ast.FuncDecl {
	for _, f := range info.Files {
	for _, d := range f.Decls {
	if d, ok := d.(*ast.FuncDecl); ok && info.Defs[d.Name] == fn {
	return d
	}
	}
	}
	return nil
	}

	func searchDefs(info *types.Info, name string) []types.Object {
	var objects []types.Object
	for id, obj := range info.Defs {
	if obj == nil {
	// e.g. blank ident.
	// TODO(adonovan): but also implicit y in
	// switch y := x.(type)
	// Needs some thought.
	continue
	}
	if id.Name == name {
	objects = append(objects, obj)
	}
	}
	return objects
	}

	func identAtOffset(fset token.FileSet, f ast.File, offset int) *ast.Ident {
	var found *ast.Ident
	ast.Inspect(f, func(n ast.Node) bool {
	if id, ok := n.(*ast.Ident); ok {
	idpos := fset.Position(id.Pos()).Offset
	if idpos <= offset && offset < idpos+len(id.Name) {
	found = id
	}
	}
	return found == nil // keep traversing only until found
	})
	return found
	}

	// ambiguityError returns an error describing an ambiguous "*" scope query.
	func ambiguityError(fset *token.FileSet, objects []types.Object) error {
	var buf bytes.Buffer
	for i, obj := range objects {
	if i > 0 {
	buf.WriteString(", ")
	}
	posn := fset.Position(obj.Pos())
	fmt.Fprintf(&buf, "%s at %s:%d:%d",
	objectKind(obj), filepath.Base(posn.Filename), posn.Line, posn.Column)
	}
	return fmt.Errorf("ambiguous specifier %s matches %s",
	objects[0].Name(), buf.String())
	}

	// Matches cgo generated comment as well as the proposed standard:
	//
	// https://golang.org/s/generatedcode
	var generatedRx = regexp.MustCompile(`// .*DO NOT EDIT\.?`)

	// generated reports whether ast.File is a generated file.
	func generated(f ast.File, tokenFile token.File) bool {

	// Iterate over the comments in the file
	for _, commentGroup := range f.Comments {
	for _, comment := range commentGroup.List {
	if matched := generatedRx.MatchString(comment.Text); matched {
	// Check if comment is at the beginning of the line in source
	if pos := tokenFile.Position(comment.Slash); pos.Column == 1 {
	return true
	}
	}
	}
	}
	return false
	}