i := 0
specs := d.Specs[:0]
for j, s := range d.Specs {
- if j > i && lineAt(fset, s.Pos()) > 1+lineAt(fset, d.Specs[j-1].End()) {
+ if j > i && fset.Position(s.Pos()).Line > 1+fset.Position(d.Specs[j-1].End()).Line {
// j begins a new run. End this one.
specs = append(specs, sortSpecs(fset, f, d.Specs[i:j])...)
i = j
// Deduping can leave a blank line before the rparen; clean that up.
if len(d.Specs) > 0 {
lastSpec := d.Specs[len(d.Specs)-1]
- lastLine := lineAt(fset, lastSpec.Pos())
- rParenLine := lineAt(fset, d.Rparen)
+ lastLine := fset.Position(lastSpec.Pos()).Line
+ rParenLine := fset.Position(d.Rparen).Line
for rParenLine > lastLine+1 {
rParenLine--
fset.File(d.Rparen).MergeLine(rParenLine)
}
}
-func lineAt(fset *token.FileSet, pos token.Pos) int {
- return fset.PositionFor(pos, false).Line
-}
-
func importPath(s Spec) string {
t, err := strconv.Unquote(s.(*ImportSpec).Path.Value)
if err == nil {
End token.Pos
}
-type cgPos struct {
- left bool // true if comment is to the left of the spec, false otherwise.
- cg *CommentGroup
-}
-
func sortSpecs(fset *token.FileSet, f *File, specs []Spec) []Spec {
// Can't short-circuit here even if specs are already sorted,
// since they might yet need deduplication.
}
// Identify comments in this range.
- begSpecs := pos[0].Start
- endSpecs := pos[len(pos)-1].End
- beg := fset.File(begSpecs).LineStart(lineAt(fset, begSpecs))
- end := fset.File(endSpecs).LineStart(lineAt(fset, endSpecs) + 1) // beginning of next line
- first := len(f.Comments)
- last := -1
+ // Any comment from pos[0].Start to the final line counts.
+ lastLine := fset.Position(pos[len(pos)-1].End).Line
+ cstart := len(f.Comments)
+ cend := len(f.Comments)
for i, g := range f.Comments {
- if g.End() >= end {
- break
+ if g.Pos() < pos[0].Start {
+ continue
}
- // g.End() < end
- if beg <= g.Pos() {
- // comment is within the range [beg, end[ of import declarations
- if i < first {
- first = i
- }
- if i > last {
- last = i
- }
+ if i < cstart {
+ cstart = i
+ }
+ if fset.Position(g.End()).Line > lastLine {
+ cend = i
+ break
}
}
+ comments := f.Comments[cstart:cend]
- var comments []*CommentGroup
- if last >= 0 {
- comments = f.Comments[first : last+1]
- }
-
- // Assign each comment to the import spec on the same line.
- importComments := map[*ImportSpec][]cgPos{}
+ // Assign each comment to the import spec preceding it.
+ importComments := map[*ImportSpec][]*CommentGroup{}
specIndex := 0
for _, g := range comments {
for specIndex+1 < len(specs) && pos[specIndex+1].Start <= g.Pos() {
specIndex++
}
- var left bool
- // A block comment can appear before the first import spec.
- if specIndex == 0 && pos[specIndex].Start > g.Pos() {
- left = true
- } else if specIndex+1 < len(specs) && // Or it can appear on the left of an import spec.
- lineAt(fset, pos[specIndex].Start)+1 == lineAt(fset, g.Pos()) {
- specIndex++
- left = true
- }
s := specs[specIndex].(*ImportSpec)
- importComments[s] = append(importComments[s], cgPos{left: left, cg: g})
+ importComments[s] = append(importComments[s], g)
}
// Sort the import specs by import path.
// Remove duplicates, when possible without data loss.
// Reassign the import paths to have the same position sequence.
- // Reassign each comment to the spec on the same line.
+ // Reassign each comment to abut the end of its spec.
// Sort the comments by new position.
sort.Slice(specs, func(i, j int) bool {
ipath := importPath(specs[i])
deduped = append(deduped, s)
} else {
p := s.Pos()
- fset.File(p).MergeLine(lineAt(fset, p))
+ fset.File(p).MergeLine(fset.Position(p).Line)
}
}
specs = deduped
s.Path.ValuePos = pos[i].Start
s.EndPos = pos[i].End
for _, g := range importComments[s] {
- for _, c := range g.cg.List {
- if g.left {
- c.Slash = pos[i].Start - 1
- } else {
- // An import spec can have both block comment and a line comment
- // to its right. In that case, both of them will have the same pos.
- // But while formatting the AST, the line comment gets moved to
- // after the block comment.
- c.Slash = pos[i].End
- }
+ for _, c := range g.List {
+ c.Slash = pos[i].End
}
}
}