Automatically add __typename to fields of interface type

In #52, I added support for interface types, but with the simplifying
restriction (among others) that the user must request the field
`__typename`.  In this commit, I remove this restriction.

The basic idea is simple: we preprocess the query to add `__typename`.
The implementation isn't much more complicated!  Although it required
some new wiring in a few places.

Issue: #8

Test plan: make tesc

Reviewers: marksandstrom, adam, miguel

generate/convert.go

@@ -259,19 +259,6 @@ func (g *generator) convertDefinition(
 			return nil, errorf(pos, "not implemented: %v", def.Kind)
 		}
 
-		// We need to request __typename so we know which concrete type to use.
-		hasTypename := false
-		for _, selection := range selectionSet {
-			field, ok := selection.(*ast.Field)
-			if ok && field.Name == "__typename" {
-				hasTypename = true
-			}
-		}
-		if !hasTypename {
-			// TODO(benkraft): Instead, modify the query to add __typename.
-			return nil, errorf(pos, "union/interface type %s must request __typename", def.Name)
-		}
-
 		implementationTypes := g.schema.GetPossibleTypes(def)
 		goType := &goInterfaceType{
 			GoName:          name,
@@ -283,6 +270,11 @@ func (g *generator) convertDefinition(
 
 		for i, implDef := range implementationTypes {
 			implName, implNamePrefix := 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)
 			if err != nil {

generate/generate.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/vektah/gqlparser/v2/ast"
 	"github.com/vektah/gqlparser/v2/formatter"
+	"github.com/vektah/gqlparser/v2/validator"
 	"golang.org/x/tools/imports"
 )
 
@@ -140,17 +141,88 @@ func (g *generator) getArgument(
 	}, nil
 }
 
+// Preprocess each query to make any changes that genqlient needs.
+//
+// At present, the only change is that we add __typename, if not already
+// requested, to each field of interface type, so we can use the right types
+// when unmarshaling.
+func (g *generator) preprocessQueryDocument(doc *ast.QueryDocument) {
+	var observers validator.Events
+	// We want to ensure that everywhere you ask for some list of fields (a
+	// selection-set) from an interface (or union) type, you ask for its
+	// __typename field.  There are four places we might find a selection-set:
+	// at the toplevel of a query, on a field, or in an inline or named
+	// fragment.  The toplevel of a query must be an object type, so we don't
+	// need to consider that.
+	// TODO(benkraft): Once we support fragments, figure out whether we need to
+	// traverse inline/named fragments here too.
+	observers.OnField(func(_ *validator.Walker, field *ast.Field) {
+		// We are interested in a field from the query like
+		//	field { subField ... }
+		// where the schema looks like
+		//	type ... {       # or interface/union
+		//		field: FieldType    # or [FieldType!]! etc.
+		//	}
+		//	interface FieldType {   # or union
+		//		subField: ...
+		//	}
+		// If FieldType is an interface/union, and none of the subFields is
+		// __typename, we want to change the query to
+		//	field { __typename subField ... }
+
+		fieldType := g.schema.Types[field.Definition.Type.Name()]
+		if fieldType.Kind != ast.Interface && fieldType.Kind != ast.Union {
+			return // a concrete type
+		}
+
+		hasTypename := false
+		for _, selection := range field.SelectionSet {
+			// Check if we already selected __typename. We ignore fragments,
+			// because we want __typename as a toplevel field.
+			subField, ok := selection.(*ast.Field)
+			if ok && subField.Name == "__typename" {
+				hasTypename = true
+			}
+		}
+		if !hasTypename {
+			// Ok, we need to add the field!
+			field.SelectionSet = append(ast.SelectionSet{
+				&ast.Field{
+					Alias: "__typename", Name: "__typename",
+					// Fake definition for the magic field __typename cribbed
+					// from gqlparser's validator/walk.go, equivalent to
+					//	__typename: String
+					// TODO(benkraft): This should in principle be
+					//	__typename: String!
+					// But genqlient doesn't care, so we just match gqlparser.
+					Definition: &ast.FieldDefinition{
+						Name: "__typename",
+						Type: ast.NamedType("String", nil /* pos */),
+					},
+					// Definition of the object that contains this field, i.e.
+					// FieldType.
+					ObjectDefinition: fieldType,
+				},
+			}, field.SelectionSet...)
+		}
+	})
+	validator.Walk(g.schema, doc, &observers)
+}
+
 func (g *generator) addOperation(op *ast.OperationDefinition) error {
 	if op.Name == "" {
 		return errorf(op.Position, "operations must have operation-names")
 	}
 
-	var builder strings.Builder
-	f := formatter.NewFormatter(&builder)
-	f.FormatQueryDocument(&ast.QueryDocument{
+	queryDoc := &ast.QueryDocument{
 		Operations: ast.OperationList{op},
 		// TODO: handle fragments
-	})
+	}
+	g.preprocessQueryDocument(queryDoc)
+
+	var builder strings.Builder
+	f := formatter.NewFormatter(&builder)
+	f.FormatQueryDocument(queryDoc)
 
 	commentLines, directive, err := g.parsePrecedingComment(op, op.Position)
 	if err != nil {

generate/genqlient_directive.go

@@ -146,6 +146,10 @@ func (g *generator) parsePrecedingComment(
 	pos *ast.Position,
 ) (comment string, directive *GenqlientDirective, err error) {
 	directive = new(GenqlientDirective)
+	if pos == nil || pos.Src == nil { // node was added by genqlient itself
+		return "", directive, nil // treated as if there were no comment
+	}
+
 	var commentLines []string
 	sourceLines := strings.Split(pos.Src.Input, "\n")
 	for i := pos.Line - 1; i > 0; i-- {

generate/testdata/queries/InterfaceListField.graphql

@@ -3,7 +3,6 @@ query InterfaceListField {
     id
     name
     children {
-      __typename
       id
       name
     }
@@ -13,7 +12,6 @@ query InterfaceListField {
     id
     name
     children {
-      __typename
       id
       name
     }

generate/testdata/queries/InterfaceListOfListsOfListsField.graphql

@@ -1,5 +1,5 @@
 query InterfaceListOfListOfListsField {
-  listOfListsOfListsOfContent { __typename id name }
+  listOfListsOfListsOfContent { id name }
   # @genqlient(pointer: true)
-  withPointer: listOfListsOfListsOfContent { __typename id name }
+  withPointer: listOfListsOfListsOfContent { id name }
 }

generate/testdata/queries/InterfaceNesting.graphql

@@ -2,13 +2,10 @@ query InterfaceNesting {
   root {
     id
     children {
-      __typename
       id
       parent {
-        __typename
         id
         children {
-          __typename
           id
         }
       }

generate/testdata/queries/InterfaceNoFragments.graphql

@@ -1,6 +1,7 @@
 query InterfaceNoFragmentsQuery {
   root { id name }       # (make sure sibling fields work)
-  randomItem { __typename id name }
+  randomItem { id name }
+  randomItemWithTypeName: randomItem { __typename id name }
   # @genqlient(pointer: true)
-  withPointer: randomItem { __typename id name }
+  withPointer: randomItem { id name }
 }

generate/testdata/snapshots/TestGenerate-InterfaceNesting.graphql-InterfaceNesting.graphql.json

@@ -2,7 +2,7 @@
   "operations": [
     {
       "operationName": "InterfaceNesting",
-      "query": "\nquery InterfaceNesting {\n\troot {\n\t\tid\n\t\tchildren {\n\t\t\t__typename\n\t\t\tid\n\t\t\tparent {\n\t\t\t\t__typename\n\t\t\t\tid\n\t\t\t\tchildren {\n\t\t\t\t\t__typename\n\t\t\t\t\tid\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n",
+      "query": "\nquery InterfaceNesting {\n\troot {\n\t\tid\n\t\tchildren {\n\t\t\t__typename\n\t\t\tid\n\t\t\tparent {\n\t\t\t\tid\n\t\t\t\tchildren {\n\t\t\t\t\t__typename\n\t\t\t\t\tid\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n",
       "sourceLocation": "testdata/queries/InterfaceNesting.graphql"
     }
   ]