go.mod: vendor golangci-lint

1 files changed, 955 insertions, 0 deletions

diff --git a/vendor/github.com/go-toolsmith/astcopy/astcopy.go b/vendor/github.com/go-toolsmith/astcopy/astcopy.go
new file mode 100644
index 000000000..2feffb199
--- /dev/null
+++ b/vendor/github.com/go-toolsmith/astcopy/astcopy.go
@@ -0,0 +1,955 @@
+// Package astcopy implements Go AST reflection-free deep copy operations.
+package astcopy
+
+import (
+	"go/ast"
+)
+
+// Node returns x node deep copy.
+// Copy of nil argument is nil.
+func Node(x ast.Node) ast.Node {
+	return copyNode(x)
+}
+
+// NodeList returns xs node slice deep copy.
+// Copy of nil argument is nil.
+func NodeList(xs []ast.Node) []ast.Node {
+	if xs == nil {
+		return nil
+	}
+	cp := make([]ast.Node, len(xs))
+	for i := range xs {
+		cp[i] = copyNode(xs[i])
+	}
+	return cp
+}
+
+// Expr returns x expression deep copy.
+// Copy of nil argument is nil.
+func Expr(x ast.Expr) ast.Expr {
+	return copyExpr(x)
+}
+
+// ExprList returns xs expression slice deep copy.
+// Copy of nil argument is nil.
+func ExprList(xs []ast.Expr) []ast.Expr {
+	if xs == nil {
+		return nil
+	}
+	cp := make([]ast.Expr, len(xs))
+	for i := range xs {
+		cp[i] = copyExpr(xs[i])
+	}
+	return cp
+}
+
+// Stmt returns x statement deep copy.
+// Copy of nil argument is nil.
+func Stmt(x ast.Stmt) ast.Stmt {
+	return copyStmt(x)
+}
+
+// StmtList returns xs statement slice deep copy.
+// Copy of nil argument is nil.
+func StmtList(xs []ast.Stmt) []ast.Stmt {
+	if xs == nil {
+		return nil
+	}
+	cp := make([]ast.Stmt, len(xs))
+	for i := range xs {
+		cp[i] = copyStmt(xs[i])
+	}
+	return cp
+}
+
+// Decl returns x declaration deep copy.
+// Copy of nil argument is nil.
+func Decl(x ast.Decl) ast.Decl {
+	return copyDecl(x)
+}
+
+// DeclList returns xs declaration slice deep copy.
+// Copy of nil argument is nil.
+func DeclList(xs []ast.Decl) []ast.Decl {
+	if xs == nil {
+		return nil
+	}
+	cp := make([]ast.Decl, len(xs))
+	for i := range xs {
+		cp[i] = copyDecl(xs[i])
+	}
+	return cp
+}
+
+// BadExpr returns x deep copy.
+// Copy of nil argument is nil.
+func BadExpr(x *ast.BadExpr) *ast.BadExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	return &cp
+}
+
+// Ident returns x deep copy.
+// Copy of nil argument is nil.
+func Ident(x *ast.Ident) *ast.Ident {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	return &cp
+}
+
+// IdentList returns xs identifier slice deep copy.
+// Copy of nil argument is nil.
+func IdentList(xs []*ast.Ident) []*ast.Ident {
+	if xs == nil {
+		return nil
+	}
+	cp := make([]*ast.Ident, len(xs))
+	for i := range xs {
+		cp[i] = Ident(xs[i])
+	}
+	return cp
+}
+
+// Ellipsis returns x deep copy.
+// Copy of nil argument is nil.
+func Ellipsis(x *ast.Ellipsis) *ast.Ellipsis {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Elt = copyExpr(x.Elt)
+	return &cp
+}
+
+// BasicLit returns x deep copy.
+// Copy of nil argument is nil.
+func BasicLit(x *ast.BasicLit) *ast.BasicLit {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	return &cp
+}
+
+// FuncLit returns x deep copy.
+// Copy of nil argument is nil.
+func FuncLit(x *ast.FuncLit) *ast.FuncLit {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Type = FuncType(x.Type)
+	cp.Body = BlockStmt(x.Body)
+	return &cp
+}
+
+// CompositeLit returns x deep copy.
+// Copy of nil argument is nil.
+func CompositeLit(x *ast.CompositeLit) *ast.CompositeLit {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Type = copyExpr(x.Type)
+	cp.Elts = ExprList(x.Elts)
+	return &cp
+}
+
+// ParenExpr returns x deep copy.
+// Copy of nil argument is nil.
+func ParenExpr(x *ast.ParenExpr) *ast.ParenExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	return &cp
+}
+
+// SelectorExpr returns x deep copy.
+// Copy of nil argument is nil.
+func SelectorExpr(x *ast.SelectorExpr) *ast.SelectorExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	cp.Sel = Ident(x.Sel)
+	return &cp
+}
+
+// IndexExpr returns x deep copy.
+// Copy of nil argument is nil.
+func IndexExpr(x *ast.IndexExpr) *ast.IndexExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	cp.Index = copyExpr(x.Index)
+	return &cp
+}
+
+// SliceExpr returns x deep copy.
+// Copy of nil argument is nil.
+func SliceExpr(x *ast.SliceExpr) *ast.SliceExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	cp.Low = copyExpr(x.Low)
+	cp.High = copyExpr(x.High)
+	cp.Max = copyExpr(x.Max)
+	return &cp
+}
+
+// TypeAssertExpr returns x deep copy.
+// Copy of nil argument is nil.
+func TypeAssertExpr(x *ast.TypeAssertExpr) *ast.TypeAssertExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	cp.Type = copyExpr(x.Type)
+	return &cp
+}
+
+// CallExpr returns x deep copy.
+// Copy of nil argument is nil.
+func CallExpr(x *ast.CallExpr) *ast.CallExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Fun = copyExpr(x.Fun)
+	cp.Args = ExprList(x.Args)
+	return &cp
+}
+
+// StarExpr returns x deep copy.
+// Copy of nil argument is nil.
+func StarExpr(x *ast.StarExpr) *ast.StarExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	return &cp
+}
+
+// UnaryExpr returns x deep copy.
+// Copy of nil argument is nil.
+func UnaryExpr(x *ast.UnaryExpr) *ast.UnaryExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	return &cp
+}
+
+// BinaryExpr returns x deep copy.
+// Copy of nil argument is nil.
+func BinaryExpr(x *ast.BinaryExpr) *ast.BinaryExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	cp.Y = copyExpr(x.Y)
+	return &cp
+}
+
+// KeyValueExpr returns x deep copy.
+// Copy of nil argument is nil.
+func KeyValueExpr(x *ast.KeyValueExpr) *ast.KeyValueExpr {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Key = copyExpr(x.Key)
+	cp.Value = copyExpr(x.Value)
+	return &cp
+}
+
+// ArrayType returns x deep copy.
+// Copy of nil argument is nil.
+func ArrayType(x *ast.ArrayType) *ast.ArrayType {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Len = copyExpr(x.Len)
+	cp.Elt = copyExpr(x.Elt)
+	return &cp
+}
+
+// StructType returns x deep copy.
+// Copy of nil argument is nil.
+func StructType(x *ast.StructType) *ast.StructType {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Fields = FieldList(x.Fields)
+	return &cp
+}
+
+// Field returns x deep copy.
+// Copy of nil argument is nil.
+func Field(x *ast.Field) *ast.Field {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Names = IdentList(x.Names)
+	cp.Type = copyExpr(x.Type)
+	cp.Tag = BasicLit(x.Tag)
+	cp.Doc = CommentGroup(x.Doc)
+	cp.Comment = CommentGroup(x.Comment)
+	return &cp
+}
+
+// FieldList returns x deep copy.
+// Copy of nil argument is nil.
+func FieldList(x *ast.FieldList) *ast.FieldList {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	if x.List != nil {
+		cp.List = make([]*ast.Field, len(x.List))
+		for i := range x.List {
+			cp.List[i] = Field(x.List[i])
+		}
+	}
+	return &cp
+}
+
+// FuncType returns x deep copy.
+// Copy of nil argument is nil.
+func FuncType(x *ast.FuncType) *ast.FuncType {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Params = FieldList(x.Params)
+	cp.Results = FieldList(x.Results)
+	return &cp
+}
+
+// InterfaceType returns x deep copy.
+// Copy of nil argument is nil.
+func InterfaceType(x *ast.InterfaceType) *ast.InterfaceType {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Methods = FieldList(x.Methods)
+	return &cp
+}
+
+// MapType returns x deep copy.
+// Copy of nil argument is nil.
+func MapType(x *ast.MapType) *ast.MapType {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Key = copyExpr(x.Key)
+	cp.Value = copyExpr(x.Value)
+	return &cp
+}
+
+// ChanType returns x deep copy.
+// Copy of nil argument is nil.
+func ChanType(x *ast.ChanType) *ast.ChanType {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Value = copyExpr(x.Value)
+	return &cp
+}
+
+// BlockStmt returns x deep copy.
+// Copy of nil argument is nil.
+func BlockStmt(x *ast.BlockStmt) *ast.BlockStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.List = StmtList(x.List)
+	return &cp
+}
+
+// ImportSpec returns x deep copy.
+// Copy of nil argument is nil.
+func ImportSpec(x *ast.ImportSpec) *ast.ImportSpec {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Name = Ident(x.Name)
+	cp.Path = BasicLit(x.Path)
+	cp.Doc = CommentGroup(x.Doc)
+	cp.Comment = CommentGroup(x.Comment)
+	return &cp
+}
+
+// ValueSpec returns x deep copy.
+// Copy of nil argument is nil.
+func ValueSpec(x *ast.ValueSpec) *ast.ValueSpec {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Names = IdentList(x.Names)
+	cp.Values = ExprList(x.Values)
+	cp.Type = copyExpr(x.Type)
+	cp.Doc = CommentGroup(x.Doc)
+	cp.Comment = CommentGroup(x.Comment)
+	return &cp
+}
+
+// TypeSpec returns x deep copy.
+// Copy of nil argument is nil.
+func TypeSpec(x *ast.TypeSpec) *ast.TypeSpec {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Name = Ident(x.Name)
+	cp.Type = copyExpr(x.Type)
+	cp.Doc = CommentGroup(x.Doc)
+	cp.Comment = CommentGroup(x.Comment)
+	return &cp
+}
+
+// Spec returns x deep copy.
+// Copy of nil argument is nil.
+func Spec(x ast.Spec) ast.Spec {
+	if x == nil {
+		return nil
+	}
+
+	switch x := x.(type) {
+	case *ast.ImportSpec:
+		return ImportSpec(x)
+	case *ast.ValueSpec:
+		return ValueSpec(x)
+	case *ast.TypeSpec:
+		return TypeSpec(x)
+	default:
+		panic("unhandled spec")
+	}
+}
+
+// SpecList returns xs spec slice deep copy.
+// Copy of nil argument is nil.
+func SpecList(xs []ast.Spec) []ast.Spec {
+	if xs == nil {
+		return nil
+	}
+	cp := make([]ast.Spec, len(xs))
+	for i := range xs {
+		cp[i] = Spec(xs[i])
+	}
+	return cp
+}
+
+// BadStmt returns x deep copy.
+// Copy of nil argument is nil.
+func BadStmt(x *ast.BadStmt) *ast.BadStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	return &cp
+}
+
+// DeclStmt returns x deep copy.
+// Copy of nil argument is nil.
+func DeclStmt(x *ast.DeclStmt) *ast.DeclStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Decl = copyDecl(x.Decl)
+	return &cp
+}
+
+// EmptyStmt returns x deep copy.
+// Copy of nil argument is nil.
+func EmptyStmt(x *ast.EmptyStmt) *ast.EmptyStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	return &cp
+}
+
+// LabeledStmt returns x deep copy.
+// Copy of nil argument is nil.
+func LabeledStmt(x *ast.LabeledStmt) *ast.LabeledStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Label = Ident(x.Label)
+	cp.Stmt = copyStmt(x.Stmt)
+	return &cp
+}
+
+// ExprStmt returns x deep copy.
+// Copy of nil argument is nil.
+func ExprStmt(x *ast.ExprStmt) *ast.ExprStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	return &cp
+}
+
+// SendStmt returns x deep copy.
+// Copy of nil argument is nil.
+func SendStmt(x *ast.SendStmt) *ast.SendStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Chan = copyExpr(x.Chan)
+	cp.Value = copyExpr(x.Value)
+	return &cp
+}
+
+// IncDecStmt returns x deep copy.
+// Copy of nil argument is nil.
+func IncDecStmt(x *ast.IncDecStmt) *ast.IncDecStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.X = copyExpr(x.X)
+	return &cp
+}
+
+// AssignStmt returns x deep copy.
+// Copy of nil argument is nil.
+func AssignStmt(x *ast.AssignStmt) *ast.AssignStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Lhs = ExprList(x.Lhs)
+	cp.Rhs = ExprList(x.Rhs)
+	return &cp
+}
+
+// GoStmt returns x deep copy.
+// Copy of nil argument is nil.
+func GoStmt(x *ast.GoStmt) *ast.GoStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Call = CallExpr(x.Call)
+	return &cp
+}
+
+// DeferStmt returns x deep copy.
+// Copy of nil argument is nil.
+func DeferStmt(x *ast.DeferStmt) *ast.DeferStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Call = CallExpr(x.Call)
+	return &cp
+}
+
+// ReturnStmt returns x deep copy.
+// Copy of nil argument is nil.
+func ReturnStmt(x *ast.ReturnStmt) *ast.ReturnStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Results = ExprList(x.Results)
+	return &cp
+}
+
+// BranchStmt returns x deep copy.
+// Copy of nil argument is nil.
+func BranchStmt(x *ast.BranchStmt) *ast.BranchStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Label = Ident(x.Label)
+	return &cp
+}
+
+// IfStmt returns x deep copy.
+// Copy of nil argument is nil.
+func IfStmt(x *ast.IfStmt) *ast.IfStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Init = copyStmt(x.Init)
+	cp.Cond = copyExpr(x.Cond)
+	cp.Body = BlockStmt(x.Body)
+	cp.Else = copyStmt(x.Else)
+	return &cp
+}
+
+// CaseClause returns x deep copy.
+// Copy of nil argument is nil.
+func CaseClause(x *ast.CaseClause) *ast.CaseClause {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.List = ExprList(x.List)
+	cp.Body = StmtList(x.Body)
+	return &cp
+}
+
+// SwitchStmt returns x deep copy.
+// Copy of nil argument is nil.
+func SwitchStmt(x *ast.SwitchStmt) *ast.SwitchStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Init = copyStmt(x.Init)
+	cp.Tag = copyExpr(x.Tag)
+	cp.Body = BlockStmt(x.Body)
+	return &cp
+}
+
+// TypeSwitchStmt returns x deep copy.
+// Copy of nil argument is nil.
+func TypeSwitchStmt(x *ast.TypeSwitchStmt) *ast.TypeSwitchStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Init = copyStmt(x.Init)
+	cp.Assign = copyStmt(x.Assign)
+	cp.Body = BlockStmt(x.Body)
+	return &cp
+}
+
+// CommClause returns x deep copy.
+// Copy of nil argument is nil.
+func CommClause(x *ast.CommClause) *ast.CommClause {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Comm = copyStmt(x.Comm)
+	cp.Body = StmtList(x.Body)
+	return &cp
+}
+
+// SelectStmt returns x deep copy.
+// Copy of nil argument is nil.
+func SelectStmt(x *ast.SelectStmt) *ast.SelectStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Body = BlockStmt(x.Body)
+	return &cp
+}
+
+// ForStmt returns x deep copy.
+// Copy of nil argument is nil.
+func ForStmt(x *ast.ForStmt) *ast.ForStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Init = copyStmt(x.Init)
+	cp.Cond = copyExpr(x.Cond)
+	cp.Post = copyStmt(x.Post)
+	cp.Body = BlockStmt(x.Body)
+	return &cp
+}
+
+// RangeStmt returns x deep copy.
+// Copy of nil argument is nil.
+func RangeStmt(x *ast.RangeStmt) *ast.RangeStmt {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Key = copyExpr(x.Key)
+	cp.Value = copyExpr(x.Value)
+	cp.X = copyExpr(x.X)
+	cp.Body = BlockStmt(x.Body)
+	return &cp
+}
+
+// Comment returns x deep copy.
+// Copy of nil argument is nil.
+func Comment(x *ast.Comment) *ast.Comment {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	return &cp
+}
+
+// CommentGroup returns x deep copy.
+// Copy of nil argument is nil.
+func CommentGroup(x *ast.CommentGroup) *ast.CommentGroup {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	if x.List != nil {
+		cp.List = make([]*ast.Comment, len(x.List))
+		for i := range x.List {
+			cp.List[i] = Comment(x.List[i])
+		}
+	}
+	return &cp
+}
+
+// File returns x deep copy.
+// Copy of nil argument is nil.
+func File(x *ast.File) *ast.File {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Doc = CommentGroup(x.Doc)
+	cp.Name = Ident(x.Name)
+	cp.Decls = DeclList(x.Decls)
+	cp.Imports = make([]*ast.ImportSpec, len(x.Imports))
+	for i := range x.Imports {
+		cp.Imports[i] = ImportSpec(x.Imports[i])
+	}
+	cp.Unresolved = IdentList(x.Unresolved)
+	cp.Comments = make([]*ast.CommentGroup, len(x.Comments))
+	for i := range x.Comments {
+		cp.Comments[i] = CommentGroup(x.Comments[i])
+	}
+	return &cp
+}
+
+// Package returns x deep copy.
+// Copy of nil argument is nil.
+func Package(x *ast.Package) *ast.Package {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Files = make(map[string]*ast.File)
+	for filename, f := range x.Files {
+		cp.Files[filename] = f
+	}
+	return &cp
+}
+
+// BadDecl returns x deep copy.
+// Copy of nil argument is nil.
+func BadDecl(x *ast.BadDecl) *ast.BadDecl {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	return &cp
+}
+
+// GenDecl returns x deep copy.
+// Copy of nil argument is nil.
+func GenDecl(x *ast.GenDecl) *ast.GenDecl {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Specs = SpecList(x.Specs)
+	cp.Doc = CommentGroup(x.Doc)
+	return &cp
+}
+
+// FuncDecl returns x deep copy.
+// Copy of nil argument is nil.
+func FuncDecl(x *ast.FuncDecl) *ast.FuncDecl {
+	if x == nil {
+		return nil
+	}
+	cp := *x
+	cp.Recv = FieldList(x.Recv)
+	cp.Name = Ident(x.Name)
+	cp.Type = FuncType(x.Type)
+	cp.Body = BlockStmt(x.Body)
+	cp.Doc = CommentGroup(x.Doc)
+	return &cp
+}
+
+func copyNode(x ast.Node) ast.Node {
+	switch x := x.(type) {
+	case ast.Expr:
+		return copyExpr(x)
+	case ast.Stmt:
+		return copyStmt(x)
+	case ast.Decl:
+		return copyDecl(x)
+
+	case ast.Spec:
+		return Spec(x)
+	case *ast.FieldList:
+		return FieldList(x)
+	case *ast.Comment:
+		return Comment(x)
+	case *ast.CommentGroup:
+		return CommentGroup(x)
+	case *ast.File:
+		return File(x)
+	case *ast.Package:
+		return Package(x)
+
+	default:
+		panic("unhandled node")
+	}
+}
+
+func copyExpr(x ast.Expr) ast.Expr {
+	if x == nil {
+		return nil
+	}
+
+	switch x := x.(type) {
+	case *ast.BadExpr:
+		return BadExpr(x)
+	case *ast.Ident:
+		return Ident(x)
+	case *ast.Ellipsis:
+		return Ellipsis(x)
+	case *ast.BasicLit:
+		return BasicLit(x)
+	case *ast.FuncLit:
+		return FuncLit(x)
+	case *ast.CompositeLit:
+		return CompositeLit(x)
+	case *ast.ParenExpr:
+		return ParenExpr(x)
+	case *ast.SelectorExpr:
+		return SelectorExpr(x)
+	case *ast.IndexExpr:
+		return IndexExpr(x)
+	case *ast.SliceExpr:
+		return SliceExpr(x)
+	case *ast.TypeAssertExpr:
+		return TypeAssertExpr(x)
+	case *ast.CallExpr:
+		return CallExpr(x)
+	case *ast.StarExpr:
+		return StarExpr(x)
+	case *ast.UnaryExpr:
+		return UnaryExpr(x)
+	case *ast.BinaryExpr:
+		return BinaryExpr(x)
+	case *ast.KeyValueExpr:
+		return KeyValueExpr(x)
+	case *ast.ArrayType:
+		return ArrayType(x)
+	case *ast.StructType:
+		return StructType(x)
+	case *ast.FuncType:
+		return FuncType(x)
+	case *ast.InterfaceType:
+		return InterfaceType(x)
+	case *ast.MapType:
+		return MapType(x)
+	case *ast.ChanType:
+		return ChanType(x)
+
+	default:
+		panic("unhandled expr")
+	}
+}
+
+func copyStmt(x ast.Stmt) ast.Stmt {
+	if x == nil {
+		return nil
+	}
+
+	switch x := x.(type) {
+	case *ast.BadStmt:
+		return BadStmt(x)
+	case *ast.DeclStmt:
+		return DeclStmt(x)
+	case *ast.EmptyStmt:
+		return EmptyStmt(x)
+	case *ast.LabeledStmt:
+		return LabeledStmt(x)
+	case *ast.ExprStmt:
+		return ExprStmt(x)
+	case *ast.SendStmt:
+		return SendStmt(x)
+	case *ast.IncDecStmt:
+		return IncDecStmt(x)
+	case *ast.AssignStmt:
+		return AssignStmt(x)
+	case *ast.GoStmt:
+		return GoStmt(x)
+	case *ast.DeferStmt:
+		return DeferStmt(x)
+	case *ast.ReturnStmt:
+		return ReturnStmt(x)
+	case *ast.BranchStmt:
+		return BranchStmt(x)
+	case *ast.BlockStmt:
+		return BlockStmt(x)
+	case *ast.IfStmt:
+		return IfStmt(x)
+	case *ast.CaseClause:
+		return CaseClause(x)
+	case *ast.SwitchStmt:
+		return SwitchStmt(x)
+	case *ast.TypeSwitchStmt:
+		return TypeSwitchStmt(x)
+	case *ast.CommClause:
+		return CommClause(x)
+	case *ast.SelectStmt:
+		return SelectStmt(x)
+	case *ast.ForStmt:
+		return ForStmt(x)
+	case *ast.RangeStmt:
+		return RangeStmt(x)
+
+	default:
+		panic("unhandled stmt")
+	}
+}
+
+func copyDecl(x ast.Decl) ast.Decl {
+	if x == nil {
+		return nil
+	}
+
+	switch x := x.(type) {
+	case *ast.BadDecl:
+		return BadDecl(x)
+	case *ast.GenDecl:
+		return GenDecl(x)
+	case *ast.FuncDecl:
+		return FuncDecl(x)
+
+	default:
+		panic("unhandled decl")
+	}
+}