Add support for interfaces, part 2: list-of-interface (#54)

## Summary:
In this commit I remove one of the limitations of our support for
interfaces, from #52, by adding support for list-of-interface fields.
This was surprisingly complex!  The issue is that, as before, it's the
containing type that has to do all the glue work -- and it's that glue
work that is complicated by list-of-interface fields.

All in all, it's not that much new code, and by far the hard part is
just 20 lines in the UnmarshalJSON template (which come with almost
twice as many lines of comments to explain them).  It may be easiest to
start by reading some of the generated code, and then read the template.

I also added support for such fields with `pointer: true` specified,
such that the type is `[][]...[]*MyInterface`, although I don't know why
you would want that.  This does *not* allow e.g. `*[]*[][]*MyInterface`;
that would require a way to specify it (see #16) but also add some extra
complexity (as we'd have to actually walk the type-unwrap chain
properly, instead of just counting the number of slices and whether
there's a pointer).

Issue: https://github.com/Khan/genqlient/issues/8

## Test plan:
make check


Author: benjaminjkraft

Reviewers: dnerdy, benjaminjkraft, aberkan, csilvers, MiguelCastillo

Required Reviewers: 

Approved by: dnerdy

Checks: ⌛ Test (1.17), ⌛ Test (1.16), ⌛ Test (1.15), ⌛ Test (1.14), ⌛ Test (1.13), ⌛ Lint, ⌛ Lint, ⌛ Test (1.17), ⌛ Test (1.16), ⌛ Test (1.15), ⌛ Test (1.14), ⌛ Test (1.13)

Pull request URL: https://github.com/Khan/genqlient/pull/54

generate/generate_test.go

@@ -71,10 +71,6 @@ func TestGenerate(t *testing.T) {
 			t.Run("Build", func(t *testing.T) {
 				if testing.Short() {
 					t.Skip("skipping build due to -short")
-				} else if sourceFilename == "InterfaceNesting.graphql" ||
-					sourceFilename == "InterfaceListField.graphql" {
-					t.Skip("TODO: enable after fixing " +
-						"https://github.com/Khan/genqlient/issues/8")
 				} else if sourceFilename == "Omitempty.graphql" {
 					t.Skip("TODO: enable after fixing " +
 						"https://github.com/Khan/genqlient/issues/43")

generate/template.go

@@ -4,6 +4,7 @@ import (
 	"io"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"text/template"
 )
 
@@ -12,13 +13,34 @@ var (
 	thisDir               = filepath.Dir(thisFilename)
 )
 
+func repeat(n int, s string) string {
+	var builder strings.Builder
+	for i := 0; i < n; i++ {
+		builder.WriteString(s)
+	}
+	return builder.String()
+}
+
+func intRange(n int) []int {
+	ret := make([]int, n)
+	for i := 0; i < n; i++ {
+		ret[i] = i
+	}
+	return ret
+}
+
+func sub(x, y int) int { return x - y }
+
 // execute executes the given template with the funcs from this generator.
 func (g *generator) execute(tmplRelFilename string, w io.Writer, data interface{}) error {
 	tmpl := g.templateCache[tmplRelFilename]
 	if tmpl == nil {
 		absFilename := filepath.Join(thisDir, tmplRelFilename)
 		funcMap := template.FuncMap{
-			"ref": g.ref,
+			"ref":      g.ref,
+			"repeat":   repeat,
+			"intRange": intRange,
+			"sub":      sub,
 		}
 		var err error
 		tmpl, err = template.New(tmplRelFilename).Funcs(funcMap).ParseFiles(absFilename)

generate/testdata/queries/InterfaceListField.graphql

@@ -1,4 +1,4 @@
-query InterfaceNoFragmentsQuery {
+query InterfaceListField {
   root {
     id
     name
@@ -8,4 +8,14 @@ query InterfaceNoFragmentsQuery {
       name
     }
   }
+  # @genqlient(pointer: true)
+  withPointer: root {
+    id
+    name
+    children {
+      __typename
+      id
+      name
+    }
+  }
 }

generate/testdata/queries/InterfaceListOfListsOfListsField.graphql

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

generate/testdata/queries/InterfaceNoFragments.graphql

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

generate/testdata/queries/schema.graphql

@@ -111,6 +111,7 @@ type Query {
   getJunk: Junk
   getComplexJunk: ComplexJunk
   listOfListsOfLists: [[[String!]!]!]!
+  listOfListsOfListsOfContent: [[[Content!]!]!]!
 }
 
 type Mutation {

generate/testdata/snapshots/TestGenerate-InterfaceListField.graphql-InterfaceListField.graphql.go

@@ -10,43 +10,77 @@ import (
 	"github.com/Khan/genqlient/internal/testutil"
 )
 
-// InterfaceNoFragmentsQueryResponse is returned by InterfaceNoFragmentsQuery on success.
-type InterfaceNoFragmentsQueryResponse struct {
-	Root InterfaceNoFragmentsQueryRootTopic `json:"root"`
+// InterfaceListFieldResponse is returned by InterfaceListField on success.
+type InterfaceListFieldResponse struct {
+	Root        InterfaceListFieldRootTopic         `json:"root"`
+	WithPointer *InterfaceListFieldWithPointerTopic `json:"withPointer"`
 }
 
-// InterfaceNoFragmentsQueryRootTopic includes the requested fields of the GraphQL type Topic.
-type InterfaceNoFragmentsQueryRootTopic struct {
+// InterfaceListFieldRootTopic includes the requested fields of the GraphQL type Topic.
+type InterfaceListFieldRootTopic struct {
 	// ID is documented in the Content interface.
-	Id       testutil.ID                                         `json:"id"`
-	Name     string                                              `json:"name"`
-	Children []InterfaceNoFragmentsQueryRootTopicChildrenContent `json:"children"`
+	Id       testutil.ID                                  `json:"id"`
+	Name     string                                       `json:"name"`
+	Children []InterfaceListFieldRootTopicChildrenContent `json:"-"`
 }
 
-// InterfaceNoFragmentsQueryRootTopicChildrenArticle includes the requested fields of the GraphQL type Article.
-type InterfaceNoFragmentsQueryRootTopicChildrenArticle struct {
+func (v *InterfaceListFieldRootTopic) UnmarshalJSON(b []byte) error {
+
+	type InterfaceListFieldRootTopicWrapper InterfaceListFieldRootTopic
+
+	var firstPass struct {
+		*InterfaceListFieldRootTopicWrapper
+		Children []json.RawMessage `json:"children"`
+	}
+	firstPass.InterfaceListFieldRootTopicWrapper = (*InterfaceListFieldRootTopicWrapper)(v)
+
+	err := json.Unmarshal(b, &firstPass)
+	if err != nil {
+		return err
+	}
+
+	{
+		target := &v.Children
+		raw := firstPass.Children
+		*target = make(
+			[]InterfaceListFieldRootTopicChildrenContent,
+			len(raw))
+		for i, raw := range raw {
+			target := &(*target)[i]
+			err = __unmarshalInterfaceListFieldRootTopicChildrenContent(
+				target, raw)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// InterfaceListFieldRootTopicChildrenArticle includes the requested fields of the GraphQL type Article.
+type InterfaceListFieldRootTopicChildrenArticle struct {
 	Typename string `json:"__typename"`
 	// ID is the identifier of the content.
 	Id   testutil.ID `json:"id"`
 	Name string      `json:"name"`
 }
 
-// InterfaceNoFragmentsQueryRootTopicChildrenContent includes the requested fields of the GraphQL type Content.
+// InterfaceListFieldRootTopicChildrenContent includes the requested fields of the GraphQL type Content.
 // The GraphQL type's documentation follows.
 //
 // Content is implemented by various types like Article, Video, and Topic.
-type InterfaceNoFragmentsQueryRootTopicChildrenContent interface {
-	implementsGraphQLInterfaceInterfaceNoFragmentsQueryRootTopicChildrenContent()
+type InterfaceListFieldRootTopicChildrenContent interface {
+	implementsGraphQLInterfaceInterfaceListFieldRootTopicChildrenContent()
 }
 
-func (v *InterfaceNoFragmentsQueryRootTopicChildrenArticle) implementsGraphQLInterfaceInterfaceNoFragmentsQueryRootTopicChildrenContent() {
+func (v *InterfaceListFieldRootTopicChildrenArticle) implementsGraphQLInterfaceInterfaceListFieldRootTopicChildrenContent() {
 }
-func (v *InterfaceNoFragmentsQueryRootTopicChildrenVideo) implementsGraphQLInterfaceInterfaceNoFragmentsQueryRootTopicChildrenContent() {
+func (v *InterfaceListFieldRootTopicChildrenVideo) implementsGraphQLInterfaceInterfaceListFieldRootTopicChildrenContent() {
 }
-func (v *InterfaceNoFragmentsQueryRootTopicChildrenTopic) implementsGraphQLInterfaceInterfaceNoFragmentsQueryRootTopicChildrenContent() {
+func (v *InterfaceListFieldRootTopicChildrenTopic) implementsGraphQLInterfaceInterfaceListFieldRootTopicChildrenContent() {
 }
 
-func __unmarshalInterfaceNoFragmentsQueryRootTopicChildrenContent(v *InterfaceNoFragmentsQueryRootTopicChildrenContent, m json.RawMessage) error {
+func __unmarshalInterfaceListFieldRootTopicChildrenContent(v *InterfaceListFieldRootTopicChildrenContent, m json.RawMessage) error {
 	if string(m) == "null" {
 		return nil
 	}
@@ -61,45 +95,154 @@ func __unmarshalInterfaceNoFragmentsQueryRootTopicChildrenContent(v *InterfaceNo
 
 	switch tn.TypeName {
 	case "Article":
-		*v = new(InterfaceNoFragmentsQueryRootTopicChildrenArticle)
+		*v = new(InterfaceListFieldRootTopicChildrenArticle)
 		return json.Unmarshal(m, *v)
 	case "Video":
-		*v = new(InterfaceNoFragmentsQueryRootTopicChildrenVideo)
+		*v = new(InterfaceListFieldRootTopicChildrenVideo)
 		return json.Unmarshal(m, *v)
 	case "Topic":
-		*v = new(InterfaceNoFragmentsQueryRootTopicChildrenTopic)
+		*v = new(InterfaceListFieldRootTopicChildrenTopic)
 		return json.Unmarshal(m, *v)
 	default:
 		return fmt.Errorf(
-			`Unexpected concrete type for InterfaceNoFragmentsQueryRootTopicChildrenContent: "%v"`, tn.TypeName)
+			`Unexpected concrete type for InterfaceListFieldRootTopicChildrenContent: "%v"`, tn.TypeName)
 	}
 }
 
-// InterfaceNoFragmentsQueryRootTopicChildrenTopic includes the requested fields of the GraphQL type Topic.
-type InterfaceNoFragmentsQueryRootTopicChildrenTopic struct {
+// InterfaceListFieldRootTopicChildrenTopic includes the requested fields of the GraphQL type Topic.
+type InterfaceListFieldRootTopicChildrenTopic struct {
 	Typename string `json:"__typename"`
 	// ID is the identifier of the content.
 	Id   testutil.ID `json:"id"`
 	Name string      `json:"name"`
 }
 
-// InterfaceNoFragmentsQueryRootTopicChildrenVideo includes the requested fields of the GraphQL type Video.
-type InterfaceNoFragmentsQueryRootTopicChildrenVideo struct {
+// InterfaceListFieldRootTopicChildrenVideo includes the requested fields of the GraphQL type Video.
+type InterfaceListFieldRootTopicChildrenVideo struct {
 	Typename string `json:"__typename"`
 	// ID is the identifier of the content.
 	Id   testutil.ID `json:"id"`
 	Name string      `json:"name"`
 }
 
-func InterfaceNoFragmentsQuery(
+// InterfaceListFieldWithPointerTopic includes the requested fields of the GraphQL type Topic.
+type InterfaceListFieldWithPointerTopic struct {
+	// ID is documented in the Content interface.
+	Id       testutil.ID                                         `json:"id"`
+	Name     string                                              `json:"name"`
+	Children []InterfaceListFieldWithPointerTopicChildrenContent `json:"-"`
+}
+
+func (v *InterfaceListFieldWithPointerTopic) UnmarshalJSON(b []byte) error {
+
+	type InterfaceListFieldWithPointerTopicWrapper InterfaceListFieldWithPointerTopic
+
+	var firstPass struct {
+		*InterfaceListFieldWithPointerTopicWrapper
+		Children []json.RawMessage `json:"children"`
+	}
+	firstPass.InterfaceListFieldWithPointerTopicWrapper = (*InterfaceListFieldWithPointerTopicWrapper)(v)
+
+	err := json.Unmarshal(b, &firstPass)
+	if err != nil {
+		return err
+	}
+
+	{
+		target := &v.Children
+		raw := firstPass.Children
+		*target = make(
+			[]InterfaceListFieldWithPointerTopicChildrenContent,
+			len(raw))
+		for i, raw := range raw {
+			target := &(*target)[i]
+			err = __unmarshalInterfaceListFieldWithPointerTopicChildrenContent(
+				target, raw)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// InterfaceListFieldWithPointerTopicChildrenArticle includes the requested fields of the GraphQL type Article.
+type InterfaceListFieldWithPointerTopicChildrenArticle struct {
+	Typename string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   testutil.ID `json:"id"`
+	Name string      `json:"name"`
+}
+
+// InterfaceListFieldWithPointerTopicChildrenContent includes the requested fields of the GraphQL type Content.
+// The GraphQL type's documentation follows.
+//
+// Content is implemented by various types like Article, Video, and Topic.
+type InterfaceListFieldWithPointerTopicChildrenContent interface {
+	implementsGraphQLInterfaceInterfaceListFieldWithPointerTopicChildrenContent()
+}
+
+func (v *InterfaceListFieldWithPointerTopicChildrenArticle) implementsGraphQLInterfaceInterfaceListFieldWithPointerTopicChildrenContent() {
+}
+func (v *InterfaceListFieldWithPointerTopicChildrenVideo) implementsGraphQLInterfaceInterfaceListFieldWithPointerTopicChildrenContent() {
+}
+func (v *InterfaceListFieldWithPointerTopicChildrenTopic) implementsGraphQLInterfaceInterfaceListFieldWithPointerTopicChildrenContent() {
+}
+
+func __unmarshalInterfaceListFieldWithPointerTopicChildrenContent(v *InterfaceListFieldWithPointerTopicChildrenContent, m json.RawMessage) error {
+	if string(m) == "null" {
+		return nil
+	}
+
+	var tn struct {
+		TypeName string `json:"__typename"`
+	}
+	err := json.Unmarshal(m, &tn)
+	if err != nil {
+		return err
+	}
+
+	switch tn.TypeName {
+	case "Article":
+		*v = new(InterfaceListFieldWithPointerTopicChildrenArticle)
+		return json.Unmarshal(m, *v)
+	case "Video":
+		*v = new(InterfaceListFieldWithPointerTopicChildrenVideo)
+		return json.Unmarshal(m, *v)
+	case "Topic":
+		*v = new(InterfaceListFieldWithPointerTopicChildrenTopic)
+		return json.Unmarshal(m, *v)
+	default:
+		return fmt.Errorf(
+			`Unexpected concrete type for InterfaceListFieldWithPointerTopicChildrenContent: "%v"`, tn.TypeName)
+	}
+}
+
+// InterfaceListFieldWithPointerTopicChildrenTopic includes the requested fields of the GraphQL type Topic.
+type InterfaceListFieldWithPointerTopicChildrenTopic struct {
+	Typename string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   testutil.ID `json:"id"`
+	Name string      `json:"name"`
+}
+
+// InterfaceListFieldWithPointerTopicChildrenVideo includes the requested fields of the GraphQL type Video.
+type InterfaceListFieldWithPointerTopicChildrenVideo struct {
+	Typename string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   testutil.ID `json:"id"`
+	Name string      `json:"name"`
+}
+
+func InterfaceListField(
 	client graphql.Client,
-) (*InterfaceNoFragmentsQueryResponse, error) {
-	var retval InterfaceNoFragmentsQueryResponse
+) (*InterfaceListFieldResponse, error) {
+	var retval InterfaceListFieldResponse
 	err := client.MakeRequest(
 		nil,
-		"InterfaceNoFragmentsQuery",
+		"InterfaceListField",
 		`
-query InterfaceNoFragmentsQuery {
+query InterfaceListField {
 	root {
 		id
 		name
@@ -109,6 +252,15 @@ query InterfaceNoFragmentsQuery {
 			name
 		}
 	}
+	withPointer: root {
+		id
+		name
+		children {
+			__typename
+			id
+			name
+		}
+	}
 }
 `,
 		&retval,

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

@@ -1,8 +1,8 @@
 {
   "operations": [
     {
-      "operationName": "InterfaceNoFragmentsQuery",
-      "query": "\nquery InterfaceNoFragmentsQuery {\n\troot {\n\t\tid\n\t\tname\n\t\tchildren {\n\t\t\t__typename\n\t\t\tid\n\t\t\tname\n\t\t}\n\t}\n}\n",
+      "operationName": "InterfaceListField",
+      "query": "\nquery InterfaceListField {\n\troot {\n\t\tid\n\t\tname\n\t\tchildren {\n\t\t\t__typename\n\t\t\tid\n\t\t\tname\n\t\t}\n\t}\n\twithPointer: root {\n\t\tid\n\t\tname\n\t\tchildren {\n\t\t\t__typename\n\t\t\tid\n\t\t\tname\n\t\t}\n\t}\n}\n",
       "sourceLocation": "testdata/queries/InterfaceListField.graphql"
     }
   ]

generate/testdata/snapshots/TestGenerate-InterfaceListOfListsOfListsField.graphql-InterfaceListOfListsOfListsField.graphql.go

@@ -0,0 +1,255 @@
+package test
+
+// Code generated by github.com/Khan/genqlient, DO NOT EDIT.
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/Khan/genqlient/graphql"
+	"github.com/Khan/genqlient/internal/testutil"
+)
+
+// InterfaceListOfListOfListsFieldListOfListsOfListsOfContent includes the requested fields of the GraphQL type Content.
+// The GraphQL type's documentation follows.
+//
+// Content is implemented by various types like Article, Video, and Topic.
+type InterfaceListOfListOfListsFieldListOfListsOfListsOfContent interface {
+	implementsGraphQLInterfaceInterfaceListOfListOfListsFieldListOfListsOfListsOfContent()
+}
+
+func (v *InterfaceListOfListOfListsFieldListOfListsOfListsOfContentArticle) implementsGraphQLInterfaceInterfaceListOfListOfListsFieldListOfListsOfListsOfContent() {
+}
+func (v *InterfaceListOfListOfListsFieldListOfListsOfListsOfContentVideo) implementsGraphQLInterfaceInterfaceListOfListOfListsFieldListOfListsOfListsOfContent() {
+}
+func (v *InterfaceListOfListOfListsFieldListOfListsOfListsOfContentTopic) implementsGraphQLInterfaceInterfaceListOfListOfListsFieldListOfListsOfListsOfContent() {
+}
+
+func __unmarshalInterfaceListOfListOfListsFieldListOfListsOfListsOfContent(v *InterfaceListOfListOfListsFieldListOfListsOfListsOfContent, m json.RawMessage) error {
+	if string(m) == "null" {
+		return nil
+	}
+
+	var tn struct {
+		TypeName string `json:"__typename"`
+	}
+	err := json.Unmarshal(m, &tn)
+	if err != nil {
+		return err
+	}
+
+	switch tn.TypeName {
+	case "Article":
+		*v = new(InterfaceListOfListOfListsFieldListOfListsOfListsOfContentArticle)
+		return json.Unmarshal(m, *v)
+	case "Video":
+		*v = new(InterfaceListOfListOfListsFieldListOfListsOfListsOfContentVideo)
+		return json.Unmarshal(m, *v)
+	case "Topic":
+		*v = new(InterfaceListOfListOfListsFieldListOfListsOfListsOfContentTopic)
+		return json.Unmarshal(m, *v)
+	default:
+		return fmt.Errorf(
+			`Unexpected concrete type for InterfaceListOfListOfListsFieldListOfListsOfListsOfContent: "%v"`, tn.TypeName)
+	}
+}
+
+// InterfaceListOfListOfListsFieldListOfListsOfListsOfContentArticle includes the requested fields of the GraphQL type Article.
+type InterfaceListOfListOfListsFieldListOfListsOfListsOfContentArticle struct {
+	Typename string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   testutil.ID `json:"id"`
+	Name string      `json:"name"`
+}
+
+// InterfaceListOfListOfListsFieldListOfListsOfListsOfContentTopic includes the requested fields of the GraphQL type Topic.
+type InterfaceListOfListOfListsFieldListOfListsOfListsOfContentTopic struct {
+	Typename string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   testutil.ID `json:"id"`
+	Name string      `json:"name"`
+}
+
+// InterfaceListOfListOfListsFieldListOfListsOfListsOfContentVideo includes the requested fields of the GraphQL type Video.
+type InterfaceListOfListOfListsFieldListOfListsOfListsOfContentVideo struct {
+	Typename string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   testutil.ID `json:"id"`
+	Name string      `json:"name"`
+}
+
+// InterfaceListOfListOfListsFieldResponse is returned by InterfaceListOfListOfListsField on success.
+type InterfaceListOfListOfListsFieldResponse struct {
+	ListOfListsOfListsOfContent [][][]InterfaceListOfListOfListsFieldListOfListsOfListsOfContent `json:"-"`
+	WithPointer                 [][][]*InterfaceListOfListOfListsFieldWithPointerContent         `json:"-"`
+}
+
+func (v *InterfaceListOfListOfListsFieldResponse) UnmarshalJSON(b []byte) error {
+
+	type InterfaceListOfListOfListsFieldResponseWrapper InterfaceListOfListOfListsFieldResponse
+
+	var firstPass struct {
+		*InterfaceListOfListOfListsFieldResponseWrapper
+		ListOfListsOfListsOfContent [][][]json.RawMessage `json:"listOfListsOfListsOfContent"`
+		WithPointer                 [][][]json.RawMessage `json:"withPointer"`
+	}
+	firstPass.InterfaceListOfListOfListsFieldResponseWrapper = (*InterfaceListOfListOfListsFieldResponseWrapper)(v)
+
+	err := json.Unmarshal(b, &firstPass)
+	if err != nil {
+		return err
+	}
+
+	{
+		target := &v.ListOfListsOfListsOfContent
+		raw := firstPass.ListOfListsOfListsOfContent
+		*target = make(
+			[][][]InterfaceListOfListOfListsFieldListOfListsOfListsOfContent,
+			len(raw))
+		for i, raw := range raw {
+			target := &(*target)[i]
+			*target = make(
+				[][]InterfaceListOfListOfListsFieldListOfListsOfListsOfContent,
+				len(raw))
+			for i, raw := range raw {
+				target := &(*target)[i]
+				*target = make(
+					[]InterfaceListOfListOfListsFieldListOfListsOfListsOfContent,
+					len(raw))
+				for i, raw := range raw {
+					target := &(*target)[i]
+					err = __unmarshalInterfaceListOfListOfListsFieldListOfListsOfListsOfContent(
+						target, raw)
+					if err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+	{
+		target := &v.WithPointer
+		raw := firstPass.WithPointer
+		*target = make(
+			[][][]*InterfaceListOfListOfListsFieldWithPointerContent,
+			len(raw))
+		for i, raw := range raw {
+			target := &(*target)[i]
+			*target = make(
+				[][]*InterfaceListOfListOfListsFieldWithPointerContent,
+				len(raw))
+			for i, raw := range raw {
+				target := &(*target)[i]
+				*target = make(
+					[]*InterfaceListOfListOfListsFieldWithPointerContent,
+					len(raw))
+				for i, raw := range raw {
+					target := &(*target)[i]
+					*target = new(InterfaceListOfListOfListsFieldWithPointerContent)
+					err = __unmarshalInterfaceListOfListOfListsFieldWithPointerContent(
+						*target, raw)
+					if err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// InterfaceListOfListOfListsFieldWithPointerArticle includes the requested fields of the GraphQL type Article.
+type InterfaceListOfListOfListsFieldWithPointerArticle struct {
+	Typename *string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   *testutil.ID `json:"id"`
+	Name *string      `json:"name"`
+}
+
+// InterfaceListOfListOfListsFieldWithPointerContent includes the requested fields of the GraphQL type Content.
+// The GraphQL type's documentation follows.
+//
+// Content is implemented by various types like Article, Video, and Topic.
+type InterfaceListOfListOfListsFieldWithPointerContent interface {
+	implementsGraphQLInterfaceInterfaceListOfListOfListsFieldWithPointerContent()
+}
+
+func (v *InterfaceListOfListOfListsFieldWithPointerArticle) implementsGraphQLInterfaceInterfaceListOfListOfListsFieldWithPointerContent() {
+}
+func (v *InterfaceListOfListOfListsFieldWithPointerVideo) implementsGraphQLInterfaceInterfaceListOfListOfListsFieldWithPointerContent() {
+}
+func (v *InterfaceListOfListOfListsFieldWithPointerTopic) implementsGraphQLInterfaceInterfaceListOfListOfListsFieldWithPointerContent() {
+}
+
+func __unmarshalInterfaceListOfListOfListsFieldWithPointerContent(v *InterfaceListOfListOfListsFieldWithPointerContent, m json.RawMessage) error {
+	if string(m) == "null" {
+		return nil
+	}
+
+	var tn struct {
+		TypeName string `json:"__typename"`
+	}
+	err := json.Unmarshal(m, &tn)
+	if err != nil {
+		return err
+	}
+
+	switch tn.TypeName {
+	case "Article":
+		*v = new(InterfaceListOfListOfListsFieldWithPointerArticle)
+		return json.Unmarshal(m, *v)
+	case "Video":
+		*v = new(InterfaceListOfListOfListsFieldWithPointerVideo)
+		return json.Unmarshal(m, *v)
+	case "Topic":
+		*v = new(InterfaceListOfListOfListsFieldWithPointerTopic)
+		return json.Unmarshal(m, *v)
+	default:
+		return fmt.Errorf(
+			`Unexpected concrete type for InterfaceListOfListOfListsFieldWithPointerContent: "%v"`, tn.TypeName)
+	}
+}
+
+// InterfaceListOfListOfListsFieldWithPointerTopic includes the requested fields of the GraphQL type Topic.
+type InterfaceListOfListOfListsFieldWithPointerTopic struct {
+	Typename *string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   *testutil.ID `json:"id"`
+	Name *string      `json:"name"`
+}
+
+// InterfaceListOfListOfListsFieldWithPointerVideo includes the requested fields of the GraphQL type Video.
+type InterfaceListOfListOfListsFieldWithPointerVideo struct {
+	Typename *string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   *testutil.ID `json:"id"`
+	Name *string      `json:"name"`
+}
+
+func InterfaceListOfListOfListsField(
+	client graphql.Client,
+) (*InterfaceListOfListOfListsFieldResponse, error) {
+	var retval InterfaceListOfListOfListsFieldResponse
+	err := client.MakeRequest(
+		nil,
+		"InterfaceListOfListOfListsField",
+		`
+query InterfaceListOfListOfListsField {
+	listOfListsOfListsOfContent {
+		__typename
+		id
+		name
+	}
+	withPointer: listOfListsOfListsOfContent {
+		__typename
+		id
+		name
+	}
+}
+`,
+		&retval,
+		nil,
+	)
+	return &retval, err
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "operations": [
+    {
+      "operationName": "InterfaceListOfListOfListsField",
+      "query": "\nquery InterfaceListOfListOfListsField {\n\tlistOfListsOfListsOfContent {\n\t\t__typename\n\t\tid\n\t\tname\n\t}\n\twithPointer: listOfListsOfListsOfContent {\n\t\t__typename\n\t\tid\n\t\tname\n\t}\n}\n",
+      "sourceLocation": "testdata/queries/InterfaceListOfListsOfListsField.graphql"
+    }
+  ]
+}

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

@@ -19,7 +19,40 @@ type InterfaceNestingResponse struct {
 type InterfaceNestingRootTopic struct {
 	// ID is documented in the Content interface.
 	Id       testutil.ID                                `json:"id"`
-	Children []InterfaceNestingRootTopicChildrenContent `json:"children"`
+	Children []InterfaceNestingRootTopicChildrenContent `json:"-"`
+}
+
+func (v *InterfaceNestingRootTopic) UnmarshalJSON(b []byte) error {
+
+	type InterfaceNestingRootTopicWrapper InterfaceNestingRootTopic
+
+	var firstPass struct {
+		*InterfaceNestingRootTopicWrapper
+		Children []json.RawMessage `json:"children"`
+	}
+	firstPass.InterfaceNestingRootTopicWrapper = (*InterfaceNestingRootTopicWrapper)(v)
+
+	err := json.Unmarshal(b, &firstPass)
+	if err != nil {
+		return err
+	}
+
+	{
+		target := &v.Children
+		raw := firstPass.Children
+		*target = make(
+			[]InterfaceNestingRootTopicChildrenContent,
+			len(raw))
+		for i, raw := range raw {
+			target := &(*target)[i]
+			err = __unmarshalInterfaceNestingRootTopicChildrenContent(
+				target, raw)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
 }
 
 // InterfaceNestingRootTopicChildrenArticle includes the requested fields of the GraphQL type Article.
@@ -35,7 +68,40 @@ type InterfaceNestingRootTopicChildrenArticleParentTopic struct {
 	Typename string `json:"__typename"`
 	// ID is documented in the Content interface.
 	Id       testutil.ID                                                          `json:"id"`
-	Children []InterfaceNestingRootTopicChildrenArticleParentTopicChildrenContent `json:"children"`
+	Children []InterfaceNestingRootTopicChildrenArticleParentTopicChildrenContent `json:"-"`
+}
+
+func (v *InterfaceNestingRootTopicChildrenArticleParentTopic) UnmarshalJSON(b []byte) error {
+
+	type InterfaceNestingRootTopicChildrenArticleParentTopicWrapper InterfaceNestingRootTopicChildrenArticleParentTopic
+
+	var firstPass struct {
+		*InterfaceNestingRootTopicChildrenArticleParentTopicWrapper
+		Children []json.RawMessage `json:"children"`
+	}
+	firstPass.InterfaceNestingRootTopicChildrenArticleParentTopicWrapper = (*InterfaceNestingRootTopicChildrenArticleParentTopicWrapper)(v)
+
+	err := json.Unmarshal(b, &firstPass)
+	if err != nil {
+		return err
+	}
+
+	{
+		target := &v.Children
+		raw := firstPass.Children
+		*target = make(
+			[]InterfaceNestingRootTopicChildrenArticleParentTopicChildrenContent,
+			len(raw))
+		for i, raw := range raw {
+			target := &(*target)[i]
+			err = __unmarshalInterfaceNestingRootTopicChildrenArticleParentTopicChildrenContent(
+				target, raw)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
 }
 
 // InterfaceNestingRootTopicChildrenArticleParentTopicChildrenArticle includes the requested fields of the GraphQL type Article.
@@ -160,7 +226,40 @@ type InterfaceNestingRootTopicChildrenTopicParentTopic struct {
 	Typename string `json:"__typename"`
 	// ID is documented in the Content interface.
 	Id       testutil.ID                                                        `json:"id"`
-	Children []InterfaceNestingRootTopicChildrenTopicParentTopicChildrenContent `json:"children"`
+	Children []InterfaceNestingRootTopicChildrenTopicParentTopicChildrenContent `json:"-"`
+}
+
+func (v *InterfaceNestingRootTopicChildrenTopicParentTopic) UnmarshalJSON(b []byte) error {
+
+	type InterfaceNestingRootTopicChildrenTopicParentTopicWrapper InterfaceNestingRootTopicChildrenTopicParentTopic
+
+	var firstPass struct {
+		*InterfaceNestingRootTopicChildrenTopicParentTopicWrapper
+		Children []json.RawMessage `json:"children"`
+	}
+	firstPass.InterfaceNestingRootTopicChildrenTopicParentTopicWrapper = (*InterfaceNestingRootTopicChildrenTopicParentTopicWrapper)(v)
+
+	err := json.Unmarshal(b, &firstPass)
+	if err != nil {
+		return err
+	}
+
+	{
+		target := &v.Children
+		raw := firstPass.Children
+		*target = make(
+			[]InterfaceNestingRootTopicChildrenTopicParentTopicChildrenContent,
+			len(raw))
+		for i, raw := range raw {
+			target := &(*target)[i]
+			err = __unmarshalInterfaceNestingRootTopicChildrenTopicParentTopicChildrenContent(
+				target, raw)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
 }
 
 // InterfaceNestingRootTopicChildrenTopicParentTopicChildrenArticle includes the requested fields of the GraphQL type Article.
@@ -241,7 +340,40 @@ type InterfaceNestingRootTopicChildrenVideoParentTopic struct {
 	Typename string `json:"__typename"`
 	// ID is documented in the Content interface.
 	Id       testutil.ID                                                        `json:"id"`
-	Children []InterfaceNestingRootTopicChildrenVideoParentTopicChildrenContent `json:"children"`
+	Children []InterfaceNestingRootTopicChildrenVideoParentTopicChildrenContent `json:"-"`
+}
+
+func (v *InterfaceNestingRootTopicChildrenVideoParentTopic) UnmarshalJSON(b []byte) error {
+
+	type InterfaceNestingRootTopicChildrenVideoParentTopicWrapper InterfaceNestingRootTopicChildrenVideoParentTopic
+
+	var firstPass struct {
+		*InterfaceNestingRootTopicChildrenVideoParentTopicWrapper
+		Children []json.RawMessage `json:"children"`
+	}
+	firstPass.InterfaceNestingRootTopicChildrenVideoParentTopicWrapper = (*InterfaceNestingRootTopicChildrenVideoParentTopicWrapper)(v)
+
+	err := json.Unmarshal(b, &firstPass)
+	if err != nil {
+		return err
+	}
+
+	{
+		target := &v.Children
+		raw := firstPass.Children
+		*target = make(
+			[]InterfaceNestingRootTopicChildrenVideoParentTopicChildrenContent,
+			len(raw))
+		for i, raw := range raw {
+			target := &(*target)[i]
+			err = __unmarshalInterfaceNestingRootTopicChildrenVideoParentTopicChildrenContent(
+				target, raw)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
 }
 
 // InterfaceNestingRootTopicChildrenVideoParentTopicChildrenArticle includes the requested fields of the GraphQL type Article.

generate/testdata/snapshots/TestGenerate-InterfaceNoFragments.graphql-InterfaceNoFragments.graphql.go

@@ -80,8 +80,9 @@ type InterfaceNoFragmentsQueryRandomItemVideo struct {
 
 // InterfaceNoFragmentsQueryResponse is returned by InterfaceNoFragmentsQuery on success.
 type InterfaceNoFragmentsQueryResponse struct {
-	Root       InterfaceNoFragmentsQueryRootTopic         `json:"root"`
-	RandomItem InterfaceNoFragmentsQueryRandomItemContent `json:"-"`
+	Root        InterfaceNoFragmentsQueryRootTopic           `json:"root"`
+	RandomItem  InterfaceNoFragmentsQueryRandomItemContent   `json:"-"`
+	WithPointer *InterfaceNoFragmentsQueryWithPointerContent `json:"-"`
 }
 
 func (v *InterfaceNoFragmentsQueryResponse) UnmarshalJSON(b []byte) error {
@@ -90,7 +91,8 @@ func (v *InterfaceNoFragmentsQueryResponse) UnmarshalJSON(b []byte) error {
 
 	var firstPass struct {
 		*InterfaceNoFragmentsQueryResponseWrapper
-		RandomItem json.RawMessage `json:"randomItem"`
+		RandomItem  json.RawMessage `json:"randomItem"`
+		WithPointer json.RawMessage `json:"withPointer"`
 	}
 	firstPass.InterfaceNoFragmentsQueryResponseWrapper = (*InterfaceNoFragmentsQueryResponseWrapper)(v)
 
@@ -99,12 +101,25 @@ func (v *InterfaceNoFragmentsQueryResponse) UnmarshalJSON(b []byte) error {
 		return err
 	}
 
-	err = __unmarshalInterfaceNoFragmentsQueryRandomItemContent(
-		&v.RandomItem, firstPass.RandomItem)
-	if err != nil {
-		return err
+	{
+		target := &v.RandomItem
+		raw := firstPass.RandomItem
+		err = __unmarshalInterfaceNoFragmentsQueryRandomItemContent(
+			target, raw)
+		if err != nil {
+			return err
+		}
+	}
+	{
+		target := &v.WithPointer
+		raw := firstPass.WithPointer
+		*target = new(InterfaceNoFragmentsQueryWithPointerContent)
+		err = __unmarshalInterfaceNoFragmentsQueryWithPointerContent(
+			*target, raw)
+		if err != nil {
+			return err
+		}
 	}
-
 	return nil
 }
 
@@ -115,6 +130,74 @@ type InterfaceNoFragmentsQueryRootTopic struct {
 	Name string      `json:"name"`
 }
 
+// InterfaceNoFragmentsQueryWithPointerArticle includes the requested fields of the GraphQL type Article.
+type InterfaceNoFragmentsQueryWithPointerArticle struct {
+	Typename *string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   *testutil.ID `json:"id"`
+	Name *string      `json:"name"`
+}
+
+// InterfaceNoFragmentsQueryWithPointerContent includes the requested fields of the GraphQL type Content.
+// The GraphQL type's documentation follows.
+//
+// Content is implemented by various types like Article, Video, and Topic.
+type InterfaceNoFragmentsQueryWithPointerContent interface {
+	implementsGraphQLInterfaceInterfaceNoFragmentsQueryWithPointerContent()
+}
+
+func (v *InterfaceNoFragmentsQueryWithPointerArticle) implementsGraphQLInterfaceInterfaceNoFragmentsQueryWithPointerContent() {
+}
+func (v *InterfaceNoFragmentsQueryWithPointerVideo) implementsGraphQLInterfaceInterfaceNoFragmentsQueryWithPointerContent() {
+}
+func (v *InterfaceNoFragmentsQueryWithPointerTopic) implementsGraphQLInterfaceInterfaceNoFragmentsQueryWithPointerContent() {
+}
+
+func __unmarshalInterfaceNoFragmentsQueryWithPointerContent(v *InterfaceNoFragmentsQueryWithPointerContent, m json.RawMessage) error {
+	if string(m) == "null" {
+		return nil
+	}
+
+	var tn struct {
+		TypeName string `json:"__typename"`
+	}
+	err := json.Unmarshal(m, &tn)
+	if err != nil {
+		return err
+	}
+
+	switch tn.TypeName {
+	case "Article":
+		*v = new(InterfaceNoFragmentsQueryWithPointerArticle)
+		return json.Unmarshal(m, *v)
+	case "Video":
+		*v = new(InterfaceNoFragmentsQueryWithPointerVideo)
+		return json.Unmarshal(m, *v)
+	case "Topic":
+		*v = new(InterfaceNoFragmentsQueryWithPointerTopic)
+		return json.Unmarshal(m, *v)
+	default:
+		return fmt.Errorf(
+			`Unexpected concrete type for InterfaceNoFragmentsQueryWithPointerContent: "%v"`, tn.TypeName)
+	}
+}
+
+// InterfaceNoFragmentsQueryWithPointerTopic includes the requested fields of the GraphQL type Topic.
+type InterfaceNoFragmentsQueryWithPointerTopic struct {
+	Typename *string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   *testutil.ID `json:"id"`
+	Name *string      `json:"name"`
+}
+
+// InterfaceNoFragmentsQueryWithPointerVideo includes the requested fields of the GraphQL type Video.
+type InterfaceNoFragmentsQueryWithPointerVideo struct {
+	Typename *string `json:"__typename"`
+	// ID is the identifier of the content.
+	Id   *testutil.ID `json:"id"`
+	Name *string      `json:"name"`
+}
+
 func InterfaceNoFragmentsQuery(
 	client graphql.Client,
 ) (*InterfaceNoFragmentsQueryResponse, error) {
@@ -133,6 +216,11 @@ query InterfaceNoFragmentsQuery {
 		id
 		name
 	}
+	withPointer: randomItem {
+		__typename
+		id
+		name
+	}
 }
 `,
 		&retval,

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

@@ -2,7 +2,7 @@
   "operations": [
     {
       "operationName": "InterfaceNoFragmentsQuery",
-      "query": "\nquery InterfaceNoFragmentsQuery {\n\troot {\n\t\tid\n\t\tname\n\t}\n\trandomItem {\n\t\t__typename\n\t\tid\n\t\tname\n\t}\n}\n",
+      "query": "\nquery InterfaceNoFragmentsQuery {\n\troot {\n\t\tid\n\t\tname\n\t}\n\trandomItem {\n\t\t__typename\n\t\tid\n\t\tname\n\t}\n\twithPointer: randomItem {\n\t\t__typename\n\t\tid\n\t\tname\n\t}\n}\n",
       "sourceLocation": "testdata/queries/InterfaceNoFragments.graphql"
     }
   ]

generate/testdata/snapshots/TestGenerate-UnionNoFragments.graphql-UnionNoFragments.graphql.go

@@ -78,12 +78,15 @@ func (v *UnionNoFragmentsQueryResponse) UnmarshalJSON(b []byte) error {
 		return err
 	}
 
-	err = __unmarshalUnionNoFragmentsQueryRandomLeafLeafContent(
-		&v.RandomLeaf, firstPass.RandomLeaf)
-	if err != nil {
-		return err
+	{
+		target := &v.RandomLeaf
+		raw := firstPass.RandomLeaf
+		err = __unmarshalUnionNoFragmentsQueryRandomLeafLeafContent(
+			target, raw)
+		if err != nil {
+			return err
+		}
 	}
-
 	return nil
 }
 

generate/types.go

@@ -22,6 +22,18 @@ type goType interface {
 	// Reference returns the Go name of this type, e.g. []*MyStruct, and may be
 	// used to refer to it in Go code.
 	Reference() string
+
+	// Remove slice/pointer wrappers, and return the underlying (named (or
+	// builtin)) type.  For example, given []*MyStruct, return MyStruct.
+	Unwrap() goType
+
+	// Count the number of times Unwrap() will unwrap a slice type.  For
+	// example, given [][][]*MyStruct (or []**[][]*MyStruct, but we never
+	// currently generate that), return 3.
+	SliceDepth() int
+
+	// True if Unwrap() will unwrap a pointer at least once.
+	IsPointer() bool
 }
 
 var (
@@ -106,6 +118,11 @@ type goStructField struct {
 	Description string
 }
 
+func isAbstract(typ goType) bool {
+	_, ok := typ.Unwrap().(*goInterfaceType)
+	return ok
+}
+
 func (typ *goStructType) WriteDefinition(w io.Writer, g *generator) error {
 	description := typ.Description
 	if typ.Incomplete {
@@ -117,7 +134,7 @@ func (typ *goStructType) WriteDefinition(w io.Writer, g *generator) error {
 	for _, field := range typ.Fields {
 		writeDescription(w, field.Description)
 		jsonName := field.JSONName
-		if _, ok := field.GoType.(*goInterfaceType); ok {
+		if isAbstract(field.GoType) {
 			// abstract types are handled in our UnmarshalJSON
 			jsonName = "-"
 		}
@@ -155,10 +172,7 @@ func (typ *goStructType) Reference() string { return typ.GoName }
 func (typ *goStructType) AbstractFields() []*goStructField {
 	var ret []*goStructField
 	for _, field := range typ.Fields {
-		// TODO(benkraft): To handle list-of-interface fields, we should really
-		// be "unwrapping" any goSliceType/goPointerType wrappers to find the
-		// goInterfaceType.
-		if _, ok := field.GoType.(*goInterfaceType); ok {
+		if isAbstract(field.GoType) {
 			ret = append(ret, field)
 		}
 	}
@@ -211,6 +225,27 @@ func (typ *goInterfaceType) WriteDefinition(w io.Writer, g *generator) error {
 
 func (typ *goInterfaceType) Reference() string { return typ.GoName }
 
+func (typ *goOpaqueType) Unwrap() goType    { return typ }
+func (typ *goSliceType) Unwrap() goType     { return typ.Elem.Unwrap() }
+func (typ *goPointerType) Unwrap() goType   { return typ.Elem.Unwrap() }
+func (typ *goEnumType) Unwrap() goType      { return typ }
+func (typ *goStructType) Unwrap() goType    { return typ }
+func (typ *goInterfaceType) Unwrap() goType { return typ }
+
+func (typ *goOpaqueType) SliceDepth() int    { return 0 }
+func (typ *goSliceType) SliceDepth() int     { return typ.Elem.SliceDepth() + 1 }
+func (typ *goPointerType) SliceDepth() int   { return 0 }
+func (typ *goEnumType) SliceDepth() int      { return 0 }
+func (typ *goStructType) SliceDepth() int    { return 0 }
+func (typ *goInterfaceType) SliceDepth() int { return 0 }
+
+func (typ *goOpaqueType) IsPointer() bool    { return false }
+func (typ *goSliceType) IsPointer() bool     { return typ.Elem.IsPointer() }
+func (typ *goPointerType) IsPointer() bool   { return true }
+func (typ *goEnumType) IsPointer() bool      { return false }
+func (typ *goStructType) IsPointer() bool    { return false }
+func (typ *goInterfaceType) IsPointer() bool { return false }
+
 func incompleteTypeDescription(goName, graphQLName, description string) string {
 	// For types where we only have some fields, note that, along with
 	// the GraphQL documentation (if any).  We don't want to just use

generate/unmarshal.go.tmpl

@@ -21,7 +21,7 @@ func (v *{{.GoName}}) UnmarshalJSON(b []byte) error {
     var firstPass struct{
         *{{.GoName}}Wrapper
         {{range .AbstractFields -}}
-        {{.GoName}} {{ref "encoding/json.RawMessage"}} `json:"{{.JSONName}}"`
+        {{.GoName}} {{repeat .GoType.SliceDepth "[]"}}{{ref "encoding/json.RawMessage"}} `json:"{{.JSONName}}"`
         {{end}}
     }
     firstPass.{{.GoName}}Wrapper = (*{{.GoName}}Wrapper)(v)
@@ -31,13 +31,67 @@ func (v *{{.GoName}}) UnmarshalJSON(b []byte) error {
         return err
     }
 
-    {{/* Now, for each field, call out to the unmarshal-helper. */}}
-    {{range .AbstractFields -}}
-    err = __unmarshal{{.GoType.Reference}}(
-        &v.{{.GoName}}, firstPass.{{.GoName}})
-    if err != nil {
-        return err
+    {{/* Now, for each field, call out to the unmarshal-helper.
+         This gets a little complicated because we may have a slice field.
+         So what we do is basically, for each field of type `[][]...[]MyType`:
+
+            target := &v.MyField      // *[][]...[]MyType
+            raw := firstPass.MyField  // [][]...[]json.RawMessage
+
+            // repeat the following three lines n times; each time, inside
+            // the loop we have one less layer of slice on raw and target
+            *target = make([][]...[]MyType, len(raw))
+            for i, raw := range raw {
+                // We need the &(*target)[i] because at each stage we want to
+                // keep target as a pointer.  (It only really has to be a
+                // pointer at the innermost level, but it's easiest to be
+                // consistent.)
+                target := &(*target)[i]
+            
+                // (now we have `target *MyType` and `raw json.RawMessage`)
+                __unmarshalMyType(target, raw)
+
+            } // (also n times)
+
+         Note that if the field also uses a pointer (`[][]...[]*MyType`), we
+         now pass around `*[][]...[]*MyType`; again in principle
+         `[][]...[]*MyType` would work but require more special-casing.  Thus
+         in the innermost loop, `target` is of type `**MyType`, so we have to
+         pass `*target` to the unmarshal-helper.  Of course, since MyType is an
+         interface, I'm not sure why you'd any of that anyway.
+
+         One additional trick is we wrap everything above in a block ({ ... }),
+         so that the variables target and raw may take on different types for
+         each field we are handling, which would otherwise conflict.  (We could
+         instead suffix the names, but that makes things much harder to read.)
+    */}}
+    {{range $field := .AbstractFields -}}
+    {
+        target := &v.{{$field.GoName}}
+        raw := firstPass.{{$field.GoName}}
+        {{range $i := intRange $field.GoType.SliceDepth -}}
+        *target = make(
+            {{repeat (sub $field.GoType.SliceDepth $i) "[]"}}{{if $field.GoType.IsPointer}}*{{end}}{{$field.GoType.Unwrap.Reference}},
+            len(raw))
+        for i, raw := range raw {
+            target := &(*target)[i]
+        {{end -}}
+        {{if $field.GoType.IsPointer -}}
+        {{/* In this case, the parent for loop did `make([]*MyType, ...)` and
+             we have a pointer into that list.  But we actually still need to
+             initialize the *elements* of the list. */ -}}
+        *target = new({{$field.GoType.Unwrap.Reference}})
+        {{end -}}
+        err = __unmarshal{{$field.GoType.Unwrap.Reference}}(
+            {{if $field.GoType.IsPointer}}*{{end}}target, raw)
+        if err != nil {
+            return err
+        }
+        {{range $i := intRange $field.GoType.SliceDepth -}}
+        }
+        {{end -}}
     }
-    {{end}}
+    {{end -}}
+
     return nil
 }