vendor: delete

3 files changed, 0 insertions, 714 deletions

diff --git a/vendor/github.com/go-toolsmith/astcast/LICENSE b/vendor/github.com/go-toolsmith/astcast/LICENSE
deleted file mode 100644
index eef17180f..000000000
--- a/vendor/github.com/go-toolsmith/astcast/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2018 go-toolsmith
-
-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/go-toolsmith/astcast/README.md b/vendor/github.com/go-toolsmith/astcast/README.md
deleted file mode 100644
index 19ca0e71d..000000000
--- a/vendor/github.com/go-toolsmith/astcast/README.md
+++ /dev/null
@@ -1,103 +0,0 @@
-# astcast
-
-[![build-img]][build-url]
-[![pkg-img]][pkg-url]
-[![reportcard-img]][reportcard-url]
-[![version-img]][version-url]
-
-Package `astcast` wraps type assertion operations in such way that you don't have
-to worry about nil pointer results anymore.
-
-## Installation
-
-Go version 1.16+
-
-```bash
-go get github.com/go-toolsmith/astcast
-```
-
-## Example
-
-```go
-package main
-
-import (
-	"fmt"
-
-	"github.com/go-toolsmith/astcast"
-	"github.com/go-toolsmith/strparse"
-)
-
-func main() {
-	x := strparse.Expr(`(foo * bar) + 1`)
-
-	// x type is ast.Expr, we want to access bar operand
-	// that is a RHS of the LHS of the addition.
-	// Note that addition LHS (X field) is has parenthesis,
-	// so we have to remove them too.
-
-	add := astcast.ToBinaryExpr(x)
-	mul := astcast.ToBinaryExpr(astcast.ToParenExpr(add.X).X)
-	bar := astcast.ToIdent(mul.Y)
-	fmt.Printf("%T %s\n", bar, bar.Name) // => *ast.Ident bar
-
-	// If argument has different dynamic type,
-	// non-nil sentinel object of requested type is returned.
-	// Those sentinel objects are exported so if you need
-	// to know whether it was a nil interface value of
-	// failed type assertion, you can compare returned
-	// object with such a sentinel.
-
-	y := astcast.ToCallExpr(strparse.Expr(`x`))
-	if y == astcast.NilCallExpr {
-		fmt.Println("it is a sentinel, type assertion failed")
-	}
-}
-```
-
-Without `astcast`, you would have to do a lots of type assertions:
-
-```go
-package main
-
-import (
-	"fmt"
-
-	"github.com/go-toolsmith/strparse"
-)
-
-func main() {
-	x := strparse.Expr(`(foo * bar) + 1`)
-
-	add, ok := x.(*ast.BinaryExpr)
-	if !ok || add == nil {
-		return
-	}
-	additionLHS, ok := add.X.(*ast.ParenExpr)
-	if !ok || additionLHS == nil {
-		return
-	}
-	mul, ok := additionLHS.X.(*ast.BinaryExpr)
-	if !ok || mul == nil {
-		return
-	}
-	bar, ok := mul.Y.(*ast.Ident)
-	if !ok || bar == nil {
-		return
-	}
-	fmt.Printf("%T %s\n", bar, bar.Name)
-}
-```
-
-## License
-
-[MIT License](LICENSE).
-
-[build-img]: https://github.com/go-toolsmith/astcast/workflows/build/badge.svg
-[build-url]: https://github.com/go-toolsmith/astcast/actions
-[pkg-img]: https://pkg.go.dev/badge/go-toolsmith/astcast
-[pkg-url]: https://pkg.go.dev/github.com/go-toolsmith/astcast
-[reportcard-img]: https://goreportcard.com/badge/go-toolsmith/astcast
-[reportcard-url]: https://goreportcard.com/report/go-toolsmith/astcast
-[version-img]: https://img.shields.io/github/v/release/go-toolsmith/astcast
-[version-url]: https://github.com/go-toolsmith/astcast/releases
diff --git a/vendor/github.com/go-toolsmith/astcast/astcast.go b/vendor/github.com/go-toolsmith/astcast/astcast.go
deleted file mode 100644
index 746d568aa..000000000
--- a/vendor/github.com/go-toolsmith/astcast/astcast.go
+++ /dev/null
@@ -1,590 +0,0 @@
-// Code generated by astcast_generate.go; DO NOT EDIT
-
-// Package astcast wraps type assertion operations in such way that you don't have
-// to worry about nil pointer results anymore.
-package astcast
-
-import (
-	"go/ast"
-)
-
-// A set of sentinel nil-like values that are returned
-// by all "casting" functions in case of failed type assertion.
-var (
-	NilArrayType      = &ast.ArrayType{}
-	NilBadExpr        = &ast.BadExpr{}
-	NilBasicLit       = &ast.BasicLit{}
-	NilBinaryExpr     = &ast.BinaryExpr{}
-	NilCallExpr       = &ast.CallExpr{}
-	NilChanType       = &ast.ChanType{}
-	NilCompositeLit   = &ast.CompositeLit{}
-	NilEllipsis       = &ast.Ellipsis{}
-	NilFuncLit        = &ast.FuncLit{}
-	NilFuncType       = &ast.FuncType{}
-	NilIdent          = &ast.Ident{}
-	NilIndexExpr      = &ast.IndexExpr{}
-	NilInterfaceType  = &ast.InterfaceType{}
-	NilKeyValueExpr   = &ast.KeyValueExpr{}
-	NilMapType        = &ast.MapType{}
-	NilParenExpr      = &ast.ParenExpr{}
-	NilSelectorExpr   = &ast.SelectorExpr{}
-	NilSliceExpr      = &ast.SliceExpr{}
-	NilStarExpr       = &ast.StarExpr{}
-	NilStructType     = &ast.StructType{}
-	NilTypeAssertExpr = &ast.TypeAssertExpr{}
-	NilUnaryExpr      = &ast.UnaryExpr{}
-	NilAssignStmt     = &ast.AssignStmt{}
-	NilBadStmt        = &ast.BadStmt{}
-	NilBlockStmt      = &ast.BlockStmt{}
-	NilBranchStmt     = &ast.BranchStmt{}
-	NilCaseClause     = &ast.CaseClause{}
-	NilCommClause     = &ast.CommClause{}
-	NilDeclStmt       = &ast.DeclStmt{}
-	NilDeferStmt      = &ast.DeferStmt{}
-	NilEmptyStmt      = &ast.EmptyStmt{}
-	NilExprStmt       = &ast.ExprStmt{}
-	NilForStmt        = &ast.ForStmt{}
-	NilGoStmt         = &ast.GoStmt{}
-	NilIfStmt         = &ast.IfStmt{}
-	NilIncDecStmt     = &ast.IncDecStmt{}
-	NilLabeledStmt    = &ast.LabeledStmt{}
-	NilRangeStmt      = &ast.RangeStmt{}
-	NilReturnStmt     = &ast.ReturnStmt{}
-	NilSelectStmt     = &ast.SelectStmt{}
-	NilSendStmt       = &ast.SendStmt{}
-	NilSwitchStmt     = &ast.SwitchStmt{}
-	NilTypeSwitchStmt = &ast.TypeSwitchStmt{}
-	NilComment        = &ast.Comment{}
-	NilCommentGroup   = &ast.CommentGroup{}
-	NilFieldList      = &ast.FieldList{}
-	NilFile           = &ast.File{}
-	NilPackage        = &ast.Package{}
-)
-
-// ToArrayType returns x as a non-nil *ast.ArrayType.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilArrayType.
-func ToArrayType(x ast.Node) *ast.ArrayType {
-	if x, ok := x.(*ast.ArrayType); ok {
-		return x
-	}
-	return NilArrayType
-}
-
-// ToBadExpr returns x as a non-nil *ast.BadExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilBadExpr.
-func ToBadExpr(x ast.Node) *ast.BadExpr {
-	if x, ok := x.(*ast.BadExpr); ok {
-		return x
-	}
-	return NilBadExpr
-}
-
-// ToBasicLit returns x as a non-nil *ast.BasicLit.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilBasicLit.
-func ToBasicLit(x ast.Node) *ast.BasicLit {
-	if x, ok := x.(*ast.BasicLit); ok {
-		return x
-	}
-	return NilBasicLit
-}
-
-// ToBinaryExpr returns x as a non-nil *ast.BinaryExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilBinaryExpr.
-func ToBinaryExpr(x ast.Node) *ast.BinaryExpr {
-	if x, ok := x.(*ast.BinaryExpr); ok {
-		return x
-	}
-	return NilBinaryExpr
-}
-
-// ToCallExpr returns x as a non-nil *ast.CallExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilCallExpr.
-func ToCallExpr(x ast.Node) *ast.CallExpr {
-	if x, ok := x.(*ast.CallExpr); ok {
-		return x
-	}
-	return NilCallExpr
-}
-
-// ToChanType returns x as a non-nil *ast.ChanType.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilChanType.
-func ToChanType(x ast.Node) *ast.ChanType {
-	if x, ok := x.(*ast.ChanType); ok {
-		return x
-	}
-	return NilChanType
-}
-
-// ToCompositeLit returns x as a non-nil *ast.CompositeLit.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilCompositeLit.
-func ToCompositeLit(x ast.Node) *ast.CompositeLit {
-	if x, ok := x.(*ast.CompositeLit); ok {
-		return x
-	}
-	return NilCompositeLit
-}
-
-// ToEllipsis returns x as a non-nil *ast.Ellipsis.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilEllipsis.
-func ToEllipsis(x ast.Node) *ast.Ellipsis {
-	if x, ok := x.(*ast.Ellipsis); ok {
-		return x
-	}
-	return NilEllipsis
-}
-
-// ToFuncLit returns x as a non-nil *ast.FuncLit.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilFuncLit.
-func ToFuncLit(x ast.Node) *ast.FuncLit {
-	if x, ok := x.(*ast.FuncLit); ok {
-		return x
-	}
-	return NilFuncLit
-}
-
-// ToFuncType returns x as a non-nil *ast.FuncType.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilFuncType.
-func ToFuncType(x ast.Node) *ast.FuncType {
-	if x, ok := x.(*ast.FuncType); ok {
-		return x
-	}
-	return NilFuncType
-}
-
-// ToIdent returns x as a non-nil *ast.Ident.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilIdent.
-func ToIdent(x ast.Node) *ast.Ident {
-	if x, ok := x.(*ast.Ident); ok {
-		return x
-	}
-	return NilIdent
-}
-
-// ToIndexExpr returns x as a non-nil *ast.IndexExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilIndexExpr.
-func ToIndexExpr(x ast.Node) *ast.IndexExpr {
-	if x, ok := x.(*ast.IndexExpr); ok {
-		return x
-	}
-	return NilIndexExpr
-}
-
-// ToInterfaceType returns x as a non-nil *ast.InterfaceType.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilInterfaceType.
-func ToInterfaceType(x ast.Node) *ast.InterfaceType {
-	if x, ok := x.(*ast.InterfaceType); ok {
-		return x
-	}
-	return NilInterfaceType
-}
-
-// ToKeyValueExpr returns x as a non-nil *ast.KeyValueExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilKeyValueExpr.
-func ToKeyValueExpr(x ast.Node) *ast.KeyValueExpr {
-	if x, ok := x.(*ast.KeyValueExpr); ok {
-		return x
-	}
-	return NilKeyValueExpr
-}
-
-// ToMapType returns x as a non-nil *ast.MapType.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilMapType.
-func ToMapType(x ast.Node) *ast.MapType {
-	if x, ok := x.(*ast.MapType); ok {
-		return x
-	}
-	return NilMapType
-}
-
-// ToParenExpr returns x as a non-nil *ast.ParenExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilParenExpr.
-func ToParenExpr(x ast.Node) *ast.ParenExpr {
-	if x, ok := x.(*ast.ParenExpr); ok {
-		return x
-	}
-	return NilParenExpr
-}
-
-// ToSelectorExpr returns x as a non-nil *ast.SelectorExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilSelectorExpr.
-func ToSelectorExpr(x ast.Node) *ast.SelectorExpr {
-	if x, ok := x.(*ast.SelectorExpr); ok {
-		return x
-	}
-	return NilSelectorExpr
-}
-
-// ToSliceExpr returns x as a non-nil *ast.SliceExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilSliceExpr.
-func ToSliceExpr(x ast.Node) *ast.SliceExpr {
-	if x, ok := x.(*ast.SliceExpr); ok {
-		return x
-	}
-	return NilSliceExpr
-}
-
-// ToStarExpr returns x as a non-nil *ast.StarExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilStarExpr.
-func ToStarExpr(x ast.Node) *ast.StarExpr {
-	if x, ok := x.(*ast.StarExpr); ok {
-		return x
-	}
-	return NilStarExpr
-}
-
-// ToStructType returns x as a non-nil *ast.StructType.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilStructType.
-func ToStructType(x ast.Node) *ast.StructType {
-	if x, ok := x.(*ast.StructType); ok {
-		return x
-	}
-	return NilStructType
-}
-
-// ToTypeAssertExpr returns x as a non-nil *ast.TypeAssertExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilTypeAssertExpr.
-func ToTypeAssertExpr(x ast.Node) *ast.TypeAssertExpr {
-	if x, ok := x.(*ast.TypeAssertExpr); ok {
-		return x
-	}
-	return NilTypeAssertExpr
-}
-
-// ToUnaryExpr returns x as a non-nil *ast.UnaryExpr.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilUnaryExpr.
-func ToUnaryExpr(x ast.Node) *ast.UnaryExpr {
-	if x, ok := x.(*ast.UnaryExpr); ok {
-		return x
-	}
-	return NilUnaryExpr
-}
-
-// ToAssignStmt returns x as a non-nil *ast.AssignStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilAssignStmt.
-func ToAssignStmt(x ast.Node) *ast.AssignStmt {
-	if x, ok := x.(*ast.AssignStmt); ok {
-		return x
-	}
-	return NilAssignStmt
-}
-
-// ToBadStmt returns x as a non-nil *ast.BadStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilBadStmt.
-func ToBadStmt(x ast.Node) *ast.BadStmt {
-	if x, ok := x.(*ast.BadStmt); ok {
-		return x
-	}
-	return NilBadStmt
-}
-
-// ToBlockStmt returns x as a non-nil *ast.BlockStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilBlockStmt.
-func ToBlockStmt(x ast.Node) *ast.BlockStmt {
-	if x, ok := x.(*ast.BlockStmt); ok {
-		return x
-	}
-	return NilBlockStmt
-}
-
-// ToBranchStmt returns x as a non-nil *ast.BranchStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilBranchStmt.
-func ToBranchStmt(x ast.Node) *ast.BranchStmt {
-	if x, ok := x.(*ast.BranchStmt); ok {
-		return x
-	}
-	return NilBranchStmt
-}
-
-// ToCaseClause returns x as a non-nil *ast.CaseClause.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilCaseClause.
-func ToCaseClause(x ast.Node) *ast.CaseClause {
-	if x, ok := x.(*ast.CaseClause); ok {
-		return x
-	}
-	return NilCaseClause
-}
-
-// ToCommClause returns x as a non-nil *ast.CommClause.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilCommClause.
-func ToCommClause(x ast.Node) *ast.CommClause {
-	if x, ok := x.(*ast.CommClause); ok {
-		return x
-	}
-	return NilCommClause
-}
-
-// ToDeclStmt returns x as a non-nil *ast.DeclStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilDeclStmt.
-func ToDeclStmt(x ast.Node) *ast.DeclStmt {
-	if x, ok := x.(*ast.DeclStmt); ok {
-		return x
-	}
-	return NilDeclStmt
-}
-
-// ToDeferStmt returns x as a non-nil *ast.DeferStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilDeferStmt.
-func ToDeferStmt(x ast.Node) *ast.DeferStmt {
-	if x, ok := x.(*ast.DeferStmt); ok {
-		return x
-	}
-	return NilDeferStmt
-}
-
-// ToEmptyStmt returns x as a non-nil *ast.EmptyStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilEmptyStmt.
-func ToEmptyStmt(x ast.Node) *ast.EmptyStmt {
-	if x, ok := x.(*ast.EmptyStmt); ok {
-		return x
-	}
-	return NilEmptyStmt
-}
-
-// ToExprStmt returns x as a non-nil *ast.ExprStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilExprStmt.
-func ToExprStmt(x ast.Node) *ast.ExprStmt {
-	if x, ok := x.(*ast.ExprStmt); ok {
-		return x
-	}
-	return NilExprStmt
-}
-
-// ToForStmt returns x as a non-nil *ast.ForStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilForStmt.
-func ToForStmt(x ast.Node) *ast.ForStmt {
-	if x, ok := x.(*ast.ForStmt); ok {
-		return x
-	}
-	return NilForStmt
-}
-
-// ToGoStmt returns x as a non-nil *ast.GoStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilGoStmt.
-func ToGoStmt(x ast.Node) *ast.GoStmt {
-	if x, ok := x.(*ast.GoStmt); ok {
-		return x
-	}
-	return NilGoStmt
-}
-
-// ToIfStmt returns x as a non-nil *ast.IfStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilIfStmt.
-func ToIfStmt(x ast.Node) *ast.IfStmt {
-	if x, ok := x.(*ast.IfStmt); ok {
-		return x
-	}
-	return NilIfStmt
-}
-
-// ToIncDecStmt returns x as a non-nil *ast.IncDecStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilIncDecStmt.
-func ToIncDecStmt(x ast.Node) *ast.IncDecStmt {
-	if x, ok := x.(*ast.IncDecStmt); ok {
-		return x
-	}
-	return NilIncDecStmt
-}
-
-// ToLabeledStmt returns x as a non-nil *ast.LabeledStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilLabeledStmt.
-func ToLabeledStmt(x ast.Node) *ast.LabeledStmt {
-	if x, ok := x.(*ast.LabeledStmt); ok {
-		return x
-	}
-	return NilLabeledStmt
-}
-
-// ToRangeStmt returns x as a non-nil *ast.RangeStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilRangeStmt.
-func ToRangeStmt(x ast.Node) *ast.RangeStmt {
-	if x, ok := x.(*ast.RangeStmt); ok {
-		return x
-	}
-	return NilRangeStmt
-}
-
-// ToReturnStmt returns x as a non-nil *ast.ReturnStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilReturnStmt.
-func ToReturnStmt(x ast.Node) *ast.ReturnStmt {
-	if x, ok := x.(*ast.ReturnStmt); ok {
-		return x
-	}
-	return NilReturnStmt
-}
-
-// ToSelectStmt returns x as a non-nil *ast.SelectStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilSelectStmt.
-func ToSelectStmt(x ast.Node) *ast.SelectStmt {
-	if x, ok := x.(*ast.SelectStmt); ok {
-		return x
-	}
-	return NilSelectStmt
-}
-
-// ToSendStmt returns x as a non-nil *ast.SendStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilSendStmt.
-func ToSendStmt(x ast.Node) *ast.SendStmt {
-	if x, ok := x.(*ast.SendStmt); ok {
-		return x
-	}
-	return NilSendStmt
-}
-
-// ToSwitchStmt returns x as a non-nil *ast.SwitchStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilSwitchStmt.
-func ToSwitchStmt(x ast.Node) *ast.SwitchStmt {
-	if x, ok := x.(*ast.SwitchStmt); ok {
-		return x
-	}
-	return NilSwitchStmt
-}
-
-// ToTypeSwitchStmt returns x as a non-nil *ast.TypeSwitchStmt.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilTypeSwitchStmt.
-func ToTypeSwitchStmt(x ast.Node) *ast.TypeSwitchStmt {
-	if x, ok := x.(*ast.TypeSwitchStmt); ok {
-		return x
-	}
-	return NilTypeSwitchStmt
-}
-
-// ToComment returns x as a non-nil *ast.Comment.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilComment.
-func ToComment(x ast.Node) *ast.Comment {
-	if x, ok := x.(*ast.Comment); ok {
-		return x
-	}
-	return NilComment
-}
-
-// ToCommentGroup returns x as a non-nil *ast.CommentGroup.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilCommentGroup.
-func ToCommentGroup(x ast.Node) *ast.CommentGroup {
-	if x, ok := x.(*ast.CommentGroup); ok {
-		return x
-	}
-	return NilCommentGroup
-}
-
-// ToFieldList returns x as a non-nil *ast.FieldList.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilFieldList.
-func ToFieldList(x ast.Node) *ast.FieldList {
-	if x, ok := x.(*ast.FieldList); ok {
-		return x
-	}
-	return NilFieldList
-}
-
-// ToFile returns x as a non-nil *ast.File.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilFile.
-func ToFile(x ast.Node) *ast.File {
-	if x, ok := x.(*ast.File); ok {
-		return x
-	}
-	return NilFile
-}
-
-// ToPackage returns x as a non-nil *ast.Package.
-// If ast.Node actually has such dynamic type, the result is
-// identical to normal type assertion. In case if it has
-// different type, the returned value is NilPackage.
-func ToPackage(x ast.Node) *ast.Package {
-	if x, ok := x.(*ast.Package); ok {
-		return x
-	}
-	return NilPackage
-}