func (f *FieldResolver) Args() []*InputValueResolver {
	res := make([]*InputValueResolver, len(f.AST.Arguments))
	for i, arg := range f.AST.Arguments {
		res[i] = &InputValueResolver{
			Lookup: f.Lookup,
			AST:    arg,
		}
	}
	return res
}
Args returns the arguments of a field.
package introspect
import (
	"reflect"
	"strings"
	"github.com/graphql-go/graphql/language/ast"
)
type ASTLookup interface {
	LookupType(ast.Type) ast.TypeDefinition
}
type ObjectResolver struct {
	Lookup         ASTLookup
	AST            *ast.ObjectDefinition
	SchemaResolver *SchemaResolver
}
func (sr *ObjectResolver) Schema() *SchemaResolver {
	return sr.SchemaResolver
}
func (sr *ObjectResolver) Type() *TypeResolver {
	return &TypeResolver{
		Lookup: sr.Lookup,
		AST:    sr.AST,
	}
}
type SchemaResolver struct {
	Lookup    ASTLookup
	RootQuery ast.TypeDefinition
	NamedTypes map[string]ast.TypeDefinition
}
func (r *SchemaResolver) QueryType() *TypeResolver {
	if r.RootQuery == nil {
		return nil
	}
	return &TypeResolver{
		Lookup: r.Lookup,
		AST:    r.RootQuery,
	}
}
func (r *SchemaResolver) Directives() []*DirectiveResolver {
	return []*DirectiveResolver{}
}
func (r *SchemaResolver) Types() []*TypeResolver {
	res := make([]*TypeResolver, len(r.NamedTypes))
	i := 0
	for _, typ := range r.NamedTypes {
		res[i] = &TypeResolver{
			AST:    typ,
			Lookup: r.Lookup,
		}
		i++
	}
	return res
}
type TypeResolver struct {
	Lookup ASTLookup
	NameCache string
	AST       ast.Node
}
func (r *TypeResolver) Kind() string {
	kindSrc := r.AST.GetKind()
	kindSrc = strings.TrimSuffix(kindSrc, "Definition")
	kindSrc = strings.ToUpper(kindSrc)
	return kindSrc
}
type namedType interface {
	GetName() *ast.Name
}
func resolveNamedType(typ ast.Node) (typeName *string) {
	named, ok := typ.(namedType)
	if !ok {
		return
	}
	name := named.GetName()
	if name == nil || name.Value == "" {
		return
	}
	return &name.Value
}
func (r *TypeResolver) Name() (typeName *string) {
	if r.NameCache != "" {
		return &r.NameCache
	}
	name := resolveNamedType(r.AST)
	if name != nil {
		r.NameCache = *name
	}
	return name
}
func (r *TypeResolver) Description() *string {
	return nil
}
func (r *TypeResolver) Fields() []*FieldResolver {
	objd, ok := r.AST.(*ast.ObjectDefinition)
	if !ok {
		return nil
	}
	res := []*FieldResolver{}
	for _, field := range objd.Fields {
		if field.Name == nil || strings.HasPrefix(field.Name.Value, "__") {
			continue
		}
		res = append(res, &FieldResolver{
			Lookup: r.Lookup,
			AST:    field,
		})
	}
	return res
}
func (r *TypeResolver) InputFields() []*InputValueResolver {
	return []*InputValueResolver{}
}
func (r *TypeResolver) Interfaces() []*TypeResolver {
	return make([]*TypeResolver, 0)
}
func (r *TypeResolver) PossibleTypes() []*TypeResolver {
	return make([]*TypeResolver, 0)
}
func (r *TypeResolver) EnumValues(args *struct{ IncludeDeprecated bool }) []*EnumValueResolver {
	ed, ok := r.AST.(*ast.EnumDefinition)
	if !ok {
		return nil
	}
	res := make([]*EnumValueResolver, len(ed.Values))
	for i, val := range ed.Values {
		res[i] = &EnumValueResolver{
			Lookup: r.Lookup,
			AST:    val,
		}
	}
	return res
}
func (sr *TypeResolver) OfType() *TypeResolver {
	list, ok := sr.AST.(*ast.List)
	if !ok {
		return nil
	}
	return &TypeResolver{
		Lookup: sr.Lookup,
		AST:    sr.Lookup.LookupType(list.Type),
	}
}
type FieldResolver struct {
	Lookup ASTLookup
	AST    *ast.FieldDefinition
}
func (r *FieldResolver) Type() *TypeResolver {
	aste := r.Lookup.LookupType(r.AST.Type)
	if aste == nil {
		return nil
	}
	return &TypeResolver{
		Lookup: r.Lookup,
		AST:    aste,
	}
}
func (e *FieldResolver) IsDeprecated() bool {
	return false
}
func (e *FieldResolver) DeprecationReason() *string {
	return nil
}
func (f *FieldResolver) Name() string {
	return f.AST.Name.Value
}
func (f *FieldResolver) Description() *string {
	return nil
}