* Use vendored go-swagger * vendor go-swagger * revert un wanteed change * remove un-needed GO111MODULE * Update Makefile Co-Authored-By: techknowlogick <matti@mdranta.net>
280 lines
7.2 KiB
Go
280 lines
7.2 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(env *ProcessEnv, 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(env, fset, f, d.Specs[i:j])...)
|
|
i = j
|
|
}
|
|
}
|
|
specs = append(specs, sortSpecs(env, 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(env *ProcessEnv, 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(env *ProcessEnv, 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{env, 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 {
|
|
env *ProcessEnv
|
|
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.env, ipath)
|
|
jgroup := importGroup(x.env, 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() }
|