mirror of
https://github.com/golang/go
synced 2024-11-05 14:46:11 -07:00
416e8f4faf
CL 239754 eagerly initialized the environment. This turns out to be a problem for gopls, which calls ApplyFixes with no ProcessEnv. Reinitializing it every time seriously harmed the performance of unimported completions. Move back to lazy initialization. Working with invalid options has caused a lot of confusion; this is only the most recent. We have to maintain backwards compatibility in the externally visible API, but everywhere else we can require fully populated options. That includes the source byte slice and the options. LocalPrefix is really more of an Option than an attribute of the ProcessEnv, and it is needed in ApplyFixes where we really don't want to have to pass a ProcessEnv. Move it up to Options. Change-Id: Ib9466c375a640a521721da4587091bf93bbdaa3c Reviewed-on: https://go-review.googlesource.com/c/tools/+/241159 Run-TryBot: Heschi Kreinick <heschi@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rebecca Stambler <rstambler@golang.org>
281 lines
7.3 KiB
Go
281 lines
7.3 KiB
Go
// Copyright 2013 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.
|
|
|
|
// Hacked up copy of go/ast/import.go
|
|
|
|
package imports
|
|
|
|
import (
|
|
"go/ast"
|
|
"go/token"
|
|
"sort"
|
|
"strconv"
|
|
)
|
|
|
|
// sortImports sorts runs of consecutive import lines in import blocks in f.
|
|
// It also removes duplicate imports when it is possible to do so without data loss.
|
|
func sortImports(localPrefix string, fset *token.FileSet, f *ast.File) {
|
|
for i, d := range f.Decls {
|
|
d, ok := d.(*ast.GenDecl)
|
|
if !ok || d.Tok != token.IMPORT {
|
|
// Not an import declaration, so we're done.
|
|
// Imports are always first.
|
|
break
|
|
}
|
|
|
|
if len(d.Specs) == 0 {
|
|
// Empty import block, remove it.
|
|
f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
|
|
}
|
|
|
|
if !d.Lparen.IsValid() {
|
|
// Not a block: sorted by default.
|
|
continue
|
|
}
|
|
|
|
// Identify and sort runs of specs on successive lines.
|
|
i := 0
|
|
specs := d.Specs[:0]
|
|
for j, s := range d.Specs {
|
|
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(localPrefix, fset, f, d.Specs[i:j])...)
|
|
i = j
|
|
}
|
|
}
|
|
specs = append(specs, sortSpecs(localPrefix, fset, f, d.Specs[i:])...)
|
|
d.Specs = specs
|
|
|
|
// 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 := fset.Position(lastSpec.Pos()).Line
|
|
if rParenLine := fset.Position(d.Rparen).Line; rParenLine > lastLine+1 {
|
|
fset.File(d.Rparen).MergeLine(rParenLine - 1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// mergeImports merges all the import declarations into the first one.
|
|
// Taken from golang.org/x/tools/ast/astutil.
|
|
func mergeImports(fset *token.FileSet, f *ast.File) {
|
|
if len(f.Decls) <= 1 {
|
|
return
|
|
}
|
|
|
|
// Merge all the import declarations into the first one.
|
|
var first *ast.GenDecl
|
|
for i := 0; i < len(f.Decls); i++ {
|
|
decl := f.Decls[i]
|
|
gen, ok := decl.(*ast.GenDecl)
|
|
if !ok || gen.Tok != token.IMPORT || declImports(gen, "C") {
|
|
continue
|
|
}
|
|
if first == nil {
|
|
first = gen
|
|
continue // Don't touch the first one.
|
|
}
|
|
// We now know there is more than one package in this import
|
|
// declaration. Ensure that it ends up parenthesized.
|
|
first.Lparen = first.Pos()
|
|
// Move the imports of the other import declaration to the first one.
|
|
for _, spec := range gen.Specs {
|
|
spec.(*ast.ImportSpec).Path.ValuePos = first.Pos()
|
|
first.Specs = append(first.Specs, spec)
|
|
}
|
|
f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
|
|
i--
|
|
}
|
|
}
|
|
|
|
// declImports reports whether gen contains an import of path.
|
|
// Taken from golang.org/x/tools/ast/astutil.
|
|
func declImports(gen *ast.GenDecl, path string) bool {
|
|
if gen.Tok != token.IMPORT {
|
|
return false
|
|
}
|
|
for _, spec := range gen.Specs {
|
|
impspec := spec.(*ast.ImportSpec)
|
|
if importPath(impspec) == path {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func importPath(s ast.Spec) string {
|
|
t, err := strconv.Unquote(s.(*ast.ImportSpec).Path.Value)
|
|
if err == nil {
|
|
return t
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func importName(s ast.Spec) string {
|
|
n := s.(*ast.ImportSpec).Name
|
|
if n == nil {
|
|
return ""
|
|
}
|
|
return n.Name
|
|
}
|
|
|
|
func importComment(s ast.Spec) string {
|
|
c := s.(*ast.ImportSpec).Comment
|
|
if c == nil {
|
|
return ""
|
|
}
|
|
return c.Text()
|
|
}
|
|
|
|
// collapse indicates whether prev may be removed, leaving only next.
|
|
func collapse(prev, next ast.Spec) bool {
|
|
if importPath(next) != importPath(prev) || importName(next) != importName(prev) {
|
|
return false
|
|
}
|
|
return prev.(*ast.ImportSpec).Comment == nil
|
|
}
|
|
|
|
type posSpan struct {
|
|
Start token.Pos
|
|
End token.Pos
|
|
}
|
|
|
|
func sortSpecs(localPrefix string, fset *token.FileSet, f *ast.File, specs []ast.Spec) []ast.Spec {
|
|
// Can't short-circuit here even if specs are already sorted,
|
|
// since they might yet need deduplication.
|
|
// A lone import, however, may be safely ignored.
|
|
if len(specs) <= 1 {
|
|
return specs
|
|
}
|
|
|
|
// Record positions for specs.
|
|
pos := make([]posSpan, len(specs))
|
|
for i, s := range specs {
|
|
pos[i] = posSpan{s.Pos(), s.End()}
|
|
}
|
|
|
|
// Identify comments in this range.
|
|
// 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.Pos() < pos[0].Start {
|
|
continue
|
|
}
|
|
if i < cstart {
|
|
cstart = i
|
|
}
|
|
if fset.Position(g.End()).Line > lastLine {
|
|
cend = i
|
|
break
|
|
}
|
|
}
|
|
comments := f.Comments[cstart:cend]
|
|
|
|
// Assign each comment to the import spec preceding it.
|
|
importComment := map[*ast.ImportSpec][]*ast.CommentGroup{}
|
|
specIndex := 0
|
|
for _, g := range comments {
|
|
for specIndex+1 < len(specs) && pos[specIndex+1].Start <= g.Pos() {
|
|
specIndex++
|
|
}
|
|
s := specs[specIndex].(*ast.ImportSpec)
|
|
importComment[s] = append(importComment[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 abut the end of its spec.
|
|
// Sort the comments by new position.
|
|
sort.Sort(byImportSpec{localPrefix, specs})
|
|
|
|
// Dedup. Thanks to our sorting, we can just consider
|
|
// adjacent pairs of imports.
|
|
deduped := specs[:0]
|
|
for i, s := range specs {
|
|
if i == len(specs)-1 || !collapse(s, specs[i+1]) {
|
|
deduped = append(deduped, s)
|
|
} else {
|
|
p := s.Pos()
|
|
fset.File(p).MergeLine(fset.Position(p).Line)
|
|
}
|
|
}
|
|
specs = deduped
|
|
|
|
// Fix up comment positions
|
|
for i, s := range specs {
|
|
s := s.(*ast.ImportSpec)
|
|
if s.Name != nil {
|
|
s.Name.NamePos = pos[i].Start
|
|
}
|
|
s.Path.ValuePos = pos[i].Start
|
|
s.EndPos = pos[i].End
|
|
nextSpecPos := pos[i].End
|
|
|
|
for _, g := range importComment[s] {
|
|
for _, c := range g.List {
|
|
c.Slash = pos[i].End
|
|
nextSpecPos = c.End()
|
|
}
|
|
}
|
|
if i < len(specs)-1 {
|
|
pos[i+1].Start = nextSpecPos
|
|
pos[i+1].End = nextSpecPos
|
|
}
|
|
}
|
|
|
|
sort.Sort(byCommentPos(comments))
|
|
|
|
// Fixup comments can insert blank lines, because import specs are on different lines.
|
|
// We remove those blank lines here by merging import spec to the first import spec line.
|
|
firstSpecLine := fset.Position(specs[0].Pos()).Line
|
|
for _, s := range specs[1:] {
|
|
p := s.Pos()
|
|
line := fset.File(p).Line(p)
|
|
for previousLine := line - 1; previousLine >= firstSpecLine; {
|
|
fset.File(p).MergeLine(previousLine)
|
|
previousLine--
|
|
}
|
|
}
|
|
return specs
|
|
}
|
|
|
|
type byImportSpec struct {
|
|
localPrefix string
|
|
specs []ast.Spec // slice of *ast.ImportSpec
|
|
}
|
|
|
|
func (x byImportSpec) Len() int { return len(x.specs) }
|
|
func (x byImportSpec) Swap(i, j int) { x.specs[i], x.specs[j] = x.specs[j], x.specs[i] }
|
|
func (x byImportSpec) Less(i, j int) bool {
|
|
ipath := importPath(x.specs[i])
|
|
jpath := importPath(x.specs[j])
|
|
|
|
igroup := importGroup(x.localPrefix, ipath)
|
|
jgroup := importGroup(x.localPrefix, jpath)
|
|
if igroup != jgroup {
|
|
return igroup < jgroup
|
|
}
|
|
|
|
if ipath != jpath {
|
|
return ipath < jpath
|
|
}
|
|
iname := importName(x.specs[i])
|
|
jname := importName(x.specs[j])
|
|
|
|
if iname != jname {
|
|
return iname < jname
|
|
}
|
|
return importComment(x.specs[i]) < importComment(x.specs[j])
|
|
}
|
|
|
|
type byCommentPos []*ast.CommentGroup
|
|
|
|
func (x byCommentPos) Len() int { return len(x) }
|
|
func (x byCommentPos) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
|
|
func (x byCommentPos) Less(i, j int) bool { return x[i].Pos() < x[j].Pos() }
|