blob: ae26738a5c303e8ccb6248d1d78d92ea6c4cfd71 [file] [log] [blame]
// Copyright 2024 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 golang
// This file defines the code action "Extract declarations to new file".
import (
"bytes"
"context"
"errors"
"fmt"
"go/ast"
"go/format"
"go/token"
"go/types"
"os"
"path/filepath"
"strings"
"golang.org/x/tools/gopls/internal/cache"
"golang.org/x/tools/gopls/internal/cache/parsego"
"golang.org/x/tools/gopls/internal/file"
"golang.org/x/tools/gopls/internal/protocol"
"golang.org/x/tools/gopls/internal/util/bug"
"golang.org/x/tools/gopls/internal/util/safetoken"
)
// canExtractToNewFile reports whether the code in the given range can be extracted to a new file.
func canExtractToNewFile(pgf *parsego.File, start, end token.Pos) bool {
_, _, _, ok := selectedToplevelDecls(pgf, start, end)
return ok
}
// findImportEdits finds imports specs that needs to be added to the new file
// or deleted from the old file if the range is extracted to a new file.
//
// TODO: handle dot imports.
func findImportEdits(file *ast.File, info *types.Info, start, end token.Pos) (adds, deletes []*ast.ImportSpec, _ error) {
// make a map from a pkgName to its references
pkgNameReferences := make(map[*types.PkgName][]*ast.Ident)
for ident, use := range info.Uses {
if pkgName, ok := use.(*types.PkgName); ok {
pkgNameReferences[pkgName] = append(pkgNameReferences[pkgName], ident)
}
}
// PkgName referenced in the extracted selection must be
// imported in the new file.
// PkgName only referenced in the extracted selection must be
// deleted from the original file.
for _, spec := range file.Imports {
if spec.Name != nil && spec.Name.Name == "." {
// TODO: support dot imports.
return nil, nil, errors.New("\"extract to new file\" does not support files containing dot imports")
}
pkgName := info.PkgNameOf(spec)
if pkgName == nil {
continue
}
usedInSelection := false
usedInNonSelection := false
for _, ident := range pkgNameReferences[pkgName] {
if posRangeContains(start, end, ident.Pos(), ident.End()) {
usedInSelection = true
} else {
usedInNonSelection = true
}
}
if usedInSelection {
adds = append(adds, spec)
}
if usedInSelection && !usedInNonSelection {
deletes = append(deletes, spec)
}
}
return adds, deletes, nil
}
// ExtractToNewFile moves selected declarations into a new file.
func ExtractToNewFile(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, rng protocol.Range) ([]protocol.DocumentChange, error) {
errorPrefix := "ExtractToNewFile"
pkg, pgf, err := NarrowestPackageForFile(ctx, snapshot, fh.URI())
if err != nil {
return nil, err
}
start, end, err := pgf.RangePos(rng)
if err != nil {
return nil, fmt.Errorf("%s: %w", errorPrefix, err)
}
start, end, firstSymbol, ok := selectedToplevelDecls(pgf, start, end)
if !ok {
return nil, bug.Errorf("invalid selection")
}
// select trailing empty lines
offset, err := safetoken.Offset(pgf.Tok, end)
if err != nil {
return nil, err
}
rest := pgf.Src[offset:]
end += token.Pos(len(rest) - len(bytes.TrimLeft(rest, " \t\n")))
replaceRange, err := pgf.PosRange(start, end)
if err != nil {
return nil, bug.Errorf("invalid range: %v", err)
}
adds, deletes, err := findImportEdits(pgf.File, pkg.TypesInfo(), start, end)
if err != nil {
return nil, err
}
var importDeletes []protocol.TextEdit
// For unparenthesised declarations like `import "fmt"` we remove
// the whole declaration because simply removing importSpec leaves
// `import \n`, which does not compile.
// For parenthesised declarations like `import ("fmt"\n "log")`
// we only remove the ImportSpec, because removing the whole declaration
// might remove other ImportsSpecs we don't want to touch.
unparenthesizedImports := unparenthesizedImports(pgf)
for _, importSpec := range deletes {
if decl := unparenthesizedImports[importSpec]; decl != nil {
importDeletes = append(importDeletes, removeNode(pgf, decl))
} else {
importDeletes = append(importDeletes, removeNode(pgf, importSpec))
}
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "package %s\n", pgf.File.Name.Name)
if len(adds) > 0 {
buf.WriteString("import (")
for _, importSpec := range adds {
if importSpec.Name != nil {
fmt.Fprintf(&buf, "%s %s\n", importSpec.Name.Name, importSpec.Path.Value)
} else {
fmt.Fprintf(&buf, "%s\n", importSpec.Path.Value)
}
}
buf.WriteString(")\n")
}
newFile, err := chooseNewFile(ctx, snapshot, pgf.URI.Dir().Path(), firstSymbol)
if err != nil {
return nil, fmt.Errorf("%s: %w", errorPrefix, err)
}
fileStart := pgf.File.FileStart
buf.Write(pgf.Src[start-fileStart : end-fileStart])
// TODO: attempt to duplicate the copyright header, if any.
newFileContent, err := format.Source(buf.Bytes())
if err != nil {
return nil, err
}
return []protocol.DocumentChange{
// edit the original file
protocol.DocumentChangeEdit(fh, append(importDeletes, protocol.TextEdit{Range: replaceRange, NewText: ""})),
// create a new file
protocol.DocumentChangeCreate(newFile.URI()),
// edit the created file
protocol.DocumentChangeEdit(newFile, []protocol.TextEdit{
{Range: protocol.Range{}, NewText: string(newFileContent)},
})}, nil
}
// chooseNewFile chooses a new filename in dir, based on the name of the
// first extracted symbol, and if necessary to disambiguate, a numeric suffix.
func chooseNewFile(ctx context.Context, snapshot *cache.Snapshot, dir string, firstSymbol string) (file.Handle, error) {
basename := strings.ToLower(firstSymbol)
newPath := protocol.URIFromPath(filepath.Join(dir, basename+".go"))
for count := 1; count < 5; count++ {
fh, err := snapshot.ReadFile(ctx, newPath)
if err != nil {
return nil, err // canceled
}
if _, err := fh.Content(); errors.Is(err, os.ErrNotExist) {
return fh, nil
}
filename := fmt.Sprintf("%s.%d.go", basename, count)
newPath = protocol.URIFromPath(filepath.Join(dir, filename))
}
return nil, fmt.Errorf("chooseNewFileURI: exceeded retry limit")
}
// selectedToplevelDecls returns the lexical extent of the top-level
// declarations enclosed by [start, end), along with the name of the
// first declaration. The returned boolean reports whether the selection
// should be offered a code action to extract the declarations.
func selectedToplevelDecls(pgf *parsego.File, start, end token.Pos) (token.Pos, token.Pos, string, bool) {
// selection cannot intersect a package declaration
if posRangeIntersects(start, end, pgf.File.Package, pgf.File.Name.End()) {
return 0, 0, "", false
}
firstName := ""
for _, decl := range pgf.File.Decls {
if posRangeIntersects(start, end, decl.Pos(), decl.End()) {
var id *ast.Ident
switch v := decl.(type) {
case *ast.BadDecl:
return 0, 0, "", false
case *ast.FuncDecl:
// if only selecting keyword "func" or function name, extend selection to the
// whole function
if posRangeContains(v.Pos(), v.Name.End(), start, end) {
start, end = v.Pos(), v.End()
}
id = v.Name
case *ast.GenDecl:
// selection cannot intersect an import declaration
if v.Tok == token.IMPORT {
return 0, 0, "", false
}
// if only selecting keyword "type", "const", or "var", extend selection to the
// whole declaration
if v.Tok == token.TYPE && posRangeContains(v.Pos(), v.Pos()+token.Pos(len("type")), start, end) ||
v.Tok == token.CONST && posRangeContains(v.Pos(), v.Pos()+token.Pos(len("const")), start, end) ||
v.Tok == token.VAR && posRangeContains(v.Pos(), v.Pos()+token.Pos(len("var")), start, end) {
start, end = v.Pos(), v.End()
}
if len(v.Specs) > 0 {
switch spec := v.Specs[0].(type) {
case *ast.TypeSpec:
id = spec.Name
case *ast.ValueSpec:
id = spec.Names[0]
}
}
}
// selection cannot partially intersect a node
if !posRangeContains(start, end, decl.Pos(), decl.End()) {
return 0, 0, "", false
}
if id != nil && firstName == "" {
// may be "_"
firstName = id.Name
}
// extends selection to docs comments
var c *ast.CommentGroup
switch decl := decl.(type) {
case *ast.GenDecl:
c = decl.Doc
case *ast.FuncDecl:
c = decl.Doc
}
if c != nil && c.Pos() < start {
start = c.Pos()
}
}
}
for _, comment := range pgf.File.Comments {
if posRangeIntersects(start, end, comment.Pos(), comment.End()) {
if !posRangeContains(start, end, comment.Pos(), comment.End()) {
// selection cannot partially intersect a comment
return 0, 0, "", false
}
}
}
if firstName == "" {
return 0, 0, "", false
}
return start, end, firstName, true
}
// unparenthesizedImports returns a map from each unparenthesized ImportSpec
// to its enclosing declaration (which may need to be deleted too).
func unparenthesizedImports(pgf *parsego.File) map[*ast.ImportSpec]*ast.GenDecl {
decls := make(map[*ast.ImportSpec]*ast.GenDecl)
for _, decl := range pgf.File.Decls {
if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.IMPORT && !decl.Lparen.IsValid() {
decls[decl.Specs[0].(*ast.ImportSpec)] = decl
}
}
return decls
}
// removeNode returns a TextEdit that removes the node.
func removeNode(pgf *parsego.File, node ast.Node) protocol.TextEdit {
rng, err := pgf.NodeRange(node)
if err != nil {
bug.Reportf("removeNode: %v", err)
}
return protocol.TextEdit{Range: rng, NewText: ""}
}
// posRangeIntersects checks if [a, b) and [c, d) intersects, assuming a <= b and c <= d.
func posRangeIntersects(a, b, c, d token.Pos) bool {
return !(b <= c || d <= a)
}
// posRangeContains checks if [a, b) contains [c, d), assuming a <= b and c <= d.
func posRangeContains(a, b, c, d token.Pos) bool {
return a <= c && d <= b
}