add prune and remove unused packages
This commit is contained in:
Michelle Au
195
vendor/golang.org/x/tools/go/ast/astutil/enclosing_test.go
generated
vendored
195
vendor/golang.org/x/tools/go/ast/astutil/enclosing_test.go
generated
vendored
@@ -1,195 +0,0 @@
|
||||
// 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.
|
||||
|
||||
package astutil_test
|
||||
|
||||
// This file defines tests of PathEnclosingInterval.
|
||||
|
||||
// TODO(adonovan): exhaustive tests that run over the whole input
|
||||
// tree, not just handcrafted examples.
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"go/ast"
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/tools/go/ast/astutil"
|
||||
)
|
||||
|
||||
// pathToString returns a string containing the concrete types of the
|
||||
// nodes in path.
|
||||
func pathToString(path []ast.Node) string {
|
||||
var buf bytes.Buffer
|
||||
fmt.Fprint(&buf, "[")
|
||||
for i, n := range path {
|
||||
if i > 0 {
|
||||
fmt.Fprint(&buf, " ")
|
||||
}
|
||||
fmt.Fprint(&buf, strings.TrimPrefix(fmt.Sprintf("%T", n), "*ast."))
|
||||
}
|
||||
fmt.Fprint(&buf, "]")
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// findInterval parses input and returns the [start, end) positions of
|
||||
// the first occurrence of substr in input. f==nil indicates failure;
|
||||
// an error has already been reported in that case.
|
||||
//
|
||||
func findInterval(t *testing.T, fset *token.FileSet, input, substr string) (f *ast.File, start, end token.Pos) {
|
||||
f, err := parser.ParseFile(fset, "<input>", input, 0)
|
||||
if err != nil {
|
||||
t.Errorf("parse error: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
i := strings.Index(input, substr)
|
||||
if i < 0 {
|
||||
t.Errorf("%q is not a substring of input", substr)
|
||||
f = nil
|
||||
return
|
||||
}
|
||||
|
||||
filePos := fset.File(f.Package)
|
||||
return f, filePos.Pos(i), filePos.Pos(i + len(substr))
|
||||
}
|
||||
|
||||
// Common input for following tests.
|
||||
const input = `
|
||||
// Hello.
|
||||
package main
|
||||
import "fmt"
|
||||
func f() {}
|
||||
func main() {
|
||||
z := (x + y) // add them
|
||||
f() // NB: ExprStmt and its CallExpr have same Pos/End
|
||||
}
|
||||
`
|
||||
|
||||
func TestPathEnclosingInterval_Exact(t *testing.T) {
|
||||
// For the exact tests, we check that a substring is mapped to
|
||||
// the canonical string for the node it denotes.
|
||||
tests := []struct {
|
||||
substr string // first occurrence of this string indicates interval
|
||||
node string // complete text of expected containing node
|
||||
}{
|
||||
{"package",
|
||||
input[11 : len(input)-1]},
|
||||
{"\npack",
|
||||
input[11 : len(input)-1]},
|
||||
{"main",
|
||||
"main"},
|
||||
{"import",
|
||||
"import \"fmt\""},
|
||||
{"\"fmt\"",
|
||||
"\"fmt\""},
|
||||
{"\nfunc f() {}\n",
|
||||
"func f() {}"},
|
||||
{"x ",
|
||||
"x"},
|
||||
{" y",
|
||||
"y"},
|
||||
{"z",
|
||||
"z"},
|
||||
{" + ",
|
||||
"x + y"},
|
||||
{" :=",
|
||||
"z := (x + y)"},
|
||||
{"x + y",
|
||||
"x + y"},
|
||||
{"(x + y)",
|
||||
"(x + y)"},
|
||||
{" (x + y) ",
|
||||
"(x + y)"},
|
||||
{" (x + y) // add",
|
||||
"(x + y)"},
|
||||
{"func",
|
||||
"func f() {}"},
|
||||
{"func f() {}",
|
||||
"func f() {}"},
|
||||
{"\nfun",
|
||||
"func f() {}"},
|
||||
{" f",
|
||||
"f"},
|
||||
}
|
||||
for _, test := range tests {
|
||||
f, start, end := findInterval(t, new(token.FileSet), input, test.substr)
|
||||
if f == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
path, exact := astutil.PathEnclosingInterval(f, start, end)
|
||||
if !exact {
|
||||
t.Errorf("PathEnclosingInterval(%q) not exact", test.substr)
|
||||
continue
|
||||
}
|
||||
|
||||
if len(path) == 0 {
|
||||
if test.node != "" {
|
||||
t.Errorf("PathEnclosingInterval(%q).path: got [], want %q",
|
||||
test.substr, test.node)
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if got := input[path[0].Pos():path[0].End()]; got != test.node {
|
||||
t.Errorf("PathEnclosingInterval(%q): got %q, want %q (path was %s)",
|
||||
test.substr, got, test.node, pathToString(path))
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPathEnclosingInterval_Paths(t *testing.T) {
|
||||
// For these tests, we check only the path of the enclosing
|
||||
// node, but not its complete text because it's often quite
|
||||
// large when !exact.
|
||||
tests := []struct {
|
||||
substr string // first occurrence of this string indicates interval
|
||||
path string // the pathToString(),exact of the expected path
|
||||
}{
|
||||
{"// add",
|
||||
"[BlockStmt FuncDecl File],false"},
|
||||
{"(x + y",
|
||||
"[ParenExpr AssignStmt BlockStmt FuncDecl File],false"},
|
||||
{"x +",
|
||||
"[BinaryExpr ParenExpr AssignStmt BlockStmt FuncDecl File],false"},
|
||||
{"z := (x",
|
||||
"[AssignStmt BlockStmt FuncDecl File],false"},
|
||||
{"func f",
|
||||
"[FuncDecl File],false"},
|
||||
{"func f()",
|
||||
"[FuncDecl File],false"},
|
||||
{" f()",
|
||||
"[FuncDecl File],false"},
|
||||
{"() {}",
|
||||
"[FuncDecl File],false"},
|
||||
{"// Hello",
|
||||
"[File],false"},
|
||||
{" f",
|
||||
"[Ident FuncDecl File],true"},
|
||||
{"func ",
|
||||
"[FuncDecl File],true"},
|
||||
{"mai",
|
||||
"[Ident File],true"},
|
||||
{"f() // NB",
|
||||
"[CallExpr ExprStmt BlockStmt FuncDecl File],true"},
|
||||
}
|
||||
for _, test := range tests {
|
||||
f, start, end := findInterval(t, new(token.FileSet), input, test.substr)
|
||||
if f == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
path, exact := astutil.PathEnclosingInterval(f, start, end)
|
||||
if got := fmt.Sprintf("%s,%v", pathToString(path), exact); got != test.path {
|
||||
t.Errorf("PathEnclosingInterval(%q): got %q, want %q",
|
||||
test.substr, got, test.path)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
2087
vendor/golang.org/x/tools/go/ast/astutil/imports_test.go
generated
vendored
2087
vendor/golang.org/x/tools/go/ast/astutil/imports_test.go
generated
vendored
File diff suppressed because it is too large
Load Diff
248
vendor/golang.org/x/tools/go/ast/astutil/rewrite_test.go
generated
vendored
248
vendor/golang.org/x/tools/go/ast/astutil/rewrite_test.go
generated
vendored
@@ -1,248 +0,0 @@
|
||||
// Copyright 2017 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.
|
||||
|
||||
package astutil_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"go/ast"
|
||||
"go/format"
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/tools/go/ast/astutil"
|
||||
)
|
||||
|
||||
var rewriteTests = [...]struct {
|
||||
name string
|
||||
orig, want string
|
||||
pre, post astutil.ApplyFunc
|
||||
}{
|
||||
{name: "nop", orig: "package p\n", want: "package p\n"},
|
||||
|
||||
{name: "replace",
|
||||
orig: `package p
|
||||
|
||||
var x int
|
||||
`,
|
||||
want: `package p
|
||||
|
||||
var t T
|
||||
`,
|
||||
post: func(c *astutil.Cursor) bool {
|
||||
if _, ok := c.Node().(*ast.ValueSpec); ok {
|
||||
c.Replace(valspec("t", "T"))
|
||||
return false
|
||||
}
|
||||
return true
|
||||
},
|
||||
},
|
||||
|
||||
{name: "set doc strings",
|
||||
orig: `package p
|
||||
|
||||
const z = 0
|
||||
|
||||
type T struct{}
|
||||
|
||||
var x int
|
||||
`,
|
||||
want: `package p
|
||||
// a foo is a foo
|
||||
const z = 0
|
||||
// a foo is a foo
|
||||
type T struct{}
|
||||
// a foo is a foo
|
||||
var x int
|
||||
`,
|
||||
post: func(c *astutil.Cursor) bool {
|
||||
if _, ok := c.Parent().(*ast.GenDecl); ok && c.Name() == "Doc" && c.Node() == nil {
|
||||
c.Replace(&ast.CommentGroup{List: []*ast.Comment{{Text: "// a foo is a foo"}}})
|
||||
}
|
||||
return true
|
||||
},
|
||||
},
|
||||
|
||||
{name: "insert names",
|
||||
orig: `package p
|
||||
|
||||
const a = 1
|
||||
`,
|
||||
want: `package p
|
||||
|
||||
const a, b, c = 1, 2, 3
|
||||
`,
|
||||
pre: func(c *astutil.Cursor) bool {
|
||||
if _, ok := c.Parent().(*ast.ValueSpec); ok {
|
||||
switch c.Name() {
|
||||
case "Names":
|
||||
c.InsertAfter(ast.NewIdent("c"))
|
||||
c.InsertAfter(ast.NewIdent("b"))
|
||||
case "Values":
|
||||
c.InsertAfter(&ast.BasicLit{Kind: token.INT, Value: "3"})
|
||||
c.InsertAfter(&ast.BasicLit{Kind: token.INT, Value: "2"})
|
||||
}
|
||||
}
|
||||
return true
|
||||
},
|
||||
},
|
||||
|
||||
{name: "insert",
|
||||
orig: `package p
|
||||
|
||||
var (
|
||||
x int
|
||||
y int
|
||||
)
|
||||
`,
|
||||
want: `package p
|
||||
|
||||
var before1 int
|
||||
var before2 int
|
||||
|
||||
var (
|
||||
x int
|
||||
y int
|
||||
)
|
||||
var after2 int
|
||||
var after1 int
|
||||
`,
|
||||
pre: func(c *astutil.Cursor) bool {
|
||||
if _, ok := c.Node().(*ast.GenDecl); ok {
|
||||
c.InsertBefore(vardecl("before1", "int"))
|
||||
c.InsertAfter(vardecl("after1", "int"))
|
||||
c.InsertAfter(vardecl("after2", "int"))
|
||||
c.InsertBefore(vardecl("before2", "int"))
|
||||
}
|
||||
return true
|
||||
},
|
||||
},
|
||||
|
||||
{name: "delete",
|
||||
orig: `package p
|
||||
|
||||
var x int
|
||||
var y int
|
||||
var z int
|
||||
`,
|
||||
want: `package p
|
||||
|
||||
var y int
|
||||
var z int
|
||||
`,
|
||||
pre: func(c *astutil.Cursor) bool {
|
||||
n := c.Node()
|
||||
if d, ok := n.(*ast.GenDecl); ok && d.Specs[0].(*ast.ValueSpec).Names[0].Name == "x" {
|
||||
c.Delete()
|
||||
}
|
||||
return true
|
||||
},
|
||||
},
|
||||
|
||||
{name: "insertafter-delete",
|
||||
orig: `package p
|
||||
|
||||
var x int
|
||||
var y int
|
||||
var z int
|
||||
`,
|
||||
want: `package p
|
||||
|
||||
var x1 int
|
||||
|
||||
var y int
|
||||
var z int
|
||||
`,
|
||||
pre: func(c *astutil.Cursor) bool {
|
||||
n := c.Node()
|
||||
if d, ok := n.(*ast.GenDecl); ok && d.Specs[0].(*ast.ValueSpec).Names[0].Name == "x" {
|
||||
c.InsertAfter(vardecl("x1", "int"))
|
||||
c.Delete()
|
||||
}
|
||||
return true
|
||||
},
|
||||
},
|
||||
|
||||
{name: "delete-insertafter",
|
||||
orig: `package p
|
||||
|
||||
var x int
|
||||
var y int
|
||||
var z int
|
||||
`,
|
||||
want: `package p
|
||||
|
||||
var y int
|
||||
var x1 int
|
||||
var z int
|
||||
`,
|
||||
pre: func(c *astutil.Cursor) bool {
|
||||
n := c.Node()
|
||||
if d, ok := n.(*ast.GenDecl); ok && d.Specs[0].(*ast.ValueSpec).Names[0].Name == "x" {
|
||||
c.Delete()
|
||||
// The cursor is now effectively atop the 'var y int' node.
|
||||
c.InsertAfter(vardecl("x1", "int"))
|
||||
}
|
||||
return true
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func valspec(name, typ string) *ast.ValueSpec {
|
||||
return &ast.ValueSpec{Names: []*ast.Ident{ast.NewIdent(name)},
|
||||
Type: ast.NewIdent(typ),
|
||||
}
|
||||
}
|
||||
|
||||
func vardecl(name, typ string) *ast.GenDecl {
|
||||
return &ast.GenDecl{
|
||||
Tok: token.VAR,
|
||||
Specs: []ast.Spec{valspec(name, typ)},
|
||||
}
|
||||
}
|
||||
|
||||
func TestRewrite(t *testing.T) {
|
||||
t.Run("*", func(t *testing.T) {
|
||||
for _, test := range rewriteTests {
|
||||
test := test
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
fset := token.NewFileSet()
|
||||
f, err := parser.ParseFile(fset, test.name, test.orig, parser.ParseComments)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
n := astutil.Apply(f, test.pre, test.post)
|
||||
var buf bytes.Buffer
|
||||
if err := format.Node(&buf, fset, n); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := buf.String()
|
||||
if got != test.want {
|
||||
t.Errorf("got:\n\n%s\nwant:\n\n%s\n", got, test.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
var sink ast.Node
|
||||
|
||||
func BenchmarkRewrite(b *testing.B) {
|
||||
for _, test := range rewriteTests {
|
||||
b.Run(test.name, func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
b.StopTimer()
|
||||
fset := token.NewFileSet()
|
||||
f, err := parser.ParseFile(fset, test.name, test.orig, parser.ParseComments)
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
b.StartTimer()
|
||||
sink = astutil.Apply(f, test.pre, test.post)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user