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/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
 }