| // Copyright 2019 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 source |
| |
| import ( |
| "bytes" |
| "context" |
| "errors" |
| "fmt" |
| "go/ast" |
| "go/format" |
| "go/token" |
| "go/types" |
| "regexp" |
| "strings" |
| |
| "golang.org/x/tools/go/types/typeutil" |
| "golang.org/x/tools/internal/event" |
| "golang.org/x/tools/internal/lsp/diff" |
| "golang.org/x/tools/internal/lsp/protocol" |
| "golang.org/x/tools/internal/span" |
| "golang.org/x/tools/refactor/satisfy" |
| ) |
| |
| type renamer struct { |
| ctx context.Context |
| fset *token.FileSet |
| refs []*ReferenceInfo |
| objsToUpdate map[types.Object]bool |
| hadConflicts bool |
| errors string |
| from, to string |
| satisfyConstraints map[satisfy.Constraint]bool |
| packages map[*types.Package]Package // may include additional packages that are a dep of pkg |
| msets typeutil.MethodSetCache |
| changeMethods bool |
| } |
| |
| type PrepareItem struct { |
| Range protocol.Range |
| Text string |
| } |
| |
| // PrepareRename searches for a valid renaming at position pp. |
| // |
| // The returned usererr is intended to be displayed to the user to explain why |
| // the prepare fails. Probably we could eliminate the redundancy in returning |
| // two errors, but for now this is done defensively. |
| func PrepareRename(ctx context.Context, snapshot Snapshot, f FileHandle, pp protocol.Position) (_ *PrepareItem, usererr, err error) { |
| fileRenameSupported := false |
| for _, op := range snapshot.View().Options().SupportedResourceOperations { |
| if op == protocol.Rename { |
| fileRenameSupported = true |
| break |
| } |
| } |
| |
| // Find position of the package name declaration |
| pgf, err := snapshot.ParseGo(ctx, f, ParseFull) |
| if err != nil { |
| return nil, err, err |
| } |
| inPackageName, err := isInPackageName(ctx, snapshot, f, pgf, pp) |
| if err != nil { |
| return nil, err, err |
| } |
| |
| if inPackageName && !fileRenameSupported { |
| err := errors.New("can't rename packages: LSP client does not support file renaming") |
| return nil, err, err |
| } |
| |
| ctx, done := event.Start(ctx, "source.PrepareRename") |
| defer done() |
| |
| qos, err := qualifiedObjsAtProtocolPos(ctx, snapshot, f.URI(), pp) |
| if err != nil { |
| return nil, nil, err |
| } |
| node, obj, pkg := qos[0].node, qos[0].obj, qos[0].sourcePkg |
| if err := checkRenamable(obj); err != nil { |
| return nil, err, err |
| } |
| mr, err := posToMappedRange(snapshot, pkg, node.Pos(), node.End()) |
| if err != nil { |
| return nil, nil, err |
| } |
| rng, err := mr.Range() |
| if err != nil { |
| return nil, nil, err |
| } |
| if _, isImport := node.(*ast.ImportSpec); isImport { |
| // We're not really renaming the import path. |
| rng.End = rng.Start |
| } |
| return &PrepareItem{ |
| Range: rng, |
| Text: obj.Name(), |
| }, nil, nil |
| } |
| |
| // checkRenamable verifies if an obj may be renamed. |
| func checkRenamable(obj types.Object) error { |
| if v, ok := obj.(*types.Var); ok && v.Embedded() { |
| return errors.New("can't rename embedded fields: rename the type directly or name the field") |
| } |
| if obj.Name() == "_" { |
| return errors.New("can't rename \"_\"") |
| } |
| return nil |
| } |
| |
| // Rename returns a map of TextEdits for each file modified when renaming a |
| // given identifier within a package. |
| func Rename(ctx context.Context, s Snapshot, f FileHandle, pp protocol.Position, newName string) (map[span.URI][]protocol.TextEdit, error) { |
| ctx, done := event.Start(ctx, "source.Rename") |
| defer done() |
| |
| pgf, err := s.ParseGo(ctx, f, ParseFull) |
| if err != nil { |
| return nil, err |
| } |
| inPackageName, err := isInPackageName(ctx, s, f, pgf, pp) |
| if err != nil { |
| return nil, err |
| } |
| |
| if inPackageName { |
| renamingPkg, err := s.PackageForFile(ctx, f.URI(), TypecheckAll, NarrowestPackage) |
| if err != nil { |
| return nil, err |
| } |
| |
| result := make(map[span.URI][]protocol.TextEdit) |
| // Rename internal references to the package in the renaming package |
| // Todo(dle): need more investigation on case when pkg.GoFiles != pkg.CompiledGoFiles if using cgo. |
| for _, f := range renamingPkg.CompiledGoFiles() { |
| pkgNameMappedRange := NewMappedRange(f.Tok, f.Mapper, f.File.Name.Pos(), f.File.Name.End()) |
| rng, err := pkgNameMappedRange.Range() |
| if err != nil { |
| return nil, err |
| } |
| result[f.URI] = []protocol.TextEdit{ |
| { |
| Range: rng, |
| NewText: newName, |
| }, |
| } |
| } |
| |
| return result, nil |
| } |
| |
| qos, err := qualifiedObjsAtProtocolPos(ctx, s, f.URI(), pp) |
| if err != nil { |
| return nil, err |
| } |
| |
| obj, pkg := qos[0].obj, qos[0].pkg |
| |
| if err := checkRenamable(obj); err != nil { |
| return nil, err |
| } |
| if obj.Name() == newName { |
| return nil, fmt.Errorf("old and new names are the same: %s", newName) |
| } |
| if !isValidIdentifier(newName) { |
| return nil, fmt.Errorf("invalid identifier to rename: %q", newName) |
| } |
| if pkg == nil || pkg.IsIllTyped() { |
| return nil, fmt.Errorf("package for %s is ill typed", f.URI()) |
| } |
| refs, err := references(ctx, s, qos, true, false, true) |
| if err != nil { |
| return nil, err |
| } |
| r := renamer{ |
| ctx: ctx, |
| fset: s.FileSet(), |
| refs: refs, |
| objsToUpdate: make(map[types.Object]bool), |
| from: obj.Name(), |
| to: newName, |
| packages: make(map[*types.Package]Package), |
| } |
| |
| // A renaming initiated at an interface method indicates the |
| // intention to rename abstract and concrete methods as needed |
| // to preserve assignability. |
| for _, ref := range refs { |
| if obj, ok := ref.obj.(*types.Func); ok { |
| recv := obj.Type().(*types.Signature).Recv() |
| if recv != nil && IsInterface(recv.Type().Underlying()) { |
| r.changeMethods = true |
| break |
| } |
| } |
| } |
| for _, from := range refs { |
| r.packages[from.pkg.GetTypes()] = from.pkg |
| } |
| |
| // Check that the renaming of the identifier is ok. |
| for _, ref := range refs { |
| r.check(ref.obj) |
| if r.hadConflicts { // one error is enough. |
| break |
| } |
| } |
| if r.hadConflicts { |
| return nil, fmt.Errorf(r.errors) |
| } |
| |
| changes, err := r.update() |
| if err != nil { |
| return nil, err |
| } |
| |
| result := make(map[span.URI][]protocol.TextEdit) |
| for uri, edits := range changes { |
| // These edits should really be associated with FileHandles for maximal correctness. |
| // For now, this is good enough. |
| fh, err := s.GetFile(ctx, uri) |
| if err != nil { |
| return nil, err |
| } |
| data, err := fh.Read() |
| if err != nil { |
| return nil, err |
| } |
| m := protocol.NewColumnMapper(uri, data) |
| // Sort the edits first. |
| diff.SortTextEdits(edits) |
| protocolEdits, err := ToProtocolEdits(m, edits) |
| if err != nil { |
| return nil, err |
| } |
| result[uri] = protocolEdits |
| } |
| return result, nil |
| } |
| |
| // Rename all references to the identifier. |
| func (r *renamer) update() (map[span.URI][]diff.TextEdit, error) { |
| result := make(map[span.URI][]diff.TextEdit) |
| seen := make(map[span.Span]bool) |
| |
| docRegexp, err := regexp.Compile(`\b` + r.from + `\b`) |
| if err != nil { |
| return nil, err |
| } |
| for _, ref := range r.refs { |
| refSpan, err := ref.Span() |
| if err != nil { |
| return nil, err |
| } |
| if seen[refSpan] { |
| continue |
| } |
| seen[refSpan] = true |
| |
| // Renaming a types.PkgName may result in the addition or removal of an identifier, |
| // so we deal with this separately. |
| if pkgName, ok := ref.obj.(*types.PkgName); ok && ref.isDeclaration { |
| edit, err := r.updatePkgName(pkgName) |
| if err != nil { |
| return nil, err |
| } |
| result[refSpan.URI()] = append(result[refSpan.URI()], *edit) |
| continue |
| } |
| |
| // Replace the identifier with r.to. |
| edit := diff.TextEdit{ |
| Span: refSpan, |
| NewText: r.to, |
| } |
| |
| result[refSpan.URI()] = append(result[refSpan.URI()], edit) |
| |
| if !ref.isDeclaration || ref.ident == nil { // uses do not have doc comments to update. |
| continue |
| } |
| |
| doc := r.docComment(ref.pkg, ref.ident) |
| if doc == nil { |
| continue |
| } |
| |
| // Perform the rename in doc comments declared in the original package. |
| // go/parser strips out \r\n returns from the comment text, so go |
| // line-by-line through the comment text to get the correct positions. |
| for _, comment := range doc.List { |
| if isDirective(comment.Text) { |
| continue |
| } |
| lines := strings.Split(comment.Text, "\n") |
| tokFile := r.fset.File(comment.Pos()) |
| commentLine := tokFile.Line(comment.Pos()) |
| for i, line := range lines { |
| lineStart := comment.Pos() |
| if i > 0 { |
| lineStart = tokFile.LineStart(commentLine + i) |
| } |
| for _, locs := range docRegexp.FindAllIndex([]byte(line), -1) { |
| rng := span.NewRange(tokFile, lineStart+token.Pos(locs[0]), lineStart+token.Pos(locs[1])) |
| spn, err := rng.Span() |
| if err != nil { |
| return nil, err |
| } |
| result[spn.URI()] = append(result[spn.URI()], diff.TextEdit{ |
| Span: spn, |
| NewText: r.to, |
| }) |
| } |
| } |
| } |
| } |
| |
| return result, nil |
| } |
| |
| // docComment returns the doc for an identifier. |
| func (r *renamer) docComment(pkg Package, id *ast.Ident) *ast.CommentGroup { |
| _, tokFile, nodes, _ := pathEnclosingInterval(r.fset, pkg, 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: |
| case *ast.AssignStmt: |
| // *ast.AssignStmt doesn't have an associated comment group. |
| // So, we try to find a comment just before the identifier. |
| |
| // Try to find a comment group only for short variable declarations (:=). |
| if decl.Tok != token.DEFINE { |
| return nil |
| } |
| |
| identLine := tokFile.Line(id.Pos()) |
| for _, comment := range nodes[len(nodes)-1].(*ast.File).Comments { |
| if comment.Pos() > id.Pos() { |
| // Comment is after the identifier. |
| continue |
| } |
| |
| lastCommentLine := tokFile.Line(comment.End()) |
| if lastCommentLine+1 == identLine { |
| return comment |
| } |
| } |
| default: |
| return nil |
| } |
| } |
| return nil |
| } |
| |
| // updatePkgName returns the updates to rename a pkgName in the import spec |
| func (r *renamer) updatePkgName(pkgName *types.PkgName) (*diff.TextEdit, error) { |
| // Modify ImportSpec syntax to add or remove the Name as needed. |
| pkg := r.packages[pkgName.Pkg()] |
| _, tokFile, path, _ := pathEnclosingInterval(r.fset, pkg, pkgName.Pos(), pkgName.Pos()) |
| if len(path) < 2 { |
| return nil, fmt.Errorf("no path enclosing interval for %s", pkgName.Name()) |
| } |
| spec, ok := path[1].(*ast.ImportSpec) |
| if !ok { |
| return nil, fmt.Errorf("failed to update PkgName for %s", pkgName.Name()) |
| } |
| |
| var astIdent *ast.Ident // will be nil if ident is removed |
| if pkgName.Imported().Name() != r.to { |
| // ImportSpec.Name needed |
| astIdent = &ast.Ident{NamePos: spec.Path.Pos(), Name: r.to} |
| } |
| |
| // Make a copy of the ident that just has the name and path. |
| updated := &ast.ImportSpec{ |
| Name: astIdent, |
| Path: spec.Path, |
| EndPos: spec.EndPos, |
| } |
| |
| rng := span.NewRange(tokFile, spec.Pos(), spec.End()) |
| spn, err := rng.Span() |
| if err != nil { |
| return nil, err |
| } |
| |
| var buf bytes.Buffer |
| format.Node(&buf, r.fset, updated) |
| newText := buf.String() |
| |
| return &diff.TextEdit{ |
| Span: spn, |
| NewText: newText, |
| }, nil |
| } |