check for valuer receivers before generating type switch

codegen/build.go

@@ -41,7 +41,7 @@ func Models(schema *schema.Schema, userTypes map[string]string, destDir string)
 
 	bindTypes(imports, namedTypes, prog)
 
-	models := buildModels(namedTypes, schema)
+	models := buildModels(namedTypes, schema, prog)
 	return &ModelBuild{
 		PackageName: filepath.Base(destDir),
 		Models:      models,
@@ -67,7 +67,7 @@ func Bind(schema *schema.Schema, userTypes map[string]string, destDir string) (*
 	b := &Build{
 		PackageName: filepath.Base(destDir),
 		Objects:     objects,
-		Interfaces:  buildInterfaces(namedTypes, schema),
+		Interfaces:  buildInterfaces(namedTypes, schema, prog),
 		Inputs:      inputs,
 		Imports:     imports,
 	}

codegen/interface.go

@@ -3,5 +3,11 @@ package codegen
 type Interface struct {
 	*NamedType
 
-	Implementors []*NamedType
+	Implementors []InterfaceImplementor
+}
+
+type InterfaceImplementor struct {
+	ValueReceiver bool
+
+	*NamedType
 }

codegen/interface_build.go

@@ -2,18 +2,21 @@ package codegen
 
 import (
 	"fmt"
+	"go/types"
+	"os"
 	"sort"
 	"strings"
 
 	"github.com/vektah/gqlgen/neelance/schema"
+	"golang.org/x/tools/go/loader"
 )
 
-func buildInterfaces(types NamedTypes, s *schema.Schema) []*Interface {
+func buildInterfaces(types NamedTypes, s *schema.Schema, prog *loader.Program) []*Interface {
 	var interfaces []*Interface
 	for _, typ := range s.Types {
 		switch typ := typ.(type) {
 		case *schema.Union, *schema.Interface:
-			interfaces = append(interfaces, buildInterface(types, typ))
+			interfaces = append(interfaces, buildInterface(types, typ, prog))
 		default:
 			continue
 		}
@@ -26,14 +29,15 @@ func buildInterfaces(types NamedTypes, s *schema.Schema) []*Interface {
 	return interfaces
 }
 
-func buildInterface(types NamedTypes, typ schema.NamedType) *Interface {
+func buildInterface(types NamedTypes, typ schema.NamedType, prog *loader.Program) *Interface {
 	switch typ := typ.(type) {
 
 	case *schema.Union:
 		i := &Interface{NamedType: types[typ.TypeName()]}
 
 		for _, implementor := range typ.PossibleTypes {
-			i.Implementors = append(i.Implementors, types[implementor.TypeName()])
+			t := types[implementor.TypeName()]
+			i.Implementors = append(i.Implementors, InterfaceImplementor{NamedType: t, ValueReceiver: true})
 		}
 
 		return i
@@ -42,11 +46,42 @@ func buildInterface(types NamedTypes, typ schema.NamedType) *Interface {
 		i := &Interface{NamedType: types[typ.TypeName()]}
 
 		for _, implementor := range typ.PossibleTypes {
-			i.Implementors = append(i.Implementors, types[implementor.TypeName()])
+			t := types[implementor.TypeName()]
+
+			i.Implementors = append(i.Implementors, InterfaceImplementor{
+				NamedType:     t,
+				ValueReceiver: isValueReceiver(types[typ.Name], t, prog),
+			})
 		}
 
 		return i
 	default:
 		panic(fmt.Errorf("unknown interface %#v", typ))
 	}
 }
+
+func isValueReceiver(intf *NamedType, implementor *NamedType, prog *loader.Program) bool {
+	interfaceType := findGoInterface(prog, intf.Package, intf.GoType)
+	implementorType := findGoNamedType(prog, implementor.Package, implementor.GoType)
+
+	if interfaceType == nil || implementorType == nil {
+		return true
+	}
+
+	for i := 0; i < interfaceType.NumMethods(); i++ {
+		intfMethod := interfaceType.Method(i)
+
+		implMethod := findMethod(implementorType, intfMethod.Name())
+		if implMethod == nil {
+			fmt.Fprintf(os.Stderr, "missing method %s on %s\n", intfMethod.Name(), implementor.GoType)
+			return false
+		}
+
+		sig := implMethod.Type().(*types.Signature)
+		if _, isPtr := sig.Recv().Type().(*types.Pointer); isPtr {
+			return false
+		}
+	}
+
+	return true
+}

codegen/models_build.go

@@ -5,9 +5,10 @@ import (
 	"strings"
 
 	"github.com/vektah/gqlgen/neelance/schema"
+	"golang.org/x/tools/go/loader"
 )
 
-func buildModels(types NamedTypes, s *schema.Schema) []Model {
+func buildModels(types NamedTypes, s *schema.Schema, prog *loader.Program) []Model {
 	var models []Model
 
 	for _, typ := range s.Types {
@@ -26,7 +27,7 @@ func buildModels(types NamedTypes, s *schema.Schema) []Model {
 			}
 			model = obj2Model(obj)
 		case *schema.Interface, *schema.Union:
-			intf := buildInterface(types, typ)
+			intf := buildInterface(types, typ, prog)
 			if intf.GoType != "" {
 				continue
 			}

codegen/templates/interface.gotpl

@@ -5,12 +5,12 @@ func (ec *executionContext) _{{$interface.GQLType}}(sel []query.Selection, obj *
 	case nil:
 		return graphql.Null
 	{{- range $implementor := $interface.Implementors }}
-	case {{$implementor.FullName}}:
-		return ec._{{$implementor.GQLType}}(sel, &obj)
-
-	case *{{$implementor.FullName}}:
-		return ec._{{$implementor.GQLType}}(sel, obj)
-
+		{{- if $implementor.ValueReceiver }}
+			case {{$implementor.FullName}}:
+				return ec._{{$implementor.GQLType}}(sel, &obj)
+		{{- end}}
+		case *{{$implementor.FullName}}:
+			return ec._{{$implementor.GQLType}}(sel, obj)
 	{{- end }}
 	default:
 		panic(fmt.Errorf("unexpected type %T", obj))

codegen/util.go

@@ -38,6 +38,39 @@ func findGoType(prog *loader.Program, pkgName string, typeName string) (types.Ob
 	return nil, fmt.Errorf("unable to find type %s\n", fullName)
 }
 
+func findGoNamedType(prog *loader.Program, pkgName string, typeName string) *types.Named {
+	def, err := findGoType(prog, pkgName, typeName)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, err.Error())
+	}
+	if def == nil {
+		return nil
+	}
+
+	namedType, ok := def.Type().(*types.Named)
+	if !ok {
+		fmt.Fprintf(os.Stderr, "expected %s to be a named type, instead found %T\n", typeName, def.Type())
+		return nil
+	}
+
+	return namedType
+}
+
+func findGoInterface(prog *loader.Program, pkgName string, typeName string) *types.Interface {
+	namedType := findGoNamedType(prog, pkgName, typeName)
+	if namedType == nil {
+		return nil
+	}
+
+	underlying, ok := namedType.Underlying().(*types.Interface)
+	if !ok {
+		fmt.Fprintf(os.Stderr, "expected %s to be a named interface, instead found %s", typeName, namedType.String())
+		return nil
+	}
+
+	return underlying
+}
+
 func findMethod(typ *types.Named, name string) *types.Func {
 	for i := 0; i < typ.NumMethods(); i++ {
 		method := typ.Method(i)

example/starwars/generated.go

@@ -1512,12 +1512,10 @@ func (ec *executionContext) _Character(sel []query.Selection, obj *Character) gr
 		return graphql.Null
 	case Human:
 		return ec._Human(sel, &obj)
-
 	case *Human:
 		return ec._Human(sel, obj)
 	case Droid:
 		return ec._Droid(sel, &obj)
-
 	case *Droid:
 		return ec._Droid(sel, obj)
 	default:
@@ -1531,17 +1529,14 @@ func (ec *executionContext) _SearchResult(sel []query.Selection, obj *SearchResu
 		return graphql.Null
 	case Human:
 		return ec._Human(sel, &obj)
-
 	case *Human:
 		return ec._Human(sel, obj)
 	case Droid:
 		return ec._Droid(sel, &obj)
-
 	case *Droid:
 		return ec._Droid(sel, obj)
 	case Starship:
 		return ec._Starship(sel, &obj)
-
 	case *Starship:
 		return ec._Starship(sel, obj)
 	default:

test/generated.go

@@ -867,14 +867,8 @@ func (ec *executionContext) _Shape(sel []query.Selection, obj *Shape) graphql.Ma
 	switch obj := (*obj).(type) {
 	case nil:
 		return graphql.Null
-	case Circle:
-		return ec._Circle(sel, &obj)
-
 	case *Circle:
 		return ec._Circle(sel, obj)
-	case Rectangle:
-		return ec._Rectangle(sel, &obj)
-
 	case *Rectangle:
 		return ec._Rectangle(sel, obj)
 	default: