Handle colliding fields in complexity root gracefully

codegen/complexity.go

@@ -0,0 +1,11 @@
+package codegen
+
+func (o *Object) UniqueFields() map[string]*Field {
+	m := map[string]*Field{}
+
+	for _, f := range o.Fields {
+		m[f.GoFieldName] = f
+	}
+
+	return m
+}

codegen/data.go

@@ -20,6 +20,7 @@ type Data struct {
 	Inputs          Objects
 	Interfaces      map[string]*Interface
 	ReferencedTypes map[string]*config.TypeReference
+	ComplexityRoots map[string]*Object
 
 	QueryRoot        *Object
 	MutationRoot     *Object

codegen/generated!.gotpl

@@ -46,7 +46,7 @@ type ComplexityRoot struct {
 {{ range $object := .Objects }}
 	{{ if not $object.IsReserved -}}
 		{{ $object.Name|go }} struct {
-		{{ range $field := $object.Fields -}}
+		{{ range $field := $object.UniqueFields -}}
 			{{ if not $field.IsReserved -}}
 				{{ $field.GoFieldName }} {{ $field.ComplexitySignature }}
 			{{ end }}
@@ -84,7 +84,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 	switch typeName + "." + field {
 	{{ range $object := .Objects }}
 		{{ if not $object.IsReserved }}
-			{{ range $field := $object.Fields }}
+			{{ range $field := $object.UniqueFields }}
 				{{ if not $field.IsReserved }}
 					case "{{$object.Name}}.{{$field.GoFieldName}}":
 						if e.complexity.{{$object.Name|go}}.{{$field.GoFieldName}} == nil {

codegen/testserver/complexity.graphql

@@ -0,0 +1,11 @@
+extend type Query {
+    overlapping: OverlappingFields
+}
+
+type OverlappingFields {
+  oneFoo: Int!
+  twoFoo: Int!
+  oldFoo: Int!
+  newFoo: Int!
+  new_foo: Int!
+}

codegen/testserver/complexity_test.go

@@ -0,0 +1,46 @@
+package testserver
+
+import (
+	"context"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/99designs/gqlgen/client"
+	"github.com/99designs/gqlgen/handler"
+	"github.com/stretchr/testify/require"
+)
+
+func TestComplexityCollisions(t *testing.T) {
+	resolvers := &Stub{}
+
+	srv := httptest.NewServer(handler.GraphQL(NewExecutableSchema(Config{Resolvers: resolvers})))
+	c := client.New(srv.URL)
+
+	resolvers.QueryResolver.Overlapping = func(ctx context.Context) (fields *OverlappingFields, e error) {
+		return &OverlappingFields{
+			Foo:    2,
+			NewFoo: 3,
+		}, nil
+	}
+
+	resolvers.OverlappingFieldsResolver.OldFoo = func(ctx context.Context, obj *OverlappingFields) (i int, e error) {
+		return obj.Foo, nil
+	}
+
+	var resp struct {
+		Overlapping struct {
+			OneFoo  int `json:"oneFoo"`
+			TwoFoo  int `json:"twoFoo"`
+			OldFoo  int `json:"oldFoo"`
+			NewFoo  int `json:"newFoo"`
+			New_foo int `json:"new_foo"`
+		}
+	}
+	c.MustPost(`query { overlapping { oneFoo, twoFoo, oldFoo, newFoo, new_foo } }`, &resp)
+	require.Equal(t, 2, resp.Overlapping.OneFoo)
+	require.Equal(t, 2, resp.Overlapping.TwoFoo)
+	require.Equal(t, 2, resp.Overlapping.OldFoo)
+	require.Equal(t, 3, resp.Overlapping.NewFoo)
+	require.Equal(t, 3, resp.Overlapping.New_foo)
+
+}