Add support for interfaces, part 4: getter methods

generate/convert.go

@@ -249,6 +249,7 @@ func (g *generator) convertDefinition(
 				GoName:      goName,
 				GoType:      fieldGoType,
 				JSONName:    field.Name,
+				GraphQLName: field.Name,
 				Description: field.Description,
 			}
 		}
@@ -264,19 +265,52 @@ func (g *generator) convertDefinition(
 			GoName:          name,
 			Description:     def.Description,
 			GraphQLName:     def.Name,
+			SharedFields:    make([]*goStructField, 0, len(selectionSet)),
 			Implementations: make([]*goStructType, len(implementationTypes)),
 		}
 		g.typeMap[name] = goType
 
+		// TODO(benkraft): This sorta-duplicates what we'll do in each
+		// implementation when it traverses the fields.  But they'll differ
+		// more once we support fragments; at that point we should figure out
+		// how to refactor.
+		for _, selection := range selectionSet {
+			field, ok := selection.(*ast.Field)
+			if !ok { // fragment/interface, not a shared field
+				continue
+			}
+			_, fieldDirective, err := g.parsePrecedingComment(field, field.GetPosition())
+			if err != nil {
+				return nil, err
+			}
+			fieldOptions := queryOptions.merge(fieldDirective)
+
+			goField, err := g.convertField(namePrefix, field, fieldOptions, queryOptions)
+			if err != nil {
+				return nil, err
+			}
+			goType.SharedFields = append(goType.SharedFields, goField)
+		}
+
 		for i, implDef := range implementationTypes {
-			implName, implNamePrefix := g.typeName(namePrefix, implDef)
+			// Note for shared fields we propagate forward the interface's
+			// name-prefix: that is, the implementations will have fields with
+			// types like
+			//	MyInterfaceMyFieldMyType
+			// not
+			//	MyInterfaceMyImplMyFieldMyType
+			//             ^^^^^^
+			// In particular, this means that the Go type of MyField will be
+			// the same across all the implementations; this is important so
+			// that we can write a method GetMyField() that returns it!
+			implName, _ := g.typeName(namePrefix, implDef)
 			// TODO(benkraft): In principle we should skip generating a Go
 			// field for __typename each of these impl-defs if you didn't
 			// request it (and it was automatically added by
 			// preprocessQueryDocument).  But in practice it doesn't really
 			// hurt, and would be extra work to avoid, so we just leave it.
 			implTyp, err := g.convertDefinition(
-				implName, implNamePrefix, implDef, pos, selectionSet, queryOptions)
+				implName, namePrefix, implDef, pos, selectionSet, queryOptions)
 			if err != nil {
 				return nil, err
 			}
@@ -356,6 +390,7 @@ func (g *generator) convertField(
 		GoName:      goName,
 		GoType:      fieldGoType,
 		JSONName:    field.Alias,
+		GraphQLName: field.Name,
 		Description: field.Definition.Description,
 	}, nil
 }

generate/generate_test.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 
@@ -62,6 +63,15 @@ func TestGenerate(t *testing.T) {
 				t.Fatal(err)
 			}
 
+			if strings.HasPrefix(runtime.Version(), "go1.13") &&
+				(sourceFilename == "InterfaceNesting.graphql" ||
+					sourceFilename == "InterfaceNoFragments.graphql") {
+				// gofmt on 1.13 formats this slightly differently.
+				// TODO(benkraft): Vendor in a specific version of gofmt,
+				// to use for all Go versions.  (Maybe only for tests.)
+				t.Skip("skipping because go1.13 formats them differently")
+			}
+
 			for filename, content := range generated {
 				t.Run(filename, func(t *testing.T) {
 					testutil.Cupaloy.SnapshotT(t, string(content))