mirror of
https://github.com/golang/go
synced 2024-11-19 09:04:41 -07:00
e504f914a8
A file is strongly associated with a view, and knows how to manage it's own contents. We can also now track files that are not "active" Change-Id: Ib9474cd40e5caa3db6596548612a9f90168b8a19 Reviewed-on: https://go-review.googlesource.com/c/147204 Run-TryBot: Ian Cottrell <iancottrell@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rebecca Stambler <rstambler@golang.org>
89 lines
2.5 KiB
Go
89 lines
2.5 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 lsp
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"go/format"
|
|
|
|
"golang.org/x/tools/internal/lsp/protocol"
|
|
"golang.org/x/tools/internal/lsp/source"
|
|
)
|
|
|
|
// formatRange formats a document with a given range.
|
|
func formatRange(v *source.View, uri protocol.DocumentURI, rng *protocol.Range) ([]protocol.TextEdit, error) {
|
|
data, err := v.GetFile(uri).Read()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if rng != nil {
|
|
start, err := positionToOffset(data, int(rng.Start.Line), int(rng.Start.Character))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
end, err := positionToOffset(data, int(rng.End.Line), int(rng.End.Character))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
data = data[start:end]
|
|
// format.Source will fail if the substring is not a balanced expression tree.
|
|
// TODO(rstambler): parse the file and use astutil.PathEnclosingInterval to
|
|
// find the largest ast.Node n contained within start:end, and format the
|
|
// region n.Pos-n.End instead.
|
|
}
|
|
// format.Source 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.
|
|
fmted, err := format.Source([]byte(data))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if rng == nil {
|
|
// Get the ending line and column numbers for the original file.
|
|
line := bytes.Count(data, []byte("\n"))
|
|
col := len(data) - bytes.LastIndex(data, []byte("\n")) - 1
|
|
if col < 0 {
|
|
col = 0
|
|
}
|
|
rng = &protocol.Range{
|
|
Start: protocol.Position{
|
|
Line: 0,
|
|
Character: 0,
|
|
},
|
|
End: protocol.Position{
|
|
Line: float64(line),
|
|
Character: float64(col),
|
|
},
|
|
}
|
|
}
|
|
// TODO(rstambler): Compute text edits instead of replacing whole file.
|
|
return []protocol.TextEdit{
|
|
{
|
|
Range: *rng,
|
|
NewText: string(fmted),
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// positionToOffset converts a 0-based line and column number in a file
|
|
// to a byte offset value.
|
|
func positionToOffset(contents []byte, line, col int) (int, error) {
|
|
start := 0
|
|
for i := 0; i < int(line); i++ {
|
|
if start >= len(contents) {
|
|
return 0, fmt.Errorf("file contains %v lines, not %v lines", i, line)
|
|
}
|
|
index := bytes.IndexByte(contents[start:], '\n')
|
|
if index == -1 {
|
|
return 0, fmt.Errorf("file contains %v lines, not %v lines", i, line)
|
|
}
|
|
start += index + 1
|
|
}
|
|
offset := start + int(col)
|
|
return offset, nil
|
|
}
|