vendor: delete

9 files changed, 0 insertions, 982 deletions

diff --git a/vendor/github.com/gostaticanalysis/analysisutil/LICENSE b/vendor/github.com/gostaticanalysis/analysisutil/LICENSE
deleted file mode 100644
index bf7e33db8..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 GoStaticAnalysis
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/vendor/github.com/gostaticanalysis/analysisutil/README.md b/vendor/github.com/gostaticanalysis/analysisutil/README.md
deleted file mode 100644
index d8fd3d2a4..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# analysisutil
-
-[![PkgGoDev](https://pkg.go.dev/badge/github.com/gostaticanalysis/analysisutil)](https://pkg.go.dev/github.com/gostaticanalysis/analysisutil)
-
-Utilities for x/tools/go/analysis package.
diff --git a/vendor/github.com/gostaticanalysis/analysisutil/call.go b/vendor/github.com/gostaticanalysis/analysisutil/call.go
deleted file mode 100644
index e3d98d1dc..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/call.go
+++ /dev/null
@@ -1,405 +0,0 @@
-package analysisutil
-
-import (
-	"go/types"
-
-	"golang.org/x/tools/go/ssa"
-)
-
-// CalledChecker checks a function is called.
-// See From and Func.
-type CalledChecker struct {
-	Ignore func(instr ssa.Instruction) bool
-}
-
-// NotIn checks whether receiver's method is called in a function.
-// If there is no methods calling at a path from an instruction
-// which type is receiver to all return instruction, NotIn returns these instructions.
-func (c *CalledChecker) NotIn(f *ssa.Function, receiver types.Type, methods ...*types.Func) []ssa.Instruction {
-	done := map[ssa.Value]bool{}
-	var instrs []ssa.Instruction
-	for _, b := range f.Blocks {
-		for i, instr := range b.Instrs {
-			v, _ := instr.(ssa.Value)
-			if v == nil || done[v] {
-				continue
-			}
-
-			if v, _ := v.(*ssa.UnOp); v != nil && done[v.X] {
-				continue
-			}
-
-			called, ok := c.From(b, i, receiver, methods...)
-			if ok && !called {
-				instrs = append(instrs, instr)
-				done[v] = true
-				if v, _ := v.(*ssa.UnOp); v != nil {
-					done[v.X] = true
-				}
-			}
-		}
-	}
-	return instrs
-}
-
-// Func returns true when f is called in the instr.
-// If recv is not nil, Func also checks the receiver.
-func (c *CalledChecker) Func(instr ssa.Instruction, recv ssa.Value, f *types.Func) bool {
-
-	if c.Ignore != nil && c.Ignore(instr) {
-		return false
-	}
-
-	call, ok := instr.(ssa.CallInstruction)
-	if !ok {
-		return false
-	}
-
-	common := call.Common()
-	if common == nil {
-		return false
-	}
-
-	callee := common.StaticCallee()
-	if callee == nil {
-		return false
-	}
-
-	fn, ok := callee.Object().(*types.Func)
-	if !ok {
-		return false
-	}
-
-	if recv != nil &&
-		common.Signature().Recv() != nil &&
-		(len(common.Args) == 0 && recv != nil || common.Args[0] != recv &&
-			!referrer(recv, common.Args[0])) {
-		return false
-	}
-
-	return fn == f
-}
-
-func referrer(a, b ssa.Value) bool {
-	return isReferrerOf(a, b) || isReferrerOf(b, a)
-}
-
-func isReferrerOf(a, b ssa.Value) bool {
-	if a == nil || b == nil {
-		return false
-	}
-	if b.Referrers() != nil {
-		brs := *b.Referrers()
-
-		for _, br := range brs {
-			brv, ok := br.(ssa.Value)
-			if !ok {
-				continue
-			}
-			if brv == a {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// From checks whether receiver's method is called in an instruction
-// which belogns to after i-th instructions, or in succsor blocks of b.
-// The first result is above value.
-// The second result is whether type of i-th instruction does not much receiver
-// or matches with ignore cases.
-func (c *CalledChecker) From(b *ssa.BasicBlock, i int, receiver types.Type, methods ...*types.Func) (called, ok bool) {
-	if b == nil || i < 0 || i >= len(b.Instrs) ||
-		receiver == nil || len(methods) == 0 {
-		return false, false
-	}
-
-	v, ok := b.Instrs[i].(ssa.Value)
-	if !ok {
-		return false, false
-	}
-
-	from := &calledFrom{recv: v, fs: methods, ignore: c.Ignore}
-
-	if !from.isRecv(receiver, v.Type()) {
-		return false, false
-	}
-
-	if from.ignored() {
-		return false, false
-	}
-
-	if from.instrs(b.Instrs[i+1:]) ||
-		from.succs(b) {
-		return true, true
-	}
-
-	from.done = nil
-	if from.storedInInstrs(b.Instrs[i+1:]) ||
-		from.storedInSuccs(b) {
-		return false, false
-	}
-
-	return false, true
-}
-
-type calledFrom struct {
-	recv   ssa.Value
-	fs     []*types.Func
-	done   map[*ssa.BasicBlock]bool
-	ignore func(ssa.Instruction) bool
-}
-
-func (c *calledFrom) ignored() bool {
-
-	switch v := c.recv.(type) {
-	case *ssa.UnOp:
-		switch v.X.(type) {
-		case *ssa.FreeVar, *ssa.Global:
-			return true
-		}
-	}
-
-	refs := c.recv.Referrers()
-	if refs == nil {
-		return false
-	}
-
-	for _, ref := range *refs {
-		done := map[ssa.Instruction]bool{}
-		if !c.isOwn(ref) &&
-			((c.ignore != nil && c.ignore(ref)) ||
-				c.isRet(ref, done) || c.isArg(ref)) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (c *calledFrom) isOwn(instr ssa.Instruction) bool {
-	v, ok := instr.(ssa.Value)
-	if !ok {
-		return false
-	}
-	return v == c.recv
-}
-
-func (c *calledFrom) isRet(instr ssa.Instruction, done map[ssa.Instruction]bool) bool {
-	if done[instr] {
-		return false
-	}
-	done[instr] = true
-
-	switch instr := instr.(type) {
-	case *ssa.Return:
-		return true
-	case *ssa.MapUpdate:
-		return c.isRetInRefs(instr.Map, done)
-	case *ssa.Store:
-		if instr, _ := instr.Addr.(ssa.Instruction); instr != nil {
-			return c.isRet(instr, done)
-		}
-		return c.isRetInRefs(instr.Addr, done)
-	case *ssa.FieldAddr:
-		return c.isRetInRefs(instr.X, done)
-	case ssa.Value:
-		return c.isRetInRefs(instr, done)
-	default:
-		return false
-	}
-}
-
-func (c *calledFrom) isRetInRefs(v ssa.Value, done map[ssa.Instruction]bool) bool {
-	refs := v.Referrers()
-	if refs == nil {
-		return false
-	}
-	for _, ref := range *refs {
-		if c.isRet(ref, done) {
-			return true
-		}
-	}
-	return false
-}
-
-func (c *calledFrom) isArg(instr ssa.Instruction) bool {
-
-	call, ok := instr.(ssa.CallInstruction)
-	if !ok {
-		return false
-	}
-
-	common := call.Common()
-	if common == nil {
-		return false
-	}
-
-	args := common.Args
-	if common.Signature().Recv() != nil {
-		args = args[1:]
-	}
-
-	for i := range args {
-		if args[i] == c.recv {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (c *calledFrom) instrs(instrs []ssa.Instruction) bool {
-	for _, instr := range instrs {
-		for _, f := range c.fs {
-			if Called(instr, c.recv, f) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func (c *calledFrom) succs(b *ssa.BasicBlock) bool {
-	if c.done == nil {
-		c.done = map[*ssa.BasicBlock]bool{}
-	}
-
-	if c.done[b] {
-		return true
-	}
-	c.done[b] = true
-
-	if len(b.Succs) == 0 {
-		return false
-	}
-
-	for _, s := range b.Succs {
-		if !c.instrs(s.Instrs) && !c.succs(s) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c *calledFrom) storedInInstrs(instrs []ssa.Instruction) bool {
-	for _, instr := range instrs {
-		switch instr := instr.(type) {
-		case *ssa.Store:
-			if instr.Val == c.recv {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func (c *calledFrom) storedInSuccs(b *ssa.BasicBlock) bool {
-	if c.done == nil {
-		c.done = map[*ssa.BasicBlock]bool{}
-	}
-
-	if c.done[b] {
-		return true
-	}
-	c.done[b] = true
-
-	if len(b.Succs) == 0 {
-		return false
-	}
-
-	for _, s := range b.Succs {
-		if !c.storedInInstrs(s.Instrs) && !c.succs(s) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c *calledFrom) isRecv(recv, typ types.Type) bool {
-	return recv == typ || identical(recv, typ) ||
-		c.isRecvInTuple(recv, typ) || c.isRecvInEmbedded(recv, typ)
-}
-
-func (c *calledFrom) isRecvInTuple(recv, typ types.Type) bool {
-	tuple, _ := typ.(*types.Tuple)
-	if tuple == nil {
-		return false
-	}
-
-	for i := 0; i < tuple.Len(); i++ {
-		if c.isRecv(recv, tuple.At(i).Type()) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (c *calledFrom) isRecvInEmbedded(recv, typ types.Type) bool {
-
-	var st *types.Struct
-	switch typ := typ.(type) {
-	case *types.Struct:
-		st = typ
-	case *types.Pointer:
-		return c.isRecvInEmbedded(recv, typ.Elem())
-	case *types.Named:
-		return c.isRecvInEmbedded(recv, typ.Underlying())
-	default:
-		return false
-	}
-
-	for i := 0; i < st.NumFields(); i++ {
-		field := st.Field(i)
-		if !field.Embedded() {
-			continue
-		}
-
-		ft := field.Type()
-		if c.isRecv(recv, ft) {
-			return true
-		}
-
-		var ptrOrUnptr types.Type
-		switch ft := ft.(type) {
-		case *types.Pointer:
-			// struct { *T } -> T
-			ptrOrUnptr = ft.Elem()
-		default:
-			// struct { T } -> *T
-			ptrOrUnptr = types.NewPointer(ft)
-		}
-
-		if c.isRecv(recv, ptrOrUnptr) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// NotCalledIn checks whether receiver's method is called in a function.
-// If there is no methods calling at a path from an instruction
-// which type is receiver to all return instruction, NotCalledIn returns these instructions.
-func NotCalledIn(f *ssa.Function, receiver types.Type, methods ...*types.Func) []ssa.Instruction {
-	return new(CalledChecker).NotIn(f, receiver, methods...)
-}
-
-// CalledFrom checks whether receiver's method is called in an instruction
-// which belogns to after i-th instructions, or in succsor blocks of b.
-// The first result is above value.
-// The second result is whether type of i-th instruction does not much receiver
-// or matches with ignore cases.
-func CalledFrom(b *ssa.BasicBlock, i int, receiver types.Type, methods ...*types.Func) (called, ok bool) {
-	return new(CalledChecker).From(b, i, receiver, methods...)
-}
-
-// Called returns true when f is called in the instr.
-// If recv is not nil, Called also checks the receiver.
-func Called(instr ssa.Instruction, recv ssa.Value, f *types.Func) bool {
-	return new(CalledChecker).Func(instr, recv, f)
-}
diff --git a/vendor/github.com/gostaticanalysis/analysisutil/diagnostic.go b/vendor/github.com/gostaticanalysis/analysisutil/diagnostic.go
deleted file mode 100644
index a911db6f1..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/diagnostic.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package analysisutil
-
-import (
-	"go/token"
-
-	"github.com/gostaticanalysis/comment"
-	"github.com/gostaticanalysis/comment/passes/commentmap"
-	"golang.org/x/tools/go/analysis"
-)
-
-// ReportWithoutIgnore returns a report function which can set to (analysis.Pass).Report.
-// The report function ignores a diagnostic which annotated by ignore comment as the below.
-//   //lint:ignore Check1[,Check2,...,CheckN] reason
-// names is a list of checker names.
-// If names was omitted, the report function ignores by pass.Analyzer.Name.
-func ReportWithoutIgnore(pass *analysis.Pass, names ...string) func(analysis.Diagnostic) {
-	cmaps, _ := pass.ResultOf[commentmap.Analyzer].(comment.Maps)
-	if cmaps == nil {
-		cmaps = comment.New(pass.Fset, pass.Files)
-	}
-
-	if len(names) == 0 {
-		names = []string{pass.Analyzer.Name}
-	}
-
-	report := pass.Report // original report func
-
-	return func(d analysis.Diagnostic) {
-		start := pass.Fset.File(d.Pos).Line(d.Pos)
-		end := start
-		if d.End != token.NoPos {
-			end = pass.Fset.File(d.End).Line(d.End)
-		}
-
-		for l := start; l <= end; l++ {
-			for _, n := range names {
-				if cmaps.IgnoreLine(pass.Fset, l, n) {
-					return
-				}
-			}
-		}
-
-		report(d)
-	}
-}
diff --git a/vendor/github.com/gostaticanalysis/analysisutil/file.go b/vendor/github.com/gostaticanalysis/analysisutil/file.go
deleted file mode 100644
index b9b295530..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/file.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package analysisutil
-
-import (
-	"go/ast"
-	"go/token"
-	"regexp"
-
-	"golang.org/x/tools/go/analysis"
-)
-
-// File finds *ast.File in pass.Files by pos.
-func File(pass *analysis.Pass, pos token.Pos) *ast.File {
-	for _, f := range pass.Files {
-		if f.Pos() <= pos && pos <= f.End() {
-			return f
-		}
-	}
-	return nil
-}
-
-var genCommentRegexp = regexp.MustCompile(`^// Code generated .* DO NOT EDIT\.$`)
-
-// IsGeneratedFile reports whether the file has been generated automatically.
-// If file is nil, IsGeneratedFile will return false.
-func IsGeneratedFile(file *ast.File) bool {
-	if file == nil || len(file.Comments) == 0 {
-		return false
-	}
-	return genCommentRegexp.MatchString(file.Comments[0].List[0].Text)
-}
diff --git a/vendor/github.com/gostaticanalysis/analysisutil/pkg.go b/vendor/github.com/gostaticanalysis/analysisutil/pkg.go
deleted file mode 100644
index b64150d81..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/pkg.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package analysisutil
-
-import (
-	"go/types"
-	"strconv"
-	"strings"
-
-	"golang.org/x/tools/go/analysis"
-)
-
-// RemoVendor removes vendoring information from import path.
-func RemoveVendor(path string) string {
-	i := strings.Index(path, "vendor/")
-	if i >= 0 {
-		return path[i+len("vendor/"):]
-	}
-	return path
-}
-
-// LookupFromImports finds an object from import paths.
-func LookupFromImports(imports []*types.Package, path, name string) types.Object {
-	path = RemoveVendor(path)
-	for i := range imports {
-		if path == RemoveVendor(imports[i].Path()) {
-			return imports[i].Scope().Lookup(name)
-		}
-	}
-	return nil
-}
-
-// Imported returns true when the given pass imports the pkg.
-func Imported(pkgPath string, pass *analysis.Pass) bool {
-	fs := pass.Files
-	if len(fs) == 0 {
-		return false
-	}
-	for _, f := range fs {
-		for _, i := range f.Imports {
-			path, err := strconv.Unquote(i.Path.Value)
-			if err != nil {
-				continue
-			}
-			if RemoveVendor(path) == pkgPath {
-				return true
-			}
-		}
-	}
-	return false
-}
diff --git a/vendor/github.com/gostaticanalysis/analysisutil/ssa.go b/vendor/github.com/gostaticanalysis/analysisutil/ssa.go
deleted file mode 100644
index 2e22bbe79..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/ssa.go
+++ /dev/null
@@ -1,152 +0,0 @@
-package analysisutil
-
-import (
-	"golang.org/x/tools/go/ssa"
-)
-
-// IfInstr returns *ssa.If which is contained in the block b.
-// If the block b has not any if instruction, IfInstr returns nil.
-func IfInstr(b *ssa.BasicBlock) *ssa.If {
-	if len(b.Instrs) == 0 {
-		return nil
-	}
-
-	ifinstr, ok := b.Instrs[len(b.Instrs)-1].(*ssa.If)
-	if !ok {
-		return nil
-	}
-
-	return ifinstr
-}
-
-// Phi returns phi values which are contained in the block b.
-func Phi(b *ssa.BasicBlock) []*ssa.Phi {
-	var phis []*ssa.Phi
-	for _, instr := range b.Instrs {
-		if phi, ok := instr.(*ssa.Phi); ok {
-			phis = append(phis, phi)
-		} else {
-			// no more phi
-			break
-		}
-	}
-	return phis
-}
-
-// Returns returns a slice of *ssa.Return in the function.
-func Returns(v ssa.Value) []*ssa.Return {
-	var fn *ssa.Function
-	switch v := v.(type) {
-	case *ssa.Function:
-		fn = v
-	case *ssa.MakeClosure:
-		return Returns(v.Fn)
-	default:
-		return nil
-	}
-
-	var rets []*ssa.Return
-	done := map[*ssa.BasicBlock]bool{}
-	for _, b := range fn.Blocks {
-		rets = append(rets, returnsInBlock(b, done)...)
-	}
-	return rets
-}
-
-func returnsInBlock(b *ssa.BasicBlock, done map[*ssa.BasicBlock]bool) (rets []*ssa.Return) {
-	if done[b] {
-		return nil
-	}
-	done[b] = true
-
-	if b.Index != 0 && len(b.Preds) == 0 {
-		return nil
-	}
-
-	if len(b.Instrs) != 0 {
-		switch instr := b.Instrs[len(b.Instrs)-1].(type) {
-		case *ssa.Return:
-			rets = append(rets, instr)
-		}
-	}
-
-	for _, s := range b.Succs {
-		rets = append(rets, returnsInBlock(s, done)...)
-	}
-
-	return rets
-}
-
-// BinOp returns binary operator values which are contained in the block b.
-func BinOp(b *ssa.BasicBlock) []*ssa.BinOp {
-	var binops []*ssa.BinOp
-	for _, instr := range b.Instrs {
-		if binop, ok := instr.(*ssa.BinOp); ok {
-			binops = append(binops, binop)
-		}
-	}
-	return binops
-}
-
-// Used returns an instruction which uses the value in the instructions.
-func Used(v ssa.Value, instrs []ssa.Instruction) ssa.Instruction {
-	if len(instrs) == 0 || v.Referrers() == nil {
-		return nil
-	}
-
-	for _, instr := range instrs {
-		if used := usedInInstr(v, instr); used != nil {
-			return used
-		}
-	}
-
-	return nil
-}
-
-func usedInInstr(v ssa.Value, instr ssa.Instruction) ssa.Instruction {
-	switch instr := instr.(type) {
-	case *ssa.MakeClosure:
-		return usedInClosure(v, instr)
-	default:
-		operands := instr.Operands(nil)
-		for _, x := range operands {
-			if x != nil && *x == v {
-				return instr
-			}
-		}
-	}
-
-	switch v := v.(type) {
-	case *ssa.UnOp:
-		return usedInInstr(v.X, instr)
-	}
-
-	return nil
-}
-
-func usedInClosure(v ssa.Value, instr *ssa.MakeClosure) ssa.Instruction {
-	fn, _ := instr.Fn.(*ssa.Function)
-	if fn == nil {
-		return nil
-	}
-
-	var fv *ssa.FreeVar
-	for i := range instr.Bindings {
-		if instr.Bindings[i] == v {
-			fv = fn.FreeVars[i]
-			break
-		}
-	}
-
-	if fv == nil {
-		return nil
-	}
-
-	for _, b := range fn.Blocks {
-		if used := Used(fv, b.Instrs); used != nil {
-			return used
-		}
-	}
-
-	return nil
-}
diff --git a/vendor/github.com/gostaticanalysis/analysisutil/ssainspect.go b/vendor/github.com/gostaticanalysis/analysisutil/ssainspect.go
deleted file mode 100644
index b2ae75f24..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/ssainspect.go
+++ /dev/null
@@ -1,47 +0,0 @@
-package analysisutil
-
-import "golang.org/x/tools/go/ssa"
-
-// InspectFuncs inspects functions.
-func InspectFuncs(funcs []*ssa.Function, f func(i int, instr ssa.Instruction) bool) {
-	for _, fun := range funcs {
-		if len(fun.Blocks) == 0 {
-			continue
-		}
-		new(instrInspector).block(fun.Blocks[0], 0, f)
-	}
-}
-
-// InspectInstr inspects from i-th instruction of start block to succsessor blocks.
-func InspectInstr(start *ssa.BasicBlock, i int, f func(i int, instr ssa.Instruction) bool) {
-	new(instrInspector).block(start, i, f)
-}
-
-type instrInspector struct {
-	done map[*ssa.BasicBlock]bool
-}
-
-func (ins *instrInspector) block(b *ssa.BasicBlock, i int, f func(i int, instr ssa.Instruction) bool) {
-	if ins.done == nil {
-		ins.done = map[*ssa.BasicBlock]bool{}
-	}
-
-	if b == nil || ins.done[b] || len(b.Instrs) <= i {
-		return
-	}
-
-	ins.done[b] = true
-	ins.instrs(i, b.Instrs[i:], f)
-	for _, s := range b.Succs {
-		ins.block(s, 0, f)
-	}
-
-}
-
-func (ins *instrInspector) instrs(offset int, instrs []ssa.Instruction, f func(i int, instr ssa.Instruction) bool) {
-	for i, instr := range instrs {
-		if !f(offset+i, instr) {
-			break
-		}
-	}
-}
diff --git a/vendor/github.com/gostaticanalysis/analysisutil/types.go b/vendor/github.com/gostaticanalysis/analysisutil/types.go
deleted file mode 100644
index 8265efc8e..000000000
--- a/vendor/github.com/gostaticanalysis/analysisutil/types.go
+++ /dev/null
@@ -1,228 +0,0 @@
-package analysisutil
-
-import (
-	"go/ast"
-	"go/types"
-
-	"golang.org/x/tools/go/analysis"
-)
-
-var errType = types.Universe.Lookup("error").Type().Underlying().(*types.Interface)
-
-// ImplementsError return whether t implements error interface.
-func ImplementsError(t types.Type) bool {
-	return types.Implements(t, errType)
-}
-
-// ObjectOf returns types.Object by given name in the package.
-func ObjectOf(pass *analysis.Pass, pkg, name string) types.Object {
-	obj := LookupFromImports(pass.Pkg.Imports(), pkg, name)
-	if obj != nil {
-		return obj
-	}
-	if RemoveVendor(pass.Pkg.Name()) != RemoveVendor(pkg) {
-		return nil
-	}
-	return pass.Pkg.Scope().Lookup(name)
-}
-
-// TypeOf returns types.Type by given name in the package.
-// TypeOf accepts pointer types such as *T.
-func TypeOf(pass *analysis.Pass, pkg, name string) types.Type {
-	if name == "" {
-		return nil
-	}
-
-	if name[0] == '*' {
-		obj := TypeOf(pass, pkg, name[1:])
-		if obj == nil {
-			return nil
-		}
-		return types.NewPointer(obj)
-	}
-
-	obj := ObjectOf(pass, pkg, name)
-	if obj == nil {
-		return nil
-	}
-
-	return obj.Type()
-}
-
-// MethodOf returns a method which has given name in the type.
-func MethodOf(typ types.Type, name string) *types.Func {
-	switch typ := typ.(type) {
-	case *types.Named:
-		for i := 0; i < typ.NumMethods(); i++ {
-			if f := typ.Method(i); f.Name() == name {
-				return f
-			}
-		}
-	case *types.Pointer:
-		return MethodOf(typ.Elem(), name)
-	}
-	return nil
-}
-
-// see: https://github.com/golang/go/issues/19670
-func identical(x, y types.Type) (ret bool) {
-	defer func() {
-		r := recover()
-		switch r := r.(type) {
-		case string:
-			if r == "unreachable" {
-				ret = false
-				return
-			}
-		case nil:
-			return
-		}
-		panic(r)
-	}()
-	return types.Identical(x, y)
-}
-
-// Interfaces returns a map of interfaces which are declared in the package.
-func Interfaces(pkg *types.Package) map[string]*types.Interface {
-	ifs := map[string]*types.Interface{}
-
-	for _, n := range pkg.Scope().Names() {
-		o := pkg.Scope().Lookup(n)
-		if o != nil {
-			i, ok := o.Type().Underlying().(*types.Interface)
-			if ok {
-				ifs[n] = i
-			}
-		}
-	}
-
-	return ifs
-}
-
-// Structs returns a map of structs which are declared in the package.
-func Structs(pkg *types.Package) map[string]*types.Struct {
-	structs := map[string]*types.Struct{}
-
-	for _, n := range pkg.Scope().Names() {
-		o := pkg.Scope().Lookup(n)
-		if o != nil {
-			s, ok := o.Type().Underlying().(*types.Struct)
-			if ok {
-				structs[n] = s
-			}
-		}
-	}
-
-	return structs
-}
-
-// HasField returns whether the struct has the field.
-func HasField(s *types.Struct, f *types.Var) bool {
-	if s == nil || f == nil {
-		return false
-	}
-
-	for i := 0; i < s.NumFields(); i++ {
-		if s.Field(i) == f {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Field returns field of the struct type.
-// If the type is not struct or has not the field,
-// Field returns -1, nil.
-// If the type is a named type or a pointer type,
-// Field calls itself recursively with
-// an underlying type or an element type of pointer.
-func Field(t types.Type, name string) (int, *types.Var) {
-	switch t := t.(type) {
-	case *types.Pointer:
-		return Field(t.Elem(), name)
-	case *types.Named:
-		return Field(t.Underlying(), name)
-	case *types.Struct:
-		for i := 0; i < t.NumFields(); i++ {
-			f := t.Field(i)
-			if f.Name() == name {
-				return i, f
-			}
-		}
-	}
-
-	return -1, nil
-}
-
-func TypesInfo(info ...*types.Info) *types.Info {
-	if len(info) == 0 {
-		return nil
-	}
-
-	var merged types.Info
-	for i := range info {
-		mergeTypesInfo(&merged, info[i])
-	}
-
-	return &merged
-}
-
-func mergeTypesInfo(i1, i2 *types.Info) {
-	// Types
-	if i1.Types == nil && i2.Types != nil {
-		i1.Types = map[ast.Expr]types.TypeAndValue{}
-	}
-	for expr, tv := range i2.Types {
-		i1.Types[expr] = tv
-	}
-
-	// Defs
-	if i1.Defs == nil && i2.Defs != nil {
-		i1.Defs = map[*ast.Ident]types.Object{}
-	}
-	for ident, obj := range i2.Defs {
-		i1.Defs[ident] = obj
-	}
-
-	// Uses
-	if i1.Uses == nil && i2.Uses != nil {
-		i1.Uses = map[*ast.Ident]types.Object{}
-	}
-	for ident, obj := range i2.Uses {
-		i1.Uses[ident] = obj
-	}
-
-	// Implicits
-	if i1.Implicits == nil && i2.Implicits != nil {
-		i1.Implicits = map[ast.Node]types.Object{}
-	}
-	for n, obj := range i2.Implicits {
-		i1.Implicits[n] = obj
-	}
-
-	// Selections
-	if i1.Selections == nil && i2.Selections != nil {
-		i1.Selections = map[*ast.SelectorExpr]*types.Selection{}
-	}
-	for expr, sel := range i2.Selections {
-		i1.Selections[expr] = sel
-	}
-
-	// Scopes
-	if i1.Scopes == nil && i2.Scopes != nil {
-		i1.Scopes = map[ast.Node]*types.Scope{}
-	}
-	for n, s := range i2.Scopes {
-		i1.Scopes[n] = s
-	}
-
-	// InitOrder
-	i1.InitOrder = append(i1.InitOrder, i2.InitOrder...)
-}
-
-// Under returns the most bottom underlying type.
-// Deprecated: (types.Type).Underlying returns same value of it.
-func Under(t types.Type) types.Type {
-	return t.Underlying()
-}