Bubble Null from List Element to Nearest Nullable Ancestor

codegen/testserver/nulls.graphql

@@ -1,5 +1,7 @@
 extend type Query {
     errorBubble: Error
+    errorBubbleList: [Error!]
+    errorList: [Error]
     errors: Errors
     valid: String!
 }

codegen/testserver/nulls_test.go

@@ -14,13 +14,18 @@ func TestNullBubbling(t *testing.T) {
 	resolvers.QueryResolver.Valid = func(ctx context.Context) (s string, e error) {
 		return "Ok", nil
 	}
-
 	resolvers.QueryResolver.Errors = func(ctx context.Context) (errors *Errors, e error) {
 		return &Errors{}, nil
 	}
 	resolvers.QueryResolver.ErrorBubble = func(ctx context.Context) (i *Error, e error) {
 		return &Error{ID: "E1234"}, nil
 	}
+	resolvers.QueryResolver.ErrorBubbleList = func(ctx context.Context) (i []*Error, e error) {
+		return []*Error{nil}, nil
+	}
+	resolvers.QueryResolver.ErrorList = func(ctx context.Context) (i []*Error, e error) {
+		return []*Error{nil}, nil
+	}
 
 	c := client.New(handler.NewDefaultServer(NewExecutableSchema(Config{Resolvers: resolvers})))
 
@@ -68,6 +73,31 @@ func TestNullBubbling(t *testing.T) {
 		require.Equal(t, "Ok", resp.Valid)
 	})
 
+	t.Run("when list element is null", func(t *testing.T) {
+		var resp struct {
+			Valid     string
+			ErrorList []*struct{}
+		}
+		err := c.Post(`query { valid, errorList { id } }`, &resp)
+
+		require.Nil(t, err)
+		require.Equal(t, len(resp.ErrorList), 1)
+		require.Nil(t, resp.ErrorList[0])
+		require.Equal(t, "Ok", resp.Valid)
+	})
+
+	t.Run("when non-null list element is null", func(t *testing.T) {
+		var resp struct {
+			Valid           string
+			ErrorBubbleList []*struct{}
+		}
+		err := c.Post(`query { valid, errorBubbleList { id } }`, &resp)
+
+		require.EqualError(t, err, `[{"message":"must not be null","path":["errorBubbleList",0]}]`)
+		require.Nil(t, resp.ErrorBubbleList)
+		require.Equal(t, "Ok", resp.Valid)
+	})
+
 	t.Run("null args", func(t *testing.T) {
 		var resp struct {
 			NullableArg *string
@@ -90,7 +120,7 @@ func TestNullBubbling(t *testing.T) {
 		resolvers.ErrorsResolver.D = func(ctx context.Context, obj *Errors) (i *Error, e error) { return nil, nil }
 		resolvers.ErrorsResolver.E = func(ctx context.Context, obj *Errors) (i *Error, e error) { return nil, nil }
 
-		err := c.Post(`{ errors { 
+		err := c.Post(`{ errors {
 			a { id },
 			b { id },
 			c { id },

codegen/testserver/resolver.go

@@ -232,6 +232,14 @@ func (r *queryResolver) ErrorBubble(ctx context.Context) (*Error, error) {
 	panic("not implemented")
 }
 
+func (r *queryResolver) ErrorBubbleList(ctx context.Context) ([]*Error, error) {
+	panic("not implemented")
+}
+
+func (r *queryResolver) ErrorList(ctx context.Context) ([]*Error, error) {
+	panic("not implemented")
+}
+
 func (r *queryResolver) Errors(ctx context.Context) (*Errors, error) {
 	panic("not implemented")
 }

codegen/testserver/slices.graphql

@@ -4,10 +4,10 @@ extend type Query {
 }
 
 type Slices {
-  test1: [String]
-  test2: [String!]
-  test3: [String]!
-  test4: [String!]!
+    test1: [String]
+    test2: [String!]
+    test3: [String]!
+    test4: [String!]!
 }
 
 scalar Bytes

codegen/type.gotpl

@@ -90,11 +90,11 @@
 						ctx := graphql.WithFieldContext(ctx, fc)
 						f := func(i int) {
 							defer func() {
-                        		if r := recover(); r != nil {
-                        			ec.Error(ctx, ec.Recover(ctx, r))
-                        			ret = nil
-                        		}
-                        	}()
+								if r := recover(); r != nil {
+									ec.Error(ctx, ec.Recover(ctx, r))
+									ret = nil
+								}
+							}()
 							if !isLen1 {
 								defer wg.Done()
 							}
@@ -107,9 +107,16 @@
 						}
 					{{ else }}
 						ret[i] = ec.{{ $type.Elem.MarshalFunc }}(ctx, sel, v[i])
-					{{- end}}
+					{{- end }}
 				}
 				{{ if not $type.IsScalar }} wg.Wait() {{ end }}
+				{{ if $type.Elem.GQL.NonNull }}
+					for _, e := range ret {
+						if e == graphql.Null {
+							return graphql.Null
+						}
+					}
+				{{ end }}
 				return ret
 			{{- else }}
 				{{- if $type.IsNilable }}