1
0
mirror of https://github.com/golang/go synced 2024-11-18 14:34:39 -07:00
go/internal/lsp/source/extract.go
Josh Baum 9c9572d6f9 internal/lsp: extract highlighted selection to variable
I add a code action that triggers upon request of the user. A variable
name is generated manually for the extracted code because the LSP does
not support a user's ability to provide a name.

Change-Id: Id1ec19b49562b7cfbc2cd416378bec9bd021d82f
Reviewed-on: https://go-review.googlesource.com/c/tools/+/240182
Run-TryBot: Josh Baum <joshbaum@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Rebecca Stambler <rstambler@golang.org>
2020-07-07 21:12:28 +00:00

141 lines
3.4 KiB
Go

// Copyright 2020 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"
"fmt"
"go/ast"
"go/format"
"go/token"
"go/types"
"golang.org/x/tools/go/ast/astutil"
"golang.org/x/tools/internal/analysisinternal"
"golang.org/x/tools/internal/lsp/protocol"
"golang.org/x/tools/internal/span"
)
func ExtractVariable(ctx context.Context, snapshot Snapshot, fh FileHandle, protoRng protocol.Range) ([]protocol.TextEdit, error) {
pkg, pgh, err := getParsedFile(ctx, snapshot, fh, NarrowestPackageHandle)
if err != nil {
return nil, fmt.Errorf("ExtractVariable: %v", err)
}
file, _, m, _, err := pgh.Cached()
if err != nil {
return nil, err
}
spn, err := m.RangeSpan(protoRng)
if err != nil {
return nil, err
}
rng, err := spn.Range(m.Converter)
if err != nil {
return nil, err
}
path, _ := astutil.PathEnclosingInterval(file, rng.Start, rng.End)
if len(path) == 0 {
return nil, nil
}
fset := snapshot.View().Session().Cache().FileSet()
node := path[0]
tok := fset.File(node.Pos())
if tok == nil {
return nil, fmt.Errorf("ExtractVariable: no token.File for %s", fh.URI())
}
var content []byte
if content, err = fh.Read(); err != nil {
return nil, err
}
if rng.Start != node.Pos() || rng.End != node.End() {
return nil, nil
}
// Adjust new variable name until no collisons in scope.
scopes := collectScopes(pkg, path, node.Pos())
name := "x0"
idx := 0
for !isValidName(name, scopes) {
idx++
name = fmt.Sprintf("x%d", idx)
}
var assignment string
expr, ok := node.(ast.Expr)
if !ok {
return nil, nil
}
// Create new AST node for extracted code
switch expr.(type) {
case *ast.BasicLit, *ast.CompositeLit, *ast.IndexExpr,
*ast.SliceExpr, *ast.UnaryExpr, *ast.BinaryExpr, *ast.SelectorExpr: // TODO: stricter rules for selectorExpr
assignStmt := &ast.AssignStmt{
Lhs: []ast.Expr{ast.NewIdent(name)},
Tok: token.DEFINE,
Rhs: []ast.Expr{expr},
}
var buf bytes.Buffer
if err = format.Node(&buf, fset, assignStmt); err != nil {
return nil, err
}
assignment = buf.String()
case *ast.CallExpr: // TODO: find number of return values and do according actions.
return nil, nil
default:
return nil, nil
}
insertBeforeStmt := analysisinternal.StmtToInsertVarBefore(path)
if insertBeforeStmt == nil {
return nil, nil
}
// Convert token.Pos to protcol.Position
rng = span.NewRange(fset, insertBeforeStmt.Pos(), insertBeforeStmt.End())
spn, err = rng.Span()
if err != nil {
return nil, nil
}
beforeStmtStart, err := m.Position(spn.Start())
if err != nil {
return nil, nil
}
stmtBeforeRng := protocol.Range{
Start: beforeStmtStart,
End: beforeStmtStart,
}
// Calculate indentation for insertion
line := tok.Line(insertBeforeStmt.Pos())
lineOffset := tok.Offset(tok.LineStart(line))
stmtOffset := tok.Offset(insertBeforeStmt.Pos())
indent := content[lineOffset:stmtOffset] // space between these is indentation.
return []protocol.TextEdit{
{
Range: stmtBeforeRng,
NewText: assignment + "\n" + string(indent),
},
{
Range: protoRng,
NewText: name,
},
}, nil
}
// Check for variable collision in scope.
func isValidName(name string, scopes []*types.Scope) bool {
for _, scope := range scopes {
if scope == nil {
continue
}
if scope.Lookup(name) != nil {
return false
}
}
return true
}