Source file src/pkg/go/ast/import.go

     1	// Copyright 2011 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package ast
     6	
     7	import (
     8		"go/token"
     9		"sort"
    10		"strconv"
    11	)
    12	
    13	// SortImports sorts runs of consecutive import lines in import blocks in f.
    14	func SortImports(fset *token.FileSet, f *File) {
    15		for _, d := range f.Decls {
    16			d, ok := d.(*GenDecl)
    17			if !ok || d.Tok != token.IMPORT {
    18				// Not an import declaration, so we're done.
    19				// Imports are always first.
    20				break
    21			}
    22	
    23			if d.Lparen == token.NoPos {
    24				// Not a block: sorted by default.
    25				continue
    26			}
    27	
    28			// Identify and sort runs of specs on successive lines.
    29			i := 0
    30			for j, s := range d.Specs {
    31				if j > i && fset.Position(s.Pos()).Line > 1+fset.Position(d.Specs[j-1].End()).Line {
    32					// j begins a new run.  End this one.
    33					sortSpecs(fset, f, d.Specs[i:j])
    34					i = j
    35				}
    36			}
    37			sortSpecs(fset, f, d.Specs[i:])
    38		}
    39	}
    40	
    41	func importPath(s Spec) string {
    42		t, err := strconv.Unquote(s.(*ImportSpec).Path.Value)
    43		if err == nil {
    44			return t
    45		}
    46		return ""
    47	}
    48	
    49	type posSpan struct {
    50		Start token.Pos
    51		End   token.Pos
    52	}
    53	
    54	func sortSpecs(fset *token.FileSet, f *File, specs []Spec) {
    55		// Avoid work if already sorted (also catches < 2 entries).
    56		sorted := true
    57		for i, s := range specs {
    58			if i > 0 && importPath(specs[i-1]) > importPath(s) {
    59				sorted = false
    60				break
    61			}
    62		}
    63		if sorted {
    64			return
    65		}
    66	
    67		// Record positions for specs.
    68		pos := make([]posSpan, len(specs))
    69		for i, s := range specs {
    70			pos[i] = posSpan{s.Pos(), s.End()}
    71		}
    72	
    73		// Identify comments in this range.
    74		// Any comment from pos[0].Start to the final line counts.
    75		lastLine := fset.Position(pos[len(pos)-1].End).Line
    76		cstart := len(f.Comments)
    77		cend := len(f.Comments)
    78		for i, g := range f.Comments {
    79			if g.Pos() < pos[0].Start {
    80				continue
    81			}
    82			if i < cstart {
    83				cstart = i
    84			}
    85			if fset.Position(g.End()).Line > lastLine {
    86				cend = i
    87				break
    88			}
    89		}
    90		comments := f.Comments[cstart:cend]
    91	
    92		// Assign each comment to the import spec preceding it.
    93		importComment := map[*ImportSpec][]*CommentGroup{}
    94		specIndex := 0
    95		for _, g := range comments {
    96			for specIndex+1 < len(specs) && pos[specIndex+1].Start <= g.Pos() {
    97				specIndex++
    98			}
    99			s := specs[specIndex].(*ImportSpec)
   100			importComment[s] = append(importComment[s], g)
   101		}
   102	
   103		// Sort the import specs by import path.
   104		// Reassign the import paths to have the same position sequence.
   105		// Reassign each comment to abut the end of its spec.
   106		// Sort the comments by new position.
   107		sort.Sort(byImportPath(specs))
   108		for i, s := range specs {
   109			s := s.(*ImportSpec)
   110			if s.Name != nil {
   111				s.Name.NamePos = pos[i].Start
   112			}
   113			s.Path.ValuePos = pos[i].Start
   114			s.EndPos = pos[i].End
   115			for _, g := range importComment[s] {
   116				for _, c := range g.List {
   117					c.Slash = pos[i].End
   118				}
   119			}
   120		}
   121		sort.Sort(byCommentPos(comments))
   122	}
   123	
   124	type byImportPath []Spec // slice of *ImportSpec
   125	
   126	func (x byImportPath) Len() int           { return len(x) }
   127	func (x byImportPath) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
   128	func (x byImportPath) Less(i, j int) bool { return importPath(x[i]) < importPath(x[j]) }
   129	
   130	type byCommentPos []*CommentGroup
   131	
   132	func (x byCommentPos) Len() int           { return len(x) }
   133	func (x byCommentPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
   134	func (x byCommentPos) Less(i, j int) bool { return x[i].Pos() < x[j].Pos() }