github.com/senomas/gqlgen@v0.17.11-0.20220626120754-9aee61b0716a/codegen/testserver/followschema/schema.generated.go (about)

     1  // Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
     2  
     3  package followschema
     4  
     5  import (
     6  	"context"
     7  	"errors"
     8  	"fmt"
     9  	"io"
    10  	"strconv"
    11  	"sync"
    12  	"sync/atomic"
    13  	"time"
    14  
    15  	introspection1 "github.com/99designs/gqlgen/codegen/testserver/followschema/introspection"
    16  	invalid_packagename "github.com/99designs/gqlgen/codegen/testserver/followschema/invalid-packagename"
    17  	"github.com/99designs/gqlgen/codegen/testserver/followschema/otherpkg"
    18  	"github.com/99designs/gqlgen/graphql"
    19  	"github.com/99designs/gqlgen/graphql/introspection"
    20  	"github.com/vektah/gqlparser/v2/ast"
    21  )
    22  
    23  // region    ************************** generated!.gotpl **************************
    24  
    25  type ForcedResolverResolver interface {
    26  	Field(ctx context.Context, obj *ForcedResolver) (*Circle, error)
    27  }
    28  type ModelMethodsResolver interface {
    29  	ResolverField(ctx context.Context, obj *ModelMethods) (bool, error)
    30  }
    31  type PetResolver interface {
    32  	Friends(ctx context.Context, obj *Pet, limit *int) ([]*Pet, error)
    33  }
    34  type QueryResolver interface {
    35  	InvalidIdentifier(ctx context.Context) (*invalid_packagename.InvalidIdentifier, error)
    36  	Collision(ctx context.Context) (*introspection1.It, error)
    37  	MapInput(ctx context.Context, input map[string]interface{}) (*bool, error)
    38  	Recursive(ctx context.Context, input *RecursiveInputSlice) (*bool, error)
    39  	NestedInputs(ctx context.Context, input [][]*OuterInput) (*bool, error)
    40  	NestedOutputs(ctx context.Context) ([][]*OuterObject, error)
    41  	ModelMethods(ctx context.Context) (*ModelMethods, error)
    42  	User(ctx context.Context, id int) (*User, error)
    43  	NullableArg(ctx context.Context, arg *int) (*string, error)
    44  	InputSlice(ctx context.Context, arg []string) (bool, error)
    45  	InputNullableSlice(ctx context.Context, arg []string) (bool, error)
    46  	ShapeUnion(ctx context.Context) (ShapeUnion, error)
    47  	Autobind(ctx context.Context) (*Autobind, error)
    48  	DeprecatedField(ctx context.Context) (string, error)
    49  	Overlapping(ctx context.Context) (*OverlappingFields, error)
    50  	DefaultParameters(ctx context.Context, falsyBoolean *bool, truthyBoolean *bool) (*DefaultParametersMirror, error)
    51  	DirectiveArg(ctx context.Context, arg string) (*string, error)
    52  	DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (*string, error)
    53  	DirectiveInputNullable(ctx context.Context, arg *InputDirectives) (*string, error)
    54  	DirectiveInput(ctx context.Context, arg InputDirectives) (*string, error)
    55  	DirectiveInputType(ctx context.Context, arg InnerInput) (*string, error)
    56  	DirectiveObject(ctx context.Context) (*ObjectDirectives, error)
    57  	DirectiveObjectWithCustomGoModel(ctx context.Context) (*ObjectDirectivesWithCustomGoModel, error)
    58  	DirectiveFieldDef(ctx context.Context, ret string) (string, error)
    59  	DirectiveField(ctx context.Context) (*string, error)
    60  	DirectiveDouble(ctx context.Context) (*string, error)
    61  	DirectiveUnimplemented(ctx context.Context) (*string, error)
    62  	EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error)
    63  	EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error)
    64  	EmbeddedCase3(ctx context.Context) (*EmbeddedCase3, error)
    65  	EnumInInput(ctx context.Context, input *InputWithEnumValue) (EnumTest, error)
    66  	Shapes(ctx context.Context) ([]Shape, error)
    67  	NoShape(ctx context.Context) (Shape, error)
    68  	Node(ctx context.Context) (Node, error)
    69  	NoShapeTypedNil(ctx context.Context) (Shape, error)
    70  	Animal(ctx context.Context) (Animal, error)
    71  	NotAnInterface(ctx context.Context) (BackedByInterface, error)
    72  	Issue896a(ctx context.Context) ([]*CheckIssue896, error)
    73  	MapStringInterface(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error)
    74  	MapNestedStringInterface(ctx context.Context, in *NestedMapInput) (map[string]interface{}, error)
    75  	ErrorBubble(ctx context.Context) (*Error, error)
    76  	ErrorBubbleList(ctx context.Context) ([]*Error, error)
    77  	ErrorList(ctx context.Context) ([]*Error, error)
    78  	Errors(ctx context.Context) (*Errors, error)
    79  	Valid(ctx context.Context) (string, error)
    80  	Panics(ctx context.Context) (*Panics, error)
    81  	PrimitiveObject(ctx context.Context) ([]Primitive, error)
    82  	PrimitiveStringObject(ctx context.Context) ([]PrimitiveString, error)
    83  	PtrToSliceContainer(ctx context.Context) (*PtrToSliceContainer, error)
    84  	Infinity(ctx context.Context) (float64, error)
    85  	StringFromContextInterface(ctx context.Context) (*StringFromContextInterface, error)
    86  	StringFromContextFunction(ctx context.Context) (string, error)
    87  	DefaultScalar(ctx context.Context, arg string) (string, error)
    88  	Slices(ctx context.Context) (*Slices, error)
    89  	ScalarSlice(ctx context.Context) ([]byte, error)
    90  	Fallback(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error)
    91  	OptionalUnion(ctx context.Context) (TestUnion, error)
    92  	VOkCaseValue(ctx context.Context) (*VOkCaseValue, error)
    93  	VOkCaseNil(ctx context.Context) (*VOkCaseNil, error)
    94  	ValidType(ctx context.Context) (*ValidType, error)
    95  	VariadicModel(ctx context.Context) (*VariadicModel, error)
    96  	WrappedStruct(ctx context.Context) (*WrappedStruct, error)
    97  	WrappedScalar(ctx context.Context) (otherpkg.Scalar, error)
    98  	WrappedMap(ctx context.Context) (WrappedMap, error)
    99  	WrappedSlice(ctx context.Context) (WrappedSlice, error)
   100  }
   101  type SubscriptionResolver interface {
   102  	Updated(ctx context.Context) (<-chan string, error)
   103  	InitPayload(ctx context.Context) (<-chan string, error)
   104  	DirectiveArg(ctx context.Context, arg string) (<-chan *string, error)
   105  	DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (<-chan *string, error)
   106  	DirectiveDouble(ctx context.Context) (<-chan *string, error)
   107  	DirectiveUnimplemented(ctx context.Context) (<-chan *string, error)
   108  	Issue896b(ctx context.Context) (<-chan []*CheckIssue896, error)
   109  	ErrorRequired(ctx context.Context) (<-chan *Error, error)
   110  }
   111  type UserResolver interface {
   112  	Friends(ctx context.Context, obj *User) ([]*User, error)
   113  
   114  	Pets(ctx context.Context, obj *User, limit *int) ([]*Pet, error)
   115  }
   116  
   117  // endregion ************************** generated!.gotpl **************************
   118  
   119  // region    ***************************** args.gotpl *****************************
   120  
   121  func (ec *executionContext) field_Pet_friends_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   122  	var err error
   123  	args := map[string]interface{}{}
   124  	var arg0 *int
   125  	if tmp, ok := rawArgs["limit"]; ok {
   126  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
   127  		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
   128  		if err != nil {
   129  			return nil, err
   130  		}
   131  	}
   132  	args["limit"] = arg0
   133  	return args, nil
   134  }
   135  
   136  func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   137  	var err error
   138  	args := map[string]interface{}{}
   139  	var arg0 string
   140  	if tmp, ok := rawArgs["name"]; ok {
   141  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
   142  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   143  		if err != nil {
   144  			return nil, err
   145  		}
   146  	}
   147  	args["name"] = arg0
   148  	return args, nil
   149  }
   150  
   151  func (ec *executionContext) field_Query_defaultParameters_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   152  	var err error
   153  	args := map[string]interface{}{}
   154  	var arg0 *bool
   155  	if tmp, ok := rawArgs["falsyBoolean"]; ok {
   156  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("falsyBoolean"))
   157  		arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
   158  		if err != nil {
   159  			return nil, err
   160  		}
   161  	}
   162  	args["falsyBoolean"] = arg0
   163  	var arg1 *bool
   164  	if tmp, ok := rawArgs["truthyBoolean"]; ok {
   165  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("truthyBoolean"))
   166  		arg1, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
   167  		if err != nil {
   168  			return nil, err
   169  		}
   170  	}
   171  	args["truthyBoolean"] = arg1
   172  	return args, nil
   173  }
   174  
   175  func (ec *executionContext) field_Query_defaultScalar_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   176  	var err error
   177  	args := map[string]interface{}{}
   178  	var arg0 string
   179  	if tmp, ok := rawArgs["arg"]; ok {
   180  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   181  		arg0, err = ec.unmarshalNDefaultScalarImplementation2string(ctx, tmp)
   182  		if err != nil {
   183  			return nil, err
   184  		}
   185  	}
   186  	args["arg"] = arg0
   187  	return args, nil
   188  }
   189  
   190  func (ec *executionContext) field_Query_directiveArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   191  	var err error
   192  	args := map[string]interface{}{}
   193  	var arg0 string
   194  	if tmp, ok := rawArgs["arg"]; ok {
   195  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   196  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, tmp) }
   197  		directive1 := func(ctx context.Context) (interface{}, error) {
   198  			min, err := ec.unmarshalNInt2int(ctx, 1)
   199  			if err != nil {
   200  				return nil, err
   201  			}
   202  			max, err := ec.unmarshalOInt2ᚖint(ctx, 255)
   203  			if err != nil {
   204  				return nil, err
   205  			}
   206  			message, err := ec.unmarshalOString2ᚖstring(ctx, "invalid length")
   207  			if err != nil {
   208  				return nil, err
   209  			}
   210  			if ec.directives.Length == nil {
   211  				return nil, errors.New("directive length is not implemented")
   212  			}
   213  			return ec.directives.Length(ctx, rawArgs, directive0, min, max, message)
   214  		}
   215  
   216  		tmp, err = directive1(ctx)
   217  		if err != nil {
   218  			return nil, graphql.ErrorOnPath(ctx, err)
   219  		}
   220  		if data, ok := tmp.(string); ok {
   221  			arg0 = data
   222  		} else {
   223  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp))
   224  		}
   225  	}
   226  	args["arg"] = arg0
   227  	return args, nil
   228  }
   229  
   230  func (ec *executionContext) field_Query_directiveFieldDef_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   231  	var err error
   232  	args := map[string]interface{}{}
   233  	var arg0 string
   234  	if tmp, ok := rawArgs["ret"]; ok {
   235  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ret"))
   236  		arg0, err = ec.unmarshalNString2string(ctx, tmp)
   237  		if err != nil {
   238  			return nil, err
   239  		}
   240  	}
   241  	args["ret"] = arg0
   242  	return args, nil
   243  }
   244  
   245  func (ec *executionContext) field_Query_directiveInputNullable_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   246  	var err error
   247  	args := map[string]interface{}{}
   248  	var arg0 *InputDirectives
   249  	if tmp, ok := rawArgs["arg"]; ok {
   250  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   251  		arg0, err = ec.unmarshalOInputDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputDirectives(ctx, tmp)
   252  		if err != nil {
   253  			return nil, err
   254  		}
   255  	}
   256  	args["arg"] = arg0
   257  	return args, nil
   258  }
   259  
   260  func (ec *executionContext) field_Query_directiveInputType_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   261  	var err error
   262  	args := map[string]interface{}{}
   263  	var arg0 InnerInput
   264  	if tmp, ok := rawArgs["arg"]; ok {
   265  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   266  		directive0 := func(ctx context.Context) (interface{}, error) {
   267  			return ec.unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx, tmp)
   268  		}
   269  		directive1 := func(ctx context.Context) (interface{}, error) {
   270  			if ec.directives.Custom == nil {
   271  				return nil, errors.New("directive custom is not implemented")
   272  			}
   273  			return ec.directives.Custom(ctx, rawArgs, directive0)
   274  		}
   275  
   276  		tmp, err = directive1(ctx)
   277  		if err != nil {
   278  			return nil, graphql.ErrorOnPath(ctx, err)
   279  		}
   280  		if data, ok := tmp.(InnerInput); ok {
   281  			arg0 = data
   282  		} else {
   283  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be github.com/99designs/gqlgen/codegen/testserver/followschema.InnerInput`, tmp))
   284  		}
   285  	}
   286  	args["arg"] = arg0
   287  	return args, nil
   288  }
   289  
   290  func (ec *executionContext) field_Query_directiveInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   291  	var err error
   292  	args := map[string]interface{}{}
   293  	var arg0 InputDirectives
   294  	if tmp, ok := rawArgs["arg"]; ok {
   295  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   296  		arg0, err = ec.unmarshalNInputDirectives2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputDirectives(ctx, tmp)
   297  		if err != nil {
   298  			return nil, err
   299  		}
   300  	}
   301  	args["arg"] = arg0
   302  	return args, nil
   303  }
   304  
   305  func (ec *executionContext) field_Query_directiveNullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   306  	var err error
   307  	args := map[string]interface{}{}
   308  	var arg0 *int
   309  	if tmp, ok := rawArgs["arg"]; ok {
   310  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   311  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
   312  		directive1 := func(ctx context.Context) (interface{}, error) {
   313  			min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
   314  			if err != nil {
   315  				return nil, err
   316  			}
   317  			if ec.directives.Range == nil {
   318  				return nil, errors.New("directive range is not implemented")
   319  			}
   320  			return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
   321  		}
   322  
   323  		tmp, err = directive1(ctx)
   324  		if err != nil {
   325  			return nil, graphql.ErrorOnPath(ctx, err)
   326  		}
   327  		if data, ok := tmp.(*int); ok {
   328  			arg0 = data
   329  		} else if tmp == nil {
   330  			arg0 = nil
   331  		} else {
   332  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
   333  		}
   334  	}
   335  	args["arg"] = arg0
   336  	var arg1 *int
   337  	if tmp, ok := rawArgs["arg2"]; ok {
   338  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg2"))
   339  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
   340  		directive1 := func(ctx context.Context) (interface{}, error) {
   341  			min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
   342  			if err != nil {
   343  				return nil, err
   344  			}
   345  			if ec.directives.Range == nil {
   346  				return nil, errors.New("directive range is not implemented")
   347  			}
   348  			return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
   349  		}
   350  
   351  		tmp, err = directive1(ctx)
   352  		if err != nil {
   353  			return nil, graphql.ErrorOnPath(ctx, err)
   354  		}
   355  		if data, ok := tmp.(*int); ok {
   356  			arg1 = data
   357  		} else if tmp == nil {
   358  			arg1 = nil
   359  		} else {
   360  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
   361  		}
   362  	}
   363  	args["arg2"] = arg1
   364  	var arg2 *string
   365  	if tmp, ok := rawArgs["arg3"]; ok {
   366  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg3"))
   367  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, tmp) }
   368  		directive1 := func(ctx context.Context) (interface{}, error) {
   369  			if ec.directives.ToNull == nil {
   370  				return nil, errors.New("directive toNull is not implemented")
   371  			}
   372  			return ec.directives.ToNull(ctx, rawArgs, directive0)
   373  		}
   374  
   375  		tmp, err = directive1(ctx)
   376  		if err != nil {
   377  			return nil, graphql.ErrorOnPath(ctx, err)
   378  		}
   379  		if data, ok := tmp.(*string); ok {
   380  			arg2 = data
   381  		} else if tmp == nil {
   382  			arg2 = nil
   383  		} else {
   384  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp))
   385  		}
   386  	}
   387  	args["arg3"] = arg2
   388  	return args, nil
   389  }
   390  
   391  func (ec *executionContext) field_Query_enumInInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   392  	var err error
   393  	args := map[string]interface{}{}
   394  	var arg0 *InputWithEnumValue
   395  	if tmp, ok := rawArgs["input"]; ok {
   396  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
   397  		arg0, err = ec.unmarshalOInputWithEnumValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputWithEnumValue(ctx, tmp)
   398  		if err != nil {
   399  			return nil, err
   400  		}
   401  	}
   402  	args["input"] = arg0
   403  	return args, nil
   404  }
   405  
   406  func (ec *executionContext) field_Query_fallback_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   407  	var err error
   408  	args := map[string]interface{}{}
   409  	var arg0 FallbackToStringEncoding
   410  	if tmp, ok := rawArgs["arg"]; ok {
   411  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   412  		arg0, err = ec.unmarshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐFallbackToStringEncoding(ctx, tmp)
   413  		if err != nil {
   414  			return nil, err
   415  		}
   416  	}
   417  	args["arg"] = arg0
   418  	return args, nil
   419  }
   420  
   421  func (ec *executionContext) field_Query_inputNullableSlice_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   422  	var err error
   423  	args := map[string]interface{}{}
   424  	var arg0 []string
   425  	if tmp, ok := rawArgs["arg"]; ok {
   426  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   427  		arg0, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
   428  		if err != nil {
   429  			return nil, err
   430  		}
   431  	}
   432  	args["arg"] = arg0
   433  	return args, nil
   434  }
   435  
   436  func (ec *executionContext) field_Query_inputSlice_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   437  	var err error
   438  	args := map[string]interface{}{}
   439  	var arg0 []string
   440  	if tmp, ok := rawArgs["arg"]; ok {
   441  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   442  		arg0, err = ec.unmarshalNString2ᚕstringᚄ(ctx, tmp)
   443  		if err != nil {
   444  			return nil, err
   445  		}
   446  	}
   447  	args["arg"] = arg0
   448  	return args, nil
   449  }
   450  
   451  func (ec *executionContext) field_Query_mapInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   452  	var err error
   453  	args := map[string]interface{}{}
   454  	var arg0 map[string]interface{}
   455  	if tmp, ok := rawArgs["input"]; ok {
   456  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
   457  		arg0, err = ec.unmarshalOChanges2map(ctx, tmp)
   458  		if err != nil {
   459  			return nil, err
   460  		}
   461  	}
   462  	args["input"] = arg0
   463  	return args, nil
   464  }
   465  
   466  func (ec *executionContext) field_Query_mapNestedStringInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   467  	var err error
   468  	args := map[string]interface{}{}
   469  	var arg0 *NestedMapInput
   470  	if tmp, ok := rawArgs["in"]; ok {
   471  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in"))
   472  		arg0, err = ec.unmarshalONestedMapInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐNestedMapInput(ctx, tmp)
   473  		if err != nil {
   474  			return nil, err
   475  		}
   476  	}
   477  	args["in"] = arg0
   478  	return args, nil
   479  }
   480  
   481  func (ec *executionContext) field_Query_mapStringInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   482  	var err error
   483  	args := map[string]interface{}{}
   484  	var arg0 map[string]interface{}
   485  	if tmp, ok := rawArgs["in"]; ok {
   486  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in"))
   487  		arg0, err = ec.unmarshalOMapStringInterfaceInput2map(ctx, tmp)
   488  		if err != nil {
   489  			return nil, err
   490  		}
   491  	}
   492  	args["in"] = arg0
   493  	return args, nil
   494  }
   495  
   496  func (ec *executionContext) field_Query_nestedInputs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   497  	var err error
   498  	args := map[string]interface{}{}
   499  	var arg0 [][]*OuterInput
   500  	if tmp, ok := rawArgs["input"]; ok {
   501  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
   502  		arg0, err = ec.unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, tmp)
   503  		if err != nil {
   504  			return nil, err
   505  		}
   506  	}
   507  	args["input"] = arg0
   508  	return args, nil
   509  }
   510  
   511  func (ec *executionContext) field_Query_nullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   512  	var err error
   513  	args := map[string]interface{}{}
   514  	var arg0 *int
   515  	if tmp, ok := rawArgs["arg"]; ok {
   516  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   517  		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
   518  		if err != nil {
   519  			return nil, err
   520  		}
   521  	}
   522  	args["arg"] = arg0
   523  	return args, nil
   524  }
   525  
   526  func (ec *executionContext) field_Query_recursive_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   527  	var err error
   528  	args := map[string]interface{}{}
   529  	var arg0 *RecursiveInputSlice
   530  	if tmp, ok := rawArgs["input"]; ok {
   531  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
   532  		arg0, err = ec.unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx, tmp)
   533  		if err != nil {
   534  			return nil, err
   535  		}
   536  	}
   537  	args["input"] = arg0
   538  	return args, nil
   539  }
   540  
   541  func (ec *executionContext) field_Query_user_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   542  	var err error
   543  	args := map[string]interface{}{}
   544  	var arg0 int
   545  	if tmp, ok := rawArgs["id"]; ok {
   546  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
   547  		arg0, err = ec.unmarshalNInt2int(ctx, tmp)
   548  		if err != nil {
   549  			return nil, err
   550  		}
   551  	}
   552  	args["id"] = arg0
   553  	return args, nil
   554  }
   555  
   556  func (ec *executionContext) field_Subscription_directiveArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   557  	var err error
   558  	args := map[string]interface{}{}
   559  	var arg0 string
   560  	if tmp, ok := rawArgs["arg"]; ok {
   561  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   562  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, tmp) }
   563  		directive1 := func(ctx context.Context) (interface{}, error) {
   564  			min, err := ec.unmarshalNInt2int(ctx, 1)
   565  			if err != nil {
   566  				return nil, err
   567  			}
   568  			max, err := ec.unmarshalOInt2ᚖint(ctx, 255)
   569  			if err != nil {
   570  				return nil, err
   571  			}
   572  			message, err := ec.unmarshalOString2ᚖstring(ctx, "invalid length")
   573  			if err != nil {
   574  				return nil, err
   575  			}
   576  			if ec.directives.Length == nil {
   577  				return nil, errors.New("directive length is not implemented")
   578  			}
   579  			return ec.directives.Length(ctx, rawArgs, directive0, min, max, message)
   580  		}
   581  
   582  		tmp, err = directive1(ctx)
   583  		if err != nil {
   584  			return nil, graphql.ErrorOnPath(ctx, err)
   585  		}
   586  		if data, ok := tmp.(string); ok {
   587  			arg0 = data
   588  		} else {
   589  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp))
   590  		}
   591  	}
   592  	args["arg"] = arg0
   593  	return args, nil
   594  }
   595  
   596  func (ec *executionContext) field_Subscription_directiveNullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   597  	var err error
   598  	args := map[string]interface{}{}
   599  	var arg0 *int
   600  	if tmp, ok := rawArgs["arg"]; ok {
   601  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
   602  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
   603  		directive1 := func(ctx context.Context) (interface{}, error) {
   604  			min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
   605  			if err != nil {
   606  				return nil, err
   607  			}
   608  			if ec.directives.Range == nil {
   609  				return nil, errors.New("directive range is not implemented")
   610  			}
   611  			return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
   612  		}
   613  
   614  		tmp, err = directive1(ctx)
   615  		if err != nil {
   616  			return nil, graphql.ErrorOnPath(ctx, err)
   617  		}
   618  		if data, ok := tmp.(*int); ok {
   619  			arg0 = data
   620  		} else if tmp == nil {
   621  			arg0 = nil
   622  		} else {
   623  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
   624  		}
   625  	}
   626  	args["arg"] = arg0
   627  	var arg1 *int
   628  	if tmp, ok := rawArgs["arg2"]; ok {
   629  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg2"))
   630  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
   631  		directive1 := func(ctx context.Context) (interface{}, error) {
   632  			min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
   633  			if err != nil {
   634  				return nil, err
   635  			}
   636  			if ec.directives.Range == nil {
   637  				return nil, errors.New("directive range is not implemented")
   638  			}
   639  			return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
   640  		}
   641  
   642  		tmp, err = directive1(ctx)
   643  		if err != nil {
   644  			return nil, graphql.ErrorOnPath(ctx, err)
   645  		}
   646  		if data, ok := tmp.(*int); ok {
   647  			arg1 = data
   648  		} else if tmp == nil {
   649  			arg1 = nil
   650  		} else {
   651  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
   652  		}
   653  	}
   654  	args["arg2"] = arg1
   655  	var arg2 *string
   656  	if tmp, ok := rawArgs["arg3"]; ok {
   657  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg3"))
   658  		directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, tmp) }
   659  		directive1 := func(ctx context.Context) (interface{}, error) {
   660  			if ec.directives.ToNull == nil {
   661  				return nil, errors.New("directive toNull is not implemented")
   662  			}
   663  			return ec.directives.ToNull(ctx, rawArgs, directive0)
   664  		}
   665  
   666  		tmp, err = directive1(ctx)
   667  		if err != nil {
   668  			return nil, graphql.ErrorOnPath(ctx, err)
   669  		}
   670  		if data, ok := tmp.(*string); ok {
   671  			arg2 = data
   672  		} else if tmp == nil {
   673  			arg2 = nil
   674  		} else {
   675  			return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp))
   676  		}
   677  	}
   678  	args["arg3"] = arg2
   679  	return args, nil
   680  }
   681  
   682  func (ec *executionContext) field_User_pets_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
   683  	var err error
   684  	args := map[string]interface{}{}
   685  	var arg0 *int
   686  	if tmp, ok := rawArgs["limit"]; ok {
   687  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
   688  		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
   689  		if err != nil {
   690  			return nil, err
   691  		}
   692  	}
   693  	args["limit"] = arg0
   694  	return args, nil
   695  }
   696  
   697  // endregion ***************************** args.gotpl *****************************
   698  
   699  // region    ************************** directives.gotpl **************************
   700  
   701  // endregion ************************** directives.gotpl **************************
   702  
   703  // region    **************************** field.gotpl *****************************
   704  
   705  func (ec *executionContext) _Autobind_int(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   706  	fc, err := ec.fieldContext_Autobind_int(ctx, field)
   707  	if err != nil {
   708  		return graphql.Null
   709  	}
   710  	ctx = graphql.WithFieldContext(ctx, fc)
   711  	defer func() {
   712  		if r := recover(); r != nil {
   713  			ec.Error(ctx, ec.Recover(ctx, r))
   714  			ret = graphql.Null
   715  		}
   716  	}()
   717  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   718  		ctx = rctx // use context from middleware stack in children
   719  		return obj.Int, nil
   720  	})
   721  
   722  	if resTmp == nil {
   723  		if !graphql.HasFieldError(ctx, fc) {
   724  			ec.Errorf(ctx, "must not be null")
   725  		}
   726  		return graphql.Null
   727  	}
   728  	res := resTmp.(int)
   729  	fc.Result = res
   730  	return ec.marshalNInt2int(ctx, field.Selections, res)
   731  }
   732  
   733  func (ec *executionContext) fieldContext_Autobind_int(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   734  	fc = &graphql.FieldContext{
   735  		Object:     "Autobind",
   736  		Field:      field,
   737  		IsMethod:   false,
   738  		IsResolver: false,
   739  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   740  			return nil, errors.New("field of type Int does not have child fields")
   741  		},
   742  	}
   743  	return fc, nil
   744  }
   745  
   746  func (ec *executionContext) _Autobind_int32(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   747  	fc, err := ec.fieldContext_Autobind_int32(ctx, field)
   748  	if err != nil {
   749  		return graphql.Null
   750  	}
   751  	ctx = graphql.WithFieldContext(ctx, fc)
   752  	defer func() {
   753  		if r := recover(); r != nil {
   754  			ec.Error(ctx, ec.Recover(ctx, r))
   755  			ret = graphql.Null
   756  		}
   757  	}()
   758  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   759  		ctx = rctx // use context from middleware stack in children
   760  		return obj.Int32, nil
   761  	})
   762  
   763  	if resTmp == nil {
   764  		if !graphql.HasFieldError(ctx, fc) {
   765  			ec.Errorf(ctx, "must not be null")
   766  		}
   767  		return graphql.Null
   768  	}
   769  	res := resTmp.(int32)
   770  	fc.Result = res
   771  	return ec.marshalNInt2int32(ctx, field.Selections, res)
   772  }
   773  
   774  func (ec *executionContext) fieldContext_Autobind_int32(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   775  	fc = &graphql.FieldContext{
   776  		Object:     "Autobind",
   777  		Field:      field,
   778  		IsMethod:   false,
   779  		IsResolver: false,
   780  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   781  			return nil, errors.New("field of type Int does not have child fields")
   782  		},
   783  	}
   784  	return fc, nil
   785  }
   786  
   787  func (ec *executionContext) _Autobind_int64(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   788  	fc, err := ec.fieldContext_Autobind_int64(ctx, field)
   789  	if err != nil {
   790  		return graphql.Null
   791  	}
   792  	ctx = graphql.WithFieldContext(ctx, fc)
   793  	defer func() {
   794  		if r := recover(); r != nil {
   795  			ec.Error(ctx, ec.Recover(ctx, r))
   796  			ret = graphql.Null
   797  		}
   798  	}()
   799  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   800  		ctx = rctx // use context from middleware stack in children
   801  		return obj.Int64, nil
   802  	})
   803  
   804  	if resTmp == nil {
   805  		if !graphql.HasFieldError(ctx, fc) {
   806  			ec.Errorf(ctx, "must not be null")
   807  		}
   808  		return graphql.Null
   809  	}
   810  	res := resTmp.(int64)
   811  	fc.Result = res
   812  	return ec.marshalNInt2int64(ctx, field.Selections, res)
   813  }
   814  
   815  func (ec *executionContext) fieldContext_Autobind_int64(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   816  	fc = &graphql.FieldContext{
   817  		Object:     "Autobind",
   818  		Field:      field,
   819  		IsMethod:   false,
   820  		IsResolver: false,
   821  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   822  			return nil, errors.New("field of type Int does not have child fields")
   823  		},
   824  	}
   825  	return fc, nil
   826  }
   827  
   828  func (ec *executionContext) _Autobind_idStr(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   829  	fc, err := ec.fieldContext_Autobind_idStr(ctx, field)
   830  	if err != nil {
   831  		return graphql.Null
   832  	}
   833  	ctx = graphql.WithFieldContext(ctx, fc)
   834  	defer func() {
   835  		if r := recover(); r != nil {
   836  			ec.Error(ctx, ec.Recover(ctx, r))
   837  			ret = graphql.Null
   838  		}
   839  	}()
   840  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   841  		ctx = rctx // use context from middleware stack in children
   842  		return obj.IdStr, nil
   843  	})
   844  
   845  	if resTmp == nil {
   846  		if !graphql.HasFieldError(ctx, fc) {
   847  			ec.Errorf(ctx, "must not be null")
   848  		}
   849  		return graphql.Null
   850  	}
   851  	res := resTmp.(string)
   852  	fc.Result = res
   853  	return ec.marshalNID2string(ctx, field.Selections, res)
   854  }
   855  
   856  func (ec *executionContext) fieldContext_Autobind_idStr(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   857  	fc = &graphql.FieldContext{
   858  		Object:     "Autobind",
   859  		Field:      field,
   860  		IsMethod:   false,
   861  		IsResolver: false,
   862  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   863  			return nil, errors.New("field of type ID does not have child fields")
   864  		},
   865  	}
   866  	return fc, nil
   867  }
   868  
   869  func (ec *executionContext) _Autobind_idInt(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
   870  	fc, err := ec.fieldContext_Autobind_idInt(ctx, field)
   871  	if err != nil {
   872  		return graphql.Null
   873  	}
   874  	ctx = graphql.WithFieldContext(ctx, fc)
   875  	defer func() {
   876  		if r := recover(); r != nil {
   877  			ec.Error(ctx, ec.Recover(ctx, r))
   878  			ret = graphql.Null
   879  		}
   880  	}()
   881  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   882  		ctx = rctx // use context from middleware stack in children
   883  		return obj.IdInt, nil
   884  	})
   885  
   886  	if resTmp == nil {
   887  		if !graphql.HasFieldError(ctx, fc) {
   888  			ec.Errorf(ctx, "must not be null")
   889  		}
   890  		return graphql.Null
   891  	}
   892  	res := resTmp.(int)
   893  	fc.Result = res
   894  	return ec.marshalNID2int(ctx, field.Selections, res)
   895  }
   896  
   897  func (ec *executionContext) fieldContext_Autobind_idInt(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   898  	fc = &graphql.FieldContext{
   899  		Object:     "Autobind",
   900  		Field:      field,
   901  		IsMethod:   false,
   902  		IsResolver: false,
   903  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   904  			return nil, errors.New("field of type ID does not have child fields")
   905  		},
   906  	}
   907  	return fc, nil
   908  }
   909  
   910  func (ec *executionContext) _EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) {
   911  	fc, err := ec.fieldContext_EmbeddedPointer_ID(ctx, field)
   912  	if err != nil {
   913  		return graphql.Null
   914  	}
   915  	ctx = graphql.WithFieldContext(ctx, fc)
   916  	defer func() {
   917  		if r := recover(); r != nil {
   918  			ec.Error(ctx, ec.Recover(ctx, r))
   919  			ret = graphql.Null
   920  		}
   921  	}()
   922  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   923  		ctx = rctx // use context from middleware stack in children
   924  		return obj.ID, nil
   925  	})
   926  
   927  	if resTmp == nil {
   928  		return graphql.Null
   929  	}
   930  	res := resTmp.(string)
   931  	fc.Result = res
   932  	return ec.marshalOString2string(ctx, field.Selections, res)
   933  }
   934  
   935  func (ec *executionContext) fieldContext_EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   936  	fc = &graphql.FieldContext{
   937  		Object:     "EmbeddedPointer",
   938  		Field:      field,
   939  		IsMethod:   false,
   940  		IsResolver: false,
   941  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   942  			return nil, errors.New("field of type String does not have child fields")
   943  		},
   944  	}
   945  	return fc, nil
   946  }
   947  
   948  func (ec *executionContext) _EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) {
   949  	fc, err := ec.fieldContext_EmbeddedPointer_Title(ctx, field)
   950  	if err != nil {
   951  		return graphql.Null
   952  	}
   953  	ctx = graphql.WithFieldContext(ctx, fc)
   954  	defer func() {
   955  		if r := recover(); r != nil {
   956  			ec.Error(ctx, ec.Recover(ctx, r))
   957  			ret = graphql.Null
   958  		}
   959  	}()
   960  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   961  		ctx = rctx // use context from middleware stack in children
   962  		return obj.Title, nil
   963  	})
   964  
   965  	if resTmp == nil {
   966  		return graphql.Null
   967  	}
   968  	res := resTmp.(string)
   969  	fc.Result = res
   970  	return ec.marshalOString2string(ctx, field.Selections, res)
   971  }
   972  
   973  func (ec *executionContext) fieldContext_EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
   974  	fc = &graphql.FieldContext{
   975  		Object:     "EmbeddedPointer",
   976  		Field:      field,
   977  		IsMethod:   false,
   978  		IsResolver: false,
   979  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
   980  			return nil, errors.New("field of type String does not have child fields")
   981  		},
   982  	}
   983  	return fc, nil
   984  }
   985  
   986  func (ec *executionContext) _ForcedResolver_field(ctx context.Context, field graphql.CollectedField, obj *ForcedResolver) (ret graphql.Marshaler) {
   987  	fc, err := ec.fieldContext_ForcedResolver_field(ctx, field)
   988  	if err != nil {
   989  		return graphql.Null
   990  	}
   991  	ctx = graphql.WithFieldContext(ctx, fc)
   992  	defer func() {
   993  		if r := recover(); r != nil {
   994  			ec.Error(ctx, ec.Recover(ctx, r))
   995  			ret = graphql.Null
   996  		}
   997  	}()
   998  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
   999  		ctx = rctx // use context from middleware stack in children
  1000  		return ec.resolvers.ForcedResolver().Field(rctx, obj)
  1001  	})
  1002  
  1003  	if resTmp == nil {
  1004  		return graphql.Null
  1005  	}
  1006  	res := resTmp.(*Circle)
  1007  	fc.Result = res
  1008  	return ec.marshalOCircle2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCircle(ctx, field.Selections, res)
  1009  }
  1010  
  1011  func (ec *executionContext) fieldContext_ForcedResolver_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1012  	fc = &graphql.FieldContext{
  1013  		Object:     "ForcedResolver",
  1014  		Field:      field,
  1015  		IsMethod:   true,
  1016  		IsResolver: true,
  1017  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1018  			switch field.Name {
  1019  			case "radius":
  1020  				return ec.fieldContext_Circle_radius(ctx, field)
  1021  			case "area":
  1022  				return ec.fieldContext_Circle_area(ctx, field)
  1023  			case "coordinates":
  1024  				return ec.fieldContext_Circle_coordinates(ctx, field)
  1025  			}
  1026  			return nil, fmt.Errorf("no field named %q was found under type Circle", field.Name)
  1027  		},
  1028  	}
  1029  	return fc, nil
  1030  }
  1031  
  1032  func (ec *executionContext) _InnerObject_id(ctx context.Context, field graphql.CollectedField, obj *InnerObject) (ret graphql.Marshaler) {
  1033  	fc, err := ec.fieldContext_InnerObject_id(ctx, field)
  1034  	if err != nil {
  1035  		return graphql.Null
  1036  	}
  1037  	ctx = graphql.WithFieldContext(ctx, fc)
  1038  	defer func() {
  1039  		if r := recover(); r != nil {
  1040  			ec.Error(ctx, ec.Recover(ctx, r))
  1041  			ret = graphql.Null
  1042  		}
  1043  	}()
  1044  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1045  		ctx = rctx // use context from middleware stack in children
  1046  		return obj.ID, nil
  1047  	})
  1048  
  1049  	if resTmp == nil {
  1050  		if !graphql.HasFieldError(ctx, fc) {
  1051  			ec.Errorf(ctx, "must not be null")
  1052  		}
  1053  		return graphql.Null
  1054  	}
  1055  	res := resTmp.(int)
  1056  	fc.Result = res
  1057  	return ec.marshalNInt2int(ctx, field.Selections, res)
  1058  }
  1059  
  1060  func (ec *executionContext) fieldContext_InnerObject_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1061  	fc = &graphql.FieldContext{
  1062  		Object:     "InnerObject",
  1063  		Field:      field,
  1064  		IsMethod:   false,
  1065  		IsResolver: false,
  1066  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1067  			return nil, errors.New("field of type Int does not have child fields")
  1068  		},
  1069  	}
  1070  	return fc, nil
  1071  }
  1072  
  1073  func (ec *executionContext) _InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField, obj *invalid_packagename.InvalidIdentifier) (ret graphql.Marshaler) {
  1074  	fc, err := ec.fieldContext_InvalidIdentifier_id(ctx, field)
  1075  	if err != nil {
  1076  		return graphql.Null
  1077  	}
  1078  	ctx = graphql.WithFieldContext(ctx, fc)
  1079  	defer func() {
  1080  		if r := recover(); r != nil {
  1081  			ec.Error(ctx, ec.Recover(ctx, r))
  1082  			ret = graphql.Null
  1083  		}
  1084  	}()
  1085  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1086  		ctx = rctx // use context from middleware stack in children
  1087  		return obj.ID, nil
  1088  	})
  1089  
  1090  	if resTmp == nil {
  1091  		if !graphql.HasFieldError(ctx, fc) {
  1092  			ec.Errorf(ctx, "must not be null")
  1093  		}
  1094  		return graphql.Null
  1095  	}
  1096  	res := resTmp.(int)
  1097  	fc.Result = res
  1098  	return ec.marshalNInt2int(ctx, field.Selections, res)
  1099  }
  1100  
  1101  func (ec *executionContext) fieldContext_InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1102  	fc = &graphql.FieldContext{
  1103  		Object:     "InvalidIdentifier",
  1104  		Field:      field,
  1105  		IsMethod:   false,
  1106  		IsResolver: false,
  1107  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1108  			return nil, errors.New("field of type Int does not have child fields")
  1109  		},
  1110  	}
  1111  	return fc, nil
  1112  }
  1113  
  1114  func (ec *executionContext) _It_id(ctx context.Context, field graphql.CollectedField, obj *introspection1.It) (ret graphql.Marshaler) {
  1115  	fc, err := ec.fieldContext_It_id(ctx, field)
  1116  	if err != nil {
  1117  		return graphql.Null
  1118  	}
  1119  	ctx = graphql.WithFieldContext(ctx, fc)
  1120  	defer func() {
  1121  		if r := recover(); r != nil {
  1122  			ec.Error(ctx, ec.Recover(ctx, r))
  1123  			ret = graphql.Null
  1124  		}
  1125  	}()
  1126  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1127  		ctx = rctx // use context from middleware stack in children
  1128  		return obj.ID, nil
  1129  	})
  1130  
  1131  	if resTmp == nil {
  1132  		if !graphql.HasFieldError(ctx, fc) {
  1133  			ec.Errorf(ctx, "must not be null")
  1134  		}
  1135  		return graphql.Null
  1136  	}
  1137  	res := resTmp.(string)
  1138  	fc.Result = res
  1139  	return ec.marshalNID2string(ctx, field.Selections, res)
  1140  }
  1141  
  1142  func (ec *executionContext) fieldContext_It_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1143  	fc = &graphql.FieldContext{
  1144  		Object:     "It",
  1145  		Field:      field,
  1146  		IsMethod:   false,
  1147  		IsResolver: false,
  1148  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1149  			return nil, errors.New("field of type ID does not have child fields")
  1150  		},
  1151  	}
  1152  	return fc, nil
  1153  }
  1154  
  1155  func (ec *executionContext) _ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
  1156  	fc, err := ec.fieldContext_ModelMethods_resolverField(ctx, field)
  1157  	if err != nil {
  1158  		return graphql.Null
  1159  	}
  1160  	ctx = graphql.WithFieldContext(ctx, fc)
  1161  	defer func() {
  1162  		if r := recover(); r != nil {
  1163  			ec.Error(ctx, ec.Recover(ctx, r))
  1164  			ret = graphql.Null
  1165  		}
  1166  	}()
  1167  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1168  		ctx = rctx // use context from middleware stack in children
  1169  		return ec.resolvers.ModelMethods().ResolverField(rctx, obj)
  1170  	})
  1171  
  1172  	if resTmp == nil {
  1173  		if !graphql.HasFieldError(ctx, fc) {
  1174  			ec.Errorf(ctx, "must not be null")
  1175  		}
  1176  		return graphql.Null
  1177  	}
  1178  	res := resTmp.(bool)
  1179  	fc.Result = res
  1180  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1181  }
  1182  
  1183  func (ec *executionContext) fieldContext_ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1184  	fc = &graphql.FieldContext{
  1185  		Object:     "ModelMethods",
  1186  		Field:      field,
  1187  		IsMethod:   true,
  1188  		IsResolver: true,
  1189  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1190  			return nil, errors.New("field of type Boolean does not have child fields")
  1191  		},
  1192  	}
  1193  	return fc, nil
  1194  }
  1195  
  1196  func (ec *executionContext) _ModelMethods_noContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
  1197  	fc, err := ec.fieldContext_ModelMethods_noContext(ctx, field)
  1198  	if err != nil {
  1199  		return graphql.Null
  1200  	}
  1201  	ctx = graphql.WithFieldContext(ctx, fc)
  1202  	defer func() {
  1203  		if r := recover(); r != nil {
  1204  			ec.Error(ctx, ec.Recover(ctx, r))
  1205  			ret = graphql.Null
  1206  		}
  1207  	}()
  1208  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1209  		ctx = rctx // use context from middleware stack in children
  1210  		return obj.NoContext(), nil
  1211  	})
  1212  
  1213  	if resTmp == nil {
  1214  		if !graphql.HasFieldError(ctx, fc) {
  1215  			ec.Errorf(ctx, "must not be null")
  1216  		}
  1217  		return graphql.Null
  1218  	}
  1219  	res := resTmp.(bool)
  1220  	fc.Result = res
  1221  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1222  }
  1223  
  1224  func (ec *executionContext) fieldContext_ModelMethods_noContext(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1225  	fc = &graphql.FieldContext{
  1226  		Object:     "ModelMethods",
  1227  		Field:      field,
  1228  		IsMethod:   true,
  1229  		IsResolver: false,
  1230  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1231  			return nil, errors.New("field of type Boolean does not have child fields")
  1232  		},
  1233  	}
  1234  	return fc, nil
  1235  }
  1236  
  1237  func (ec *executionContext) _ModelMethods_withContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
  1238  	fc, err := ec.fieldContext_ModelMethods_withContext(ctx, field)
  1239  	if err != nil {
  1240  		return graphql.Null
  1241  	}
  1242  	ctx = graphql.WithFieldContext(ctx, fc)
  1243  	defer func() {
  1244  		if r := recover(); r != nil {
  1245  			ec.Error(ctx, ec.Recover(ctx, r))
  1246  			ret = graphql.Null
  1247  		}
  1248  	}()
  1249  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1250  		ctx = rctx // use context from middleware stack in children
  1251  		return obj.WithContext(ctx), nil
  1252  	})
  1253  
  1254  	if resTmp == nil {
  1255  		if !graphql.HasFieldError(ctx, fc) {
  1256  			ec.Errorf(ctx, "must not be null")
  1257  		}
  1258  		return graphql.Null
  1259  	}
  1260  	res := resTmp.(bool)
  1261  	fc.Result = res
  1262  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1263  }
  1264  
  1265  func (ec *executionContext) fieldContext_ModelMethods_withContext(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1266  	fc = &graphql.FieldContext{
  1267  		Object:     "ModelMethods",
  1268  		Field:      field,
  1269  		IsMethod:   true,
  1270  		IsResolver: false,
  1271  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1272  			return nil, errors.New("field of type Boolean does not have child fields")
  1273  		},
  1274  	}
  1275  	return fc, nil
  1276  }
  1277  
  1278  func (ec *executionContext) _OuterObject_inner(ctx context.Context, field graphql.CollectedField, obj *OuterObject) (ret graphql.Marshaler) {
  1279  	fc, err := ec.fieldContext_OuterObject_inner(ctx, field)
  1280  	if err != nil {
  1281  		return graphql.Null
  1282  	}
  1283  	ctx = graphql.WithFieldContext(ctx, fc)
  1284  	defer func() {
  1285  		if r := recover(); r != nil {
  1286  			ec.Error(ctx, ec.Recover(ctx, r))
  1287  			ret = graphql.Null
  1288  		}
  1289  	}()
  1290  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1291  		ctx = rctx // use context from middleware stack in children
  1292  		return obj.Inner, nil
  1293  	})
  1294  
  1295  	if resTmp == nil {
  1296  		if !graphql.HasFieldError(ctx, fc) {
  1297  			ec.Errorf(ctx, "must not be null")
  1298  		}
  1299  		return graphql.Null
  1300  	}
  1301  	res := resTmp.(*InnerObject)
  1302  	fc.Result = res
  1303  	return ec.marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerObject(ctx, field.Selections, res)
  1304  }
  1305  
  1306  func (ec *executionContext) fieldContext_OuterObject_inner(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1307  	fc = &graphql.FieldContext{
  1308  		Object:     "OuterObject",
  1309  		Field:      field,
  1310  		IsMethod:   false,
  1311  		IsResolver: false,
  1312  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1313  			switch field.Name {
  1314  			case "id":
  1315  				return ec.fieldContext_InnerObject_id(ctx, field)
  1316  			}
  1317  			return nil, fmt.Errorf("no field named %q was found under type InnerObject", field.Name)
  1318  		},
  1319  	}
  1320  	return fc, nil
  1321  }
  1322  
  1323  func (ec *executionContext) _Pet_id(ctx context.Context, field graphql.CollectedField, obj *Pet) (ret graphql.Marshaler) {
  1324  	fc, err := ec.fieldContext_Pet_id(ctx, field)
  1325  	if err != nil {
  1326  		return graphql.Null
  1327  	}
  1328  	ctx = graphql.WithFieldContext(ctx, fc)
  1329  	defer func() {
  1330  		if r := recover(); r != nil {
  1331  			ec.Error(ctx, ec.Recover(ctx, r))
  1332  			ret = graphql.Null
  1333  		}
  1334  	}()
  1335  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1336  		ctx = rctx // use context from middleware stack in children
  1337  		return obj.ID, nil
  1338  	})
  1339  
  1340  	if resTmp == nil {
  1341  		if !graphql.HasFieldError(ctx, fc) {
  1342  			ec.Errorf(ctx, "must not be null")
  1343  		}
  1344  		return graphql.Null
  1345  	}
  1346  	res := resTmp.(int)
  1347  	fc.Result = res
  1348  	return ec.marshalNInt2int(ctx, field.Selections, res)
  1349  }
  1350  
  1351  func (ec *executionContext) fieldContext_Pet_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1352  	fc = &graphql.FieldContext{
  1353  		Object:     "Pet",
  1354  		Field:      field,
  1355  		IsMethod:   false,
  1356  		IsResolver: false,
  1357  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1358  			return nil, errors.New("field of type Int does not have child fields")
  1359  		},
  1360  	}
  1361  	return fc, nil
  1362  }
  1363  
  1364  func (ec *executionContext) _Pet_friends(ctx context.Context, field graphql.CollectedField, obj *Pet) (ret graphql.Marshaler) {
  1365  	fc, err := ec.fieldContext_Pet_friends(ctx, field)
  1366  	if err != nil {
  1367  		return graphql.Null
  1368  	}
  1369  	ctx = graphql.WithFieldContext(ctx, fc)
  1370  	defer func() {
  1371  		if r := recover(); r != nil {
  1372  			ec.Error(ctx, ec.Recover(ctx, r))
  1373  			ret = graphql.Null
  1374  		}
  1375  	}()
  1376  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  1377  		ctx = rctx // use context from middleware stack in children
  1378  		return ec.resolvers.Pet().Friends(rctx, obj, fc.Args["limit"].(*int))
  1379  	})
  1380  
  1381  	if resTmp == nil {
  1382  		return graphql.Null
  1383  	}
  1384  	res := resTmp.([]*Pet)
  1385  	fc.Result = res
  1386  	return ec.marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx, field.Selections, res)
  1387  }
  1388  
  1389  func (ec *executionContext) fieldContext_Pet_friends(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1390  	fc = &graphql.FieldContext{
  1391  		Object:     "Pet",
  1392  		Field:      field,
  1393  		IsMethod:   true,
  1394  		IsResolver: true,
  1395  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1396  			switch field.Name {
  1397  			case "id":
  1398  				return ec.fieldContext_Pet_id(ctx, field)
  1399  			case "friends":
  1400  				return ec.fieldContext_Pet_friends(ctx, field)
  1401  			}
  1402  			return nil, fmt.Errorf("no field named %q was found under type Pet", field.Name)
  1403  		},
  1404  	}
  1405  	defer func() {
  1406  		if r := recover(); r != nil {
  1407  			err = ec.Recover(ctx, r)
  1408  			ec.Error(ctx, err)
  1409  		}
  1410  	}()
  1411  	ctx = graphql.WithFieldContext(ctx, fc)
  1412  	if fc.Args, err = ec.field_Pet_friends_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1413  		ec.Error(ctx, err)
  1414  		return
  1415  	}
  1416  	return fc, nil
  1417  }
  1418  
  1419  func (ec *executionContext) _Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1420  	fc, err := ec.fieldContext_Query_invalidIdentifier(ctx, field)
  1421  	if err != nil {
  1422  		return graphql.Null
  1423  	}
  1424  	ctx = graphql.WithFieldContext(ctx, fc)
  1425  	defer func() {
  1426  		if r := recover(); r != nil {
  1427  			ec.Error(ctx, ec.Recover(ctx, r))
  1428  			ret = graphql.Null
  1429  		}
  1430  	}()
  1431  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1432  		ctx = rctx // use context from middleware stack in children
  1433  		return ec.resolvers.Query().InvalidIdentifier(rctx)
  1434  	})
  1435  
  1436  	if resTmp == nil {
  1437  		return graphql.Null
  1438  	}
  1439  	res := resTmp.(*invalid_packagename.InvalidIdentifier)
  1440  	fc.Result = res
  1441  	return ec.marshalOInvalidIdentifier2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋinvalidᚑpackagenameᚐInvalidIdentifier(ctx, field.Selections, res)
  1442  }
  1443  
  1444  func (ec *executionContext) fieldContext_Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1445  	fc = &graphql.FieldContext{
  1446  		Object:     "Query",
  1447  		Field:      field,
  1448  		IsMethod:   true,
  1449  		IsResolver: true,
  1450  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1451  			switch field.Name {
  1452  			case "id":
  1453  				return ec.fieldContext_InvalidIdentifier_id(ctx, field)
  1454  			}
  1455  			return nil, fmt.Errorf("no field named %q was found under type InvalidIdentifier", field.Name)
  1456  		},
  1457  	}
  1458  	return fc, nil
  1459  }
  1460  
  1461  func (ec *executionContext) _Query_collision(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1462  	fc, err := ec.fieldContext_Query_collision(ctx, field)
  1463  	if err != nil {
  1464  		return graphql.Null
  1465  	}
  1466  	ctx = graphql.WithFieldContext(ctx, fc)
  1467  	defer func() {
  1468  		if r := recover(); r != nil {
  1469  			ec.Error(ctx, ec.Recover(ctx, r))
  1470  			ret = graphql.Null
  1471  		}
  1472  	}()
  1473  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1474  		ctx = rctx // use context from middleware stack in children
  1475  		return ec.resolvers.Query().Collision(rctx)
  1476  	})
  1477  
  1478  	if resTmp == nil {
  1479  		return graphql.Null
  1480  	}
  1481  	res := resTmp.(*introspection1.It)
  1482  	fc.Result = res
  1483  	return ec.marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋintrospectionᚐIt(ctx, field.Selections, res)
  1484  }
  1485  
  1486  func (ec *executionContext) fieldContext_Query_collision(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1487  	fc = &graphql.FieldContext{
  1488  		Object:     "Query",
  1489  		Field:      field,
  1490  		IsMethod:   true,
  1491  		IsResolver: true,
  1492  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1493  			switch field.Name {
  1494  			case "id":
  1495  				return ec.fieldContext_It_id(ctx, field)
  1496  			}
  1497  			return nil, fmt.Errorf("no field named %q was found under type It", field.Name)
  1498  		},
  1499  	}
  1500  	return fc, nil
  1501  }
  1502  
  1503  func (ec *executionContext) _Query_mapInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1504  	fc, err := ec.fieldContext_Query_mapInput(ctx, field)
  1505  	if err != nil {
  1506  		return graphql.Null
  1507  	}
  1508  	ctx = graphql.WithFieldContext(ctx, fc)
  1509  	defer func() {
  1510  		if r := recover(); r != nil {
  1511  			ec.Error(ctx, ec.Recover(ctx, r))
  1512  			ret = graphql.Null
  1513  		}
  1514  	}()
  1515  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1516  		ctx = rctx // use context from middleware stack in children
  1517  		return ec.resolvers.Query().MapInput(rctx, fc.Args["input"].(map[string]interface{}))
  1518  	})
  1519  
  1520  	if resTmp == nil {
  1521  		return graphql.Null
  1522  	}
  1523  	res := resTmp.(*bool)
  1524  	fc.Result = res
  1525  	return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
  1526  }
  1527  
  1528  func (ec *executionContext) fieldContext_Query_mapInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1529  	fc = &graphql.FieldContext{
  1530  		Object:     "Query",
  1531  		Field:      field,
  1532  		IsMethod:   true,
  1533  		IsResolver: true,
  1534  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1535  			return nil, errors.New("field of type Boolean does not have child fields")
  1536  		},
  1537  	}
  1538  	defer func() {
  1539  		if r := recover(); r != nil {
  1540  			err = ec.Recover(ctx, r)
  1541  			ec.Error(ctx, err)
  1542  		}
  1543  	}()
  1544  	ctx = graphql.WithFieldContext(ctx, fc)
  1545  	if fc.Args, err = ec.field_Query_mapInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1546  		ec.Error(ctx, err)
  1547  		return
  1548  	}
  1549  	return fc, nil
  1550  }
  1551  
  1552  func (ec *executionContext) _Query_recursive(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1553  	fc, err := ec.fieldContext_Query_recursive(ctx, field)
  1554  	if err != nil {
  1555  		return graphql.Null
  1556  	}
  1557  	ctx = graphql.WithFieldContext(ctx, fc)
  1558  	defer func() {
  1559  		if r := recover(); r != nil {
  1560  			ec.Error(ctx, ec.Recover(ctx, r))
  1561  			ret = graphql.Null
  1562  		}
  1563  	}()
  1564  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1565  		ctx = rctx // use context from middleware stack in children
  1566  		return ec.resolvers.Query().Recursive(rctx, fc.Args["input"].(*RecursiveInputSlice))
  1567  	})
  1568  
  1569  	if resTmp == nil {
  1570  		return graphql.Null
  1571  	}
  1572  	res := resTmp.(*bool)
  1573  	fc.Result = res
  1574  	return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
  1575  }
  1576  
  1577  func (ec *executionContext) fieldContext_Query_recursive(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1578  	fc = &graphql.FieldContext{
  1579  		Object:     "Query",
  1580  		Field:      field,
  1581  		IsMethod:   true,
  1582  		IsResolver: true,
  1583  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1584  			return nil, errors.New("field of type Boolean does not have child fields")
  1585  		},
  1586  	}
  1587  	defer func() {
  1588  		if r := recover(); r != nil {
  1589  			err = ec.Recover(ctx, r)
  1590  			ec.Error(ctx, err)
  1591  		}
  1592  	}()
  1593  	ctx = graphql.WithFieldContext(ctx, fc)
  1594  	if fc.Args, err = ec.field_Query_recursive_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1595  		ec.Error(ctx, err)
  1596  		return
  1597  	}
  1598  	return fc, nil
  1599  }
  1600  
  1601  func (ec *executionContext) _Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1602  	fc, err := ec.fieldContext_Query_nestedInputs(ctx, field)
  1603  	if err != nil {
  1604  		return graphql.Null
  1605  	}
  1606  	ctx = graphql.WithFieldContext(ctx, fc)
  1607  	defer func() {
  1608  		if r := recover(); r != nil {
  1609  			ec.Error(ctx, ec.Recover(ctx, r))
  1610  			ret = graphql.Null
  1611  		}
  1612  	}()
  1613  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1614  		ctx = rctx // use context from middleware stack in children
  1615  		return ec.resolvers.Query().NestedInputs(rctx, fc.Args["input"].([][]*OuterInput))
  1616  	})
  1617  
  1618  	if resTmp == nil {
  1619  		return graphql.Null
  1620  	}
  1621  	res := resTmp.(*bool)
  1622  	fc.Result = res
  1623  	return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
  1624  }
  1625  
  1626  func (ec *executionContext) fieldContext_Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1627  	fc = &graphql.FieldContext{
  1628  		Object:     "Query",
  1629  		Field:      field,
  1630  		IsMethod:   true,
  1631  		IsResolver: true,
  1632  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1633  			return nil, errors.New("field of type Boolean does not have child fields")
  1634  		},
  1635  	}
  1636  	defer func() {
  1637  		if r := recover(); r != nil {
  1638  			err = ec.Recover(ctx, r)
  1639  			ec.Error(ctx, err)
  1640  		}
  1641  	}()
  1642  	ctx = graphql.WithFieldContext(ctx, fc)
  1643  	if fc.Args, err = ec.field_Query_nestedInputs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1644  		ec.Error(ctx, err)
  1645  		return
  1646  	}
  1647  	return fc, nil
  1648  }
  1649  
  1650  func (ec *executionContext) _Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1651  	fc, err := ec.fieldContext_Query_nestedOutputs(ctx, field)
  1652  	if err != nil {
  1653  		return graphql.Null
  1654  	}
  1655  	ctx = graphql.WithFieldContext(ctx, fc)
  1656  	defer func() {
  1657  		if r := recover(); r != nil {
  1658  			ec.Error(ctx, ec.Recover(ctx, r))
  1659  			ret = graphql.Null
  1660  		}
  1661  	}()
  1662  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1663  		ctx = rctx // use context from middleware stack in children
  1664  		return ec.resolvers.Query().NestedOutputs(rctx)
  1665  	})
  1666  
  1667  	if resTmp == nil {
  1668  		return graphql.Null
  1669  	}
  1670  	res := resTmp.([][]*OuterObject)
  1671  	fc.Result = res
  1672  	return ec.marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, field.Selections, res)
  1673  }
  1674  
  1675  func (ec *executionContext) fieldContext_Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1676  	fc = &graphql.FieldContext{
  1677  		Object:     "Query",
  1678  		Field:      field,
  1679  		IsMethod:   true,
  1680  		IsResolver: true,
  1681  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1682  			switch field.Name {
  1683  			case "inner":
  1684  				return ec.fieldContext_OuterObject_inner(ctx, field)
  1685  			}
  1686  			return nil, fmt.Errorf("no field named %q was found under type OuterObject", field.Name)
  1687  		},
  1688  	}
  1689  	return fc, nil
  1690  }
  1691  
  1692  func (ec *executionContext) _Query_modelMethods(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1693  	fc, err := ec.fieldContext_Query_modelMethods(ctx, field)
  1694  	if err != nil {
  1695  		return graphql.Null
  1696  	}
  1697  	ctx = graphql.WithFieldContext(ctx, fc)
  1698  	defer func() {
  1699  		if r := recover(); r != nil {
  1700  			ec.Error(ctx, ec.Recover(ctx, r))
  1701  			ret = graphql.Null
  1702  		}
  1703  	}()
  1704  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1705  		ctx = rctx // use context from middleware stack in children
  1706  		return ec.resolvers.Query().ModelMethods(rctx)
  1707  	})
  1708  
  1709  	if resTmp == nil {
  1710  		return graphql.Null
  1711  	}
  1712  	res := resTmp.(*ModelMethods)
  1713  	fc.Result = res
  1714  	return ec.marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐModelMethods(ctx, field.Selections, res)
  1715  }
  1716  
  1717  func (ec *executionContext) fieldContext_Query_modelMethods(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1718  	fc = &graphql.FieldContext{
  1719  		Object:     "Query",
  1720  		Field:      field,
  1721  		IsMethod:   true,
  1722  		IsResolver: true,
  1723  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1724  			switch field.Name {
  1725  			case "resolverField":
  1726  				return ec.fieldContext_ModelMethods_resolverField(ctx, field)
  1727  			case "noContext":
  1728  				return ec.fieldContext_ModelMethods_noContext(ctx, field)
  1729  			case "withContext":
  1730  				return ec.fieldContext_ModelMethods_withContext(ctx, field)
  1731  			}
  1732  			return nil, fmt.Errorf("no field named %q was found under type ModelMethods", field.Name)
  1733  		},
  1734  	}
  1735  	return fc, nil
  1736  }
  1737  
  1738  func (ec *executionContext) _Query_user(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1739  	fc, err := ec.fieldContext_Query_user(ctx, field)
  1740  	if err != nil {
  1741  		return graphql.Null
  1742  	}
  1743  	ctx = graphql.WithFieldContext(ctx, fc)
  1744  	defer func() {
  1745  		if r := recover(); r != nil {
  1746  			ec.Error(ctx, ec.Recover(ctx, r))
  1747  			ret = graphql.Null
  1748  		}
  1749  	}()
  1750  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1751  		ctx = rctx // use context from middleware stack in children
  1752  		return ec.resolvers.Query().User(rctx, fc.Args["id"].(int))
  1753  	})
  1754  
  1755  	if resTmp == nil {
  1756  		if !graphql.HasFieldError(ctx, fc) {
  1757  			ec.Errorf(ctx, "must not be null")
  1758  		}
  1759  		return graphql.Null
  1760  	}
  1761  	res := resTmp.(*User)
  1762  	fc.Result = res
  1763  	return ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx, field.Selections, res)
  1764  }
  1765  
  1766  func (ec *executionContext) fieldContext_Query_user(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1767  	fc = &graphql.FieldContext{
  1768  		Object:     "Query",
  1769  		Field:      field,
  1770  		IsMethod:   true,
  1771  		IsResolver: true,
  1772  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1773  			switch field.Name {
  1774  			case "id":
  1775  				return ec.fieldContext_User_id(ctx, field)
  1776  			case "friends":
  1777  				return ec.fieldContext_User_friends(ctx, field)
  1778  			case "created":
  1779  				return ec.fieldContext_User_created(ctx, field)
  1780  			case "updated":
  1781  				return ec.fieldContext_User_updated(ctx, field)
  1782  			case "pets":
  1783  				return ec.fieldContext_User_pets(ctx, field)
  1784  			}
  1785  			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
  1786  		},
  1787  	}
  1788  	defer func() {
  1789  		if r := recover(); r != nil {
  1790  			err = ec.Recover(ctx, r)
  1791  			ec.Error(ctx, err)
  1792  		}
  1793  	}()
  1794  	ctx = graphql.WithFieldContext(ctx, fc)
  1795  	if fc.Args, err = ec.field_Query_user_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1796  		ec.Error(ctx, err)
  1797  		return
  1798  	}
  1799  	return fc, nil
  1800  }
  1801  
  1802  func (ec *executionContext) _Query_nullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1803  	fc, err := ec.fieldContext_Query_nullableArg(ctx, field)
  1804  	if err != nil {
  1805  		return graphql.Null
  1806  	}
  1807  	ctx = graphql.WithFieldContext(ctx, fc)
  1808  	defer func() {
  1809  		if r := recover(); r != nil {
  1810  			ec.Error(ctx, ec.Recover(ctx, r))
  1811  			ret = graphql.Null
  1812  		}
  1813  	}()
  1814  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1815  		ctx = rctx // use context from middleware stack in children
  1816  		return ec.resolvers.Query().NullableArg(rctx, fc.Args["arg"].(*int))
  1817  	})
  1818  
  1819  	if resTmp == nil {
  1820  		return graphql.Null
  1821  	}
  1822  	res := resTmp.(*string)
  1823  	fc.Result = res
  1824  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  1825  }
  1826  
  1827  func (ec *executionContext) fieldContext_Query_nullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1828  	fc = &graphql.FieldContext{
  1829  		Object:     "Query",
  1830  		Field:      field,
  1831  		IsMethod:   true,
  1832  		IsResolver: true,
  1833  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1834  			return nil, errors.New("field of type String does not have child fields")
  1835  		},
  1836  	}
  1837  	defer func() {
  1838  		if r := recover(); r != nil {
  1839  			err = ec.Recover(ctx, r)
  1840  			ec.Error(ctx, err)
  1841  		}
  1842  	}()
  1843  	ctx = graphql.WithFieldContext(ctx, fc)
  1844  	if fc.Args, err = ec.field_Query_nullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1845  		ec.Error(ctx, err)
  1846  		return
  1847  	}
  1848  	return fc, nil
  1849  }
  1850  
  1851  func (ec *executionContext) _Query_inputSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1852  	fc, err := ec.fieldContext_Query_inputSlice(ctx, field)
  1853  	if err != nil {
  1854  		return graphql.Null
  1855  	}
  1856  	ctx = graphql.WithFieldContext(ctx, fc)
  1857  	defer func() {
  1858  		if r := recover(); r != nil {
  1859  			ec.Error(ctx, ec.Recover(ctx, r))
  1860  			ret = graphql.Null
  1861  		}
  1862  	}()
  1863  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1864  		ctx = rctx // use context from middleware stack in children
  1865  		return ec.resolvers.Query().InputSlice(rctx, fc.Args["arg"].([]string))
  1866  	})
  1867  
  1868  	if resTmp == nil {
  1869  		if !graphql.HasFieldError(ctx, fc) {
  1870  			ec.Errorf(ctx, "must not be null")
  1871  		}
  1872  		return graphql.Null
  1873  	}
  1874  	res := resTmp.(bool)
  1875  	fc.Result = res
  1876  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1877  }
  1878  
  1879  func (ec *executionContext) fieldContext_Query_inputSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1880  	fc = &graphql.FieldContext{
  1881  		Object:     "Query",
  1882  		Field:      field,
  1883  		IsMethod:   true,
  1884  		IsResolver: true,
  1885  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1886  			return nil, errors.New("field of type Boolean does not have child fields")
  1887  		},
  1888  	}
  1889  	defer func() {
  1890  		if r := recover(); r != nil {
  1891  			err = ec.Recover(ctx, r)
  1892  			ec.Error(ctx, err)
  1893  		}
  1894  	}()
  1895  	ctx = graphql.WithFieldContext(ctx, fc)
  1896  	if fc.Args, err = ec.field_Query_inputSlice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1897  		ec.Error(ctx, err)
  1898  		return
  1899  	}
  1900  	return fc, nil
  1901  }
  1902  
  1903  func (ec *executionContext) _Query_inputNullableSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1904  	fc, err := ec.fieldContext_Query_inputNullableSlice(ctx, field)
  1905  	if err != nil {
  1906  		return graphql.Null
  1907  	}
  1908  	ctx = graphql.WithFieldContext(ctx, fc)
  1909  	defer func() {
  1910  		if r := recover(); r != nil {
  1911  			ec.Error(ctx, ec.Recover(ctx, r))
  1912  			ret = graphql.Null
  1913  		}
  1914  	}()
  1915  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1916  		ctx = rctx // use context from middleware stack in children
  1917  		return ec.resolvers.Query().InputNullableSlice(rctx, fc.Args["arg"].([]string))
  1918  	})
  1919  
  1920  	if resTmp == nil {
  1921  		if !graphql.HasFieldError(ctx, fc) {
  1922  			ec.Errorf(ctx, "must not be null")
  1923  		}
  1924  		return graphql.Null
  1925  	}
  1926  	res := resTmp.(bool)
  1927  	fc.Result = res
  1928  	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
  1929  }
  1930  
  1931  func (ec *executionContext) fieldContext_Query_inputNullableSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1932  	fc = &graphql.FieldContext{
  1933  		Object:     "Query",
  1934  		Field:      field,
  1935  		IsMethod:   true,
  1936  		IsResolver: true,
  1937  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1938  			return nil, errors.New("field of type Boolean does not have child fields")
  1939  		},
  1940  	}
  1941  	defer func() {
  1942  		if r := recover(); r != nil {
  1943  			err = ec.Recover(ctx, r)
  1944  			ec.Error(ctx, err)
  1945  		}
  1946  	}()
  1947  	ctx = graphql.WithFieldContext(ctx, fc)
  1948  	if fc.Args, err = ec.field_Query_inputNullableSlice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  1949  		ec.Error(ctx, err)
  1950  		return
  1951  	}
  1952  	return fc, nil
  1953  }
  1954  
  1955  func (ec *executionContext) _Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1956  	fc, err := ec.fieldContext_Query_shapeUnion(ctx, field)
  1957  	if err != nil {
  1958  		return graphql.Null
  1959  	}
  1960  	ctx = graphql.WithFieldContext(ctx, fc)
  1961  	defer func() {
  1962  		if r := recover(); r != nil {
  1963  			ec.Error(ctx, ec.Recover(ctx, r))
  1964  			ret = graphql.Null
  1965  		}
  1966  	}()
  1967  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  1968  		ctx = rctx // use context from middleware stack in children
  1969  		return ec.resolvers.Query().ShapeUnion(rctx)
  1970  	})
  1971  
  1972  	if resTmp == nil {
  1973  		if !graphql.HasFieldError(ctx, fc) {
  1974  			ec.Errorf(ctx, "must not be null")
  1975  		}
  1976  		return graphql.Null
  1977  	}
  1978  	res := resTmp.(ShapeUnion)
  1979  	fc.Result = res
  1980  	return ec.marshalNShapeUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShapeUnion(ctx, field.Selections, res)
  1981  }
  1982  
  1983  func (ec *executionContext) fieldContext_Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  1984  	fc = &graphql.FieldContext{
  1985  		Object:     "Query",
  1986  		Field:      field,
  1987  		IsMethod:   true,
  1988  		IsResolver: true,
  1989  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  1990  			return nil, errors.New("field of type ShapeUnion does not have child fields")
  1991  		},
  1992  	}
  1993  	return fc, nil
  1994  }
  1995  
  1996  func (ec *executionContext) _Query_autobind(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  1997  	fc, err := ec.fieldContext_Query_autobind(ctx, field)
  1998  	if err != nil {
  1999  		return graphql.Null
  2000  	}
  2001  	ctx = graphql.WithFieldContext(ctx, fc)
  2002  	defer func() {
  2003  		if r := recover(); r != nil {
  2004  			ec.Error(ctx, ec.Recover(ctx, r))
  2005  			ret = graphql.Null
  2006  		}
  2007  	}()
  2008  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2009  		ctx = rctx // use context from middleware stack in children
  2010  		return ec.resolvers.Query().Autobind(rctx)
  2011  	})
  2012  
  2013  	if resTmp == nil {
  2014  		return graphql.Null
  2015  	}
  2016  	res := resTmp.(*Autobind)
  2017  	fc.Result = res
  2018  	return ec.marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAutobind(ctx, field.Selections, res)
  2019  }
  2020  
  2021  func (ec *executionContext) fieldContext_Query_autobind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2022  	fc = &graphql.FieldContext{
  2023  		Object:     "Query",
  2024  		Field:      field,
  2025  		IsMethod:   true,
  2026  		IsResolver: true,
  2027  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2028  			switch field.Name {
  2029  			case "int":
  2030  				return ec.fieldContext_Autobind_int(ctx, field)
  2031  			case "int32":
  2032  				return ec.fieldContext_Autobind_int32(ctx, field)
  2033  			case "int64":
  2034  				return ec.fieldContext_Autobind_int64(ctx, field)
  2035  			case "idStr":
  2036  				return ec.fieldContext_Autobind_idStr(ctx, field)
  2037  			case "idInt":
  2038  				return ec.fieldContext_Autobind_idInt(ctx, field)
  2039  			}
  2040  			return nil, fmt.Errorf("no field named %q was found under type Autobind", field.Name)
  2041  		},
  2042  	}
  2043  	return fc, nil
  2044  }
  2045  
  2046  func (ec *executionContext) _Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2047  	fc, err := ec.fieldContext_Query_deprecatedField(ctx, field)
  2048  	if err != nil {
  2049  		return graphql.Null
  2050  	}
  2051  	ctx = graphql.WithFieldContext(ctx, fc)
  2052  	defer func() {
  2053  		if r := recover(); r != nil {
  2054  			ec.Error(ctx, ec.Recover(ctx, r))
  2055  			ret = graphql.Null
  2056  		}
  2057  	}()
  2058  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2059  		ctx = rctx // use context from middleware stack in children
  2060  		return ec.resolvers.Query().DeprecatedField(rctx)
  2061  	})
  2062  
  2063  	if resTmp == nil {
  2064  		if !graphql.HasFieldError(ctx, fc) {
  2065  			ec.Errorf(ctx, "must not be null")
  2066  		}
  2067  		return graphql.Null
  2068  	}
  2069  	res := resTmp.(string)
  2070  	fc.Result = res
  2071  	return ec.marshalNString2string(ctx, field.Selections, res)
  2072  }
  2073  
  2074  func (ec *executionContext) fieldContext_Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2075  	fc = &graphql.FieldContext{
  2076  		Object:     "Query",
  2077  		Field:      field,
  2078  		IsMethod:   true,
  2079  		IsResolver: true,
  2080  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2081  			return nil, errors.New("field of type String does not have child fields")
  2082  		},
  2083  	}
  2084  	return fc, nil
  2085  }
  2086  
  2087  func (ec *executionContext) _Query_overlapping(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2088  	fc, err := ec.fieldContext_Query_overlapping(ctx, field)
  2089  	if err != nil {
  2090  		return graphql.Null
  2091  	}
  2092  	ctx = graphql.WithFieldContext(ctx, fc)
  2093  	defer func() {
  2094  		if r := recover(); r != nil {
  2095  			ec.Error(ctx, ec.Recover(ctx, r))
  2096  			ret = graphql.Null
  2097  		}
  2098  	}()
  2099  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2100  		ctx = rctx // use context from middleware stack in children
  2101  		return ec.resolvers.Query().Overlapping(rctx)
  2102  	})
  2103  
  2104  	if resTmp == nil {
  2105  		return graphql.Null
  2106  	}
  2107  	res := resTmp.(*OverlappingFields)
  2108  	fc.Result = res
  2109  	return ec.marshalOOverlappingFields2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOverlappingFields(ctx, field.Selections, res)
  2110  }
  2111  
  2112  func (ec *executionContext) fieldContext_Query_overlapping(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2113  	fc = &graphql.FieldContext{
  2114  		Object:     "Query",
  2115  		Field:      field,
  2116  		IsMethod:   true,
  2117  		IsResolver: true,
  2118  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2119  			switch field.Name {
  2120  			case "oneFoo":
  2121  				return ec.fieldContext_OverlappingFields_oneFoo(ctx, field)
  2122  			case "twoFoo":
  2123  				return ec.fieldContext_OverlappingFields_twoFoo(ctx, field)
  2124  			case "oldFoo":
  2125  				return ec.fieldContext_OverlappingFields_oldFoo(ctx, field)
  2126  			case "newFoo":
  2127  				return ec.fieldContext_OverlappingFields_newFoo(ctx, field)
  2128  			case "new_foo":
  2129  				return ec.fieldContext_OverlappingFields_new_foo(ctx, field)
  2130  			}
  2131  			return nil, fmt.Errorf("no field named %q was found under type OverlappingFields", field.Name)
  2132  		},
  2133  	}
  2134  	return fc, nil
  2135  }
  2136  
  2137  func (ec *executionContext) _Query_defaultParameters(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2138  	fc, err := ec.fieldContext_Query_defaultParameters(ctx, field)
  2139  	if err != nil {
  2140  		return graphql.Null
  2141  	}
  2142  	ctx = graphql.WithFieldContext(ctx, fc)
  2143  	defer func() {
  2144  		if r := recover(); r != nil {
  2145  			ec.Error(ctx, ec.Recover(ctx, r))
  2146  			ret = graphql.Null
  2147  		}
  2148  	}()
  2149  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2150  		ctx = rctx // use context from middleware stack in children
  2151  		return ec.resolvers.Query().DefaultParameters(rctx, fc.Args["falsyBoolean"].(*bool), fc.Args["truthyBoolean"].(*bool))
  2152  	})
  2153  
  2154  	if resTmp == nil {
  2155  		if !graphql.HasFieldError(ctx, fc) {
  2156  			ec.Errorf(ctx, "must not be null")
  2157  		}
  2158  		return graphql.Null
  2159  	}
  2160  	res := resTmp.(*DefaultParametersMirror)
  2161  	fc.Result = res
  2162  	return ec.marshalNDefaultParametersMirror2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐDefaultParametersMirror(ctx, field.Selections, res)
  2163  }
  2164  
  2165  func (ec *executionContext) fieldContext_Query_defaultParameters(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2166  	fc = &graphql.FieldContext{
  2167  		Object:     "Query",
  2168  		Field:      field,
  2169  		IsMethod:   true,
  2170  		IsResolver: true,
  2171  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2172  			switch field.Name {
  2173  			case "falsyBoolean":
  2174  				return ec.fieldContext_DefaultParametersMirror_falsyBoolean(ctx, field)
  2175  			case "truthyBoolean":
  2176  				return ec.fieldContext_DefaultParametersMirror_truthyBoolean(ctx, field)
  2177  			}
  2178  			return nil, fmt.Errorf("no field named %q was found under type DefaultParametersMirror", field.Name)
  2179  		},
  2180  	}
  2181  	defer func() {
  2182  		if r := recover(); r != nil {
  2183  			err = ec.Recover(ctx, r)
  2184  			ec.Error(ctx, err)
  2185  		}
  2186  	}()
  2187  	ctx = graphql.WithFieldContext(ctx, fc)
  2188  	if fc.Args, err = ec.field_Query_defaultParameters_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2189  		ec.Error(ctx, err)
  2190  		return
  2191  	}
  2192  	return fc, nil
  2193  }
  2194  
  2195  func (ec *executionContext) _Query_directiveArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2196  	fc, err := ec.fieldContext_Query_directiveArg(ctx, field)
  2197  	if err != nil {
  2198  		return graphql.Null
  2199  	}
  2200  	ctx = graphql.WithFieldContext(ctx, fc)
  2201  	defer func() {
  2202  		if r := recover(); r != nil {
  2203  			ec.Error(ctx, ec.Recover(ctx, r))
  2204  			ret = graphql.Null
  2205  		}
  2206  	}()
  2207  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2208  		ctx = rctx // use context from middleware stack in children
  2209  		return ec.resolvers.Query().DirectiveArg(rctx, fc.Args["arg"].(string))
  2210  	})
  2211  
  2212  	if resTmp == nil {
  2213  		return graphql.Null
  2214  	}
  2215  	res := resTmp.(*string)
  2216  	fc.Result = res
  2217  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2218  }
  2219  
  2220  func (ec *executionContext) fieldContext_Query_directiveArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2221  	fc = &graphql.FieldContext{
  2222  		Object:     "Query",
  2223  		Field:      field,
  2224  		IsMethod:   true,
  2225  		IsResolver: true,
  2226  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2227  			return nil, errors.New("field of type String does not have child fields")
  2228  		},
  2229  	}
  2230  	defer func() {
  2231  		if r := recover(); r != nil {
  2232  			err = ec.Recover(ctx, r)
  2233  			ec.Error(ctx, err)
  2234  		}
  2235  	}()
  2236  	ctx = graphql.WithFieldContext(ctx, fc)
  2237  	if fc.Args, err = ec.field_Query_directiveArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2238  		ec.Error(ctx, err)
  2239  		return
  2240  	}
  2241  	return fc, nil
  2242  }
  2243  
  2244  func (ec *executionContext) _Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2245  	fc, err := ec.fieldContext_Query_directiveNullableArg(ctx, field)
  2246  	if err != nil {
  2247  		return graphql.Null
  2248  	}
  2249  	ctx = graphql.WithFieldContext(ctx, fc)
  2250  	defer func() {
  2251  		if r := recover(); r != nil {
  2252  			ec.Error(ctx, ec.Recover(ctx, r))
  2253  			ret = graphql.Null
  2254  		}
  2255  	}()
  2256  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2257  		ctx = rctx // use context from middleware stack in children
  2258  		return ec.resolvers.Query().DirectiveNullableArg(rctx, fc.Args["arg"].(*int), fc.Args["arg2"].(*int), fc.Args["arg3"].(*string))
  2259  	})
  2260  
  2261  	if resTmp == nil {
  2262  		return graphql.Null
  2263  	}
  2264  	res := resTmp.(*string)
  2265  	fc.Result = res
  2266  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2267  }
  2268  
  2269  func (ec *executionContext) fieldContext_Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2270  	fc = &graphql.FieldContext{
  2271  		Object:     "Query",
  2272  		Field:      field,
  2273  		IsMethod:   true,
  2274  		IsResolver: true,
  2275  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2276  			return nil, errors.New("field of type String does not have child fields")
  2277  		},
  2278  	}
  2279  	defer func() {
  2280  		if r := recover(); r != nil {
  2281  			err = ec.Recover(ctx, r)
  2282  			ec.Error(ctx, err)
  2283  		}
  2284  	}()
  2285  	ctx = graphql.WithFieldContext(ctx, fc)
  2286  	if fc.Args, err = ec.field_Query_directiveNullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2287  		ec.Error(ctx, err)
  2288  		return
  2289  	}
  2290  	return fc, nil
  2291  }
  2292  
  2293  func (ec *executionContext) _Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2294  	fc, err := ec.fieldContext_Query_directiveInputNullable(ctx, field)
  2295  	if err != nil {
  2296  		return graphql.Null
  2297  	}
  2298  	ctx = graphql.WithFieldContext(ctx, fc)
  2299  	defer func() {
  2300  		if r := recover(); r != nil {
  2301  			ec.Error(ctx, ec.Recover(ctx, r))
  2302  			ret = graphql.Null
  2303  		}
  2304  	}()
  2305  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2306  		ctx = rctx // use context from middleware stack in children
  2307  		return ec.resolvers.Query().DirectiveInputNullable(rctx, fc.Args["arg"].(*InputDirectives))
  2308  	})
  2309  
  2310  	if resTmp == nil {
  2311  		return graphql.Null
  2312  	}
  2313  	res := resTmp.(*string)
  2314  	fc.Result = res
  2315  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2316  }
  2317  
  2318  func (ec *executionContext) fieldContext_Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2319  	fc = &graphql.FieldContext{
  2320  		Object:     "Query",
  2321  		Field:      field,
  2322  		IsMethod:   true,
  2323  		IsResolver: true,
  2324  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2325  			return nil, errors.New("field of type String does not have child fields")
  2326  		},
  2327  	}
  2328  	defer func() {
  2329  		if r := recover(); r != nil {
  2330  			err = ec.Recover(ctx, r)
  2331  			ec.Error(ctx, err)
  2332  		}
  2333  	}()
  2334  	ctx = graphql.WithFieldContext(ctx, fc)
  2335  	if fc.Args, err = ec.field_Query_directiveInputNullable_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2336  		ec.Error(ctx, err)
  2337  		return
  2338  	}
  2339  	return fc, nil
  2340  }
  2341  
  2342  func (ec *executionContext) _Query_directiveInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2343  	fc, err := ec.fieldContext_Query_directiveInput(ctx, field)
  2344  	if err != nil {
  2345  		return graphql.Null
  2346  	}
  2347  	ctx = graphql.WithFieldContext(ctx, fc)
  2348  	defer func() {
  2349  		if r := recover(); r != nil {
  2350  			ec.Error(ctx, ec.Recover(ctx, r))
  2351  			ret = graphql.Null
  2352  		}
  2353  	}()
  2354  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2355  		ctx = rctx // use context from middleware stack in children
  2356  		return ec.resolvers.Query().DirectiveInput(rctx, fc.Args["arg"].(InputDirectives))
  2357  	})
  2358  
  2359  	if resTmp == nil {
  2360  		return graphql.Null
  2361  	}
  2362  	res := resTmp.(*string)
  2363  	fc.Result = res
  2364  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2365  }
  2366  
  2367  func (ec *executionContext) fieldContext_Query_directiveInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2368  	fc = &graphql.FieldContext{
  2369  		Object:     "Query",
  2370  		Field:      field,
  2371  		IsMethod:   true,
  2372  		IsResolver: true,
  2373  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2374  			return nil, errors.New("field of type String does not have child fields")
  2375  		},
  2376  	}
  2377  	defer func() {
  2378  		if r := recover(); r != nil {
  2379  			err = ec.Recover(ctx, r)
  2380  			ec.Error(ctx, err)
  2381  		}
  2382  	}()
  2383  	ctx = graphql.WithFieldContext(ctx, fc)
  2384  	if fc.Args, err = ec.field_Query_directiveInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2385  		ec.Error(ctx, err)
  2386  		return
  2387  	}
  2388  	return fc, nil
  2389  }
  2390  
  2391  func (ec *executionContext) _Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2392  	fc, err := ec.fieldContext_Query_directiveInputType(ctx, field)
  2393  	if err != nil {
  2394  		return graphql.Null
  2395  	}
  2396  	ctx = graphql.WithFieldContext(ctx, fc)
  2397  	defer func() {
  2398  		if r := recover(); r != nil {
  2399  			ec.Error(ctx, ec.Recover(ctx, r))
  2400  			ret = graphql.Null
  2401  		}
  2402  	}()
  2403  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2404  		ctx = rctx // use context from middleware stack in children
  2405  		return ec.resolvers.Query().DirectiveInputType(rctx, fc.Args["arg"].(InnerInput))
  2406  	})
  2407  
  2408  	if resTmp == nil {
  2409  		return graphql.Null
  2410  	}
  2411  	res := resTmp.(*string)
  2412  	fc.Result = res
  2413  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2414  }
  2415  
  2416  func (ec *executionContext) fieldContext_Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2417  	fc = &graphql.FieldContext{
  2418  		Object:     "Query",
  2419  		Field:      field,
  2420  		IsMethod:   true,
  2421  		IsResolver: true,
  2422  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2423  			return nil, errors.New("field of type String does not have child fields")
  2424  		},
  2425  	}
  2426  	defer func() {
  2427  		if r := recover(); r != nil {
  2428  			err = ec.Recover(ctx, r)
  2429  			ec.Error(ctx, err)
  2430  		}
  2431  	}()
  2432  	ctx = graphql.WithFieldContext(ctx, fc)
  2433  	if fc.Args, err = ec.field_Query_directiveInputType_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2434  		ec.Error(ctx, err)
  2435  		return
  2436  	}
  2437  	return fc, nil
  2438  }
  2439  
  2440  func (ec *executionContext) _Query_directiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2441  	fc, err := ec.fieldContext_Query_directiveObject(ctx, field)
  2442  	if err != nil {
  2443  		return graphql.Null
  2444  	}
  2445  	ctx = graphql.WithFieldContext(ctx, fc)
  2446  	defer func() {
  2447  		if r := recover(); r != nil {
  2448  			ec.Error(ctx, ec.Recover(ctx, r))
  2449  			ret = graphql.Null
  2450  		}
  2451  	}()
  2452  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2453  		directive0 := func(rctx context.Context) (interface{}, error) {
  2454  			ctx = rctx // use context from middleware stack in children
  2455  			return ec.resolvers.Query().DirectiveObject(rctx)
  2456  		}
  2457  		directive1 := func(ctx context.Context) (interface{}, error) {
  2458  			location, err := ec.unmarshalNString2string(ctx, "order1_1")
  2459  			if err != nil {
  2460  				return nil, err
  2461  			}
  2462  			if ec.directives.Order1 == nil {
  2463  				return nil, errors.New("directive order1 is not implemented")
  2464  			}
  2465  			return ec.directives.Order1(ctx, nil, directive0, location)
  2466  		}
  2467  		directive2 := func(ctx context.Context) (interface{}, error) {
  2468  			location, err := ec.unmarshalNString2string(ctx, "order1_2")
  2469  			if err != nil {
  2470  				return nil, err
  2471  			}
  2472  			if ec.directives.Order1 == nil {
  2473  				return nil, errors.New("directive order1 is not implemented")
  2474  			}
  2475  			return ec.directives.Order1(ctx, nil, directive1, location)
  2476  		}
  2477  		directive3 := func(ctx context.Context) (interface{}, error) {
  2478  			location, err := ec.unmarshalNString2string(ctx, "order2_1")
  2479  			if err != nil {
  2480  				return nil, err
  2481  			}
  2482  			if ec.directives.Order2 == nil {
  2483  				return nil, errors.New("directive order2 is not implemented")
  2484  			}
  2485  			return ec.directives.Order2(ctx, nil, directive2, location)
  2486  		}
  2487  		directive4 := func(ctx context.Context) (interface{}, error) {
  2488  			location, err := ec.unmarshalNString2string(ctx, "Query_field")
  2489  			if err != nil {
  2490  				return nil, err
  2491  			}
  2492  			if ec.directives.Order1 == nil {
  2493  				return nil, errors.New("directive order1 is not implemented")
  2494  			}
  2495  			return ec.directives.Order1(ctx, nil, directive3, location)
  2496  		}
  2497  
  2498  		tmp, err := directive4(rctx)
  2499  		if err != nil {
  2500  			return nil, graphql.ErrorOnPath(ctx, err)
  2501  		}
  2502  		if tmp == nil {
  2503  			return nil, nil
  2504  		}
  2505  		if data, ok := tmp.(*ObjectDirectives); ok {
  2506  			return data, nil
  2507  		}
  2508  		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/99designs/gqlgen/codegen/testserver/followschema.ObjectDirectives`, tmp)
  2509  	})
  2510  
  2511  	if resTmp == nil {
  2512  		return graphql.Null
  2513  	}
  2514  	res := resTmp.(*ObjectDirectives)
  2515  	fc.Result = res
  2516  	return ec.marshalOObjectDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐObjectDirectives(ctx, field.Selections, res)
  2517  }
  2518  
  2519  func (ec *executionContext) fieldContext_Query_directiveObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2520  	fc = &graphql.FieldContext{
  2521  		Object:     "Query",
  2522  		Field:      field,
  2523  		IsMethod:   true,
  2524  		IsResolver: true,
  2525  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2526  			switch field.Name {
  2527  			case "text":
  2528  				return ec.fieldContext_ObjectDirectives_text(ctx, field)
  2529  			case "nullableText":
  2530  				return ec.fieldContext_ObjectDirectives_nullableText(ctx, field)
  2531  			case "order":
  2532  				return ec.fieldContext_ObjectDirectives_order(ctx, field)
  2533  			}
  2534  			return nil, fmt.Errorf("no field named %q was found under type ObjectDirectives", field.Name)
  2535  		},
  2536  	}
  2537  	return fc, nil
  2538  }
  2539  
  2540  func (ec *executionContext) _Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2541  	fc, err := ec.fieldContext_Query_directiveObjectWithCustomGoModel(ctx, field)
  2542  	if err != nil {
  2543  		return graphql.Null
  2544  	}
  2545  	ctx = graphql.WithFieldContext(ctx, fc)
  2546  	defer func() {
  2547  		if r := recover(); r != nil {
  2548  			ec.Error(ctx, ec.Recover(ctx, r))
  2549  			ret = graphql.Null
  2550  		}
  2551  	}()
  2552  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2553  		ctx = rctx // use context from middleware stack in children
  2554  		return ec.resolvers.Query().DirectiveObjectWithCustomGoModel(rctx)
  2555  	})
  2556  
  2557  	if resTmp == nil {
  2558  		return graphql.Null
  2559  	}
  2560  	res := resTmp.(*ObjectDirectivesWithCustomGoModel)
  2561  	fc.Result = res
  2562  	return ec.marshalOObjectDirectivesWithCustomGoModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐObjectDirectivesWithCustomGoModel(ctx, field.Selections, res)
  2563  }
  2564  
  2565  func (ec *executionContext) fieldContext_Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2566  	fc = &graphql.FieldContext{
  2567  		Object:     "Query",
  2568  		Field:      field,
  2569  		IsMethod:   true,
  2570  		IsResolver: true,
  2571  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2572  			switch field.Name {
  2573  			case "nullableText":
  2574  				return ec.fieldContext_ObjectDirectivesWithCustomGoModel_nullableText(ctx, field)
  2575  			}
  2576  			return nil, fmt.Errorf("no field named %q was found under type ObjectDirectivesWithCustomGoModel", field.Name)
  2577  		},
  2578  	}
  2579  	return fc, nil
  2580  }
  2581  
  2582  func (ec *executionContext) _Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2583  	fc, err := ec.fieldContext_Query_directiveFieldDef(ctx, field)
  2584  	if err != nil {
  2585  		return graphql.Null
  2586  	}
  2587  	ctx = graphql.WithFieldContext(ctx, fc)
  2588  	defer func() {
  2589  		if r := recover(); r != nil {
  2590  			ec.Error(ctx, ec.Recover(ctx, r))
  2591  			ret = graphql.Null
  2592  		}
  2593  	}()
  2594  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2595  		directive0 := func(rctx context.Context) (interface{}, error) {
  2596  			ctx = rctx // use context from middleware stack in children
  2597  			return ec.resolvers.Query().DirectiveFieldDef(rctx, fc.Args["ret"].(string))
  2598  		}
  2599  		directive1 := func(ctx context.Context) (interface{}, error) {
  2600  			min, err := ec.unmarshalNInt2int(ctx, 1)
  2601  			if err != nil {
  2602  				return nil, err
  2603  			}
  2604  			message, err := ec.unmarshalOString2ᚖstring(ctx, "not valid")
  2605  			if err != nil {
  2606  				return nil, err
  2607  			}
  2608  			if ec.directives.Length == nil {
  2609  				return nil, errors.New("directive length is not implemented")
  2610  			}
  2611  			return ec.directives.Length(ctx, nil, directive0, min, nil, message)
  2612  		}
  2613  
  2614  		tmp, err := directive1(rctx)
  2615  		if err != nil {
  2616  			return nil, graphql.ErrorOnPath(ctx, err)
  2617  		}
  2618  		if tmp == nil {
  2619  			return nil, nil
  2620  		}
  2621  		if data, ok := tmp.(string); ok {
  2622  			return data, nil
  2623  		}
  2624  		return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
  2625  	})
  2626  
  2627  	if resTmp == nil {
  2628  		if !graphql.HasFieldError(ctx, fc) {
  2629  			ec.Errorf(ctx, "must not be null")
  2630  		}
  2631  		return graphql.Null
  2632  	}
  2633  	res := resTmp.(string)
  2634  	fc.Result = res
  2635  	return ec.marshalNString2string(ctx, field.Selections, res)
  2636  }
  2637  
  2638  func (ec *executionContext) fieldContext_Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2639  	fc = &graphql.FieldContext{
  2640  		Object:     "Query",
  2641  		Field:      field,
  2642  		IsMethod:   true,
  2643  		IsResolver: true,
  2644  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2645  			return nil, errors.New("field of type String does not have child fields")
  2646  		},
  2647  	}
  2648  	defer func() {
  2649  		if r := recover(); r != nil {
  2650  			err = ec.Recover(ctx, r)
  2651  			ec.Error(ctx, err)
  2652  		}
  2653  	}()
  2654  	ctx = graphql.WithFieldContext(ctx, fc)
  2655  	if fc.Args, err = ec.field_Query_directiveFieldDef_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2656  		ec.Error(ctx, err)
  2657  		return
  2658  	}
  2659  	return fc, nil
  2660  }
  2661  
  2662  func (ec *executionContext) _Query_directiveField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2663  	fc, err := ec.fieldContext_Query_directiveField(ctx, field)
  2664  	if err != nil {
  2665  		return graphql.Null
  2666  	}
  2667  	ctx = graphql.WithFieldContext(ctx, fc)
  2668  	defer func() {
  2669  		if r := recover(); r != nil {
  2670  			ec.Error(ctx, ec.Recover(ctx, r))
  2671  			ret = graphql.Null
  2672  		}
  2673  	}()
  2674  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2675  		ctx = rctx // use context from middleware stack in children
  2676  		return ec.resolvers.Query().DirectiveField(rctx)
  2677  	})
  2678  
  2679  	if resTmp == nil {
  2680  		return graphql.Null
  2681  	}
  2682  	res := resTmp.(*string)
  2683  	fc.Result = res
  2684  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2685  }
  2686  
  2687  func (ec *executionContext) fieldContext_Query_directiveField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2688  	fc = &graphql.FieldContext{
  2689  		Object:     "Query",
  2690  		Field:      field,
  2691  		IsMethod:   true,
  2692  		IsResolver: true,
  2693  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2694  			return nil, errors.New("field of type String does not have child fields")
  2695  		},
  2696  	}
  2697  	return fc, nil
  2698  }
  2699  
  2700  func (ec *executionContext) _Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2701  	fc, err := ec.fieldContext_Query_directiveDouble(ctx, field)
  2702  	if err != nil {
  2703  		return graphql.Null
  2704  	}
  2705  	ctx = graphql.WithFieldContext(ctx, fc)
  2706  	defer func() {
  2707  		if r := recover(); r != nil {
  2708  			ec.Error(ctx, ec.Recover(ctx, r))
  2709  			ret = graphql.Null
  2710  		}
  2711  	}()
  2712  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2713  		directive0 := func(rctx context.Context) (interface{}, error) {
  2714  			ctx = rctx // use context from middleware stack in children
  2715  			return ec.resolvers.Query().DirectiveDouble(rctx)
  2716  		}
  2717  		directive1 := func(ctx context.Context) (interface{}, error) {
  2718  			if ec.directives.Directive1 == nil {
  2719  				return nil, errors.New("directive directive1 is not implemented")
  2720  			}
  2721  			return ec.directives.Directive1(ctx, nil, directive0)
  2722  		}
  2723  		directive2 := func(ctx context.Context) (interface{}, error) {
  2724  			if ec.directives.Directive2 == nil {
  2725  				return nil, errors.New("directive directive2 is not implemented")
  2726  			}
  2727  			return ec.directives.Directive2(ctx, nil, directive1)
  2728  		}
  2729  
  2730  		tmp, err := directive2(rctx)
  2731  		if err != nil {
  2732  			return nil, graphql.ErrorOnPath(ctx, err)
  2733  		}
  2734  		if tmp == nil {
  2735  			return nil, nil
  2736  		}
  2737  		if data, ok := tmp.(*string); ok {
  2738  			return data, nil
  2739  		}
  2740  		return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
  2741  	})
  2742  
  2743  	if resTmp == nil {
  2744  		return graphql.Null
  2745  	}
  2746  	res := resTmp.(*string)
  2747  	fc.Result = res
  2748  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2749  }
  2750  
  2751  func (ec *executionContext) fieldContext_Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2752  	fc = &graphql.FieldContext{
  2753  		Object:     "Query",
  2754  		Field:      field,
  2755  		IsMethod:   true,
  2756  		IsResolver: true,
  2757  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2758  			return nil, errors.New("field of type String does not have child fields")
  2759  		},
  2760  	}
  2761  	return fc, nil
  2762  }
  2763  
  2764  func (ec *executionContext) _Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2765  	fc, err := ec.fieldContext_Query_directiveUnimplemented(ctx, field)
  2766  	if err != nil {
  2767  		return graphql.Null
  2768  	}
  2769  	ctx = graphql.WithFieldContext(ctx, fc)
  2770  	defer func() {
  2771  		if r := recover(); r != nil {
  2772  			ec.Error(ctx, ec.Recover(ctx, r))
  2773  			ret = graphql.Null
  2774  		}
  2775  	}()
  2776  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2777  		directive0 := func(rctx context.Context) (interface{}, error) {
  2778  			ctx = rctx // use context from middleware stack in children
  2779  			return ec.resolvers.Query().DirectiveUnimplemented(rctx)
  2780  		}
  2781  		directive1 := func(ctx context.Context) (interface{}, error) {
  2782  			if ec.directives.Unimplemented == nil {
  2783  				return nil, errors.New("directive unimplemented is not implemented")
  2784  			}
  2785  			return ec.directives.Unimplemented(ctx, nil, directive0)
  2786  		}
  2787  
  2788  		tmp, err := directive1(rctx)
  2789  		if err != nil {
  2790  			return nil, graphql.ErrorOnPath(ctx, err)
  2791  		}
  2792  		if tmp == nil {
  2793  			return nil, nil
  2794  		}
  2795  		if data, ok := tmp.(*string); ok {
  2796  			return data, nil
  2797  		}
  2798  		return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
  2799  	})
  2800  
  2801  	if resTmp == nil {
  2802  		return graphql.Null
  2803  	}
  2804  	res := resTmp.(*string)
  2805  	fc.Result = res
  2806  	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
  2807  }
  2808  
  2809  func (ec *executionContext) fieldContext_Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2810  	fc = &graphql.FieldContext{
  2811  		Object:     "Query",
  2812  		Field:      field,
  2813  		IsMethod:   true,
  2814  		IsResolver: true,
  2815  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2816  			return nil, errors.New("field of type String does not have child fields")
  2817  		},
  2818  	}
  2819  	return fc, nil
  2820  }
  2821  
  2822  func (ec *executionContext) _Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2823  	fc, err := ec.fieldContext_Query_embeddedCase1(ctx, field)
  2824  	if err != nil {
  2825  		return graphql.Null
  2826  	}
  2827  	ctx = graphql.WithFieldContext(ctx, fc)
  2828  	defer func() {
  2829  		if r := recover(); r != nil {
  2830  			ec.Error(ctx, ec.Recover(ctx, r))
  2831  			ret = graphql.Null
  2832  		}
  2833  	}()
  2834  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2835  		ctx = rctx // use context from middleware stack in children
  2836  		return ec.resolvers.Query().EmbeddedCase1(rctx)
  2837  	})
  2838  
  2839  	if resTmp == nil {
  2840  		return graphql.Null
  2841  	}
  2842  	res := resTmp.(*EmbeddedCase1)
  2843  	fc.Result = res
  2844  	return ec.marshalOEmbeddedCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase1(ctx, field.Selections, res)
  2845  }
  2846  
  2847  func (ec *executionContext) fieldContext_Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2848  	fc = &graphql.FieldContext{
  2849  		Object:     "Query",
  2850  		Field:      field,
  2851  		IsMethod:   true,
  2852  		IsResolver: true,
  2853  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2854  			switch field.Name {
  2855  			case "exportedEmbeddedPointerExportedMethod":
  2856  				return ec.fieldContext_EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx, field)
  2857  			}
  2858  			return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase1", field.Name)
  2859  		},
  2860  	}
  2861  	return fc, nil
  2862  }
  2863  
  2864  func (ec *executionContext) _Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2865  	fc, err := ec.fieldContext_Query_embeddedCase2(ctx, field)
  2866  	if err != nil {
  2867  		return graphql.Null
  2868  	}
  2869  	ctx = graphql.WithFieldContext(ctx, fc)
  2870  	defer func() {
  2871  		if r := recover(); r != nil {
  2872  			ec.Error(ctx, ec.Recover(ctx, r))
  2873  			ret = graphql.Null
  2874  		}
  2875  	}()
  2876  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2877  		ctx = rctx // use context from middleware stack in children
  2878  		return ec.resolvers.Query().EmbeddedCase2(rctx)
  2879  	})
  2880  
  2881  	if resTmp == nil {
  2882  		return graphql.Null
  2883  	}
  2884  	res := resTmp.(*EmbeddedCase2)
  2885  	fc.Result = res
  2886  	return ec.marshalOEmbeddedCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase2(ctx, field.Selections, res)
  2887  }
  2888  
  2889  func (ec *executionContext) fieldContext_Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2890  	fc = &graphql.FieldContext{
  2891  		Object:     "Query",
  2892  		Field:      field,
  2893  		IsMethod:   true,
  2894  		IsResolver: true,
  2895  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2896  			switch field.Name {
  2897  			case "unexportedEmbeddedPointerExportedMethod":
  2898  				return ec.fieldContext_EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx, field)
  2899  			}
  2900  			return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase2", field.Name)
  2901  		},
  2902  	}
  2903  	return fc, nil
  2904  }
  2905  
  2906  func (ec *executionContext) _Query_embeddedCase3(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2907  	fc, err := ec.fieldContext_Query_embeddedCase3(ctx, field)
  2908  	if err != nil {
  2909  		return graphql.Null
  2910  	}
  2911  	ctx = graphql.WithFieldContext(ctx, fc)
  2912  	defer func() {
  2913  		if r := recover(); r != nil {
  2914  			ec.Error(ctx, ec.Recover(ctx, r))
  2915  			ret = graphql.Null
  2916  		}
  2917  	}()
  2918  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2919  		ctx = rctx // use context from middleware stack in children
  2920  		return ec.resolvers.Query().EmbeddedCase3(rctx)
  2921  	})
  2922  
  2923  	if resTmp == nil {
  2924  		return graphql.Null
  2925  	}
  2926  	res := resTmp.(*EmbeddedCase3)
  2927  	fc.Result = res
  2928  	return ec.marshalOEmbeddedCase32ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase3(ctx, field.Selections, res)
  2929  }
  2930  
  2931  func (ec *executionContext) fieldContext_Query_embeddedCase3(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2932  	fc = &graphql.FieldContext{
  2933  		Object:     "Query",
  2934  		Field:      field,
  2935  		IsMethod:   true,
  2936  		IsResolver: true,
  2937  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2938  			switch field.Name {
  2939  			case "unexportedEmbeddedInterfaceExportedMethod":
  2940  				return ec.fieldContext_EmbeddedCase3_unexportedEmbeddedInterfaceExportedMethod(ctx, field)
  2941  			}
  2942  			return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase3", field.Name)
  2943  		},
  2944  	}
  2945  	return fc, nil
  2946  }
  2947  
  2948  func (ec *executionContext) _Query_enumInInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  2949  	fc, err := ec.fieldContext_Query_enumInInput(ctx, field)
  2950  	if err != nil {
  2951  		return graphql.Null
  2952  	}
  2953  	ctx = graphql.WithFieldContext(ctx, fc)
  2954  	defer func() {
  2955  		if r := recover(); r != nil {
  2956  			ec.Error(ctx, ec.Recover(ctx, r))
  2957  			ret = graphql.Null
  2958  		}
  2959  	}()
  2960  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  2961  		ctx = rctx // use context from middleware stack in children
  2962  		return ec.resolvers.Query().EnumInInput(rctx, fc.Args["input"].(*InputWithEnumValue))
  2963  	})
  2964  
  2965  	if resTmp == nil {
  2966  		if !graphql.HasFieldError(ctx, fc) {
  2967  			ec.Errorf(ctx, "must not be null")
  2968  		}
  2969  		return graphql.Null
  2970  	}
  2971  	res := resTmp.(EnumTest)
  2972  	fc.Result = res
  2973  	return ec.marshalNEnumTest2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEnumTest(ctx, field.Selections, res)
  2974  }
  2975  
  2976  func (ec *executionContext) fieldContext_Query_enumInInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  2977  	fc = &graphql.FieldContext{
  2978  		Object:     "Query",
  2979  		Field:      field,
  2980  		IsMethod:   true,
  2981  		IsResolver: true,
  2982  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  2983  			return nil, errors.New("field of type EnumTest does not have child fields")
  2984  		},
  2985  	}
  2986  	defer func() {
  2987  		if r := recover(); r != nil {
  2988  			err = ec.Recover(ctx, r)
  2989  			ec.Error(ctx, err)
  2990  		}
  2991  	}()
  2992  	ctx = graphql.WithFieldContext(ctx, fc)
  2993  	if fc.Args, err = ec.field_Query_enumInInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  2994  		ec.Error(ctx, err)
  2995  		return
  2996  	}
  2997  	return fc, nil
  2998  }
  2999  
  3000  func (ec *executionContext) _Query_shapes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3001  	fc, err := ec.fieldContext_Query_shapes(ctx, field)
  3002  	if err != nil {
  3003  		return graphql.Null
  3004  	}
  3005  	ctx = graphql.WithFieldContext(ctx, fc)
  3006  	defer func() {
  3007  		if r := recover(); r != nil {
  3008  			ec.Error(ctx, ec.Recover(ctx, r))
  3009  			ret = graphql.Null
  3010  		}
  3011  	}()
  3012  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3013  		ctx = rctx // use context from middleware stack in children
  3014  		return ec.resolvers.Query().Shapes(rctx)
  3015  	})
  3016  
  3017  	if resTmp == nil {
  3018  		return graphql.Null
  3019  	}
  3020  	res := resTmp.([]Shape)
  3021  	fc.Result = res
  3022  	return ec.marshalOShape2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res)
  3023  }
  3024  
  3025  func (ec *executionContext) fieldContext_Query_shapes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3026  	fc = &graphql.FieldContext{
  3027  		Object:     "Query",
  3028  		Field:      field,
  3029  		IsMethod:   true,
  3030  		IsResolver: true,
  3031  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3032  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3033  		},
  3034  	}
  3035  	return fc, nil
  3036  }
  3037  
  3038  func (ec *executionContext) _Query_noShape(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3039  	fc, err := ec.fieldContext_Query_noShape(ctx, field)
  3040  	if err != nil {
  3041  		return graphql.Null
  3042  	}
  3043  	ctx = graphql.WithFieldContext(ctx, fc)
  3044  	defer func() {
  3045  		if r := recover(); r != nil {
  3046  			ec.Error(ctx, ec.Recover(ctx, r))
  3047  			ret = graphql.Null
  3048  		}
  3049  	}()
  3050  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3051  		directive0 := func(rctx context.Context) (interface{}, error) {
  3052  			ctx = rctx // use context from middleware stack in children
  3053  			return ec.resolvers.Query().NoShape(rctx)
  3054  		}
  3055  		directive1 := func(ctx context.Context) (interface{}, error) {
  3056  			if ec.directives.MakeNil == nil {
  3057  				return nil, errors.New("directive makeNil is not implemented")
  3058  			}
  3059  			return ec.directives.MakeNil(ctx, nil, directive0)
  3060  		}
  3061  
  3062  		tmp, err := directive1(rctx)
  3063  		if err != nil {
  3064  			return nil, graphql.ErrorOnPath(ctx, err)
  3065  		}
  3066  		if tmp == nil {
  3067  			return nil, nil
  3068  		}
  3069  		if data, ok := tmp.(Shape); ok {
  3070  			return data, nil
  3071  		}
  3072  		return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/99designs/gqlgen/codegen/testserver/followschema.Shape`, tmp)
  3073  	})
  3074  
  3075  	if resTmp == nil {
  3076  		return graphql.Null
  3077  	}
  3078  	res := resTmp.(Shape)
  3079  	fc.Result = res
  3080  	return ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res)
  3081  }
  3082  
  3083  func (ec *executionContext) fieldContext_Query_noShape(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3084  	fc = &graphql.FieldContext{
  3085  		Object:     "Query",
  3086  		Field:      field,
  3087  		IsMethod:   true,
  3088  		IsResolver: true,
  3089  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3090  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3091  		},
  3092  	}
  3093  	return fc, nil
  3094  }
  3095  
  3096  func (ec *executionContext) _Query_node(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3097  	fc, err := ec.fieldContext_Query_node(ctx, field)
  3098  	if err != nil {
  3099  		return graphql.Null
  3100  	}
  3101  	ctx = graphql.WithFieldContext(ctx, fc)
  3102  	defer func() {
  3103  		if r := recover(); r != nil {
  3104  			ec.Error(ctx, ec.Recover(ctx, r))
  3105  			ret = graphql.Null
  3106  		}
  3107  	}()
  3108  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3109  		ctx = rctx // use context from middleware stack in children
  3110  		return ec.resolvers.Query().Node(rctx)
  3111  	})
  3112  
  3113  	if resTmp == nil {
  3114  		if !graphql.HasFieldError(ctx, fc) {
  3115  			ec.Errorf(ctx, "must not be null")
  3116  		}
  3117  		return graphql.Null
  3118  	}
  3119  	res := resTmp.(Node)
  3120  	fc.Result = res
  3121  	return ec.marshalNNode2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐNode(ctx, field.Selections, res)
  3122  }
  3123  
  3124  func (ec *executionContext) fieldContext_Query_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3125  	fc = &graphql.FieldContext{
  3126  		Object:     "Query",
  3127  		Field:      field,
  3128  		IsMethod:   true,
  3129  		IsResolver: true,
  3130  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3131  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3132  		},
  3133  	}
  3134  	return fc, nil
  3135  }
  3136  
  3137  func (ec *executionContext) _Query_noShapeTypedNil(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3138  	fc, err := ec.fieldContext_Query_noShapeTypedNil(ctx, field)
  3139  	if err != nil {
  3140  		return graphql.Null
  3141  	}
  3142  	ctx = graphql.WithFieldContext(ctx, fc)
  3143  	defer func() {
  3144  		if r := recover(); r != nil {
  3145  			ec.Error(ctx, ec.Recover(ctx, r))
  3146  			ret = graphql.Null
  3147  		}
  3148  	}()
  3149  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3150  		directive0 := func(rctx context.Context) (interface{}, error) {
  3151  			ctx = rctx // use context from middleware stack in children
  3152  			return ec.resolvers.Query().NoShapeTypedNil(rctx)
  3153  		}
  3154  		directive1 := func(ctx context.Context) (interface{}, error) {
  3155  			if ec.directives.MakeTypedNil == nil {
  3156  				return nil, errors.New("directive makeTypedNil is not implemented")
  3157  			}
  3158  			return ec.directives.MakeTypedNil(ctx, nil, directive0)
  3159  		}
  3160  
  3161  		tmp, err := directive1(rctx)
  3162  		if err != nil {
  3163  			return nil, graphql.ErrorOnPath(ctx, err)
  3164  		}
  3165  		if tmp == nil {
  3166  			return nil, nil
  3167  		}
  3168  		if data, ok := tmp.(Shape); ok {
  3169  			return data, nil
  3170  		}
  3171  		return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/99designs/gqlgen/codegen/testserver/followschema.Shape`, tmp)
  3172  	})
  3173  
  3174  	if resTmp == nil {
  3175  		return graphql.Null
  3176  	}
  3177  	res := resTmp.(Shape)
  3178  	fc.Result = res
  3179  	return ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res)
  3180  }
  3181  
  3182  func (ec *executionContext) fieldContext_Query_noShapeTypedNil(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3183  	fc = &graphql.FieldContext{
  3184  		Object:     "Query",
  3185  		Field:      field,
  3186  		IsMethod:   true,
  3187  		IsResolver: true,
  3188  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3189  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3190  		},
  3191  	}
  3192  	return fc, nil
  3193  }
  3194  
  3195  func (ec *executionContext) _Query_animal(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3196  	fc, err := ec.fieldContext_Query_animal(ctx, field)
  3197  	if err != nil {
  3198  		return graphql.Null
  3199  	}
  3200  	ctx = graphql.WithFieldContext(ctx, fc)
  3201  	defer func() {
  3202  		if r := recover(); r != nil {
  3203  			ec.Error(ctx, ec.Recover(ctx, r))
  3204  			ret = graphql.Null
  3205  		}
  3206  	}()
  3207  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3208  		directive0 := func(rctx context.Context) (interface{}, error) {
  3209  			ctx = rctx // use context from middleware stack in children
  3210  			return ec.resolvers.Query().Animal(rctx)
  3211  		}
  3212  		directive1 := func(ctx context.Context) (interface{}, error) {
  3213  			if ec.directives.MakeTypedNil == nil {
  3214  				return nil, errors.New("directive makeTypedNil is not implemented")
  3215  			}
  3216  			return ec.directives.MakeTypedNil(ctx, nil, directive0)
  3217  		}
  3218  
  3219  		tmp, err := directive1(rctx)
  3220  		if err != nil {
  3221  			return nil, graphql.ErrorOnPath(ctx, err)
  3222  		}
  3223  		if tmp == nil {
  3224  			return nil, nil
  3225  		}
  3226  		if data, ok := tmp.(Animal); ok {
  3227  			return data, nil
  3228  		}
  3229  		return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/99designs/gqlgen/codegen/testserver/followschema.Animal`, tmp)
  3230  	})
  3231  
  3232  	if resTmp == nil {
  3233  		return graphql.Null
  3234  	}
  3235  	res := resTmp.(Animal)
  3236  	fc.Result = res
  3237  	return ec.marshalOAnimal2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAnimal(ctx, field.Selections, res)
  3238  }
  3239  
  3240  func (ec *executionContext) fieldContext_Query_animal(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3241  	fc = &graphql.FieldContext{
  3242  		Object:     "Query",
  3243  		Field:      field,
  3244  		IsMethod:   true,
  3245  		IsResolver: true,
  3246  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3247  			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
  3248  		},
  3249  	}
  3250  	return fc, nil
  3251  }
  3252  
  3253  func (ec *executionContext) _Query_notAnInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3254  	fc, err := ec.fieldContext_Query_notAnInterface(ctx, field)
  3255  	if err != nil {
  3256  		return graphql.Null
  3257  	}
  3258  	ctx = graphql.WithFieldContext(ctx, fc)
  3259  	defer func() {
  3260  		if r := recover(); r != nil {
  3261  			ec.Error(ctx, ec.Recover(ctx, r))
  3262  			ret = graphql.Null
  3263  		}
  3264  	}()
  3265  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3266  		ctx = rctx // use context from middleware stack in children
  3267  		return ec.resolvers.Query().NotAnInterface(rctx)
  3268  	})
  3269  
  3270  	if resTmp == nil {
  3271  		return graphql.Null
  3272  	}
  3273  	res := resTmp.(BackedByInterface)
  3274  	fc.Result = res
  3275  	return ec.marshalOBackedByInterface2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐBackedByInterface(ctx, field.Selections, res)
  3276  }
  3277  
  3278  func (ec *executionContext) fieldContext_Query_notAnInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3279  	fc = &graphql.FieldContext{
  3280  		Object:     "Query",
  3281  		Field:      field,
  3282  		IsMethod:   true,
  3283  		IsResolver: true,
  3284  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3285  			switch field.Name {
  3286  			case "id":
  3287  				return ec.fieldContext_BackedByInterface_id(ctx, field)
  3288  			case "thisShouldBind":
  3289  				return ec.fieldContext_BackedByInterface_thisShouldBind(ctx, field)
  3290  			case "thisShouldBindWithError":
  3291  				return ec.fieldContext_BackedByInterface_thisShouldBindWithError(ctx, field)
  3292  			}
  3293  			return nil, fmt.Errorf("no field named %q was found under type BackedByInterface", field.Name)
  3294  		},
  3295  	}
  3296  	return fc, nil
  3297  }
  3298  
  3299  func (ec *executionContext) _Query_issue896a(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3300  	fc, err := ec.fieldContext_Query_issue896a(ctx, field)
  3301  	if err != nil {
  3302  		return graphql.Null
  3303  	}
  3304  	ctx = graphql.WithFieldContext(ctx, fc)
  3305  	defer func() {
  3306  		if r := recover(); r != nil {
  3307  			ec.Error(ctx, ec.Recover(ctx, r))
  3308  			ret = graphql.Null
  3309  		}
  3310  	}()
  3311  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3312  		ctx = rctx // use context from middleware stack in children
  3313  		return ec.resolvers.Query().Issue896a(rctx)
  3314  	})
  3315  
  3316  	if resTmp == nil {
  3317  		return graphql.Null
  3318  	}
  3319  	res := resTmp.([]*CheckIssue896)
  3320  	fc.Result = res
  3321  	return ec.marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCheckIssue896ᚄ(ctx, field.Selections, res)
  3322  }
  3323  
  3324  func (ec *executionContext) fieldContext_Query_issue896a(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3325  	fc = &graphql.FieldContext{
  3326  		Object:     "Query",
  3327  		Field:      field,
  3328  		IsMethod:   true,
  3329  		IsResolver: true,
  3330  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3331  			switch field.Name {
  3332  			case "id":
  3333  				return ec.fieldContext_CheckIssue896_id(ctx, field)
  3334  			}
  3335  			return nil, fmt.Errorf("no field named %q was found under type CheckIssue896", field.Name)
  3336  		},
  3337  	}
  3338  	return fc, nil
  3339  }
  3340  
  3341  func (ec *executionContext) _Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3342  	fc, err := ec.fieldContext_Query_mapStringInterface(ctx, field)
  3343  	if err != nil {
  3344  		return graphql.Null
  3345  	}
  3346  	ctx = graphql.WithFieldContext(ctx, fc)
  3347  	defer func() {
  3348  		if r := recover(); r != nil {
  3349  			ec.Error(ctx, ec.Recover(ctx, r))
  3350  			ret = graphql.Null
  3351  		}
  3352  	}()
  3353  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3354  		ctx = rctx // use context from middleware stack in children
  3355  		return ec.resolvers.Query().MapStringInterface(rctx, fc.Args["in"].(map[string]interface{}))
  3356  	})
  3357  
  3358  	if resTmp == nil {
  3359  		return graphql.Null
  3360  	}
  3361  	res := resTmp.(map[string]interface{})
  3362  	fc.Result = res
  3363  	return ec.marshalOMapStringInterfaceType2map(ctx, field.Selections, res)
  3364  }
  3365  
  3366  func (ec *executionContext) fieldContext_Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3367  	fc = &graphql.FieldContext{
  3368  		Object:     "Query",
  3369  		Field:      field,
  3370  		IsMethod:   true,
  3371  		IsResolver: true,
  3372  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3373  			switch field.Name {
  3374  			case "a":
  3375  				return ec.fieldContext_MapStringInterfaceType_a(ctx, field)
  3376  			case "b":
  3377  				return ec.fieldContext_MapStringInterfaceType_b(ctx, field)
  3378  			}
  3379  			return nil, fmt.Errorf("no field named %q was found under type MapStringInterfaceType", field.Name)
  3380  		},
  3381  	}
  3382  	defer func() {
  3383  		if r := recover(); r != nil {
  3384  			err = ec.Recover(ctx, r)
  3385  			ec.Error(ctx, err)
  3386  		}
  3387  	}()
  3388  	ctx = graphql.WithFieldContext(ctx, fc)
  3389  	if fc.Args, err = ec.field_Query_mapStringInterface_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  3390  		ec.Error(ctx, err)
  3391  		return
  3392  	}
  3393  	return fc, nil
  3394  }
  3395  
  3396  func (ec *executionContext) _Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3397  	fc, err := ec.fieldContext_Query_mapNestedStringInterface(ctx, field)
  3398  	if err != nil {
  3399  		return graphql.Null
  3400  	}
  3401  	ctx = graphql.WithFieldContext(ctx, fc)
  3402  	defer func() {
  3403  		if r := recover(); r != nil {
  3404  			ec.Error(ctx, ec.Recover(ctx, r))
  3405  			ret = graphql.Null
  3406  		}
  3407  	}()
  3408  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3409  		ctx = rctx // use context from middleware stack in children
  3410  		return ec.resolvers.Query().MapNestedStringInterface(rctx, fc.Args["in"].(*NestedMapInput))
  3411  	})
  3412  
  3413  	if resTmp == nil {
  3414  		return graphql.Null
  3415  	}
  3416  	res := resTmp.(map[string]interface{})
  3417  	fc.Result = res
  3418  	return ec.marshalOMapStringInterfaceType2map(ctx, field.Selections, res)
  3419  }
  3420  
  3421  func (ec *executionContext) fieldContext_Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3422  	fc = &graphql.FieldContext{
  3423  		Object:     "Query",
  3424  		Field:      field,
  3425  		IsMethod:   true,
  3426  		IsResolver: true,
  3427  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3428  			switch field.Name {
  3429  			case "a":
  3430  				return ec.fieldContext_MapStringInterfaceType_a(ctx, field)
  3431  			case "b":
  3432  				return ec.fieldContext_MapStringInterfaceType_b(ctx, field)
  3433  			}
  3434  			return nil, fmt.Errorf("no field named %q was found under type MapStringInterfaceType", field.Name)
  3435  		},
  3436  	}
  3437  	defer func() {
  3438  		if r := recover(); r != nil {
  3439  			err = ec.Recover(ctx, r)
  3440  			ec.Error(ctx, err)
  3441  		}
  3442  	}()
  3443  	ctx = graphql.WithFieldContext(ctx, fc)
  3444  	if fc.Args, err = ec.field_Query_mapNestedStringInterface_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  3445  		ec.Error(ctx, err)
  3446  		return
  3447  	}
  3448  	return fc, nil
  3449  }
  3450  
  3451  func (ec *executionContext) _Query_errorBubble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3452  	fc, err := ec.fieldContext_Query_errorBubble(ctx, field)
  3453  	if err != nil {
  3454  		return graphql.Null
  3455  	}
  3456  	ctx = graphql.WithFieldContext(ctx, fc)
  3457  	defer func() {
  3458  		if r := recover(); r != nil {
  3459  			ec.Error(ctx, ec.Recover(ctx, r))
  3460  			ret = graphql.Null
  3461  		}
  3462  	}()
  3463  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3464  		ctx = rctx // use context from middleware stack in children
  3465  		return ec.resolvers.Query().ErrorBubble(rctx)
  3466  	})
  3467  
  3468  	if resTmp == nil {
  3469  		return graphql.Null
  3470  	}
  3471  	res := resTmp.(*Error)
  3472  	fc.Result = res
  3473  	return ec.marshalOError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res)
  3474  }
  3475  
  3476  func (ec *executionContext) fieldContext_Query_errorBubble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3477  	fc = &graphql.FieldContext{
  3478  		Object:     "Query",
  3479  		Field:      field,
  3480  		IsMethod:   true,
  3481  		IsResolver: true,
  3482  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3483  			switch field.Name {
  3484  			case "id":
  3485  				return ec.fieldContext_Error_id(ctx, field)
  3486  			case "errorOnNonRequiredField":
  3487  				return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
  3488  			case "errorOnRequiredField":
  3489  				return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
  3490  			case "nilOnRequiredField":
  3491  				return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
  3492  			}
  3493  			return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
  3494  		},
  3495  	}
  3496  	return fc, nil
  3497  }
  3498  
  3499  func (ec *executionContext) _Query_errorBubbleList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3500  	fc, err := ec.fieldContext_Query_errorBubbleList(ctx, field)
  3501  	if err != nil {
  3502  		return graphql.Null
  3503  	}
  3504  	ctx = graphql.WithFieldContext(ctx, fc)
  3505  	defer func() {
  3506  		if r := recover(); r != nil {
  3507  			ec.Error(ctx, ec.Recover(ctx, r))
  3508  			ret = graphql.Null
  3509  		}
  3510  	}()
  3511  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3512  		ctx = rctx // use context from middleware stack in children
  3513  		return ec.resolvers.Query().ErrorBubbleList(rctx)
  3514  	})
  3515  
  3516  	if resTmp == nil {
  3517  		return graphql.Null
  3518  	}
  3519  	res := resTmp.([]*Error)
  3520  	fc.Result = res
  3521  	return ec.marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐErrorᚄ(ctx, field.Selections, res)
  3522  }
  3523  
  3524  func (ec *executionContext) fieldContext_Query_errorBubbleList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3525  	fc = &graphql.FieldContext{
  3526  		Object:     "Query",
  3527  		Field:      field,
  3528  		IsMethod:   true,
  3529  		IsResolver: true,
  3530  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3531  			switch field.Name {
  3532  			case "id":
  3533  				return ec.fieldContext_Error_id(ctx, field)
  3534  			case "errorOnNonRequiredField":
  3535  				return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
  3536  			case "errorOnRequiredField":
  3537  				return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
  3538  			case "nilOnRequiredField":
  3539  				return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
  3540  			}
  3541  			return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
  3542  		},
  3543  	}
  3544  	return fc, nil
  3545  }
  3546  
  3547  func (ec *executionContext) _Query_errorList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3548  	fc, err := ec.fieldContext_Query_errorList(ctx, field)
  3549  	if err != nil {
  3550  		return graphql.Null
  3551  	}
  3552  	ctx = graphql.WithFieldContext(ctx, fc)
  3553  	defer func() {
  3554  		if r := recover(); r != nil {
  3555  			ec.Error(ctx, ec.Recover(ctx, r))
  3556  			ret = graphql.Null
  3557  		}
  3558  	}()
  3559  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3560  		ctx = rctx // use context from middleware stack in children
  3561  		return ec.resolvers.Query().ErrorList(rctx)
  3562  	})
  3563  
  3564  	if resTmp == nil {
  3565  		return graphql.Null
  3566  	}
  3567  	res := resTmp.([]*Error)
  3568  	fc.Result = res
  3569  	return ec.marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res)
  3570  }
  3571  
  3572  func (ec *executionContext) fieldContext_Query_errorList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3573  	fc = &graphql.FieldContext{
  3574  		Object:     "Query",
  3575  		Field:      field,
  3576  		IsMethod:   true,
  3577  		IsResolver: true,
  3578  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3579  			switch field.Name {
  3580  			case "id":
  3581  				return ec.fieldContext_Error_id(ctx, field)
  3582  			case "errorOnNonRequiredField":
  3583  				return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
  3584  			case "errorOnRequiredField":
  3585  				return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
  3586  			case "nilOnRequiredField":
  3587  				return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
  3588  			}
  3589  			return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
  3590  		},
  3591  	}
  3592  	return fc, nil
  3593  }
  3594  
  3595  func (ec *executionContext) _Query_errors(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3596  	fc, err := ec.fieldContext_Query_errors(ctx, field)
  3597  	if err != nil {
  3598  		return graphql.Null
  3599  	}
  3600  	ctx = graphql.WithFieldContext(ctx, fc)
  3601  	defer func() {
  3602  		if r := recover(); r != nil {
  3603  			ec.Error(ctx, ec.Recover(ctx, r))
  3604  			ret = graphql.Null
  3605  		}
  3606  	}()
  3607  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3608  		ctx = rctx // use context from middleware stack in children
  3609  		return ec.resolvers.Query().Errors(rctx)
  3610  	})
  3611  
  3612  	if resTmp == nil {
  3613  		return graphql.Null
  3614  	}
  3615  	res := resTmp.(*Errors)
  3616  	fc.Result = res
  3617  	return ec.marshalOErrors2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐErrors(ctx, field.Selections, res)
  3618  }
  3619  
  3620  func (ec *executionContext) fieldContext_Query_errors(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3621  	fc = &graphql.FieldContext{
  3622  		Object:     "Query",
  3623  		Field:      field,
  3624  		IsMethod:   true,
  3625  		IsResolver: true,
  3626  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3627  			switch field.Name {
  3628  			case "a":
  3629  				return ec.fieldContext_Errors_a(ctx, field)
  3630  			case "b":
  3631  				return ec.fieldContext_Errors_b(ctx, field)
  3632  			case "c":
  3633  				return ec.fieldContext_Errors_c(ctx, field)
  3634  			case "d":
  3635  				return ec.fieldContext_Errors_d(ctx, field)
  3636  			case "e":
  3637  				return ec.fieldContext_Errors_e(ctx, field)
  3638  			}
  3639  			return nil, fmt.Errorf("no field named %q was found under type Errors", field.Name)
  3640  		},
  3641  	}
  3642  	return fc, nil
  3643  }
  3644  
  3645  func (ec *executionContext) _Query_valid(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3646  	fc, err := ec.fieldContext_Query_valid(ctx, field)
  3647  	if err != nil {
  3648  		return graphql.Null
  3649  	}
  3650  	ctx = graphql.WithFieldContext(ctx, fc)
  3651  	defer func() {
  3652  		if r := recover(); r != nil {
  3653  			ec.Error(ctx, ec.Recover(ctx, r))
  3654  			ret = graphql.Null
  3655  		}
  3656  	}()
  3657  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3658  		ctx = rctx // use context from middleware stack in children
  3659  		return ec.resolvers.Query().Valid(rctx)
  3660  	})
  3661  
  3662  	if resTmp == nil {
  3663  		if !graphql.HasFieldError(ctx, fc) {
  3664  			ec.Errorf(ctx, "must not be null")
  3665  		}
  3666  		return graphql.Null
  3667  	}
  3668  	res := resTmp.(string)
  3669  	fc.Result = res
  3670  	return ec.marshalNString2string(ctx, field.Selections, res)
  3671  }
  3672  
  3673  func (ec *executionContext) fieldContext_Query_valid(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3674  	fc = &graphql.FieldContext{
  3675  		Object:     "Query",
  3676  		Field:      field,
  3677  		IsMethod:   true,
  3678  		IsResolver: true,
  3679  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3680  			return nil, errors.New("field of type String does not have child fields")
  3681  		},
  3682  	}
  3683  	return fc, nil
  3684  }
  3685  
  3686  func (ec *executionContext) _Query_panics(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3687  	fc, err := ec.fieldContext_Query_panics(ctx, field)
  3688  	if err != nil {
  3689  		return graphql.Null
  3690  	}
  3691  	ctx = graphql.WithFieldContext(ctx, fc)
  3692  	defer func() {
  3693  		if r := recover(); r != nil {
  3694  			ec.Error(ctx, ec.Recover(ctx, r))
  3695  			ret = graphql.Null
  3696  		}
  3697  	}()
  3698  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3699  		ctx = rctx // use context from middleware stack in children
  3700  		return ec.resolvers.Query().Panics(rctx)
  3701  	})
  3702  
  3703  	if resTmp == nil {
  3704  		return graphql.Null
  3705  	}
  3706  	res := resTmp.(*Panics)
  3707  	fc.Result = res
  3708  	return ec.marshalOPanics2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPanics(ctx, field.Selections, res)
  3709  }
  3710  
  3711  func (ec *executionContext) fieldContext_Query_panics(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3712  	fc = &graphql.FieldContext{
  3713  		Object:     "Query",
  3714  		Field:      field,
  3715  		IsMethod:   true,
  3716  		IsResolver: true,
  3717  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3718  			switch field.Name {
  3719  			case "fieldScalarMarshal":
  3720  				return ec.fieldContext_Panics_fieldScalarMarshal(ctx, field)
  3721  			case "fieldFuncMarshal":
  3722  				return ec.fieldContext_Panics_fieldFuncMarshal(ctx, field)
  3723  			case "argUnmarshal":
  3724  				return ec.fieldContext_Panics_argUnmarshal(ctx, field)
  3725  			}
  3726  			return nil, fmt.Errorf("no field named %q was found under type Panics", field.Name)
  3727  		},
  3728  	}
  3729  	return fc, nil
  3730  }
  3731  
  3732  func (ec *executionContext) _Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3733  	fc, err := ec.fieldContext_Query_primitiveObject(ctx, field)
  3734  	if err != nil {
  3735  		return graphql.Null
  3736  	}
  3737  	ctx = graphql.WithFieldContext(ctx, fc)
  3738  	defer func() {
  3739  		if r := recover(); r != nil {
  3740  			ec.Error(ctx, ec.Recover(ctx, r))
  3741  			ret = graphql.Null
  3742  		}
  3743  	}()
  3744  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3745  		ctx = rctx // use context from middleware stack in children
  3746  		return ec.resolvers.Query().PrimitiveObject(rctx)
  3747  	})
  3748  
  3749  	if resTmp == nil {
  3750  		if !graphql.HasFieldError(ctx, fc) {
  3751  			ec.Errorf(ctx, "must not be null")
  3752  		}
  3753  		return graphql.Null
  3754  	}
  3755  	res := resTmp.([]Primitive)
  3756  	fc.Result = res
  3757  	return ec.marshalNPrimitive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPrimitiveᚄ(ctx, field.Selections, res)
  3758  }
  3759  
  3760  func (ec *executionContext) fieldContext_Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3761  	fc = &graphql.FieldContext{
  3762  		Object:     "Query",
  3763  		Field:      field,
  3764  		IsMethod:   true,
  3765  		IsResolver: true,
  3766  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3767  			switch field.Name {
  3768  			case "value":
  3769  				return ec.fieldContext_Primitive_value(ctx, field)
  3770  			case "squared":
  3771  				return ec.fieldContext_Primitive_squared(ctx, field)
  3772  			}
  3773  			return nil, fmt.Errorf("no field named %q was found under type Primitive", field.Name)
  3774  		},
  3775  	}
  3776  	return fc, nil
  3777  }
  3778  
  3779  func (ec *executionContext) _Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3780  	fc, err := ec.fieldContext_Query_primitiveStringObject(ctx, field)
  3781  	if err != nil {
  3782  		return graphql.Null
  3783  	}
  3784  	ctx = graphql.WithFieldContext(ctx, fc)
  3785  	defer func() {
  3786  		if r := recover(); r != nil {
  3787  			ec.Error(ctx, ec.Recover(ctx, r))
  3788  			ret = graphql.Null
  3789  		}
  3790  	}()
  3791  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3792  		ctx = rctx // use context from middleware stack in children
  3793  		return ec.resolvers.Query().PrimitiveStringObject(rctx)
  3794  	})
  3795  
  3796  	if resTmp == nil {
  3797  		if !graphql.HasFieldError(ctx, fc) {
  3798  			ec.Errorf(ctx, "must not be null")
  3799  		}
  3800  		return graphql.Null
  3801  	}
  3802  	res := resTmp.([]PrimitiveString)
  3803  	fc.Result = res
  3804  	return ec.marshalNPrimitiveString2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPrimitiveStringᚄ(ctx, field.Selections, res)
  3805  }
  3806  
  3807  func (ec *executionContext) fieldContext_Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3808  	fc = &graphql.FieldContext{
  3809  		Object:     "Query",
  3810  		Field:      field,
  3811  		IsMethod:   true,
  3812  		IsResolver: true,
  3813  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3814  			switch field.Name {
  3815  			case "value":
  3816  				return ec.fieldContext_PrimitiveString_value(ctx, field)
  3817  			case "doubled":
  3818  				return ec.fieldContext_PrimitiveString_doubled(ctx, field)
  3819  			case "len":
  3820  				return ec.fieldContext_PrimitiveString_len(ctx, field)
  3821  			}
  3822  			return nil, fmt.Errorf("no field named %q was found under type PrimitiveString", field.Name)
  3823  		},
  3824  	}
  3825  	return fc, nil
  3826  }
  3827  
  3828  func (ec *executionContext) _Query_ptrToSliceContainer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3829  	fc, err := ec.fieldContext_Query_ptrToSliceContainer(ctx, field)
  3830  	if err != nil {
  3831  		return graphql.Null
  3832  	}
  3833  	ctx = graphql.WithFieldContext(ctx, fc)
  3834  	defer func() {
  3835  		if r := recover(); r != nil {
  3836  			ec.Error(ctx, ec.Recover(ctx, r))
  3837  			ret = graphql.Null
  3838  		}
  3839  	}()
  3840  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3841  		ctx = rctx // use context from middleware stack in children
  3842  		return ec.resolvers.Query().PtrToSliceContainer(rctx)
  3843  	})
  3844  
  3845  	if resTmp == nil {
  3846  		if !graphql.HasFieldError(ctx, fc) {
  3847  			ec.Errorf(ctx, "must not be null")
  3848  		}
  3849  		return graphql.Null
  3850  	}
  3851  	res := resTmp.(*PtrToSliceContainer)
  3852  	fc.Result = res
  3853  	return ec.marshalNPtrToSliceContainer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPtrToSliceContainer(ctx, field.Selections, res)
  3854  }
  3855  
  3856  func (ec *executionContext) fieldContext_Query_ptrToSliceContainer(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3857  	fc = &graphql.FieldContext{
  3858  		Object:     "Query",
  3859  		Field:      field,
  3860  		IsMethod:   true,
  3861  		IsResolver: true,
  3862  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3863  			switch field.Name {
  3864  			case "ptrToSlice":
  3865  				return ec.fieldContext_PtrToSliceContainer_ptrToSlice(ctx, field)
  3866  			}
  3867  			return nil, fmt.Errorf("no field named %q was found under type PtrToSliceContainer", field.Name)
  3868  		},
  3869  	}
  3870  	return fc, nil
  3871  }
  3872  
  3873  func (ec *executionContext) _Query_infinity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3874  	fc, err := ec.fieldContext_Query_infinity(ctx, field)
  3875  	if err != nil {
  3876  		return graphql.Null
  3877  	}
  3878  	ctx = graphql.WithFieldContext(ctx, fc)
  3879  	defer func() {
  3880  		if r := recover(); r != nil {
  3881  			ec.Error(ctx, ec.Recover(ctx, r))
  3882  			ret = graphql.Null
  3883  		}
  3884  	}()
  3885  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3886  		ctx = rctx // use context from middleware stack in children
  3887  		return ec.resolvers.Query().Infinity(rctx)
  3888  	})
  3889  
  3890  	if resTmp == nil {
  3891  		if !graphql.HasFieldError(ctx, fc) {
  3892  			ec.Errorf(ctx, "must not be null")
  3893  		}
  3894  		return graphql.Null
  3895  	}
  3896  	res := resTmp.(float64)
  3897  	fc.Result = res
  3898  	return ec.marshalNFloat2float64(ctx, field.Selections, res)
  3899  }
  3900  
  3901  func (ec *executionContext) fieldContext_Query_infinity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3902  	fc = &graphql.FieldContext{
  3903  		Object:     "Query",
  3904  		Field:      field,
  3905  		IsMethod:   true,
  3906  		IsResolver: true,
  3907  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3908  			return nil, errors.New("field of type Float does not have child fields")
  3909  		},
  3910  	}
  3911  	return fc, nil
  3912  }
  3913  
  3914  func (ec *executionContext) _Query_stringFromContextInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3915  	fc, err := ec.fieldContext_Query_stringFromContextInterface(ctx, field)
  3916  	if err != nil {
  3917  		return graphql.Null
  3918  	}
  3919  	ctx = graphql.WithFieldContext(ctx, fc)
  3920  	defer func() {
  3921  		if r := recover(); r != nil {
  3922  			ec.Error(ctx, ec.Recover(ctx, r))
  3923  			ret = graphql.Null
  3924  		}
  3925  	}()
  3926  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3927  		ctx = rctx // use context from middleware stack in children
  3928  		return ec.resolvers.Query().StringFromContextInterface(rctx)
  3929  	})
  3930  
  3931  	if resTmp == nil {
  3932  		if !graphql.HasFieldError(ctx, fc) {
  3933  			ec.Errorf(ctx, "must not be null")
  3934  		}
  3935  		return graphql.Null
  3936  	}
  3937  	res := resTmp.(*StringFromContextInterface)
  3938  	fc.Result = res
  3939  	return ec.marshalNStringFromContextInterface2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐStringFromContextInterface(ctx, field.Selections, res)
  3940  }
  3941  
  3942  func (ec *executionContext) fieldContext_Query_stringFromContextInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3943  	fc = &graphql.FieldContext{
  3944  		Object:     "Query",
  3945  		Field:      field,
  3946  		IsMethod:   true,
  3947  		IsResolver: true,
  3948  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3949  			return nil, errors.New("field of type StringFromContextInterface does not have child fields")
  3950  		},
  3951  	}
  3952  	return fc, nil
  3953  }
  3954  
  3955  func (ec *executionContext) _Query_stringFromContextFunction(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3956  	fc, err := ec.fieldContext_Query_stringFromContextFunction(ctx, field)
  3957  	if err != nil {
  3958  		return graphql.Null
  3959  	}
  3960  	ctx = graphql.WithFieldContext(ctx, fc)
  3961  	defer func() {
  3962  		if r := recover(); r != nil {
  3963  			ec.Error(ctx, ec.Recover(ctx, r))
  3964  			ret = graphql.Null
  3965  		}
  3966  	}()
  3967  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  3968  		ctx = rctx // use context from middleware stack in children
  3969  		return ec.resolvers.Query().StringFromContextFunction(rctx)
  3970  	})
  3971  
  3972  	if resTmp == nil {
  3973  		if !graphql.HasFieldError(ctx, fc) {
  3974  			ec.Errorf(ctx, "must not be null")
  3975  		}
  3976  		return graphql.Null
  3977  	}
  3978  	res := resTmp.(string)
  3979  	fc.Result = res
  3980  	return ec.marshalNStringFromContextFunction2string(ctx, field.Selections, res)
  3981  }
  3982  
  3983  func (ec *executionContext) fieldContext_Query_stringFromContextFunction(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  3984  	fc = &graphql.FieldContext{
  3985  		Object:     "Query",
  3986  		Field:      field,
  3987  		IsMethod:   true,
  3988  		IsResolver: true,
  3989  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  3990  			return nil, errors.New("field of type StringFromContextFunction does not have child fields")
  3991  		},
  3992  	}
  3993  	return fc, nil
  3994  }
  3995  
  3996  func (ec *executionContext) _Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  3997  	fc, err := ec.fieldContext_Query_defaultScalar(ctx, field)
  3998  	if err != nil {
  3999  		return graphql.Null
  4000  	}
  4001  	ctx = graphql.WithFieldContext(ctx, fc)
  4002  	defer func() {
  4003  		if r := recover(); r != nil {
  4004  			ec.Error(ctx, ec.Recover(ctx, r))
  4005  			ret = graphql.Null
  4006  		}
  4007  	}()
  4008  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4009  		ctx = rctx // use context from middleware stack in children
  4010  		return ec.resolvers.Query().DefaultScalar(rctx, fc.Args["arg"].(string))
  4011  	})
  4012  
  4013  	if resTmp == nil {
  4014  		if !graphql.HasFieldError(ctx, fc) {
  4015  			ec.Errorf(ctx, "must not be null")
  4016  		}
  4017  		return graphql.Null
  4018  	}
  4019  	res := resTmp.(string)
  4020  	fc.Result = res
  4021  	return ec.marshalNDefaultScalarImplementation2string(ctx, field.Selections, res)
  4022  }
  4023  
  4024  func (ec *executionContext) fieldContext_Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4025  	fc = &graphql.FieldContext{
  4026  		Object:     "Query",
  4027  		Field:      field,
  4028  		IsMethod:   true,
  4029  		IsResolver: true,
  4030  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4031  			return nil, errors.New("field of type DefaultScalarImplementation does not have child fields")
  4032  		},
  4033  	}
  4034  	defer func() {
  4035  		if r := recover(); r != nil {
  4036  			err = ec.Recover(ctx, r)
  4037  			ec.Error(ctx, err)
  4038  		}
  4039  	}()
  4040  	ctx = graphql.WithFieldContext(ctx, fc)
  4041  	if fc.Args, err = ec.field_Query_defaultScalar_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4042  		ec.Error(ctx, err)
  4043  		return
  4044  	}
  4045  	return fc, nil
  4046  }
  4047  
  4048  func (ec *executionContext) _Query_slices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4049  	fc, err := ec.fieldContext_Query_slices(ctx, field)
  4050  	if err != nil {
  4051  		return graphql.Null
  4052  	}
  4053  	ctx = graphql.WithFieldContext(ctx, fc)
  4054  	defer func() {
  4055  		if r := recover(); r != nil {
  4056  			ec.Error(ctx, ec.Recover(ctx, r))
  4057  			ret = graphql.Null
  4058  		}
  4059  	}()
  4060  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4061  		ctx = rctx // use context from middleware stack in children
  4062  		return ec.resolvers.Query().Slices(rctx)
  4063  	})
  4064  
  4065  	if resTmp == nil {
  4066  		return graphql.Null
  4067  	}
  4068  	res := resTmp.(*Slices)
  4069  	fc.Result = res
  4070  	return ec.marshalOSlices2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐSlices(ctx, field.Selections, res)
  4071  }
  4072  
  4073  func (ec *executionContext) fieldContext_Query_slices(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4074  	fc = &graphql.FieldContext{
  4075  		Object:     "Query",
  4076  		Field:      field,
  4077  		IsMethod:   true,
  4078  		IsResolver: true,
  4079  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4080  			switch field.Name {
  4081  			case "test1":
  4082  				return ec.fieldContext_Slices_test1(ctx, field)
  4083  			case "test2":
  4084  				return ec.fieldContext_Slices_test2(ctx, field)
  4085  			case "test3":
  4086  				return ec.fieldContext_Slices_test3(ctx, field)
  4087  			case "test4":
  4088  				return ec.fieldContext_Slices_test4(ctx, field)
  4089  			}
  4090  			return nil, fmt.Errorf("no field named %q was found under type Slices", field.Name)
  4091  		},
  4092  	}
  4093  	return fc, nil
  4094  }
  4095  
  4096  func (ec *executionContext) _Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4097  	fc, err := ec.fieldContext_Query_scalarSlice(ctx, field)
  4098  	if err != nil {
  4099  		return graphql.Null
  4100  	}
  4101  	ctx = graphql.WithFieldContext(ctx, fc)
  4102  	defer func() {
  4103  		if r := recover(); r != nil {
  4104  			ec.Error(ctx, ec.Recover(ctx, r))
  4105  			ret = graphql.Null
  4106  		}
  4107  	}()
  4108  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4109  		ctx = rctx // use context from middleware stack in children
  4110  		return ec.resolvers.Query().ScalarSlice(rctx)
  4111  	})
  4112  
  4113  	if resTmp == nil {
  4114  		if !graphql.HasFieldError(ctx, fc) {
  4115  			ec.Errorf(ctx, "must not be null")
  4116  		}
  4117  		return graphql.Null
  4118  	}
  4119  	res := resTmp.([]byte)
  4120  	fc.Result = res
  4121  	return ec.marshalNBytes2ᚕbyte(ctx, field.Selections, res)
  4122  }
  4123  
  4124  func (ec *executionContext) fieldContext_Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4125  	fc = &graphql.FieldContext{
  4126  		Object:     "Query",
  4127  		Field:      field,
  4128  		IsMethod:   true,
  4129  		IsResolver: true,
  4130  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4131  			return nil, errors.New("field of type Bytes does not have child fields")
  4132  		},
  4133  	}
  4134  	return fc, nil
  4135  }
  4136  
  4137  func (ec *executionContext) _Query_fallback(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4138  	fc, err := ec.fieldContext_Query_fallback(ctx, field)
  4139  	if err != nil {
  4140  		return graphql.Null
  4141  	}
  4142  	ctx = graphql.WithFieldContext(ctx, fc)
  4143  	defer func() {
  4144  		if r := recover(); r != nil {
  4145  			ec.Error(ctx, ec.Recover(ctx, r))
  4146  			ret = graphql.Null
  4147  		}
  4148  	}()
  4149  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4150  		ctx = rctx // use context from middleware stack in children
  4151  		return ec.resolvers.Query().Fallback(rctx, fc.Args["arg"].(FallbackToStringEncoding))
  4152  	})
  4153  
  4154  	if resTmp == nil {
  4155  		if !graphql.HasFieldError(ctx, fc) {
  4156  			ec.Errorf(ctx, "must not be null")
  4157  		}
  4158  		return graphql.Null
  4159  	}
  4160  	res := resTmp.(FallbackToStringEncoding)
  4161  	fc.Result = res
  4162  	return ec.marshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐFallbackToStringEncoding(ctx, field.Selections, res)
  4163  }
  4164  
  4165  func (ec *executionContext) fieldContext_Query_fallback(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4166  	fc = &graphql.FieldContext{
  4167  		Object:     "Query",
  4168  		Field:      field,
  4169  		IsMethod:   true,
  4170  		IsResolver: true,
  4171  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4172  			return nil, errors.New("field of type FallbackToStringEncoding does not have child fields")
  4173  		},
  4174  	}
  4175  	defer func() {
  4176  		if r := recover(); r != nil {
  4177  			err = ec.Recover(ctx, r)
  4178  			ec.Error(ctx, err)
  4179  		}
  4180  	}()
  4181  	ctx = graphql.WithFieldContext(ctx, fc)
  4182  	if fc.Args, err = ec.field_Query_fallback_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4183  		ec.Error(ctx, err)
  4184  		return
  4185  	}
  4186  	return fc, nil
  4187  }
  4188  
  4189  func (ec *executionContext) _Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4190  	fc, err := ec.fieldContext_Query_optionalUnion(ctx, field)
  4191  	if err != nil {
  4192  		return graphql.Null
  4193  	}
  4194  	ctx = graphql.WithFieldContext(ctx, fc)
  4195  	defer func() {
  4196  		if r := recover(); r != nil {
  4197  			ec.Error(ctx, ec.Recover(ctx, r))
  4198  			ret = graphql.Null
  4199  		}
  4200  	}()
  4201  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4202  		ctx = rctx // use context from middleware stack in children
  4203  		return ec.resolvers.Query().OptionalUnion(rctx)
  4204  	})
  4205  
  4206  	if resTmp == nil {
  4207  		return graphql.Null
  4208  	}
  4209  	res := resTmp.(TestUnion)
  4210  	fc.Result = res
  4211  	return ec.marshalOTestUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐTestUnion(ctx, field.Selections, res)
  4212  }
  4213  
  4214  func (ec *executionContext) fieldContext_Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4215  	fc = &graphql.FieldContext{
  4216  		Object:     "Query",
  4217  		Field:      field,
  4218  		IsMethod:   true,
  4219  		IsResolver: true,
  4220  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4221  			return nil, errors.New("field of type TestUnion does not have child fields")
  4222  		},
  4223  	}
  4224  	return fc, nil
  4225  }
  4226  
  4227  func (ec *executionContext) _Query_vOkCaseValue(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4228  	fc, err := ec.fieldContext_Query_vOkCaseValue(ctx, field)
  4229  	if err != nil {
  4230  		return graphql.Null
  4231  	}
  4232  	ctx = graphql.WithFieldContext(ctx, fc)
  4233  	defer func() {
  4234  		if r := recover(); r != nil {
  4235  			ec.Error(ctx, ec.Recover(ctx, r))
  4236  			ret = graphql.Null
  4237  		}
  4238  	}()
  4239  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4240  		ctx = rctx // use context from middleware stack in children
  4241  		return ec.resolvers.Query().VOkCaseValue(rctx)
  4242  	})
  4243  
  4244  	if resTmp == nil {
  4245  		return graphql.Null
  4246  	}
  4247  	res := resTmp.(*VOkCaseValue)
  4248  	fc.Result = res
  4249  	return ec.marshalOVOkCaseValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVOkCaseValue(ctx, field.Selections, res)
  4250  }
  4251  
  4252  func (ec *executionContext) fieldContext_Query_vOkCaseValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4253  	fc = &graphql.FieldContext{
  4254  		Object:     "Query",
  4255  		Field:      field,
  4256  		IsMethod:   true,
  4257  		IsResolver: true,
  4258  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4259  			switch field.Name {
  4260  			case "value":
  4261  				return ec.fieldContext_VOkCaseValue_value(ctx, field)
  4262  			}
  4263  			return nil, fmt.Errorf("no field named %q was found under type VOkCaseValue", field.Name)
  4264  		},
  4265  	}
  4266  	return fc, nil
  4267  }
  4268  
  4269  func (ec *executionContext) _Query_vOkCaseNil(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4270  	fc, err := ec.fieldContext_Query_vOkCaseNil(ctx, field)
  4271  	if err != nil {
  4272  		return graphql.Null
  4273  	}
  4274  	ctx = graphql.WithFieldContext(ctx, fc)
  4275  	defer func() {
  4276  		if r := recover(); r != nil {
  4277  			ec.Error(ctx, ec.Recover(ctx, r))
  4278  			ret = graphql.Null
  4279  		}
  4280  	}()
  4281  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4282  		ctx = rctx // use context from middleware stack in children
  4283  		return ec.resolvers.Query().VOkCaseNil(rctx)
  4284  	})
  4285  
  4286  	if resTmp == nil {
  4287  		return graphql.Null
  4288  	}
  4289  	res := resTmp.(*VOkCaseNil)
  4290  	fc.Result = res
  4291  	return ec.marshalOVOkCaseNil2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVOkCaseNil(ctx, field.Selections, res)
  4292  }
  4293  
  4294  func (ec *executionContext) fieldContext_Query_vOkCaseNil(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4295  	fc = &graphql.FieldContext{
  4296  		Object:     "Query",
  4297  		Field:      field,
  4298  		IsMethod:   true,
  4299  		IsResolver: true,
  4300  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4301  			switch field.Name {
  4302  			case "value":
  4303  				return ec.fieldContext_VOkCaseNil_value(ctx, field)
  4304  			}
  4305  			return nil, fmt.Errorf("no field named %q was found under type VOkCaseNil", field.Name)
  4306  		},
  4307  	}
  4308  	return fc, nil
  4309  }
  4310  
  4311  func (ec *executionContext) _Query_validType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4312  	fc, err := ec.fieldContext_Query_validType(ctx, field)
  4313  	if err != nil {
  4314  		return graphql.Null
  4315  	}
  4316  	ctx = graphql.WithFieldContext(ctx, fc)
  4317  	defer func() {
  4318  		if r := recover(); r != nil {
  4319  			ec.Error(ctx, ec.Recover(ctx, r))
  4320  			ret = graphql.Null
  4321  		}
  4322  	}()
  4323  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4324  		ctx = rctx // use context from middleware stack in children
  4325  		return ec.resolvers.Query().ValidType(rctx)
  4326  	})
  4327  
  4328  	if resTmp == nil {
  4329  		return graphql.Null
  4330  	}
  4331  	res := resTmp.(*ValidType)
  4332  	fc.Result = res
  4333  	return ec.marshalOValidType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐValidType(ctx, field.Selections, res)
  4334  }
  4335  
  4336  func (ec *executionContext) fieldContext_Query_validType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4337  	fc = &graphql.FieldContext{
  4338  		Object:     "Query",
  4339  		Field:      field,
  4340  		IsMethod:   true,
  4341  		IsResolver: true,
  4342  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4343  			switch field.Name {
  4344  			case "differentCase":
  4345  				return ec.fieldContext_ValidType_differentCase(ctx, field)
  4346  			case "different_case":
  4347  				return ec.fieldContext_ValidType_different_case(ctx, field)
  4348  			case "validInputKeywords":
  4349  				return ec.fieldContext_ValidType_validInputKeywords(ctx, field)
  4350  			case "validArgs":
  4351  				return ec.fieldContext_ValidType_validArgs(ctx, field)
  4352  			}
  4353  			return nil, fmt.Errorf("no field named %q was found under type ValidType", field.Name)
  4354  		},
  4355  	}
  4356  	return fc, nil
  4357  }
  4358  
  4359  func (ec *executionContext) _Query_variadicModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4360  	fc, err := ec.fieldContext_Query_variadicModel(ctx, field)
  4361  	if err != nil {
  4362  		return graphql.Null
  4363  	}
  4364  	ctx = graphql.WithFieldContext(ctx, fc)
  4365  	defer func() {
  4366  		if r := recover(); r != nil {
  4367  			ec.Error(ctx, ec.Recover(ctx, r))
  4368  			ret = graphql.Null
  4369  		}
  4370  	}()
  4371  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4372  		ctx = rctx // use context from middleware stack in children
  4373  		return ec.resolvers.Query().VariadicModel(rctx)
  4374  	})
  4375  
  4376  	if resTmp == nil {
  4377  		return graphql.Null
  4378  	}
  4379  	res := resTmp.(*VariadicModel)
  4380  	fc.Result = res
  4381  	return ec.marshalOVariadicModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVariadicModel(ctx, field.Selections, res)
  4382  }
  4383  
  4384  func (ec *executionContext) fieldContext_Query_variadicModel(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4385  	fc = &graphql.FieldContext{
  4386  		Object:     "Query",
  4387  		Field:      field,
  4388  		IsMethod:   true,
  4389  		IsResolver: true,
  4390  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4391  			switch field.Name {
  4392  			case "value":
  4393  				return ec.fieldContext_VariadicModel_value(ctx, field)
  4394  			}
  4395  			return nil, fmt.Errorf("no field named %q was found under type VariadicModel", field.Name)
  4396  		},
  4397  	}
  4398  	return fc, nil
  4399  }
  4400  
  4401  func (ec *executionContext) _Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4402  	fc, err := ec.fieldContext_Query_wrappedStruct(ctx, field)
  4403  	if err != nil {
  4404  		return graphql.Null
  4405  	}
  4406  	ctx = graphql.WithFieldContext(ctx, fc)
  4407  	defer func() {
  4408  		if r := recover(); r != nil {
  4409  			ec.Error(ctx, ec.Recover(ctx, r))
  4410  			ret = graphql.Null
  4411  		}
  4412  	}()
  4413  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4414  		ctx = rctx // use context from middleware stack in children
  4415  		return ec.resolvers.Query().WrappedStruct(rctx)
  4416  	})
  4417  
  4418  	if resTmp == nil {
  4419  		if !graphql.HasFieldError(ctx, fc) {
  4420  			ec.Errorf(ctx, "must not be null")
  4421  		}
  4422  		return graphql.Null
  4423  	}
  4424  	res := resTmp.(*WrappedStruct)
  4425  	fc.Result = res
  4426  	return ec.marshalNWrappedStruct2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedStruct(ctx, field.Selections, res)
  4427  }
  4428  
  4429  func (ec *executionContext) fieldContext_Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4430  	fc = &graphql.FieldContext{
  4431  		Object:     "Query",
  4432  		Field:      field,
  4433  		IsMethod:   true,
  4434  		IsResolver: true,
  4435  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4436  			switch field.Name {
  4437  			case "name":
  4438  				return ec.fieldContext_WrappedStruct_name(ctx, field)
  4439  			case "desc":
  4440  				return ec.fieldContext_WrappedStruct_desc(ctx, field)
  4441  			}
  4442  			return nil, fmt.Errorf("no field named %q was found under type WrappedStruct", field.Name)
  4443  		},
  4444  	}
  4445  	return fc, nil
  4446  }
  4447  
  4448  func (ec *executionContext) _Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4449  	fc, err := ec.fieldContext_Query_wrappedScalar(ctx, field)
  4450  	if err != nil {
  4451  		return graphql.Null
  4452  	}
  4453  	ctx = graphql.WithFieldContext(ctx, fc)
  4454  	defer func() {
  4455  		if r := recover(); r != nil {
  4456  			ec.Error(ctx, ec.Recover(ctx, r))
  4457  			ret = graphql.Null
  4458  		}
  4459  	}()
  4460  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4461  		ctx = rctx // use context from middleware stack in children
  4462  		return ec.resolvers.Query().WrappedScalar(rctx)
  4463  	})
  4464  
  4465  	if resTmp == nil {
  4466  		if !graphql.HasFieldError(ctx, fc) {
  4467  			ec.Errorf(ctx, "must not be null")
  4468  		}
  4469  		return graphql.Null
  4470  	}
  4471  	res := resTmp.(otherpkg.Scalar)
  4472  	fc.Result = res
  4473  	return ec.marshalNWrappedScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋotherpkgᚐScalar(ctx, field.Selections, res)
  4474  }
  4475  
  4476  func (ec *executionContext) fieldContext_Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4477  	fc = &graphql.FieldContext{
  4478  		Object:     "Query",
  4479  		Field:      field,
  4480  		IsMethod:   true,
  4481  		IsResolver: true,
  4482  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4483  			return nil, errors.New("field of type WrappedScalar does not have child fields")
  4484  		},
  4485  	}
  4486  	return fc, nil
  4487  }
  4488  
  4489  func (ec *executionContext) _Query_wrappedMap(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4490  	fc, err := ec.fieldContext_Query_wrappedMap(ctx, field)
  4491  	if err != nil {
  4492  		return graphql.Null
  4493  	}
  4494  	ctx = graphql.WithFieldContext(ctx, fc)
  4495  	defer func() {
  4496  		if r := recover(); r != nil {
  4497  			ec.Error(ctx, ec.Recover(ctx, r))
  4498  			ret = graphql.Null
  4499  		}
  4500  	}()
  4501  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4502  		ctx = rctx // use context from middleware stack in children
  4503  		return ec.resolvers.Query().WrappedMap(rctx)
  4504  	})
  4505  
  4506  	if resTmp == nil {
  4507  		if !graphql.HasFieldError(ctx, fc) {
  4508  			ec.Errorf(ctx, "must not be null")
  4509  		}
  4510  		return graphql.Null
  4511  	}
  4512  	res := resTmp.(WrappedMap)
  4513  	fc.Result = res
  4514  	return ec.marshalNWrappedMap2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedMap(ctx, field.Selections, res)
  4515  }
  4516  
  4517  func (ec *executionContext) fieldContext_Query_wrappedMap(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4518  	fc = &graphql.FieldContext{
  4519  		Object:     "Query",
  4520  		Field:      field,
  4521  		IsMethod:   true,
  4522  		IsResolver: true,
  4523  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4524  			switch field.Name {
  4525  			case "get":
  4526  				return ec.fieldContext_WrappedMap_get(ctx, field)
  4527  			}
  4528  			return nil, fmt.Errorf("no field named %q was found under type WrappedMap", field.Name)
  4529  		},
  4530  	}
  4531  	return fc, nil
  4532  }
  4533  
  4534  func (ec *executionContext) _Query_wrappedSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4535  	fc, err := ec.fieldContext_Query_wrappedSlice(ctx, field)
  4536  	if err != nil {
  4537  		return graphql.Null
  4538  	}
  4539  	ctx = graphql.WithFieldContext(ctx, fc)
  4540  	defer func() {
  4541  		if r := recover(); r != nil {
  4542  			ec.Error(ctx, ec.Recover(ctx, r))
  4543  			ret = graphql.Null
  4544  		}
  4545  	}()
  4546  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4547  		ctx = rctx // use context from middleware stack in children
  4548  		return ec.resolvers.Query().WrappedSlice(rctx)
  4549  	})
  4550  
  4551  	if resTmp == nil {
  4552  		if !graphql.HasFieldError(ctx, fc) {
  4553  			ec.Errorf(ctx, "must not be null")
  4554  		}
  4555  		return graphql.Null
  4556  	}
  4557  	res := resTmp.(WrappedSlice)
  4558  	fc.Result = res
  4559  	return ec.marshalNWrappedSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedSlice(ctx, field.Selections, res)
  4560  }
  4561  
  4562  func (ec *executionContext) fieldContext_Query_wrappedSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4563  	fc = &graphql.FieldContext{
  4564  		Object:     "Query",
  4565  		Field:      field,
  4566  		IsMethod:   true,
  4567  		IsResolver: true,
  4568  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4569  			switch field.Name {
  4570  			case "get":
  4571  				return ec.fieldContext_WrappedSlice_get(ctx, field)
  4572  			}
  4573  			return nil, fmt.Errorf("no field named %q was found under type WrappedSlice", field.Name)
  4574  		},
  4575  	}
  4576  	return fc, nil
  4577  }
  4578  
  4579  func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4580  	fc, err := ec.fieldContext_Query___type(ctx, field)
  4581  	if err != nil {
  4582  		return graphql.Null
  4583  	}
  4584  	ctx = graphql.WithFieldContext(ctx, fc)
  4585  	defer func() {
  4586  		if r := recover(); r != nil {
  4587  			ec.Error(ctx, ec.Recover(ctx, r))
  4588  			ret = graphql.Null
  4589  		}
  4590  	}()
  4591  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4592  		ctx = rctx // use context from middleware stack in children
  4593  		return ec.introspectType(fc.Args["name"].(string))
  4594  	})
  4595  
  4596  	if resTmp == nil {
  4597  		return graphql.Null
  4598  	}
  4599  	res := resTmp.(*introspection.Type)
  4600  	fc.Result = res
  4601  	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
  4602  }
  4603  
  4604  func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4605  	fc = &graphql.FieldContext{
  4606  		Object:     "Query",
  4607  		Field:      field,
  4608  		IsMethod:   true,
  4609  		IsResolver: false,
  4610  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4611  			switch field.Name {
  4612  			case "kind":
  4613  				return ec.fieldContext___Type_kind(ctx, field)
  4614  			case "name":
  4615  				return ec.fieldContext___Type_name(ctx, field)
  4616  			case "description":
  4617  				return ec.fieldContext___Type_description(ctx, field)
  4618  			case "fields":
  4619  				return ec.fieldContext___Type_fields(ctx, field)
  4620  			case "interfaces":
  4621  				return ec.fieldContext___Type_interfaces(ctx, field)
  4622  			case "possibleTypes":
  4623  				return ec.fieldContext___Type_possibleTypes(ctx, field)
  4624  			case "enumValues":
  4625  				return ec.fieldContext___Type_enumValues(ctx, field)
  4626  			case "inputFields":
  4627  				return ec.fieldContext___Type_inputFields(ctx, field)
  4628  			case "ofType":
  4629  				return ec.fieldContext___Type_ofType(ctx, field)
  4630  			case "specifiedByURL":
  4631  				return ec.fieldContext___Type_specifiedByURL(ctx, field)
  4632  			}
  4633  			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
  4634  		},
  4635  	}
  4636  	defer func() {
  4637  		if r := recover(); r != nil {
  4638  			err = ec.Recover(ctx, r)
  4639  			ec.Error(ctx, err)
  4640  		}
  4641  	}()
  4642  	ctx = graphql.WithFieldContext(ctx, fc)
  4643  	if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4644  		ec.Error(ctx, err)
  4645  		return
  4646  	}
  4647  	return fc, nil
  4648  }
  4649  
  4650  func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
  4651  	fc, err := ec.fieldContext_Query___schema(ctx, field)
  4652  	if err != nil {
  4653  		return graphql.Null
  4654  	}
  4655  	ctx = graphql.WithFieldContext(ctx, fc)
  4656  	defer func() {
  4657  		if r := recover(); r != nil {
  4658  			ec.Error(ctx, ec.Recover(ctx, r))
  4659  			ret = graphql.Null
  4660  		}
  4661  	}()
  4662  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4663  		ctx = rctx // use context from middleware stack in children
  4664  		return ec.introspectSchema()
  4665  	})
  4666  
  4667  	if resTmp == nil {
  4668  		return graphql.Null
  4669  	}
  4670  	res := resTmp.(*introspection.Schema)
  4671  	fc.Result = res
  4672  	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
  4673  }
  4674  
  4675  func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4676  	fc = &graphql.FieldContext{
  4677  		Object:     "Query",
  4678  		Field:      field,
  4679  		IsMethod:   true,
  4680  		IsResolver: false,
  4681  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4682  			switch field.Name {
  4683  			case "description":
  4684  				return ec.fieldContext___Schema_description(ctx, field)
  4685  			case "types":
  4686  				return ec.fieldContext___Schema_types(ctx, field)
  4687  			case "queryType":
  4688  				return ec.fieldContext___Schema_queryType(ctx, field)
  4689  			case "mutationType":
  4690  				return ec.fieldContext___Schema_mutationType(ctx, field)
  4691  			case "subscriptionType":
  4692  				return ec.fieldContext___Schema_subscriptionType(ctx, field)
  4693  			case "directives":
  4694  				return ec.fieldContext___Schema_directives(ctx, field)
  4695  			}
  4696  			return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
  4697  		},
  4698  	}
  4699  	return fc, nil
  4700  }
  4701  
  4702  func (ec *executionContext) _Subscription_updated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4703  	fc, err := ec.fieldContext_Subscription_updated(ctx, field)
  4704  	if err != nil {
  4705  		return nil
  4706  	}
  4707  	ctx = graphql.WithFieldContext(ctx, fc)
  4708  	defer func() {
  4709  		if r := recover(); r != nil {
  4710  			ec.Error(ctx, ec.Recover(ctx, r))
  4711  			ret = nil
  4712  		}
  4713  	}()
  4714  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4715  		ctx = rctx // use context from middleware stack in children
  4716  		return ec.resolvers.Subscription().Updated(rctx)
  4717  	})
  4718  
  4719  	if resTmp == nil {
  4720  		if !graphql.HasFieldError(ctx, fc) {
  4721  			ec.Errorf(ctx, "must not be null")
  4722  		}
  4723  		return nil
  4724  	}
  4725  	return func(ctx context.Context) graphql.Marshaler {
  4726  		select {
  4727  		case res, ok := <-resTmp.(<-chan string):
  4728  			if !ok {
  4729  				return nil
  4730  			}
  4731  			return graphql.WriterFunc(func(w io.Writer) {
  4732  				w.Write([]byte{'{'})
  4733  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4734  				w.Write([]byte{':'})
  4735  				ec.marshalNString2string(ctx, field.Selections, res).MarshalGQL(w)
  4736  				w.Write([]byte{'}'})
  4737  			})
  4738  		case <-ctx.Done():
  4739  			return nil
  4740  		}
  4741  	}
  4742  }
  4743  
  4744  func (ec *executionContext) fieldContext_Subscription_updated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4745  	fc = &graphql.FieldContext{
  4746  		Object:     "Subscription",
  4747  		Field:      field,
  4748  		IsMethod:   true,
  4749  		IsResolver: true,
  4750  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4751  			return nil, errors.New("field of type String does not have child fields")
  4752  		},
  4753  	}
  4754  	return fc, nil
  4755  }
  4756  
  4757  func (ec *executionContext) _Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4758  	fc, err := ec.fieldContext_Subscription_initPayload(ctx, field)
  4759  	if err != nil {
  4760  		return nil
  4761  	}
  4762  	ctx = graphql.WithFieldContext(ctx, fc)
  4763  	defer func() {
  4764  		if r := recover(); r != nil {
  4765  			ec.Error(ctx, ec.Recover(ctx, r))
  4766  			ret = nil
  4767  		}
  4768  	}()
  4769  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4770  		ctx = rctx // use context from middleware stack in children
  4771  		return ec.resolvers.Subscription().InitPayload(rctx)
  4772  	})
  4773  
  4774  	if resTmp == nil {
  4775  		if !graphql.HasFieldError(ctx, fc) {
  4776  			ec.Errorf(ctx, "must not be null")
  4777  		}
  4778  		return nil
  4779  	}
  4780  	return func(ctx context.Context) graphql.Marshaler {
  4781  		select {
  4782  		case res, ok := <-resTmp.(<-chan string):
  4783  			if !ok {
  4784  				return nil
  4785  			}
  4786  			return graphql.WriterFunc(func(w io.Writer) {
  4787  				w.Write([]byte{'{'})
  4788  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4789  				w.Write([]byte{':'})
  4790  				ec.marshalNString2string(ctx, field.Selections, res).MarshalGQL(w)
  4791  				w.Write([]byte{'}'})
  4792  			})
  4793  		case <-ctx.Done():
  4794  			return nil
  4795  		}
  4796  	}
  4797  }
  4798  
  4799  func (ec *executionContext) fieldContext_Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4800  	fc = &graphql.FieldContext{
  4801  		Object:     "Subscription",
  4802  		Field:      field,
  4803  		IsMethod:   true,
  4804  		IsResolver: true,
  4805  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4806  			return nil, errors.New("field of type String does not have child fields")
  4807  		},
  4808  	}
  4809  	return fc, nil
  4810  }
  4811  
  4812  func (ec *executionContext) _Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4813  	fc, err := ec.fieldContext_Subscription_directiveArg(ctx, field)
  4814  	if err != nil {
  4815  		return nil
  4816  	}
  4817  	ctx = graphql.WithFieldContext(ctx, fc)
  4818  	defer func() {
  4819  		if r := recover(); r != nil {
  4820  			ec.Error(ctx, ec.Recover(ctx, r))
  4821  			ret = nil
  4822  		}
  4823  	}()
  4824  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4825  		ctx = rctx // use context from middleware stack in children
  4826  		return ec.resolvers.Subscription().DirectiveArg(rctx, fc.Args["arg"].(string))
  4827  	})
  4828  
  4829  	if resTmp == nil {
  4830  		return nil
  4831  	}
  4832  	return func(ctx context.Context) graphql.Marshaler {
  4833  		select {
  4834  		case res, ok := <-resTmp.(<-chan *string):
  4835  			if !ok {
  4836  				return nil
  4837  			}
  4838  			return graphql.WriterFunc(func(w io.Writer) {
  4839  				w.Write([]byte{'{'})
  4840  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4841  				w.Write([]byte{':'})
  4842  				ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
  4843  				w.Write([]byte{'}'})
  4844  			})
  4845  		case <-ctx.Done():
  4846  			return nil
  4847  		}
  4848  	}
  4849  }
  4850  
  4851  func (ec *executionContext) fieldContext_Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4852  	fc = &graphql.FieldContext{
  4853  		Object:     "Subscription",
  4854  		Field:      field,
  4855  		IsMethod:   true,
  4856  		IsResolver: true,
  4857  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4858  			return nil, errors.New("field of type String does not have child fields")
  4859  		},
  4860  	}
  4861  	defer func() {
  4862  		if r := recover(); r != nil {
  4863  			err = ec.Recover(ctx, r)
  4864  			ec.Error(ctx, err)
  4865  		}
  4866  	}()
  4867  	ctx = graphql.WithFieldContext(ctx, fc)
  4868  	if fc.Args, err = ec.field_Subscription_directiveArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4869  		ec.Error(ctx, err)
  4870  		return
  4871  	}
  4872  	return fc, nil
  4873  }
  4874  
  4875  func (ec *executionContext) _Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4876  	fc, err := ec.fieldContext_Subscription_directiveNullableArg(ctx, field)
  4877  	if err != nil {
  4878  		return nil
  4879  	}
  4880  	ctx = graphql.WithFieldContext(ctx, fc)
  4881  	defer func() {
  4882  		if r := recover(); r != nil {
  4883  			ec.Error(ctx, ec.Recover(ctx, r))
  4884  			ret = nil
  4885  		}
  4886  	}()
  4887  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4888  		ctx = rctx // use context from middleware stack in children
  4889  		return ec.resolvers.Subscription().DirectiveNullableArg(rctx, fc.Args["arg"].(*int), fc.Args["arg2"].(*int), fc.Args["arg3"].(*string))
  4890  	})
  4891  
  4892  	if resTmp == nil {
  4893  		return nil
  4894  	}
  4895  	return func(ctx context.Context) graphql.Marshaler {
  4896  		select {
  4897  		case res, ok := <-resTmp.(<-chan *string):
  4898  			if !ok {
  4899  				return nil
  4900  			}
  4901  			return graphql.WriterFunc(func(w io.Writer) {
  4902  				w.Write([]byte{'{'})
  4903  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4904  				w.Write([]byte{':'})
  4905  				ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
  4906  				w.Write([]byte{'}'})
  4907  			})
  4908  		case <-ctx.Done():
  4909  			return nil
  4910  		}
  4911  	}
  4912  }
  4913  
  4914  func (ec *executionContext) fieldContext_Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  4915  	fc = &graphql.FieldContext{
  4916  		Object:     "Subscription",
  4917  		Field:      field,
  4918  		IsMethod:   true,
  4919  		IsResolver: true,
  4920  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  4921  			return nil, errors.New("field of type String does not have child fields")
  4922  		},
  4923  	}
  4924  	defer func() {
  4925  		if r := recover(); r != nil {
  4926  			err = ec.Recover(ctx, r)
  4927  			ec.Error(ctx, err)
  4928  		}
  4929  	}()
  4930  	ctx = graphql.WithFieldContext(ctx, fc)
  4931  	if fc.Args, err = ec.field_Subscription_directiveNullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  4932  		ec.Error(ctx, err)
  4933  		return
  4934  	}
  4935  	return fc, nil
  4936  }
  4937  
  4938  func (ec *executionContext) _Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  4939  	fc, err := ec.fieldContext_Subscription_directiveDouble(ctx, field)
  4940  	if err != nil {
  4941  		return nil
  4942  	}
  4943  	ctx = graphql.WithFieldContext(ctx, fc)
  4944  	defer func() {
  4945  		if r := recover(); r != nil {
  4946  			ec.Error(ctx, ec.Recover(ctx, r))
  4947  			ret = nil
  4948  		}
  4949  	}()
  4950  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  4951  		directive0 := func(rctx context.Context) (interface{}, error) {
  4952  			ctx = rctx // use context from middleware stack in children
  4953  			return ec.resolvers.Subscription().DirectiveDouble(rctx)
  4954  		}
  4955  		directive1 := func(ctx context.Context) (interface{}, error) {
  4956  			if ec.directives.Directive1 == nil {
  4957  				return nil, errors.New("directive directive1 is not implemented")
  4958  			}
  4959  			return ec.directives.Directive1(ctx, nil, directive0)
  4960  		}
  4961  		directive2 := func(ctx context.Context) (interface{}, error) {
  4962  			if ec.directives.Directive2 == nil {
  4963  				return nil, errors.New("directive directive2 is not implemented")
  4964  			}
  4965  			return ec.directives.Directive2(ctx, nil, directive1)
  4966  		}
  4967  
  4968  		tmp, err := directive2(rctx)
  4969  		if err != nil {
  4970  			return nil, graphql.ErrorOnPath(ctx, err)
  4971  		}
  4972  		if tmp == nil {
  4973  			return nil, nil
  4974  		}
  4975  		if data, ok := tmp.(<-chan *string); ok {
  4976  			return data, nil
  4977  		}
  4978  		return nil, fmt.Errorf(`unexpected type %T from directive, should be <-chan *string`, tmp)
  4979  	})
  4980  
  4981  	if resTmp == nil {
  4982  		return nil
  4983  	}
  4984  	return func(ctx context.Context) graphql.Marshaler {
  4985  		select {
  4986  		case res, ok := <-resTmp.(<-chan *string):
  4987  			if !ok {
  4988  				return nil
  4989  			}
  4990  			return graphql.WriterFunc(func(w io.Writer) {
  4991  				w.Write([]byte{'{'})
  4992  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  4993  				w.Write([]byte{':'})
  4994  				ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
  4995  				w.Write([]byte{'}'})
  4996  			})
  4997  		case <-ctx.Done():
  4998  			return nil
  4999  		}
  5000  	}
  5001  }
  5002  
  5003  func (ec *executionContext) fieldContext_Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5004  	fc = &graphql.FieldContext{
  5005  		Object:     "Subscription",
  5006  		Field:      field,
  5007  		IsMethod:   true,
  5008  		IsResolver: true,
  5009  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5010  			return nil, errors.New("field of type String does not have child fields")
  5011  		},
  5012  	}
  5013  	return fc, nil
  5014  }
  5015  
  5016  func (ec *executionContext) _Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  5017  	fc, err := ec.fieldContext_Subscription_directiveUnimplemented(ctx, field)
  5018  	if err != nil {
  5019  		return nil
  5020  	}
  5021  	ctx = graphql.WithFieldContext(ctx, fc)
  5022  	defer func() {
  5023  		if r := recover(); r != nil {
  5024  			ec.Error(ctx, ec.Recover(ctx, r))
  5025  			ret = nil
  5026  		}
  5027  	}()
  5028  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  5029  		directive0 := func(rctx context.Context) (interface{}, error) {
  5030  			ctx = rctx // use context from middleware stack in children
  5031  			return ec.resolvers.Subscription().DirectiveUnimplemented(rctx)
  5032  		}
  5033  		directive1 := func(ctx context.Context) (interface{}, error) {
  5034  			if ec.directives.Unimplemented == nil {
  5035  				return nil, errors.New("directive unimplemented is not implemented")
  5036  			}
  5037  			return ec.directives.Unimplemented(ctx, nil, directive0)
  5038  		}
  5039  
  5040  		tmp, err := directive1(rctx)
  5041  		if err != nil {
  5042  			return nil, graphql.ErrorOnPath(ctx, err)
  5043  		}
  5044  		if tmp == nil {
  5045  			return nil, nil
  5046  		}
  5047  		if data, ok := tmp.(<-chan *string); ok {
  5048  			return data, nil
  5049  		}
  5050  		return nil, fmt.Errorf(`unexpected type %T from directive, should be <-chan *string`, tmp)
  5051  	})
  5052  
  5053  	if resTmp == nil {
  5054  		return nil
  5055  	}
  5056  	return func(ctx context.Context) graphql.Marshaler {
  5057  		select {
  5058  		case res, ok := <-resTmp.(<-chan *string):
  5059  			if !ok {
  5060  				return nil
  5061  			}
  5062  			return graphql.WriterFunc(func(w io.Writer) {
  5063  				w.Write([]byte{'{'})
  5064  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  5065  				w.Write([]byte{':'})
  5066  				ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
  5067  				w.Write([]byte{'}'})
  5068  			})
  5069  		case <-ctx.Done():
  5070  			return nil
  5071  		}
  5072  	}
  5073  }
  5074  
  5075  func (ec *executionContext) fieldContext_Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5076  	fc = &graphql.FieldContext{
  5077  		Object:     "Subscription",
  5078  		Field:      field,
  5079  		IsMethod:   true,
  5080  		IsResolver: true,
  5081  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5082  			return nil, errors.New("field of type String does not have child fields")
  5083  		},
  5084  	}
  5085  	return fc, nil
  5086  }
  5087  
  5088  func (ec *executionContext) _Subscription_issue896b(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  5089  	fc, err := ec.fieldContext_Subscription_issue896b(ctx, field)
  5090  	if err != nil {
  5091  		return nil
  5092  	}
  5093  	ctx = graphql.WithFieldContext(ctx, fc)
  5094  	defer func() {
  5095  		if r := recover(); r != nil {
  5096  			ec.Error(ctx, ec.Recover(ctx, r))
  5097  			ret = nil
  5098  		}
  5099  	}()
  5100  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  5101  		ctx = rctx // use context from middleware stack in children
  5102  		return ec.resolvers.Subscription().Issue896b(rctx)
  5103  	})
  5104  
  5105  	if resTmp == nil {
  5106  		return nil
  5107  	}
  5108  	return func(ctx context.Context) graphql.Marshaler {
  5109  		select {
  5110  		case res, ok := <-resTmp.(<-chan []*CheckIssue896):
  5111  			if !ok {
  5112  				return nil
  5113  			}
  5114  			return graphql.WriterFunc(func(w io.Writer) {
  5115  				w.Write([]byte{'{'})
  5116  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  5117  				w.Write([]byte{':'})
  5118  				ec.marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCheckIssue896(ctx, field.Selections, res).MarshalGQL(w)
  5119  				w.Write([]byte{'}'})
  5120  			})
  5121  		case <-ctx.Done():
  5122  			return nil
  5123  		}
  5124  	}
  5125  }
  5126  
  5127  func (ec *executionContext) fieldContext_Subscription_issue896b(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5128  	fc = &graphql.FieldContext{
  5129  		Object:     "Subscription",
  5130  		Field:      field,
  5131  		IsMethod:   true,
  5132  		IsResolver: true,
  5133  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5134  			switch field.Name {
  5135  			case "id":
  5136  				return ec.fieldContext_CheckIssue896_id(ctx, field)
  5137  			}
  5138  			return nil, fmt.Errorf("no field named %q was found under type CheckIssue896", field.Name)
  5139  		},
  5140  	}
  5141  	return fc, nil
  5142  }
  5143  
  5144  func (ec *executionContext) _Subscription_errorRequired(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
  5145  	fc, err := ec.fieldContext_Subscription_errorRequired(ctx, field)
  5146  	if err != nil {
  5147  		return nil
  5148  	}
  5149  	ctx = graphql.WithFieldContext(ctx, fc)
  5150  	defer func() {
  5151  		if r := recover(); r != nil {
  5152  			ec.Error(ctx, ec.Recover(ctx, r))
  5153  			ret = nil
  5154  		}
  5155  	}()
  5156  	resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
  5157  		ctx = rctx // use context from middleware stack in children
  5158  		return ec.resolvers.Subscription().ErrorRequired(rctx)
  5159  	})
  5160  
  5161  	if resTmp == nil {
  5162  		if !graphql.HasFieldError(ctx, fc) {
  5163  			ec.Errorf(ctx, "must not be null")
  5164  		}
  5165  		return nil
  5166  	}
  5167  	return func(ctx context.Context) graphql.Marshaler {
  5168  		select {
  5169  		case res, ok := <-resTmp.(<-chan *Error):
  5170  			if !ok {
  5171  				return nil
  5172  			}
  5173  			return graphql.WriterFunc(func(w io.Writer) {
  5174  				w.Write([]byte{'{'})
  5175  				graphql.MarshalString(field.Alias).MarshalGQL(w)
  5176  				w.Write([]byte{':'})
  5177  				ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res).MarshalGQL(w)
  5178  				w.Write([]byte{'}'})
  5179  			})
  5180  		case <-ctx.Done():
  5181  			return nil
  5182  		}
  5183  	}
  5184  }
  5185  
  5186  func (ec *executionContext) fieldContext_Subscription_errorRequired(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5187  	fc = &graphql.FieldContext{
  5188  		Object:     "Subscription",
  5189  		Field:      field,
  5190  		IsMethod:   true,
  5191  		IsResolver: true,
  5192  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5193  			switch field.Name {
  5194  			case "id":
  5195  				return ec.fieldContext_Error_id(ctx, field)
  5196  			case "errorOnNonRequiredField":
  5197  				return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
  5198  			case "errorOnRequiredField":
  5199  				return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
  5200  			case "nilOnRequiredField":
  5201  				return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
  5202  			}
  5203  			return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
  5204  		},
  5205  	}
  5206  	return fc, nil
  5207  }
  5208  
  5209  func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5210  	fc, err := ec.fieldContext_User_id(ctx, field)
  5211  	if err != nil {
  5212  		return graphql.Null
  5213  	}
  5214  	ctx = graphql.WithFieldContext(ctx, fc)
  5215  	defer func() {
  5216  		if r := recover(); r != nil {
  5217  			ec.Error(ctx, ec.Recover(ctx, r))
  5218  			ret = graphql.Null
  5219  		}
  5220  	}()
  5221  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5222  		ctx = rctx // use context from middleware stack in children
  5223  		return obj.ID, nil
  5224  	})
  5225  
  5226  	if resTmp == nil {
  5227  		if !graphql.HasFieldError(ctx, fc) {
  5228  			ec.Errorf(ctx, "must not be null")
  5229  		}
  5230  		return graphql.Null
  5231  	}
  5232  	res := resTmp.(int)
  5233  	fc.Result = res
  5234  	return ec.marshalNInt2int(ctx, field.Selections, res)
  5235  }
  5236  
  5237  func (ec *executionContext) fieldContext_User_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5238  	fc = &graphql.FieldContext{
  5239  		Object:     "User",
  5240  		Field:      field,
  5241  		IsMethod:   false,
  5242  		IsResolver: false,
  5243  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5244  			return nil, errors.New("field of type Int does not have child fields")
  5245  		},
  5246  	}
  5247  	return fc, nil
  5248  }
  5249  
  5250  func (ec *executionContext) _User_friends(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5251  	fc, err := ec.fieldContext_User_friends(ctx, field)
  5252  	if err != nil {
  5253  		return graphql.Null
  5254  	}
  5255  	ctx = graphql.WithFieldContext(ctx, fc)
  5256  	defer func() {
  5257  		if r := recover(); r != nil {
  5258  			ec.Error(ctx, ec.Recover(ctx, r))
  5259  			ret = graphql.Null
  5260  		}
  5261  	}()
  5262  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5263  		ctx = rctx // use context from middleware stack in children
  5264  		return ec.resolvers.User().Friends(rctx, obj)
  5265  	})
  5266  
  5267  	if resTmp == nil {
  5268  		if !graphql.HasFieldError(ctx, fc) {
  5269  			ec.Errorf(ctx, "must not be null")
  5270  		}
  5271  		return graphql.Null
  5272  	}
  5273  	res := resTmp.([]*User)
  5274  	fc.Result = res
  5275  	return ec.marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUserᚄ(ctx, field.Selections, res)
  5276  }
  5277  
  5278  func (ec *executionContext) fieldContext_User_friends(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5279  	fc = &graphql.FieldContext{
  5280  		Object:     "User",
  5281  		Field:      field,
  5282  		IsMethod:   true,
  5283  		IsResolver: true,
  5284  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5285  			switch field.Name {
  5286  			case "id":
  5287  				return ec.fieldContext_User_id(ctx, field)
  5288  			case "friends":
  5289  				return ec.fieldContext_User_friends(ctx, field)
  5290  			case "created":
  5291  				return ec.fieldContext_User_created(ctx, field)
  5292  			case "updated":
  5293  				return ec.fieldContext_User_updated(ctx, field)
  5294  			case "pets":
  5295  				return ec.fieldContext_User_pets(ctx, field)
  5296  			}
  5297  			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
  5298  		},
  5299  	}
  5300  	return fc, nil
  5301  }
  5302  
  5303  func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5304  	fc, err := ec.fieldContext_User_created(ctx, field)
  5305  	if err != nil {
  5306  		return graphql.Null
  5307  	}
  5308  	ctx = graphql.WithFieldContext(ctx, fc)
  5309  	defer func() {
  5310  		if r := recover(); r != nil {
  5311  			ec.Error(ctx, ec.Recover(ctx, r))
  5312  			ret = graphql.Null
  5313  		}
  5314  	}()
  5315  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5316  		ctx = rctx // use context from middleware stack in children
  5317  		return obj.Created, nil
  5318  	})
  5319  
  5320  	if resTmp == nil {
  5321  		if !graphql.HasFieldError(ctx, fc) {
  5322  			ec.Errorf(ctx, "must not be null")
  5323  		}
  5324  		return graphql.Null
  5325  	}
  5326  	res := resTmp.(time.Time)
  5327  	fc.Result = res
  5328  	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
  5329  }
  5330  
  5331  func (ec *executionContext) fieldContext_User_created(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5332  	fc = &graphql.FieldContext{
  5333  		Object:     "User",
  5334  		Field:      field,
  5335  		IsMethod:   false,
  5336  		IsResolver: false,
  5337  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5338  			return nil, errors.New("field of type Time does not have child fields")
  5339  		},
  5340  	}
  5341  	return fc, nil
  5342  }
  5343  
  5344  func (ec *executionContext) _User_updated(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5345  	fc, err := ec.fieldContext_User_updated(ctx, field)
  5346  	if err != nil {
  5347  		return graphql.Null
  5348  	}
  5349  	ctx = graphql.WithFieldContext(ctx, fc)
  5350  	defer func() {
  5351  		if r := recover(); r != nil {
  5352  			ec.Error(ctx, ec.Recover(ctx, r))
  5353  			ret = graphql.Null
  5354  		}
  5355  	}()
  5356  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5357  		ctx = rctx // use context from middleware stack in children
  5358  		return obj.Updated, nil
  5359  	})
  5360  
  5361  	if resTmp == nil {
  5362  		return graphql.Null
  5363  	}
  5364  	res := resTmp.(*time.Time)
  5365  	fc.Result = res
  5366  	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
  5367  }
  5368  
  5369  func (ec *executionContext) fieldContext_User_updated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5370  	fc = &graphql.FieldContext{
  5371  		Object:     "User",
  5372  		Field:      field,
  5373  		IsMethod:   false,
  5374  		IsResolver: false,
  5375  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5376  			return nil, errors.New("field of type Time does not have child fields")
  5377  		},
  5378  	}
  5379  	return fc, nil
  5380  }
  5381  
  5382  func (ec *executionContext) _User_pets(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
  5383  	fc, err := ec.fieldContext_User_pets(ctx, field)
  5384  	if err != nil {
  5385  		return graphql.Null
  5386  	}
  5387  	ctx = graphql.WithFieldContext(ctx, fc)
  5388  	defer func() {
  5389  		if r := recover(); r != nil {
  5390  			ec.Error(ctx, ec.Recover(ctx, r))
  5391  			ret = graphql.Null
  5392  		}
  5393  	}()
  5394  	resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
  5395  		ctx = rctx // use context from middleware stack in children
  5396  		return ec.resolvers.User().Pets(rctx, obj, fc.Args["limit"].(*int))
  5397  	})
  5398  
  5399  	if resTmp == nil {
  5400  		return graphql.Null
  5401  	}
  5402  	res := resTmp.([]*Pet)
  5403  	fc.Result = res
  5404  	return ec.marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx, field.Selections, res)
  5405  }
  5406  
  5407  func (ec *executionContext) fieldContext_User_pets(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
  5408  	fc = &graphql.FieldContext{
  5409  		Object:     "User",
  5410  		Field:      field,
  5411  		IsMethod:   true,
  5412  		IsResolver: true,
  5413  		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
  5414  			switch field.Name {
  5415  			case "id":
  5416  				return ec.fieldContext_Pet_id(ctx, field)
  5417  			case "friends":
  5418  				return ec.fieldContext_Pet_friends(ctx, field)
  5419  			}
  5420  			return nil, fmt.Errorf("no field named %q was found under type Pet", field.Name)
  5421  		},
  5422  	}
  5423  	defer func() {
  5424  		if r := recover(); r != nil {
  5425  			err = ec.Recover(ctx, r)
  5426  			ec.Error(ctx, err)
  5427  		}
  5428  	}()
  5429  	ctx = graphql.WithFieldContext(ctx, fc)
  5430  	if fc.Args, err = ec.field_User_pets_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
  5431  		ec.Error(ctx, err)
  5432  		return
  5433  	}
  5434  	return fc, nil
  5435  }
  5436  
  5437  // endregion **************************** field.gotpl *****************************
  5438  
  5439  // region    **************************** input.gotpl *****************************
  5440  
  5441  func (ec *executionContext) unmarshalInputInnerInput(ctx context.Context, obj interface{}) (InnerInput, error) {
  5442  	var it InnerInput
  5443  	asMap := map[string]interface{}{}
  5444  	for k, v := range obj.(map[string]interface{}) {
  5445  		asMap[k] = v
  5446  	}
  5447  
  5448  	for k, v := range asMap {
  5449  		switch k {
  5450  		case "id":
  5451  			var err error
  5452  
  5453  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
  5454  			it.ID, err = ec.unmarshalNInt2int(ctx, v)
  5455  			if err != nil {
  5456  				return it, err
  5457  			}
  5458  		}
  5459  	}
  5460  
  5461  	return it, nil
  5462  }
  5463  
  5464  func (ec *executionContext) unmarshalInputOuterInput(ctx context.Context, obj interface{}) (OuterInput, error) {
  5465  	var it OuterInput
  5466  	asMap := map[string]interface{}{}
  5467  	for k, v := range obj.(map[string]interface{}) {
  5468  		asMap[k] = v
  5469  	}
  5470  
  5471  	for k, v := range asMap {
  5472  		switch k {
  5473  		case "inner":
  5474  			var err error
  5475  
  5476  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("inner"))
  5477  			it.Inner, err = ec.unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx, v)
  5478  			if err != nil {
  5479  				return it, err
  5480  			}
  5481  		}
  5482  	}
  5483  
  5484  	return it, nil
  5485  }
  5486  
  5487  func (ec *executionContext) unmarshalInputRecursiveInputSlice(ctx context.Context, obj interface{}) (RecursiveInputSlice, error) {
  5488  	var it RecursiveInputSlice
  5489  	asMap := map[string]interface{}{}
  5490  	for k, v := range obj.(map[string]interface{}) {
  5491  		asMap[k] = v
  5492  	}
  5493  
  5494  	for k, v := range asMap {
  5495  		switch k {
  5496  		case "self":
  5497  			var err error
  5498  
  5499  			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("self"))
  5500  			it.Self, err = ec.unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSliceᚄ(ctx, v)
  5501  			if err != nil {
  5502  				return it, err
  5503  			}
  5504  		}
  5505  	}
  5506  
  5507  	return it, nil
  5508  }
  5509  
  5510  // endregion **************************** input.gotpl *****************************
  5511  
  5512  // region    ************************** interface.gotpl ***************************
  5513  
  5514  // endregion ************************** interface.gotpl ***************************
  5515  
  5516  // region    **************************** object.gotpl ****************************
  5517  
  5518  var autobindImplementors = []string{"Autobind"}
  5519  
  5520  func (ec *executionContext) _Autobind(ctx context.Context, sel ast.SelectionSet, obj *Autobind) graphql.Marshaler {
  5521  	fields := graphql.CollectFields(ec.OperationContext, sel, autobindImplementors)
  5522  	out := graphql.NewFieldSet(fields)
  5523  	var invalids uint32
  5524  	for i, field := range fields {
  5525  		switch field.Name {
  5526  		case "__typename":
  5527  			out.Values[i] = graphql.MarshalString("Autobind")
  5528  		case "int":
  5529  
  5530  			out.Values[i] = ec._Autobind_int(ctx, field, obj)
  5531  
  5532  			if out.Values[i] == graphql.Null {
  5533  				invalids++
  5534  			}
  5535  		case "int32":
  5536  
  5537  			out.Values[i] = ec._Autobind_int32(ctx, field, obj)
  5538  
  5539  			if out.Values[i] == graphql.Null {
  5540  				invalids++
  5541  			}
  5542  		case "int64":
  5543  
  5544  			out.Values[i] = ec._Autobind_int64(ctx, field, obj)
  5545  
  5546  			if out.Values[i] == graphql.Null {
  5547  				invalids++
  5548  			}
  5549  		case "idStr":
  5550  
  5551  			out.Values[i] = ec._Autobind_idStr(ctx, field, obj)
  5552  
  5553  			if out.Values[i] == graphql.Null {
  5554  				invalids++
  5555  			}
  5556  		case "idInt":
  5557  
  5558  			out.Values[i] = ec._Autobind_idInt(ctx, field, obj)
  5559  
  5560  			if out.Values[i] == graphql.Null {
  5561  				invalids++
  5562  			}
  5563  		default:
  5564  			panic("unknown field " + strconv.Quote(field.Name))
  5565  		}
  5566  	}
  5567  	out.Dispatch()
  5568  	if invalids > 0 {
  5569  		return graphql.Null
  5570  	}
  5571  	return out
  5572  }
  5573  
  5574  var embeddedPointerImplementors = []string{"EmbeddedPointer"}
  5575  
  5576  func (ec *executionContext) _EmbeddedPointer(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedPointerModel) graphql.Marshaler {
  5577  	fields := graphql.CollectFields(ec.OperationContext, sel, embeddedPointerImplementors)
  5578  	out := graphql.NewFieldSet(fields)
  5579  	var invalids uint32
  5580  	for i, field := range fields {
  5581  		switch field.Name {
  5582  		case "__typename":
  5583  			out.Values[i] = graphql.MarshalString("EmbeddedPointer")
  5584  		case "ID":
  5585  
  5586  			out.Values[i] = ec._EmbeddedPointer_ID(ctx, field, obj)
  5587  
  5588  		case "Title":
  5589  
  5590  			out.Values[i] = ec._EmbeddedPointer_Title(ctx, field, obj)
  5591  
  5592  		default:
  5593  			panic("unknown field " + strconv.Quote(field.Name))
  5594  		}
  5595  	}
  5596  	out.Dispatch()
  5597  	if invalids > 0 {
  5598  		return graphql.Null
  5599  	}
  5600  	return out
  5601  }
  5602  
  5603  var forcedResolverImplementors = []string{"ForcedResolver"}
  5604  
  5605  func (ec *executionContext) _ForcedResolver(ctx context.Context, sel ast.SelectionSet, obj *ForcedResolver) graphql.Marshaler {
  5606  	fields := graphql.CollectFields(ec.OperationContext, sel, forcedResolverImplementors)
  5607  	out := graphql.NewFieldSet(fields)
  5608  	var invalids uint32
  5609  	for i, field := range fields {
  5610  		switch field.Name {
  5611  		case "__typename":
  5612  			out.Values[i] = graphql.MarshalString("ForcedResolver")
  5613  		case "field":
  5614  			field := field
  5615  
  5616  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5617  				defer func() {
  5618  					if r := recover(); r != nil {
  5619  						ec.Error(ctx, ec.Recover(ctx, r))
  5620  					}
  5621  				}()
  5622  				res = ec._ForcedResolver_field(ctx, field, obj)
  5623  				return res
  5624  			}
  5625  
  5626  			out.Concurrently(i, func() graphql.Marshaler {
  5627  				return innerFunc(ctx)
  5628  
  5629  			})
  5630  		default:
  5631  			panic("unknown field " + strconv.Quote(field.Name))
  5632  		}
  5633  	}
  5634  	out.Dispatch()
  5635  	if invalids > 0 {
  5636  		return graphql.Null
  5637  	}
  5638  	return out
  5639  }
  5640  
  5641  var innerObjectImplementors = []string{"InnerObject"}
  5642  
  5643  func (ec *executionContext) _InnerObject(ctx context.Context, sel ast.SelectionSet, obj *InnerObject) graphql.Marshaler {
  5644  	fields := graphql.CollectFields(ec.OperationContext, sel, innerObjectImplementors)
  5645  	out := graphql.NewFieldSet(fields)
  5646  	var invalids uint32
  5647  	for i, field := range fields {
  5648  		switch field.Name {
  5649  		case "__typename":
  5650  			out.Values[i] = graphql.MarshalString("InnerObject")
  5651  		case "id":
  5652  
  5653  			out.Values[i] = ec._InnerObject_id(ctx, field, obj)
  5654  
  5655  			if out.Values[i] == graphql.Null {
  5656  				invalids++
  5657  			}
  5658  		default:
  5659  			panic("unknown field " + strconv.Quote(field.Name))
  5660  		}
  5661  	}
  5662  	out.Dispatch()
  5663  	if invalids > 0 {
  5664  		return graphql.Null
  5665  	}
  5666  	return out
  5667  }
  5668  
  5669  var invalidIdentifierImplementors = []string{"InvalidIdentifier"}
  5670  
  5671  func (ec *executionContext) _InvalidIdentifier(ctx context.Context, sel ast.SelectionSet, obj *invalid_packagename.InvalidIdentifier) graphql.Marshaler {
  5672  	fields := graphql.CollectFields(ec.OperationContext, sel, invalidIdentifierImplementors)
  5673  	out := graphql.NewFieldSet(fields)
  5674  	var invalids uint32
  5675  	for i, field := range fields {
  5676  		switch field.Name {
  5677  		case "__typename":
  5678  			out.Values[i] = graphql.MarshalString("InvalidIdentifier")
  5679  		case "id":
  5680  
  5681  			out.Values[i] = ec._InvalidIdentifier_id(ctx, field, obj)
  5682  
  5683  			if out.Values[i] == graphql.Null {
  5684  				invalids++
  5685  			}
  5686  		default:
  5687  			panic("unknown field " + strconv.Quote(field.Name))
  5688  		}
  5689  	}
  5690  	out.Dispatch()
  5691  	if invalids > 0 {
  5692  		return graphql.Null
  5693  	}
  5694  	return out
  5695  }
  5696  
  5697  var itImplementors = []string{"It"}
  5698  
  5699  func (ec *executionContext) _It(ctx context.Context, sel ast.SelectionSet, obj *introspection1.It) graphql.Marshaler {
  5700  	fields := graphql.CollectFields(ec.OperationContext, sel, itImplementors)
  5701  	out := graphql.NewFieldSet(fields)
  5702  	var invalids uint32
  5703  	for i, field := range fields {
  5704  		switch field.Name {
  5705  		case "__typename":
  5706  			out.Values[i] = graphql.MarshalString("It")
  5707  		case "id":
  5708  
  5709  			out.Values[i] = ec._It_id(ctx, field, obj)
  5710  
  5711  			if out.Values[i] == graphql.Null {
  5712  				invalids++
  5713  			}
  5714  		default:
  5715  			panic("unknown field " + strconv.Quote(field.Name))
  5716  		}
  5717  	}
  5718  	out.Dispatch()
  5719  	if invalids > 0 {
  5720  		return graphql.Null
  5721  	}
  5722  	return out
  5723  }
  5724  
  5725  var modelMethodsImplementors = []string{"ModelMethods"}
  5726  
  5727  func (ec *executionContext) _ModelMethods(ctx context.Context, sel ast.SelectionSet, obj *ModelMethods) graphql.Marshaler {
  5728  	fields := graphql.CollectFields(ec.OperationContext, sel, modelMethodsImplementors)
  5729  	out := graphql.NewFieldSet(fields)
  5730  	var invalids uint32
  5731  	for i, field := range fields {
  5732  		switch field.Name {
  5733  		case "__typename":
  5734  			out.Values[i] = graphql.MarshalString("ModelMethods")
  5735  		case "resolverField":
  5736  			field := field
  5737  
  5738  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5739  				defer func() {
  5740  					if r := recover(); r != nil {
  5741  						ec.Error(ctx, ec.Recover(ctx, r))
  5742  					}
  5743  				}()
  5744  				res = ec._ModelMethods_resolverField(ctx, field, obj)
  5745  				if res == graphql.Null {
  5746  					atomic.AddUint32(&invalids, 1)
  5747  				}
  5748  				return res
  5749  			}
  5750  
  5751  			out.Concurrently(i, func() graphql.Marshaler {
  5752  				return innerFunc(ctx)
  5753  
  5754  			})
  5755  		case "noContext":
  5756  
  5757  			out.Values[i] = ec._ModelMethods_noContext(ctx, field, obj)
  5758  
  5759  			if out.Values[i] == graphql.Null {
  5760  				atomic.AddUint32(&invalids, 1)
  5761  			}
  5762  		case "withContext":
  5763  			field := field
  5764  
  5765  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5766  				defer func() {
  5767  					if r := recover(); r != nil {
  5768  						ec.Error(ctx, ec.Recover(ctx, r))
  5769  					}
  5770  				}()
  5771  				res = ec._ModelMethods_withContext(ctx, field, obj)
  5772  				if res == graphql.Null {
  5773  					atomic.AddUint32(&invalids, 1)
  5774  				}
  5775  				return res
  5776  			}
  5777  
  5778  			out.Concurrently(i, func() graphql.Marshaler {
  5779  				return innerFunc(ctx)
  5780  
  5781  			})
  5782  		default:
  5783  			panic("unknown field " + strconv.Quote(field.Name))
  5784  		}
  5785  	}
  5786  	out.Dispatch()
  5787  	if invalids > 0 {
  5788  		return graphql.Null
  5789  	}
  5790  	return out
  5791  }
  5792  
  5793  var outerObjectImplementors = []string{"OuterObject"}
  5794  
  5795  func (ec *executionContext) _OuterObject(ctx context.Context, sel ast.SelectionSet, obj *OuterObject) graphql.Marshaler {
  5796  	fields := graphql.CollectFields(ec.OperationContext, sel, outerObjectImplementors)
  5797  	out := graphql.NewFieldSet(fields)
  5798  	var invalids uint32
  5799  	for i, field := range fields {
  5800  		switch field.Name {
  5801  		case "__typename":
  5802  			out.Values[i] = graphql.MarshalString("OuterObject")
  5803  		case "inner":
  5804  
  5805  			out.Values[i] = ec._OuterObject_inner(ctx, field, obj)
  5806  
  5807  			if out.Values[i] == graphql.Null {
  5808  				invalids++
  5809  			}
  5810  		default:
  5811  			panic("unknown field " + strconv.Quote(field.Name))
  5812  		}
  5813  	}
  5814  	out.Dispatch()
  5815  	if invalids > 0 {
  5816  		return graphql.Null
  5817  	}
  5818  	return out
  5819  }
  5820  
  5821  var petImplementors = []string{"Pet"}
  5822  
  5823  func (ec *executionContext) _Pet(ctx context.Context, sel ast.SelectionSet, obj *Pet) graphql.Marshaler {
  5824  	fields := graphql.CollectFields(ec.OperationContext, sel, petImplementors)
  5825  	out := graphql.NewFieldSet(fields)
  5826  	var invalids uint32
  5827  	for i, field := range fields {
  5828  		switch field.Name {
  5829  		case "__typename":
  5830  			out.Values[i] = graphql.MarshalString("Pet")
  5831  		case "id":
  5832  
  5833  			out.Values[i] = ec._Pet_id(ctx, field, obj)
  5834  
  5835  			if out.Values[i] == graphql.Null {
  5836  				atomic.AddUint32(&invalids, 1)
  5837  			}
  5838  		case "friends":
  5839  			field := field
  5840  
  5841  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5842  				defer func() {
  5843  					if r := recover(); r != nil {
  5844  						ec.Error(ctx, ec.Recover(ctx, r))
  5845  					}
  5846  				}()
  5847  				res = ec._Pet_friends(ctx, field, obj)
  5848  				return res
  5849  			}
  5850  
  5851  			out.Concurrently(i, func() graphql.Marshaler {
  5852  				return innerFunc(ctx)
  5853  
  5854  			})
  5855  		default:
  5856  			panic("unknown field " + strconv.Quote(field.Name))
  5857  		}
  5858  	}
  5859  	out.Dispatch()
  5860  	if invalids > 0 {
  5861  		return graphql.Null
  5862  	}
  5863  	return out
  5864  }
  5865  
  5866  var queryImplementors = []string{"Query"}
  5867  
  5868  func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
  5869  	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
  5870  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  5871  		Object: "Query",
  5872  	})
  5873  
  5874  	out := graphql.NewFieldSet(fields)
  5875  	var invalids uint32
  5876  	for i, field := range fields {
  5877  		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
  5878  			Object: field.Name,
  5879  			Field:  field,
  5880  		})
  5881  
  5882  		switch field.Name {
  5883  		case "__typename":
  5884  			out.Values[i] = graphql.MarshalString("Query")
  5885  		case "invalidIdentifier":
  5886  			field := field
  5887  
  5888  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5889  				defer func() {
  5890  					if r := recover(); r != nil {
  5891  						ec.Error(ctx, ec.Recover(ctx, r))
  5892  					}
  5893  				}()
  5894  				res = ec._Query_invalidIdentifier(ctx, field)
  5895  				return res
  5896  			}
  5897  
  5898  			rrm := func(ctx context.Context) graphql.Marshaler {
  5899  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  5900  			}
  5901  
  5902  			out.Concurrently(i, func() graphql.Marshaler {
  5903  				return rrm(innerCtx)
  5904  			})
  5905  		case "collision":
  5906  			field := field
  5907  
  5908  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5909  				defer func() {
  5910  					if r := recover(); r != nil {
  5911  						ec.Error(ctx, ec.Recover(ctx, r))
  5912  					}
  5913  				}()
  5914  				res = ec._Query_collision(ctx, field)
  5915  				return res
  5916  			}
  5917  
  5918  			rrm := func(ctx context.Context) graphql.Marshaler {
  5919  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  5920  			}
  5921  
  5922  			out.Concurrently(i, func() graphql.Marshaler {
  5923  				return rrm(innerCtx)
  5924  			})
  5925  		case "mapInput":
  5926  			field := field
  5927  
  5928  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5929  				defer func() {
  5930  					if r := recover(); r != nil {
  5931  						ec.Error(ctx, ec.Recover(ctx, r))
  5932  					}
  5933  				}()
  5934  				res = ec._Query_mapInput(ctx, field)
  5935  				return res
  5936  			}
  5937  
  5938  			rrm := func(ctx context.Context) graphql.Marshaler {
  5939  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  5940  			}
  5941  
  5942  			out.Concurrently(i, func() graphql.Marshaler {
  5943  				return rrm(innerCtx)
  5944  			})
  5945  		case "recursive":
  5946  			field := field
  5947  
  5948  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5949  				defer func() {
  5950  					if r := recover(); r != nil {
  5951  						ec.Error(ctx, ec.Recover(ctx, r))
  5952  					}
  5953  				}()
  5954  				res = ec._Query_recursive(ctx, field)
  5955  				return res
  5956  			}
  5957  
  5958  			rrm := func(ctx context.Context) graphql.Marshaler {
  5959  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  5960  			}
  5961  
  5962  			out.Concurrently(i, func() graphql.Marshaler {
  5963  				return rrm(innerCtx)
  5964  			})
  5965  		case "nestedInputs":
  5966  			field := field
  5967  
  5968  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5969  				defer func() {
  5970  					if r := recover(); r != nil {
  5971  						ec.Error(ctx, ec.Recover(ctx, r))
  5972  					}
  5973  				}()
  5974  				res = ec._Query_nestedInputs(ctx, field)
  5975  				return res
  5976  			}
  5977  
  5978  			rrm := func(ctx context.Context) graphql.Marshaler {
  5979  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  5980  			}
  5981  
  5982  			out.Concurrently(i, func() graphql.Marshaler {
  5983  				return rrm(innerCtx)
  5984  			})
  5985  		case "nestedOutputs":
  5986  			field := field
  5987  
  5988  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  5989  				defer func() {
  5990  					if r := recover(); r != nil {
  5991  						ec.Error(ctx, ec.Recover(ctx, r))
  5992  					}
  5993  				}()
  5994  				res = ec._Query_nestedOutputs(ctx, field)
  5995  				return res
  5996  			}
  5997  
  5998  			rrm := func(ctx context.Context) graphql.Marshaler {
  5999  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6000  			}
  6001  
  6002  			out.Concurrently(i, func() graphql.Marshaler {
  6003  				return rrm(innerCtx)
  6004  			})
  6005  		case "modelMethods":
  6006  			field := field
  6007  
  6008  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6009  				defer func() {
  6010  					if r := recover(); r != nil {
  6011  						ec.Error(ctx, ec.Recover(ctx, r))
  6012  					}
  6013  				}()
  6014  				res = ec._Query_modelMethods(ctx, field)
  6015  				return res
  6016  			}
  6017  
  6018  			rrm := func(ctx context.Context) graphql.Marshaler {
  6019  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6020  			}
  6021  
  6022  			out.Concurrently(i, func() graphql.Marshaler {
  6023  				return rrm(innerCtx)
  6024  			})
  6025  		case "user":
  6026  			field := field
  6027  
  6028  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6029  				defer func() {
  6030  					if r := recover(); r != nil {
  6031  						ec.Error(ctx, ec.Recover(ctx, r))
  6032  					}
  6033  				}()
  6034  				res = ec._Query_user(ctx, field)
  6035  				if res == graphql.Null {
  6036  					atomic.AddUint32(&invalids, 1)
  6037  				}
  6038  				return res
  6039  			}
  6040  
  6041  			rrm := func(ctx context.Context) graphql.Marshaler {
  6042  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6043  			}
  6044  
  6045  			out.Concurrently(i, func() graphql.Marshaler {
  6046  				return rrm(innerCtx)
  6047  			})
  6048  		case "nullableArg":
  6049  			field := field
  6050  
  6051  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6052  				defer func() {
  6053  					if r := recover(); r != nil {
  6054  						ec.Error(ctx, ec.Recover(ctx, r))
  6055  					}
  6056  				}()
  6057  				res = ec._Query_nullableArg(ctx, field)
  6058  				return res
  6059  			}
  6060  
  6061  			rrm := func(ctx context.Context) graphql.Marshaler {
  6062  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6063  			}
  6064  
  6065  			out.Concurrently(i, func() graphql.Marshaler {
  6066  				return rrm(innerCtx)
  6067  			})
  6068  		case "inputSlice":
  6069  			field := field
  6070  
  6071  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6072  				defer func() {
  6073  					if r := recover(); r != nil {
  6074  						ec.Error(ctx, ec.Recover(ctx, r))
  6075  					}
  6076  				}()
  6077  				res = ec._Query_inputSlice(ctx, field)
  6078  				if res == graphql.Null {
  6079  					atomic.AddUint32(&invalids, 1)
  6080  				}
  6081  				return res
  6082  			}
  6083  
  6084  			rrm := func(ctx context.Context) graphql.Marshaler {
  6085  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6086  			}
  6087  
  6088  			out.Concurrently(i, func() graphql.Marshaler {
  6089  				return rrm(innerCtx)
  6090  			})
  6091  		case "inputNullableSlice":
  6092  			field := field
  6093  
  6094  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6095  				defer func() {
  6096  					if r := recover(); r != nil {
  6097  						ec.Error(ctx, ec.Recover(ctx, r))
  6098  					}
  6099  				}()
  6100  				res = ec._Query_inputNullableSlice(ctx, field)
  6101  				if res == graphql.Null {
  6102  					atomic.AddUint32(&invalids, 1)
  6103  				}
  6104  				return res
  6105  			}
  6106  
  6107  			rrm := func(ctx context.Context) graphql.Marshaler {
  6108  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6109  			}
  6110  
  6111  			out.Concurrently(i, func() graphql.Marshaler {
  6112  				return rrm(innerCtx)
  6113  			})
  6114  		case "shapeUnion":
  6115  			field := field
  6116  
  6117  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6118  				defer func() {
  6119  					if r := recover(); r != nil {
  6120  						ec.Error(ctx, ec.Recover(ctx, r))
  6121  					}
  6122  				}()
  6123  				res = ec._Query_shapeUnion(ctx, field)
  6124  				if res == graphql.Null {
  6125  					atomic.AddUint32(&invalids, 1)
  6126  				}
  6127  				return res
  6128  			}
  6129  
  6130  			rrm := func(ctx context.Context) graphql.Marshaler {
  6131  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6132  			}
  6133  
  6134  			out.Concurrently(i, func() graphql.Marshaler {
  6135  				return rrm(innerCtx)
  6136  			})
  6137  		case "autobind":
  6138  			field := field
  6139  
  6140  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6141  				defer func() {
  6142  					if r := recover(); r != nil {
  6143  						ec.Error(ctx, ec.Recover(ctx, r))
  6144  					}
  6145  				}()
  6146  				res = ec._Query_autobind(ctx, field)
  6147  				return res
  6148  			}
  6149  
  6150  			rrm := func(ctx context.Context) graphql.Marshaler {
  6151  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6152  			}
  6153  
  6154  			out.Concurrently(i, func() graphql.Marshaler {
  6155  				return rrm(innerCtx)
  6156  			})
  6157  		case "deprecatedField":
  6158  			field := field
  6159  
  6160  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6161  				defer func() {
  6162  					if r := recover(); r != nil {
  6163  						ec.Error(ctx, ec.Recover(ctx, r))
  6164  					}
  6165  				}()
  6166  				res = ec._Query_deprecatedField(ctx, field)
  6167  				if res == graphql.Null {
  6168  					atomic.AddUint32(&invalids, 1)
  6169  				}
  6170  				return res
  6171  			}
  6172  
  6173  			rrm := func(ctx context.Context) graphql.Marshaler {
  6174  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6175  			}
  6176  
  6177  			out.Concurrently(i, func() graphql.Marshaler {
  6178  				return rrm(innerCtx)
  6179  			})
  6180  		case "overlapping":
  6181  			field := field
  6182  
  6183  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6184  				defer func() {
  6185  					if r := recover(); r != nil {
  6186  						ec.Error(ctx, ec.Recover(ctx, r))
  6187  					}
  6188  				}()
  6189  				res = ec._Query_overlapping(ctx, field)
  6190  				return res
  6191  			}
  6192  
  6193  			rrm := func(ctx context.Context) graphql.Marshaler {
  6194  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6195  			}
  6196  
  6197  			out.Concurrently(i, func() graphql.Marshaler {
  6198  				return rrm(innerCtx)
  6199  			})
  6200  		case "defaultParameters":
  6201  			field := field
  6202  
  6203  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6204  				defer func() {
  6205  					if r := recover(); r != nil {
  6206  						ec.Error(ctx, ec.Recover(ctx, r))
  6207  					}
  6208  				}()
  6209  				res = ec._Query_defaultParameters(ctx, field)
  6210  				if res == graphql.Null {
  6211  					atomic.AddUint32(&invalids, 1)
  6212  				}
  6213  				return res
  6214  			}
  6215  
  6216  			rrm := func(ctx context.Context) graphql.Marshaler {
  6217  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6218  			}
  6219  
  6220  			out.Concurrently(i, func() graphql.Marshaler {
  6221  				return rrm(innerCtx)
  6222  			})
  6223  		case "directiveArg":
  6224  			field := field
  6225  
  6226  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6227  				defer func() {
  6228  					if r := recover(); r != nil {
  6229  						ec.Error(ctx, ec.Recover(ctx, r))
  6230  					}
  6231  				}()
  6232  				res = ec._Query_directiveArg(ctx, field)
  6233  				return res
  6234  			}
  6235  
  6236  			rrm := func(ctx context.Context) graphql.Marshaler {
  6237  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6238  			}
  6239  
  6240  			out.Concurrently(i, func() graphql.Marshaler {
  6241  				return rrm(innerCtx)
  6242  			})
  6243  		case "directiveNullableArg":
  6244  			field := field
  6245  
  6246  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6247  				defer func() {
  6248  					if r := recover(); r != nil {
  6249  						ec.Error(ctx, ec.Recover(ctx, r))
  6250  					}
  6251  				}()
  6252  				res = ec._Query_directiveNullableArg(ctx, field)
  6253  				return res
  6254  			}
  6255  
  6256  			rrm := func(ctx context.Context) graphql.Marshaler {
  6257  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6258  			}
  6259  
  6260  			out.Concurrently(i, func() graphql.Marshaler {
  6261  				return rrm(innerCtx)
  6262  			})
  6263  		case "directiveInputNullable":
  6264  			field := field
  6265  
  6266  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6267  				defer func() {
  6268  					if r := recover(); r != nil {
  6269  						ec.Error(ctx, ec.Recover(ctx, r))
  6270  					}
  6271  				}()
  6272  				res = ec._Query_directiveInputNullable(ctx, field)
  6273  				return res
  6274  			}
  6275  
  6276  			rrm := func(ctx context.Context) graphql.Marshaler {
  6277  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6278  			}
  6279  
  6280  			out.Concurrently(i, func() graphql.Marshaler {
  6281  				return rrm(innerCtx)
  6282  			})
  6283  		case "directiveInput":
  6284  			field := field
  6285  
  6286  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6287  				defer func() {
  6288  					if r := recover(); r != nil {
  6289  						ec.Error(ctx, ec.Recover(ctx, r))
  6290  					}
  6291  				}()
  6292  				res = ec._Query_directiveInput(ctx, field)
  6293  				return res
  6294  			}
  6295  
  6296  			rrm := func(ctx context.Context) graphql.Marshaler {
  6297  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6298  			}
  6299  
  6300  			out.Concurrently(i, func() graphql.Marshaler {
  6301  				return rrm(innerCtx)
  6302  			})
  6303  		case "directiveInputType":
  6304  			field := field
  6305  
  6306  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6307  				defer func() {
  6308  					if r := recover(); r != nil {
  6309  						ec.Error(ctx, ec.Recover(ctx, r))
  6310  					}
  6311  				}()
  6312  				res = ec._Query_directiveInputType(ctx, field)
  6313  				return res
  6314  			}
  6315  
  6316  			rrm := func(ctx context.Context) graphql.Marshaler {
  6317  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6318  			}
  6319  
  6320  			out.Concurrently(i, func() graphql.Marshaler {
  6321  				return rrm(innerCtx)
  6322  			})
  6323  		case "directiveObject":
  6324  			field := field
  6325  
  6326  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6327  				defer func() {
  6328  					if r := recover(); r != nil {
  6329  						ec.Error(ctx, ec.Recover(ctx, r))
  6330  					}
  6331  				}()
  6332  				res = ec._Query_directiveObject(ctx, field)
  6333  				return res
  6334  			}
  6335  
  6336  			rrm := func(ctx context.Context) graphql.Marshaler {
  6337  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6338  			}
  6339  
  6340  			out.Concurrently(i, func() graphql.Marshaler {
  6341  				return rrm(innerCtx)
  6342  			})
  6343  		case "directiveObjectWithCustomGoModel":
  6344  			field := field
  6345  
  6346  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6347  				defer func() {
  6348  					if r := recover(); r != nil {
  6349  						ec.Error(ctx, ec.Recover(ctx, r))
  6350  					}
  6351  				}()
  6352  				res = ec._Query_directiveObjectWithCustomGoModel(ctx, field)
  6353  				return res
  6354  			}
  6355  
  6356  			rrm := func(ctx context.Context) graphql.Marshaler {
  6357  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6358  			}
  6359  
  6360  			out.Concurrently(i, func() graphql.Marshaler {
  6361  				return rrm(innerCtx)
  6362  			})
  6363  		case "directiveFieldDef":
  6364  			field := field
  6365  
  6366  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6367  				defer func() {
  6368  					if r := recover(); r != nil {
  6369  						ec.Error(ctx, ec.Recover(ctx, r))
  6370  					}
  6371  				}()
  6372  				res = ec._Query_directiveFieldDef(ctx, field)
  6373  				if res == graphql.Null {
  6374  					atomic.AddUint32(&invalids, 1)
  6375  				}
  6376  				return res
  6377  			}
  6378  
  6379  			rrm := func(ctx context.Context) graphql.Marshaler {
  6380  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6381  			}
  6382  
  6383  			out.Concurrently(i, func() graphql.Marshaler {
  6384  				return rrm(innerCtx)
  6385  			})
  6386  		case "directiveField":
  6387  			field := field
  6388  
  6389  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6390  				defer func() {
  6391  					if r := recover(); r != nil {
  6392  						ec.Error(ctx, ec.Recover(ctx, r))
  6393  					}
  6394  				}()
  6395  				res = ec._Query_directiveField(ctx, field)
  6396  				return res
  6397  			}
  6398  
  6399  			rrm := func(ctx context.Context) graphql.Marshaler {
  6400  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6401  			}
  6402  
  6403  			out.Concurrently(i, func() graphql.Marshaler {
  6404  				return rrm(innerCtx)
  6405  			})
  6406  		case "directiveDouble":
  6407  			field := field
  6408  
  6409  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6410  				defer func() {
  6411  					if r := recover(); r != nil {
  6412  						ec.Error(ctx, ec.Recover(ctx, r))
  6413  					}
  6414  				}()
  6415  				res = ec._Query_directiveDouble(ctx, field)
  6416  				return res
  6417  			}
  6418  
  6419  			rrm := func(ctx context.Context) graphql.Marshaler {
  6420  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6421  			}
  6422  
  6423  			out.Concurrently(i, func() graphql.Marshaler {
  6424  				return rrm(innerCtx)
  6425  			})
  6426  		case "directiveUnimplemented":
  6427  			field := field
  6428  
  6429  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6430  				defer func() {
  6431  					if r := recover(); r != nil {
  6432  						ec.Error(ctx, ec.Recover(ctx, r))
  6433  					}
  6434  				}()
  6435  				res = ec._Query_directiveUnimplemented(ctx, field)
  6436  				return res
  6437  			}
  6438  
  6439  			rrm := func(ctx context.Context) graphql.Marshaler {
  6440  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6441  			}
  6442  
  6443  			out.Concurrently(i, func() graphql.Marshaler {
  6444  				return rrm(innerCtx)
  6445  			})
  6446  		case "embeddedCase1":
  6447  			field := field
  6448  
  6449  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6450  				defer func() {
  6451  					if r := recover(); r != nil {
  6452  						ec.Error(ctx, ec.Recover(ctx, r))
  6453  					}
  6454  				}()
  6455  				res = ec._Query_embeddedCase1(ctx, field)
  6456  				return res
  6457  			}
  6458  
  6459  			rrm := func(ctx context.Context) graphql.Marshaler {
  6460  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6461  			}
  6462  
  6463  			out.Concurrently(i, func() graphql.Marshaler {
  6464  				return rrm(innerCtx)
  6465  			})
  6466  		case "embeddedCase2":
  6467  			field := field
  6468  
  6469  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6470  				defer func() {
  6471  					if r := recover(); r != nil {
  6472  						ec.Error(ctx, ec.Recover(ctx, r))
  6473  					}
  6474  				}()
  6475  				res = ec._Query_embeddedCase2(ctx, field)
  6476  				return res
  6477  			}
  6478  
  6479  			rrm := func(ctx context.Context) graphql.Marshaler {
  6480  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6481  			}
  6482  
  6483  			out.Concurrently(i, func() graphql.Marshaler {
  6484  				return rrm(innerCtx)
  6485  			})
  6486  		case "embeddedCase3":
  6487  			field := field
  6488  
  6489  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6490  				defer func() {
  6491  					if r := recover(); r != nil {
  6492  						ec.Error(ctx, ec.Recover(ctx, r))
  6493  					}
  6494  				}()
  6495  				res = ec._Query_embeddedCase3(ctx, field)
  6496  				return res
  6497  			}
  6498  
  6499  			rrm := func(ctx context.Context) graphql.Marshaler {
  6500  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6501  			}
  6502  
  6503  			out.Concurrently(i, func() graphql.Marshaler {
  6504  				return rrm(innerCtx)
  6505  			})
  6506  		case "enumInInput":
  6507  			field := field
  6508  
  6509  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6510  				defer func() {
  6511  					if r := recover(); r != nil {
  6512  						ec.Error(ctx, ec.Recover(ctx, r))
  6513  					}
  6514  				}()
  6515  				res = ec._Query_enumInInput(ctx, field)
  6516  				if res == graphql.Null {
  6517  					atomic.AddUint32(&invalids, 1)
  6518  				}
  6519  				return res
  6520  			}
  6521  
  6522  			rrm := func(ctx context.Context) graphql.Marshaler {
  6523  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6524  			}
  6525  
  6526  			out.Concurrently(i, func() graphql.Marshaler {
  6527  				return rrm(innerCtx)
  6528  			})
  6529  		case "shapes":
  6530  			field := field
  6531  
  6532  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6533  				defer func() {
  6534  					if r := recover(); r != nil {
  6535  						ec.Error(ctx, ec.Recover(ctx, r))
  6536  					}
  6537  				}()
  6538  				res = ec._Query_shapes(ctx, field)
  6539  				return res
  6540  			}
  6541  
  6542  			rrm := func(ctx context.Context) graphql.Marshaler {
  6543  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6544  			}
  6545  
  6546  			out.Concurrently(i, func() graphql.Marshaler {
  6547  				return rrm(innerCtx)
  6548  			})
  6549  		case "noShape":
  6550  			field := field
  6551  
  6552  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6553  				defer func() {
  6554  					if r := recover(); r != nil {
  6555  						ec.Error(ctx, ec.Recover(ctx, r))
  6556  					}
  6557  				}()
  6558  				res = ec._Query_noShape(ctx, field)
  6559  				return res
  6560  			}
  6561  
  6562  			rrm := func(ctx context.Context) graphql.Marshaler {
  6563  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6564  			}
  6565  
  6566  			out.Concurrently(i, func() graphql.Marshaler {
  6567  				return rrm(innerCtx)
  6568  			})
  6569  		case "node":
  6570  			field := field
  6571  
  6572  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6573  				defer func() {
  6574  					if r := recover(); r != nil {
  6575  						ec.Error(ctx, ec.Recover(ctx, r))
  6576  					}
  6577  				}()
  6578  				res = ec._Query_node(ctx, field)
  6579  				if res == graphql.Null {
  6580  					atomic.AddUint32(&invalids, 1)
  6581  				}
  6582  				return res
  6583  			}
  6584  
  6585  			rrm := func(ctx context.Context) graphql.Marshaler {
  6586  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6587  			}
  6588  
  6589  			out.Concurrently(i, func() graphql.Marshaler {
  6590  				return rrm(innerCtx)
  6591  			})
  6592  		case "noShapeTypedNil":
  6593  			field := field
  6594  
  6595  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6596  				defer func() {
  6597  					if r := recover(); r != nil {
  6598  						ec.Error(ctx, ec.Recover(ctx, r))
  6599  					}
  6600  				}()
  6601  				res = ec._Query_noShapeTypedNil(ctx, field)
  6602  				return res
  6603  			}
  6604  
  6605  			rrm := func(ctx context.Context) graphql.Marshaler {
  6606  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6607  			}
  6608  
  6609  			out.Concurrently(i, func() graphql.Marshaler {
  6610  				return rrm(innerCtx)
  6611  			})
  6612  		case "animal":
  6613  			field := field
  6614  
  6615  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6616  				defer func() {
  6617  					if r := recover(); r != nil {
  6618  						ec.Error(ctx, ec.Recover(ctx, r))
  6619  					}
  6620  				}()
  6621  				res = ec._Query_animal(ctx, field)
  6622  				return res
  6623  			}
  6624  
  6625  			rrm := func(ctx context.Context) graphql.Marshaler {
  6626  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6627  			}
  6628  
  6629  			out.Concurrently(i, func() graphql.Marshaler {
  6630  				return rrm(innerCtx)
  6631  			})
  6632  		case "notAnInterface":
  6633  			field := field
  6634  
  6635  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6636  				defer func() {
  6637  					if r := recover(); r != nil {
  6638  						ec.Error(ctx, ec.Recover(ctx, r))
  6639  					}
  6640  				}()
  6641  				res = ec._Query_notAnInterface(ctx, field)
  6642  				return res
  6643  			}
  6644  
  6645  			rrm := func(ctx context.Context) graphql.Marshaler {
  6646  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6647  			}
  6648  
  6649  			out.Concurrently(i, func() graphql.Marshaler {
  6650  				return rrm(innerCtx)
  6651  			})
  6652  		case "issue896a":
  6653  			field := field
  6654  
  6655  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6656  				defer func() {
  6657  					if r := recover(); r != nil {
  6658  						ec.Error(ctx, ec.Recover(ctx, r))
  6659  					}
  6660  				}()
  6661  				res = ec._Query_issue896a(ctx, field)
  6662  				return res
  6663  			}
  6664  
  6665  			rrm := func(ctx context.Context) graphql.Marshaler {
  6666  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6667  			}
  6668  
  6669  			out.Concurrently(i, func() graphql.Marshaler {
  6670  				return rrm(innerCtx)
  6671  			})
  6672  		case "mapStringInterface":
  6673  			field := field
  6674  
  6675  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6676  				defer func() {
  6677  					if r := recover(); r != nil {
  6678  						ec.Error(ctx, ec.Recover(ctx, r))
  6679  					}
  6680  				}()
  6681  				res = ec._Query_mapStringInterface(ctx, field)
  6682  				return res
  6683  			}
  6684  
  6685  			rrm := func(ctx context.Context) graphql.Marshaler {
  6686  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6687  			}
  6688  
  6689  			out.Concurrently(i, func() graphql.Marshaler {
  6690  				return rrm(innerCtx)
  6691  			})
  6692  		case "mapNestedStringInterface":
  6693  			field := field
  6694  
  6695  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6696  				defer func() {
  6697  					if r := recover(); r != nil {
  6698  						ec.Error(ctx, ec.Recover(ctx, r))
  6699  					}
  6700  				}()
  6701  				res = ec._Query_mapNestedStringInterface(ctx, field)
  6702  				return res
  6703  			}
  6704  
  6705  			rrm := func(ctx context.Context) graphql.Marshaler {
  6706  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6707  			}
  6708  
  6709  			out.Concurrently(i, func() graphql.Marshaler {
  6710  				return rrm(innerCtx)
  6711  			})
  6712  		case "errorBubble":
  6713  			field := field
  6714  
  6715  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6716  				defer func() {
  6717  					if r := recover(); r != nil {
  6718  						ec.Error(ctx, ec.Recover(ctx, r))
  6719  					}
  6720  				}()
  6721  				res = ec._Query_errorBubble(ctx, field)
  6722  				return res
  6723  			}
  6724  
  6725  			rrm := func(ctx context.Context) graphql.Marshaler {
  6726  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6727  			}
  6728  
  6729  			out.Concurrently(i, func() graphql.Marshaler {
  6730  				return rrm(innerCtx)
  6731  			})
  6732  		case "errorBubbleList":
  6733  			field := field
  6734  
  6735  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6736  				defer func() {
  6737  					if r := recover(); r != nil {
  6738  						ec.Error(ctx, ec.Recover(ctx, r))
  6739  					}
  6740  				}()
  6741  				res = ec._Query_errorBubbleList(ctx, field)
  6742  				return res
  6743  			}
  6744  
  6745  			rrm := func(ctx context.Context) graphql.Marshaler {
  6746  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6747  			}
  6748  
  6749  			out.Concurrently(i, func() graphql.Marshaler {
  6750  				return rrm(innerCtx)
  6751  			})
  6752  		case "errorList":
  6753  			field := field
  6754  
  6755  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6756  				defer func() {
  6757  					if r := recover(); r != nil {
  6758  						ec.Error(ctx, ec.Recover(ctx, r))
  6759  					}
  6760  				}()
  6761  				res = ec._Query_errorList(ctx, field)
  6762  				return res
  6763  			}
  6764  
  6765  			rrm := func(ctx context.Context) graphql.Marshaler {
  6766  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6767  			}
  6768  
  6769  			out.Concurrently(i, func() graphql.Marshaler {
  6770  				return rrm(innerCtx)
  6771  			})
  6772  		case "errors":
  6773  			field := field
  6774  
  6775  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6776  				defer func() {
  6777  					if r := recover(); r != nil {
  6778  						ec.Error(ctx, ec.Recover(ctx, r))
  6779  					}
  6780  				}()
  6781  				res = ec._Query_errors(ctx, field)
  6782  				return res
  6783  			}
  6784  
  6785  			rrm := func(ctx context.Context) graphql.Marshaler {
  6786  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6787  			}
  6788  
  6789  			out.Concurrently(i, func() graphql.Marshaler {
  6790  				return rrm(innerCtx)
  6791  			})
  6792  		case "valid":
  6793  			field := field
  6794  
  6795  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6796  				defer func() {
  6797  					if r := recover(); r != nil {
  6798  						ec.Error(ctx, ec.Recover(ctx, r))
  6799  					}
  6800  				}()
  6801  				res = ec._Query_valid(ctx, field)
  6802  				if res == graphql.Null {
  6803  					atomic.AddUint32(&invalids, 1)
  6804  				}
  6805  				return res
  6806  			}
  6807  
  6808  			rrm := func(ctx context.Context) graphql.Marshaler {
  6809  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6810  			}
  6811  
  6812  			out.Concurrently(i, func() graphql.Marshaler {
  6813  				return rrm(innerCtx)
  6814  			})
  6815  		case "panics":
  6816  			field := field
  6817  
  6818  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6819  				defer func() {
  6820  					if r := recover(); r != nil {
  6821  						ec.Error(ctx, ec.Recover(ctx, r))
  6822  					}
  6823  				}()
  6824  				res = ec._Query_panics(ctx, field)
  6825  				return res
  6826  			}
  6827  
  6828  			rrm := func(ctx context.Context) graphql.Marshaler {
  6829  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6830  			}
  6831  
  6832  			out.Concurrently(i, func() graphql.Marshaler {
  6833  				return rrm(innerCtx)
  6834  			})
  6835  		case "primitiveObject":
  6836  			field := field
  6837  
  6838  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6839  				defer func() {
  6840  					if r := recover(); r != nil {
  6841  						ec.Error(ctx, ec.Recover(ctx, r))
  6842  					}
  6843  				}()
  6844  				res = ec._Query_primitiveObject(ctx, field)
  6845  				if res == graphql.Null {
  6846  					atomic.AddUint32(&invalids, 1)
  6847  				}
  6848  				return res
  6849  			}
  6850  
  6851  			rrm := func(ctx context.Context) graphql.Marshaler {
  6852  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6853  			}
  6854  
  6855  			out.Concurrently(i, func() graphql.Marshaler {
  6856  				return rrm(innerCtx)
  6857  			})
  6858  		case "primitiveStringObject":
  6859  			field := field
  6860  
  6861  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6862  				defer func() {
  6863  					if r := recover(); r != nil {
  6864  						ec.Error(ctx, ec.Recover(ctx, r))
  6865  					}
  6866  				}()
  6867  				res = ec._Query_primitiveStringObject(ctx, field)
  6868  				if res == graphql.Null {
  6869  					atomic.AddUint32(&invalids, 1)
  6870  				}
  6871  				return res
  6872  			}
  6873  
  6874  			rrm := func(ctx context.Context) graphql.Marshaler {
  6875  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6876  			}
  6877  
  6878  			out.Concurrently(i, func() graphql.Marshaler {
  6879  				return rrm(innerCtx)
  6880  			})
  6881  		case "ptrToSliceContainer":
  6882  			field := field
  6883  
  6884  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6885  				defer func() {
  6886  					if r := recover(); r != nil {
  6887  						ec.Error(ctx, ec.Recover(ctx, r))
  6888  					}
  6889  				}()
  6890  				res = ec._Query_ptrToSliceContainer(ctx, field)
  6891  				if res == graphql.Null {
  6892  					atomic.AddUint32(&invalids, 1)
  6893  				}
  6894  				return res
  6895  			}
  6896  
  6897  			rrm := func(ctx context.Context) graphql.Marshaler {
  6898  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6899  			}
  6900  
  6901  			out.Concurrently(i, func() graphql.Marshaler {
  6902  				return rrm(innerCtx)
  6903  			})
  6904  		case "infinity":
  6905  			field := field
  6906  
  6907  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6908  				defer func() {
  6909  					if r := recover(); r != nil {
  6910  						ec.Error(ctx, ec.Recover(ctx, r))
  6911  					}
  6912  				}()
  6913  				res = ec._Query_infinity(ctx, field)
  6914  				if res == graphql.Null {
  6915  					atomic.AddUint32(&invalids, 1)
  6916  				}
  6917  				return res
  6918  			}
  6919  
  6920  			rrm := func(ctx context.Context) graphql.Marshaler {
  6921  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6922  			}
  6923  
  6924  			out.Concurrently(i, func() graphql.Marshaler {
  6925  				return rrm(innerCtx)
  6926  			})
  6927  		case "stringFromContextInterface":
  6928  			field := field
  6929  
  6930  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6931  				defer func() {
  6932  					if r := recover(); r != nil {
  6933  						ec.Error(ctx, ec.Recover(ctx, r))
  6934  					}
  6935  				}()
  6936  				res = ec._Query_stringFromContextInterface(ctx, field)
  6937  				if res == graphql.Null {
  6938  					atomic.AddUint32(&invalids, 1)
  6939  				}
  6940  				return res
  6941  			}
  6942  
  6943  			rrm := func(ctx context.Context) graphql.Marshaler {
  6944  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6945  			}
  6946  
  6947  			out.Concurrently(i, func() graphql.Marshaler {
  6948  				return rrm(innerCtx)
  6949  			})
  6950  		case "stringFromContextFunction":
  6951  			field := field
  6952  
  6953  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6954  				defer func() {
  6955  					if r := recover(); r != nil {
  6956  						ec.Error(ctx, ec.Recover(ctx, r))
  6957  					}
  6958  				}()
  6959  				res = ec._Query_stringFromContextFunction(ctx, field)
  6960  				if res == graphql.Null {
  6961  					atomic.AddUint32(&invalids, 1)
  6962  				}
  6963  				return res
  6964  			}
  6965  
  6966  			rrm := func(ctx context.Context) graphql.Marshaler {
  6967  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6968  			}
  6969  
  6970  			out.Concurrently(i, func() graphql.Marshaler {
  6971  				return rrm(innerCtx)
  6972  			})
  6973  		case "defaultScalar":
  6974  			field := field
  6975  
  6976  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  6977  				defer func() {
  6978  					if r := recover(); r != nil {
  6979  						ec.Error(ctx, ec.Recover(ctx, r))
  6980  					}
  6981  				}()
  6982  				res = ec._Query_defaultScalar(ctx, field)
  6983  				if res == graphql.Null {
  6984  					atomic.AddUint32(&invalids, 1)
  6985  				}
  6986  				return res
  6987  			}
  6988  
  6989  			rrm := func(ctx context.Context) graphql.Marshaler {
  6990  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  6991  			}
  6992  
  6993  			out.Concurrently(i, func() graphql.Marshaler {
  6994  				return rrm(innerCtx)
  6995  			})
  6996  		case "slices":
  6997  			field := field
  6998  
  6999  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7000  				defer func() {
  7001  					if r := recover(); r != nil {
  7002  						ec.Error(ctx, ec.Recover(ctx, r))
  7003  					}
  7004  				}()
  7005  				res = ec._Query_slices(ctx, field)
  7006  				return res
  7007  			}
  7008  
  7009  			rrm := func(ctx context.Context) graphql.Marshaler {
  7010  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7011  			}
  7012  
  7013  			out.Concurrently(i, func() graphql.Marshaler {
  7014  				return rrm(innerCtx)
  7015  			})
  7016  		case "scalarSlice":
  7017  			field := field
  7018  
  7019  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7020  				defer func() {
  7021  					if r := recover(); r != nil {
  7022  						ec.Error(ctx, ec.Recover(ctx, r))
  7023  					}
  7024  				}()
  7025  				res = ec._Query_scalarSlice(ctx, field)
  7026  				if res == graphql.Null {
  7027  					atomic.AddUint32(&invalids, 1)
  7028  				}
  7029  				return res
  7030  			}
  7031  
  7032  			rrm := func(ctx context.Context) graphql.Marshaler {
  7033  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7034  			}
  7035  
  7036  			out.Concurrently(i, func() graphql.Marshaler {
  7037  				return rrm(innerCtx)
  7038  			})
  7039  		case "fallback":
  7040  			field := field
  7041  
  7042  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7043  				defer func() {
  7044  					if r := recover(); r != nil {
  7045  						ec.Error(ctx, ec.Recover(ctx, r))
  7046  					}
  7047  				}()
  7048  				res = ec._Query_fallback(ctx, field)
  7049  				if res == graphql.Null {
  7050  					atomic.AddUint32(&invalids, 1)
  7051  				}
  7052  				return res
  7053  			}
  7054  
  7055  			rrm := func(ctx context.Context) graphql.Marshaler {
  7056  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7057  			}
  7058  
  7059  			out.Concurrently(i, func() graphql.Marshaler {
  7060  				return rrm(innerCtx)
  7061  			})
  7062  		case "optionalUnion":
  7063  			field := field
  7064  
  7065  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7066  				defer func() {
  7067  					if r := recover(); r != nil {
  7068  						ec.Error(ctx, ec.Recover(ctx, r))
  7069  					}
  7070  				}()
  7071  				res = ec._Query_optionalUnion(ctx, field)
  7072  				return res
  7073  			}
  7074  
  7075  			rrm := func(ctx context.Context) graphql.Marshaler {
  7076  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7077  			}
  7078  
  7079  			out.Concurrently(i, func() graphql.Marshaler {
  7080  				return rrm(innerCtx)
  7081  			})
  7082  		case "vOkCaseValue":
  7083  			field := field
  7084  
  7085  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7086  				defer func() {
  7087  					if r := recover(); r != nil {
  7088  						ec.Error(ctx, ec.Recover(ctx, r))
  7089  					}
  7090  				}()
  7091  				res = ec._Query_vOkCaseValue(ctx, field)
  7092  				return res
  7093  			}
  7094  
  7095  			rrm := func(ctx context.Context) graphql.Marshaler {
  7096  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7097  			}
  7098  
  7099  			out.Concurrently(i, func() graphql.Marshaler {
  7100  				return rrm(innerCtx)
  7101  			})
  7102  		case "vOkCaseNil":
  7103  			field := field
  7104  
  7105  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7106  				defer func() {
  7107  					if r := recover(); r != nil {
  7108  						ec.Error(ctx, ec.Recover(ctx, r))
  7109  					}
  7110  				}()
  7111  				res = ec._Query_vOkCaseNil(ctx, field)
  7112  				return res
  7113  			}
  7114  
  7115  			rrm := func(ctx context.Context) graphql.Marshaler {
  7116  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7117  			}
  7118  
  7119  			out.Concurrently(i, func() graphql.Marshaler {
  7120  				return rrm(innerCtx)
  7121  			})
  7122  		case "validType":
  7123  			field := field
  7124  
  7125  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7126  				defer func() {
  7127  					if r := recover(); r != nil {
  7128  						ec.Error(ctx, ec.Recover(ctx, r))
  7129  					}
  7130  				}()
  7131  				res = ec._Query_validType(ctx, field)
  7132  				return res
  7133  			}
  7134  
  7135  			rrm := func(ctx context.Context) graphql.Marshaler {
  7136  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7137  			}
  7138  
  7139  			out.Concurrently(i, func() graphql.Marshaler {
  7140  				return rrm(innerCtx)
  7141  			})
  7142  		case "variadicModel":
  7143  			field := field
  7144  
  7145  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7146  				defer func() {
  7147  					if r := recover(); r != nil {
  7148  						ec.Error(ctx, ec.Recover(ctx, r))
  7149  					}
  7150  				}()
  7151  				res = ec._Query_variadicModel(ctx, field)
  7152  				return res
  7153  			}
  7154  
  7155  			rrm := func(ctx context.Context) graphql.Marshaler {
  7156  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7157  			}
  7158  
  7159  			out.Concurrently(i, func() graphql.Marshaler {
  7160  				return rrm(innerCtx)
  7161  			})
  7162  		case "wrappedStruct":
  7163  			field := field
  7164  
  7165  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7166  				defer func() {
  7167  					if r := recover(); r != nil {
  7168  						ec.Error(ctx, ec.Recover(ctx, r))
  7169  					}
  7170  				}()
  7171  				res = ec._Query_wrappedStruct(ctx, field)
  7172  				if res == graphql.Null {
  7173  					atomic.AddUint32(&invalids, 1)
  7174  				}
  7175  				return res
  7176  			}
  7177  
  7178  			rrm := func(ctx context.Context) graphql.Marshaler {
  7179  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7180  			}
  7181  
  7182  			out.Concurrently(i, func() graphql.Marshaler {
  7183  				return rrm(innerCtx)
  7184  			})
  7185  		case "wrappedScalar":
  7186  			field := field
  7187  
  7188  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7189  				defer func() {
  7190  					if r := recover(); r != nil {
  7191  						ec.Error(ctx, ec.Recover(ctx, r))
  7192  					}
  7193  				}()
  7194  				res = ec._Query_wrappedScalar(ctx, field)
  7195  				if res == graphql.Null {
  7196  					atomic.AddUint32(&invalids, 1)
  7197  				}
  7198  				return res
  7199  			}
  7200  
  7201  			rrm := func(ctx context.Context) graphql.Marshaler {
  7202  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7203  			}
  7204  
  7205  			out.Concurrently(i, func() graphql.Marshaler {
  7206  				return rrm(innerCtx)
  7207  			})
  7208  		case "wrappedMap":
  7209  			field := field
  7210  
  7211  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7212  				defer func() {
  7213  					if r := recover(); r != nil {
  7214  						ec.Error(ctx, ec.Recover(ctx, r))
  7215  					}
  7216  				}()
  7217  				res = ec._Query_wrappedMap(ctx, field)
  7218  				if res == graphql.Null {
  7219  					atomic.AddUint32(&invalids, 1)
  7220  				}
  7221  				return res
  7222  			}
  7223  
  7224  			rrm := func(ctx context.Context) graphql.Marshaler {
  7225  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7226  			}
  7227  
  7228  			out.Concurrently(i, func() graphql.Marshaler {
  7229  				return rrm(innerCtx)
  7230  			})
  7231  		case "wrappedSlice":
  7232  			field := field
  7233  
  7234  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7235  				defer func() {
  7236  					if r := recover(); r != nil {
  7237  						ec.Error(ctx, ec.Recover(ctx, r))
  7238  					}
  7239  				}()
  7240  				res = ec._Query_wrappedSlice(ctx, field)
  7241  				if res == graphql.Null {
  7242  					atomic.AddUint32(&invalids, 1)
  7243  				}
  7244  				return res
  7245  			}
  7246  
  7247  			rrm := func(ctx context.Context) graphql.Marshaler {
  7248  				return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
  7249  			}
  7250  
  7251  			out.Concurrently(i, func() graphql.Marshaler {
  7252  				return rrm(innerCtx)
  7253  			})
  7254  		case "__type":
  7255  
  7256  			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
  7257  				return ec._Query___type(ctx, field)
  7258  			})
  7259  
  7260  		case "__schema":
  7261  
  7262  			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
  7263  				return ec._Query___schema(ctx, field)
  7264  			})
  7265  
  7266  		default:
  7267  			panic("unknown field " + strconv.Quote(field.Name))
  7268  		}
  7269  	}
  7270  	out.Dispatch()
  7271  	if invalids > 0 {
  7272  		return graphql.Null
  7273  	}
  7274  	return out
  7275  }
  7276  
  7277  var subscriptionImplementors = []string{"Subscription"}
  7278  
  7279  func (ec *executionContext) _Subscription(ctx context.Context, sel ast.SelectionSet) func(ctx context.Context) graphql.Marshaler {
  7280  	fields := graphql.CollectFields(ec.OperationContext, sel, subscriptionImplementors)
  7281  	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
  7282  		Object: "Subscription",
  7283  	})
  7284  	if len(fields) != 1 {
  7285  		ec.Errorf(ctx, "must subscribe to exactly one stream")
  7286  		return nil
  7287  	}
  7288  
  7289  	switch fields[0].Name {
  7290  	case "updated":
  7291  		return ec._Subscription_updated(ctx, fields[0])
  7292  	case "initPayload":
  7293  		return ec._Subscription_initPayload(ctx, fields[0])
  7294  	case "directiveArg":
  7295  		return ec._Subscription_directiveArg(ctx, fields[0])
  7296  	case "directiveNullableArg":
  7297  		return ec._Subscription_directiveNullableArg(ctx, fields[0])
  7298  	case "directiveDouble":
  7299  		return ec._Subscription_directiveDouble(ctx, fields[0])
  7300  	case "directiveUnimplemented":
  7301  		return ec._Subscription_directiveUnimplemented(ctx, fields[0])
  7302  	case "issue896b":
  7303  		return ec._Subscription_issue896b(ctx, fields[0])
  7304  	case "errorRequired":
  7305  		return ec._Subscription_errorRequired(ctx, fields[0])
  7306  	default:
  7307  		panic("unknown field " + strconv.Quote(fields[0].Name))
  7308  	}
  7309  }
  7310  
  7311  var userImplementors = []string{"User"}
  7312  
  7313  func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler {
  7314  	fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors)
  7315  	out := graphql.NewFieldSet(fields)
  7316  	var invalids uint32
  7317  	for i, field := range fields {
  7318  		switch field.Name {
  7319  		case "__typename":
  7320  			out.Values[i] = graphql.MarshalString("User")
  7321  		case "id":
  7322  
  7323  			out.Values[i] = ec._User_id(ctx, field, obj)
  7324  
  7325  			if out.Values[i] == graphql.Null {
  7326  				atomic.AddUint32(&invalids, 1)
  7327  			}
  7328  		case "friends":
  7329  			field := field
  7330  
  7331  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7332  				defer func() {
  7333  					if r := recover(); r != nil {
  7334  						ec.Error(ctx, ec.Recover(ctx, r))
  7335  					}
  7336  				}()
  7337  				res = ec._User_friends(ctx, field, obj)
  7338  				if res == graphql.Null {
  7339  					atomic.AddUint32(&invalids, 1)
  7340  				}
  7341  				return res
  7342  			}
  7343  
  7344  			out.Concurrently(i, func() graphql.Marshaler {
  7345  				return innerFunc(ctx)
  7346  
  7347  			})
  7348  		case "created":
  7349  
  7350  			out.Values[i] = ec._User_created(ctx, field, obj)
  7351  
  7352  			if out.Values[i] == graphql.Null {
  7353  				atomic.AddUint32(&invalids, 1)
  7354  			}
  7355  		case "updated":
  7356  
  7357  			out.Values[i] = ec._User_updated(ctx, field, obj)
  7358  
  7359  		case "pets":
  7360  			field := field
  7361  
  7362  			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
  7363  				defer func() {
  7364  					if r := recover(); r != nil {
  7365  						ec.Error(ctx, ec.Recover(ctx, r))
  7366  					}
  7367  				}()
  7368  				res = ec._User_pets(ctx, field, obj)
  7369  				return res
  7370  			}
  7371  
  7372  			out.Concurrently(i, func() graphql.Marshaler {
  7373  				return innerFunc(ctx)
  7374  
  7375  			})
  7376  		default:
  7377  			panic("unknown field " + strconv.Quote(field.Name))
  7378  		}
  7379  	}
  7380  	out.Dispatch()
  7381  	if invalids > 0 {
  7382  		return graphql.Null
  7383  	}
  7384  	return out
  7385  }
  7386  
  7387  // endregion **************************** object.gotpl ****************************
  7388  
  7389  // region    ***************************** type.gotpl *****************************
  7390  
  7391  func (ec *executionContext) unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx context.Context, v interface{}) (InnerInput, error) {
  7392  	res, err := ec.unmarshalInputInnerInput(ctx, v)
  7393  	return res, graphql.ErrorOnPath(ctx, err)
  7394  }
  7395  
  7396  func (ec *executionContext) unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx context.Context, v interface{}) (*InnerInput, error) {
  7397  	res, err := ec.unmarshalInputInnerInput(ctx, v)
  7398  	return &res, graphql.ErrorOnPath(ctx, err)
  7399  }
  7400  
  7401  func (ec *executionContext) marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerObject(ctx context.Context, sel ast.SelectionSet, v *InnerObject) graphql.Marshaler {
  7402  	if v == nil {
  7403  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7404  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7405  		}
  7406  		return graphql.Null
  7407  	}
  7408  	return ec._InnerObject(ctx, sel, v)
  7409  }
  7410  
  7411  func (ec *executionContext) marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPet(ctx context.Context, sel ast.SelectionSet, v *Pet) graphql.Marshaler {
  7412  	if v == nil {
  7413  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7414  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7415  		}
  7416  		return graphql.Null
  7417  	}
  7418  	return ec._Pet(ctx, sel, v)
  7419  }
  7420  
  7421  func (ec *executionContext) unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx context.Context, v interface{}) (RecursiveInputSlice, error) {
  7422  	res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v)
  7423  	return res, graphql.ErrorOnPath(ctx, err)
  7424  }
  7425  
  7426  func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
  7427  	res, err := graphql.UnmarshalTime(v)
  7428  	return res, graphql.ErrorOnPath(ctx, err)
  7429  }
  7430  
  7431  func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
  7432  	res := graphql.MarshalTime(v)
  7433  	if res == graphql.Null {
  7434  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7435  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7436  		}
  7437  	}
  7438  	return res
  7439  }
  7440  
  7441  func (ec *executionContext) unmarshalNUUID2string(ctx context.Context, v interface{}) (string, error) {
  7442  	res, err := graphql.UnmarshalString(v)
  7443  	return res, graphql.ErrorOnPath(ctx, err)
  7444  }
  7445  
  7446  func (ec *executionContext) marshalNUUID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
  7447  	res := graphql.MarshalString(v)
  7448  	if res == graphql.Null {
  7449  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7450  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7451  		}
  7452  	}
  7453  	return res
  7454  }
  7455  
  7456  func (ec *executionContext) marshalNUser2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler {
  7457  	return ec._User(ctx, sel, &v)
  7458  }
  7459  
  7460  func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUserᚄ(ctx context.Context, sel ast.SelectionSet, v []*User) graphql.Marshaler {
  7461  	ret := make(graphql.Array, len(v))
  7462  	var wg sync.WaitGroup
  7463  	isLen1 := len(v) == 1
  7464  	if !isLen1 {
  7465  		wg.Add(len(v))
  7466  	}
  7467  	for i := range v {
  7468  		i := i
  7469  		fc := &graphql.FieldContext{
  7470  			Index:  &i,
  7471  			Result: &v[i],
  7472  		}
  7473  		ctx := graphql.WithFieldContext(ctx, fc)
  7474  		f := func(i int) {
  7475  			defer func() {
  7476  				if r := recover(); r != nil {
  7477  					ec.Error(ctx, ec.Recover(ctx, r))
  7478  					ret = nil
  7479  				}
  7480  			}()
  7481  			if !isLen1 {
  7482  				defer wg.Done()
  7483  			}
  7484  			ret[i] = ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx, sel, v[i])
  7485  		}
  7486  		if isLen1 {
  7487  			f(i)
  7488  		} else {
  7489  			go f(i)
  7490  		}
  7491  
  7492  	}
  7493  	wg.Wait()
  7494  
  7495  	for _, e := range ret {
  7496  		if e == graphql.Null {
  7497  			return graphql.Null
  7498  		}
  7499  	}
  7500  
  7501  	return ret
  7502  }
  7503  
  7504  func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
  7505  	if v == nil {
  7506  		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
  7507  			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
  7508  		}
  7509  		return graphql.Null
  7510  	}
  7511  	return ec._User(ctx, sel, v)
  7512  }
  7513  
  7514  func (ec *executionContext) marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAutobind(ctx context.Context, sel ast.SelectionSet, v *Autobind) graphql.Marshaler {
  7515  	if v == nil {
  7516  		return graphql.Null
  7517  	}
  7518  	return ec._Autobind(ctx, sel, v)
  7519  }
  7520  
  7521  func (ec *executionContext) unmarshalOChanges2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
  7522  	if v == nil {
  7523  		return nil, nil
  7524  	}
  7525  	return v.(map[string]interface{}), nil
  7526  }
  7527  
  7528  func (ec *executionContext) marshalOInvalidIdentifier2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋinvalidᚑpackagenameᚐInvalidIdentifier(ctx context.Context, sel ast.SelectionSet, v *invalid_packagename.InvalidIdentifier) graphql.Marshaler {
  7529  	if v == nil {
  7530  		return graphql.Null
  7531  	}
  7532  	return ec._InvalidIdentifier(ctx, sel, v)
  7533  }
  7534  
  7535  func (ec *executionContext) marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋintrospectionᚐIt(ctx context.Context, sel ast.SelectionSet, v *introspection1.It) graphql.Marshaler {
  7536  	if v == nil {
  7537  		return graphql.Null
  7538  	}
  7539  	return ec._It(ctx, sel, v)
  7540  }
  7541  
  7542  func (ec *executionContext) marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐModelMethods(ctx context.Context, sel ast.SelectionSet, v *ModelMethods) graphql.Marshaler {
  7543  	if v == nil {
  7544  		return graphql.Null
  7545  	}
  7546  	return ec._ModelMethods(ctx, sel, v)
  7547  }
  7548  
  7549  func (ec *executionContext) unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) ([][]*OuterInput, error) {
  7550  	if v == nil {
  7551  		return nil, nil
  7552  	}
  7553  	var vSlice []interface{}
  7554  	if v != nil {
  7555  		vSlice = graphql.CoerceList(v)
  7556  	}
  7557  	var err error
  7558  	res := make([][]*OuterInput, len(vSlice))
  7559  	for i := range vSlice {
  7560  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7561  		res[i], err = ec.unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, vSlice[i])
  7562  		if err != nil {
  7563  			return nil, err
  7564  		}
  7565  	}
  7566  	return res, nil
  7567  }
  7568  
  7569  func (ec *executionContext) unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) ([]*OuterInput, error) {
  7570  	if v == nil {
  7571  		return nil, nil
  7572  	}
  7573  	var vSlice []interface{}
  7574  	if v != nil {
  7575  		vSlice = graphql.CoerceList(v)
  7576  	}
  7577  	var err error
  7578  	res := make([]*OuterInput, len(vSlice))
  7579  	for i := range vSlice {
  7580  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7581  		res[i], err = ec.unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, vSlice[i])
  7582  		if err != nil {
  7583  			return nil, err
  7584  		}
  7585  	}
  7586  	return res, nil
  7587  }
  7588  
  7589  func (ec *executionContext) unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) (*OuterInput, error) {
  7590  	if v == nil {
  7591  		return nil, nil
  7592  	}
  7593  	res, err := ec.unmarshalInputOuterInput(ctx, v)
  7594  	return &res, graphql.ErrorOnPath(ctx, err)
  7595  }
  7596  
  7597  func (ec *executionContext) marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v [][]*OuterObject) graphql.Marshaler {
  7598  	if v == nil {
  7599  		return graphql.Null
  7600  	}
  7601  	ret := make(graphql.Array, len(v))
  7602  	var wg sync.WaitGroup
  7603  	isLen1 := len(v) == 1
  7604  	if !isLen1 {
  7605  		wg.Add(len(v))
  7606  	}
  7607  	for i := range v {
  7608  		i := i
  7609  		fc := &graphql.FieldContext{
  7610  			Index:  &i,
  7611  			Result: &v[i],
  7612  		}
  7613  		ctx := graphql.WithFieldContext(ctx, fc)
  7614  		f := func(i int) {
  7615  			defer func() {
  7616  				if r := recover(); r != nil {
  7617  					ec.Error(ctx, ec.Recover(ctx, r))
  7618  					ret = nil
  7619  				}
  7620  			}()
  7621  			if !isLen1 {
  7622  				defer wg.Done()
  7623  			}
  7624  			ret[i] = ec.marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, sel, v[i])
  7625  		}
  7626  		if isLen1 {
  7627  			f(i)
  7628  		} else {
  7629  			go f(i)
  7630  		}
  7631  
  7632  	}
  7633  	wg.Wait()
  7634  
  7635  	return ret
  7636  }
  7637  
  7638  func (ec *executionContext) marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v []*OuterObject) graphql.Marshaler {
  7639  	if v == nil {
  7640  		return graphql.Null
  7641  	}
  7642  	ret := make(graphql.Array, len(v))
  7643  	var wg sync.WaitGroup
  7644  	isLen1 := len(v) == 1
  7645  	if !isLen1 {
  7646  		wg.Add(len(v))
  7647  	}
  7648  	for i := range v {
  7649  		i := i
  7650  		fc := &graphql.FieldContext{
  7651  			Index:  &i,
  7652  			Result: &v[i],
  7653  		}
  7654  		ctx := graphql.WithFieldContext(ctx, fc)
  7655  		f := func(i int) {
  7656  			defer func() {
  7657  				if r := recover(); r != nil {
  7658  					ec.Error(ctx, ec.Recover(ctx, r))
  7659  					ret = nil
  7660  				}
  7661  			}()
  7662  			if !isLen1 {
  7663  				defer wg.Done()
  7664  			}
  7665  			ret[i] = ec.marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, sel, v[i])
  7666  		}
  7667  		if isLen1 {
  7668  			f(i)
  7669  		} else {
  7670  			go f(i)
  7671  		}
  7672  
  7673  	}
  7674  	wg.Wait()
  7675  
  7676  	return ret
  7677  }
  7678  
  7679  func (ec *executionContext) marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v *OuterObject) graphql.Marshaler {
  7680  	if v == nil {
  7681  		return graphql.Null
  7682  	}
  7683  	return ec._OuterObject(ctx, sel, v)
  7684  }
  7685  
  7686  func (ec *executionContext) marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx context.Context, sel ast.SelectionSet, v []*Pet) graphql.Marshaler {
  7687  	if v == nil {
  7688  		return graphql.Null
  7689  	}
  7690  	ret := make(graphql.Array, len(v))
  7691  	var wg sync.WaitGroup
  7692  	isLen1 := len(v) == 1
  7693  	if !isLen1 {
  7694  		wg.Add(len(v))
  7695  	}
  7696  	for i := range v {
  7697  		i := i
  7698  		fc := &graphql.FieldContext{
  7699  			Index:  &i,
  7700  			Result: &v[i],
  7701  		}
  7702  		ctx := graphql.WithFieldContext(ctx, fc)
  7703  		f := func(i int) {
  7704  			defer func() {
  7705  				if r := recover(); r != nil {
  7706  					ec.Error(ctx, ec.Recover(ctx, r))
  7707  					ret = nil
  7708  				}
  7709  			}()
  7710  			if !isLen1 {
  7711  				defer wg.Done()
  7712  			}
  7713  			ret[i] = ec.marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPet(ctx, sel, v[i])
  7714  		}
  7715  		if isLen1 {
  7716  			f(i)
  7717  		} else {
  7718  			go f(i)
  7719  		}
  7720  
  7721  	}
  7722  	wg.Wait()
  7723  
  7724  	for _, e := range ret {
  7725  		if e == graphql.Null {
  7726  			return graphql.Null
  7727  		}
  7728  	}
  7729  
  7730  	return ret
  7731  }
  7732  
  7733  func (ec *executionContext) unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSliceᚄ(ctx context.Context, v interface{}) ([]RecursiveInputSlice, error) {
  7734  	if v == nil {
  7735  		return nil, nil
  7736  	}
  7737  	var vSlice []interface{}
  7738  	if v != nil {
  7739  		vSlice = graphql.CoerceList(v)
  7740  	}
  7741  	var err error
  7742  	res := make([]RecursiveInputSlice, len(vSlice))
  7743  	for i := range vSlice {
  7744  		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
  7745  		res[i], err = ec.unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx, vSlice[i])
  7746  		if err != nil {
  7747  			return nil, err
  7748  		}
  7749  	}
  7750  	return res, nil
  7751  }
  7752  
  7753  func (ec *executionContext) unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx context.Context, v interface{}) (*RecursiveInputSlice, error) {
  7754  	if v == nil {
  7755  		return nil, nil
  7756  	}
  7757  	res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v)
  7758  	return &res, graphql.ErrorOnPath(ctx, err)
  7759  }
  7760  
  7761  func (ec *executionContext) unmarshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐThirdParty(ctx context.Context, v interface{}) (*ThirdParty, error) {
  7762  	if v == nil {
  7763  		return nil, nil
  7764  	}
  7765  	res, err := UnmarshalThirdParty(v)
  7766  	return &res, graphql.ErrorOnPath(ctx, err)
  7767  }
  7768  
  7769  func (ec *executionContext) marshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐThirdParty(ctx context.Context, sel ast.SelectionSet, v *ThirdParty) graphql.Marshaler {
  7770  	if v == nil {
  7771  		return graphql.Null
  7772  	}
  7773  	res := MarshalThirdParty(*v)
  7774  	return res
  7775  }
  7776  
  7777  func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
  7778  	if v == nil {
  7779  		return nil, nil
  7780  	}
  7781  	res, err := graphql.UnmarshalTime(v)
  7782  	return &res, graphql.ErrorOnPath(ctx, err)
  7783  }
  7784  
  7785  func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
  7786  	if v == nil {
  7787  		return graphql.Null
  7788  	}
  7789  	res := graphql.MarshalTime(*v)
  7790  	return res
  7791  }
  7792  
  7793  // endregion ***************************** type.gotpl *****************************