Enable an implementing type to have peer types

Author: Andrew Poydence

pubsub-gen/internal/end2end/end2end_test.go

@@ -60,7 +60,11 @@ func TestEnd2End(t *testing.T) {
 		ps.Subscribe(sub8.write, pubsub.WithPath(StructTraverserCreatePath(&XFilter{MapY: []string{"a", "b"}})))
 		ps.Subscribe(sub9.write, pubsub.WithPath(StructTraverserCreatePath(&XFilter{E2: &EmptyFilter{}})))
 		ps.Subscribe(sub10.write, pubsub.WithPath(StructTraverserCreatePath(&XFilter{
-			M_M3: &M3Filter{},
+			M_M3: &M3Filter{
+				A: &M1Filter{
+					A: setters.Int(9),
+				},
+			},
 		})))
 
 		ps.Publish(&X{
@@ -77,7 +81,7 @@ func TestEnd2End(t *testing.T) {
 		ps.Publish(&X{I: 1, J: "a", Y1: Y{I: 2, J: "b"}, Y2: &Y{I: 1, J: "a"}}, StructTraverserTraverse)
 		ps.Publish(&X{I: 1, J: "x", Y1: Y{I: 2, J: "b"}}, StructTraverserTraverse)
 		ps.Publish(&X{I: 1, J: "x", Y1: Y{I: 2, J: "b"}, M: &M2{A: 1, B: 2}}, StructTraverserTraverse)
-		ps.Publish(&X{M: &M3{}}, StructTraverserTraverse)
+		ps.Publish(&X{M: &M3{A: M1{A: 9}}}, StructTraverserTraverse)
 
 		Expect(t, sub1.callCount).To(Equal(5))
 		Expect(t, sub2.callCount).To(Equal(1))

pubsub-gen/internal/end2end/generated_traverser_test.go

@@ -181,15 +181,14 @@ func ___Y1_Y2_E1_E2_M(idx int, data interface{}) (path uint64, nextTraverser pub
 
 	case 4:
 		switch data.(*end2end.X).M.(type) {
+		case end2end.M1:
+			return 5, _M_M1_A, true
+
 		case *end2end.M2:
 			return 6, _M_M2_A, true
 
 		case *end2end.M3:
-			// Interface implementation with no fields
-			return 7, pubsub.TreeTraverser(done), true
-
-		case end2end.M1:
-			return 5, _M_M1_A, true
+			return 7, _M_M3_A, true
 
 		default:
 			return 0, pubsub.TreeTraverser(done), true
@@ -537,6 +536,45 @@ func _M_M3(data interface{}) pubsub.Paths {
 	})
 }
 
+func ___M_M3_A(idx int, data interface{}) (path uint64, nextTraverser pubsub.TreeTraverser, ok bool) {
+	switch idx {
+
+	case 0:
+
+		return 1, pubsub.TreeTraverser(_M_M3_A_A), true
+
+	default:
+		return 0, nil, false
+	}
+}
+
+func _M_M3_A(data interface{}) pubsub.Paths {
+
+	return pubsub.Paths(func(idx int, data interface{}) (path uint64, nextTraverser pubsub.TreeTraverser, ok bool) {
+		switch idx {
+		case 0:
+			return 1, pubsub.TreeTraverser(_M_M3_A_A), true
+		default:
+			return 0, nil, false
+		}
+	})
+}
+
+func _M_M3_A_A(data interface{}) pubsub.Paths {
+
+	return pubsub.Paths(func(idx int, data interface{}) (path uint64, nextTraverser pubsub.TreeTraverser, ok bool) {
+		switch idx {
+		case 0:
+			return 0, pubsub.TreeTraverser(done), true
+		case 1:
+
+			return hashUint64(uint64(data.(*end2end.X).M.(*end2end.M3).A.A)), pubsub.TreeTraverser(done), true
+		default:
+			return 0, nil, false
+		}
+	})
+}
+
 type XFilter struct {
 	I         *int
 	J         *string
@@ -572,6 +610,7 @@ type M2Filter struct {
 }
 
 type M3Filter struct {
+	A *M1Filter
 }
 
 func StructTraverserCreatePath(f *XFilter) []uint64 {
@@ -926,9 +965,38 @@ func createPath__M_M3(f *M3Filter) []uint64 {
 	path = append(path, 7)
 
 	var count int
+	if f.A != nil {
+		count++
+	}
+
 	if count > 1 {
 		panic("Only one field can be set")
 	}
 
+	path = append(path, createPath__M3_A(f.A)...)
+
+	return path
+}
+
+func createPath__M3_A(f *M1Filter) []uint64 {
+	if f == nil {
+		return nil
+	}
+	var path []uint64
+
+	path = append(path, 1)
+
+	var count int
+	if count > 1 {
+		panic("Only one field can be set")
+	}
+
+	if f.A != nil {
+
+		path = append(path, hashUint64(uint64(*f.A)))
+	} else {
+		path = append(path, 0)
+	}
+
 	return path
 }

pubsub-gen/internal/end2end/test_types.go

@@ -40,6 +40,9 @@ type M2 struct {
 
 func (m *M2) message() {}
 
-type M3 struct{}
+type M3 struct {
+	A M1
+	//I int TODO
+}
 
 func (m *M3) message() {}

pubsub-gen/internal/generator/traverser_generator.go

@@ -189,13 +189,15 @@ func (g TraverserGenerator) generateStructFns(
 		implementersWithFields := make(map[string]string)
 		for _, impl := range implementers {
 			trimmedImpl := strings.Trim(impl, "*")
-			if len(m[trimmedImpl].Fields) == 0 {
+			if len(m[trimmedImpl].Fields) == 0 && len(m[trimmedImpl].PeerTypeFields) == 0 {
 				implementersWithFields[impl] = ""
 				continue
 			}
 
 			var name string
-			if len(m[trimmedImpl].Fields) > 0 {
+			if len(m[trimmedImpl].PeerTypeFields) > 0 {
+				name = m[trimmedImpl].PeerTypeFields[0].Name
+			} else if len(m[trimmedImpl].Fields) > 0 {
 				name = m[trimmedImpl].Fields[0].Name
 			}
 
@@ -290,7 +292,7 @@ func hashSplitFn(t, dataValue string, slice inspector.Slice, m inspector.Map) (c
 		_, value := hashSplitFn(t, x, inspector.Slice{}, inspector.Map{})
 		return fmt.Sprintf(`
 	var total uint64
-	for _, x := range %s{ 
+	for _, x := range %s{
 		total += %s
 	}`, dataValue, value), "hashUint64(total)"
 	}
@@ -299,7 +301,7 @@ func hashSplitFn(t, dataValue string, slice inspector.Slice, m inspector.Map) (c
 		_, value := hashSplitFn(t, "x", inspector.Slice{}, inspector.Map{})
 		return fmt.Sprintf(`
 	var total uint64
-	for x := range %s{ 
+	for x := range %s{
 		total += %s
 	}`, dataValue, value), "hashUint64(total)"
 	}