// TestLineComments, using a simple test case, checks that consequtive line
// comments are properly terminated with a newline even if the AST position
// information is incorrect.
//
func TestLineComments(t *testing.T) {
const src = `// comment 1
// comment 2
// comment 3
package main
`
fset := token.NewFileSet()
ast1, err1 := parser.ParseFile(fset, "", src, parser.ParseComments, nil)
if err1 != nil {
panic(err1)
}
var buf bytes.Buffer
fset = token.NewFileSet() // use the wrong file set
Fprint(&buf, fset, ast1)
nlines := 0
for _, ch := range buf.Bytes() {
if ch == '\n' {
nlines++
}
}
const expected = 3
if nlines < expected {
t.Errorf("got %d, expected %d\n", nlines, expected)
}
}
func NewContext() *Context {
ctxt := &Context{
pkgCache: make(map[string]*ast.Package),
FileSet: token.NewFileSet(),
ChangedFiles: make(map[string]*ast.File),
}
ctxt.importer = ctxt.importerFunc()
return ctxt
}
"testing"
"time"
"github.com/rogpeppe/godef/go/ast"
"github.com/rogpeppe/godef/go/parser"
"github.com/rogpeppe/godef/go/token"
)
const (
dataDir = "testdata"
tabwidth = 8
)
var update = flag.Bool("update", false, "update golden files")
var fset = token.NewFileSet()
func lineString(text []byte, i int) string {
i0 := i
for i < len(text) && text[i] != '\n' {
i++
}
return string(text[i0:i])
}
type checkMode uint
const (
export checkMode = 1 << iota
rawFormat
)
if err != nil {
panic("cannot unquote")
}
return v
}
type astVisitor func(n ast.Node) bool
func (f astVisitor) Visit(n ast.Node) ast.Visitor {
if f(n) {
return f
}
return nil
}
var emptyFileSet = token.NewFileSet()
func pretty(n ast.Node) string {
var b bytes.Buffer
printer.Fprint(&b, emptyFileSet, n)
return b.String()
}
var printConfig = &printer.Config{
Mode: printer.TabIndent | printer.UseSpaces,
Tabwidth: 8,
}
func (ctxt *Context) gofmtFile(f *ast.File) ([]byte, error) {
var buf bytes.Buffer
_, err := printConfig.Fprint(&buf, ctxt.FileSet, f)
var falseIdent = predecl("false")
var trueIdent = predecl("true")
var iotaIdent = predecl("iota")
var boolIdent = predecl("bool")
var intIdent = predecl("int")
var floatIdent = predecl("float")
var stringIdent = predecl("string")
func predecl(name string) *ast.Ident {
return &ast.Ident{Name: name, Obj: parser.Universe.Lookup(name)}
}
type Importer func(path string, srcDir string) *ast.Package
// When DefaultImporter is called, it adds any files to FileSet.
var FileSet = token.NewFileSet()
// DefaultImporter looks for the package; if it finds it,
// it parses and returns it. If no package was found, it returns nil.
func DefaultImporter(path string, srcDir string) *ast.Package {
bpkg, err := build.Default.Import(path, srcDir, 0)
if err != nil {
return nil
}
pkgs, err := parser.ParseDir(FileSet, bpkg.Dir, isGoFile, 0, DefaultImportPathToName)
if err != nil {
if Debug {
switch err := err.(type) {
case scanner.ErrorList:
for _, e := range err {
debugp("\t%v: %s", e.Pos, e.Msg)