mirror of
https://github.com/golang/go
synced 2024-10-01 10:18:32 -06:00
00c44ba9c1
This change adds an additional cache for type information, which here is just a *packages.Package for each package. The metadata cache maintains the import graph, which allows us to easily determine when a package X (and therefore any other package that imports X) should be invalidated. Additionally, rather than performing content changes as they happen, we queue up content changes and apply them the next time that any type information is requested. Updates golang/go#30309 Change-Id: Iaf569f641f84ce69b0c0d5bdabbaa85635eeb8bf Reviewed-on: https://go-review.googlesource.com/c/tools/+/165438 Run-TryBot: Rebecca Stambler <rstambler@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Cottrell <iancottrell@google.com>
102 lines
2.9 KiB
Go
102 lines
2.9 KiB
Go
// Copyright 2018 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 provides core features for use by Go editors and tools.
|
|
package source
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"go/ast"
|
|
"go/format"
|
|
"go/token"
|
|
"strings"
|
|
|
|
"golang.org/x/tools/go/ast/astutil"
|
|
"golang.org/x/tools/imports"
|
|
"golang.org/x/tools/internal/lsp/diff"
|
|
)
|
|
|
|
// Format formats a file with a given range.
|
|
func Format(ctx context.Context, f File, rng Range) ([]TextEdit, error) {
|
|
fAST := f.GetAST(ctx)
|
|
path, exact := astutil.PathEnclosingInterval(fAST, rng.Start, rng.End)
|
|
if !exact || len(path) == 0 {
|
|
return nil, fmt.Errorf("no exact AST node matching the specified range")
|
|
}
|
|
node := path[0]
|
|
// format.Node can fail when the AST contains a bad expression or
|
|
// statement. For now, we preemptively check for one.
|
|
// TODO(rstambler): This should really return an error from format.Node.
|
|
var isBad bool
|
|
ast.Inspect(node, func(n ast.Node) bool {
|
|
switch n.(type) {
|
|
case *ast.BadDecl, *ast.BadExpr, *ast.BadStmt:
|
|
isBad = true
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
})
|
|
if isBad {
|
|
return nil, fmt.Errorf("unable to format file due to a badly formatted AST")
|
|
}
|
|
// format.Node changes slightly from one release to another, so the version
|
|
// of Go used to build the LSP server will determine how it formats code.
|
|
// This should be acceptable for all users, who likely be prompted to rebuild
|
|
// the LSP server on each Go release.
|
|
fset := f.GetFileSet(ctx)
|
|
buf := &bytes.Buffer{}
|
|
if err := format.Node(buf, fset, node); err != nil {
|
|
return nil, err
|
|
}
|
|
return computeTextEdits(ctx, f, buf.String()), nil
|
|
}
|
|
|
|
// Imports formats a file using the goimports tool.
|
|
func Imports(ctx context.Context, f File, rng Range) ([]TextEdit, error) {
|
|
formatted, err := imports.Process(f.GetToken(ctx).Name(), f.GetContent(ctx), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return computeTextEdits(ctx, f, string(formatted)), nil
|
|
}
|
|
|
|
func computeTextEdits(ctx context.Context, file File, formatted string) (edits []TextEdit) {
|
|
u := strings.SplitAfter(string(file.GetContent(ctx)), "\n")
|
|
tok := file.GetToken(ctx)
|
|
f := strings.SplitAfter(formatted, "\n")
|
|
for _, op := range diff.Operations(u, f) {
|
|
start := lineStart(tok, op.I1+1)
|
|
if start == token.NoPos && op.I1 == len(u) {
|
|
start = tok.Pos(tok.Size())
|
|
}
|
|
end := lineStart(tok, op.I2+1)
|
|
if end == token.NoPos && op.I2 == len(u) {
|
|
end = tok.Pos(tok.Size())
|
|
}
|
|
switch op.Kind {
|
|
case diff.Delete:
|
|
// Delete: unformatted[i1:i2] is deleted.
|
|
edits = append(edits, TextEdit{
|
|
Range: Range{
|
|
Start: start,
|
|
End: end,
|
|
},
|
|
})
|
|
case diff.Insert:
|
|
// Insert: formatted[j1:j2] is inserted at unformatted[i1:i1].
|
|
edits = append(edits, TextEdit{
|
|
Range: Range{
|
|
Start: start,
|
|
End: start,
|
|
},
|
|
NewText: op.Content,
|
|
})
|
|
}
|
|
}
|
|
return edits
|
|
}
|