mirror of
https://github.com/golang/go
synced 2024-11-18 20:54:40 -07:00
2f43c6d1a2
Change span to hide its fields and have validating accessors This catches the cases where either the offset or the position is being used when it was not set. It also normalizes the forms as the API now controls them, and allows us to simplify some of the logic. The converters are now allowed to return an error, which lets us cleanly propagate bad cases. The lsp was then converted to the new format, and also had some error checking of its own added on the top. All this allowed me to find and fix a few issues, most notably a case where the wrong column mapper was being used during the conversion of definition results. Change-Id: Iebdf8901e8269b28aaef60caf76574baa25c46d4 Reviewed-on: https://go-review.googlesource.com/c/tools/+/167858 Run-TryBot: Ian Cottrell <iancottrell@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rebecca Stambler <rstambler@golang.org>
83 lines
2.5 KiB
Go
83 lines
2.5 KiB
Go
// 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 span
|
|
|
|
import (
|
|
"fmt"
|
|
"unicode/utf16"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// ToUTF16Column calculates the utf16 column expressed by the point given the
|
|
// supplied file contents.
|
|
// This is used to convert from the native (always in bytes) column
|
|
// representation and the utf16 counts used by some editors.
|
|
func ToUTF16Column(p Point, content []byte) (int, error) {
|
|
if content == nil {
|
|
return -1, fmt.Errorf("ToUTF16Column: missing content")
|
|
}
|
|
if !p.HasPosition() {
|
|
return -1, fmt.Errorf("ToUTF16Column: point is missing position")
|
|
}
|
|
if !p.HasOffset() {
|
|
return -1, fmt.Errorf("ToUTF16Column: point is missing offset")
|
|
}
|
|
offset := p.Offset()
|
|
col := p.Column()
|
|
if col == 1 {
|
|
// column 1, so it must be chr 1
|
|
return 1, nil
|
|
}
|
|
// work out the offset at the start of the line using the column
|
|
lineOffset := offset - (col - 1)
|
|
if lineOffset < 0 || offset > len(content) {
|
|
return -1, fmt.Errorf("ToUTF16Column: offsets %v-%v outside file contents (%v)", lineOffset, offset, len(content))
|
|
}
|
|
// use the offset to pick out the line start
|
|
start := content[lineOffset:]
|
|
// now truncate down to the supplied column
|
|
start = start[:col]
|
|
// and count the number of utf16 characters
|
|
// in theory we could do this by hand more efficiently...
|
|
return len(utf16.Encode([]rune(string(start)))), nil
|
|
}
|
|
|
|
// FromUTF16Column advances the point by the utf16 character offset given the
|
|
// supplied line contents.
|
|
// This is used to convert from the utf16 counts used by some editors to the
|
|
// native (always in bytes) column representation.
|
|
func FromUTF16Column(p Point, chr int, content []byte) (Point, error) {
|
|
if !p.HasOffset() {
|
|
return Point{}, fmt.Errorf("FromUTF16Column: point is missing offset")
|
|
}
|
|
// if chr is 1 then no adjustment needed
|
|
if chr <= 1 {
|
|
return p, nil
|
|
}
|
|
remains := content[p.Offset():]
|
|
// scan forward the specified number of characters
|
|
for count := 1; count < chr; count++ {
|
|
if len(remains) <= 0 {
|
|
return Point{}, fmt.Errorf("FromUTF16Column: chr goes beyond the content")
|
|
}
|
|
r, w := utf8.DecodeRune(remains)
|
|
if r == '\n' {
|
|
return Point{}, fmt.Errorf("FromUTF16Column: chr goes beyond the line")
|
|
}
|
|
remains = remains[w:]
|
|
if r >= 0x10000 {
|
|
// a two point rune
|
|
count++
|
|
// if we finished in a two point rune, do not advance past the first
|
|
if count >= chr {
|
|
break
|
|
}
|
|
}
|
|
p.v.Column += w
|
|
p.v.Offset += w
|
|
}
|
|
return p, nil
|
|
}
|