go.mod: vendor golangci-lint

1 files changed, 590 insertions, 0 deletions

diff --git a/vendor/github.com/go-toolsmith/astcast/astcast.go b/vendor/github.com/go-toolsmith/astcast/astcast.go
new file mode 100644
index 000000000..746d568aa
--- /dev/null
+++ b/vendor/github.com/go-toolsmith/astcast/astcast.go
@@ -0,0 +1,590 @@
+// 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
+}