feat(bindnode): support listpairs struct representation

node/bindnode/node.go

@@ -36,6 +36,8 @@ var (
 	_ datamodel.NodeBuilder   = (*_builderRepr)(nil)
 	_ datamodel.NodeAssembler = (*_assembler)(nil)
 	_ datamodel.NodeAssembler = (*_assemblerRepr)(nil)
+	_ datamodel.NodeAssembler = (*_errorAssembler)(nil)
+	_ datamodel.NodeAssembler = (*_listpairsFieldAssemblerRepr)(nil)
 
 	_ datamodel.MapAssembler = (*_structAssembler)(nil)
 	_ datamodel.MapAssembler = (*_structAssemblerRepr)(nil)
@@ -44,8 +46,11 @@ var (
 
 	_ datamodel.ListAssembler = (*_listAssembler)(nil)
 	_ datamodel.ListAssembler = (*_listAssemblerRepr)(nil)
+	_ datamodel.ListAssembler = (*_listStructAssemblerRepr)(nil)
+	_ datamodel.ListAssembler = (*_listpairsFieldListAssemblerRepr)(nil)
 	_ datamodel.ListIterator  = (*_listIterator)(nil)
 	_ datamodel.ListIterator  = (*_tupleIteratorRepr)(nil)
+	_ datamodel.ListIterator  = (*_listpairsIteratorRepr)(nil)
 
 	_ datamodel.MapAssembler = (*_unionAssembler)(nil)
 	_ datamodel.MapAssembler = (*_unionAssemblerRepr)(nil)

node/bindnode/repr.go

@@ -53,7 +53,7 @@ func (w *_nodeRepr) Kind() datamodel.Kind {
 		return datamodel.Kind_String
 	case schema.StructRepresentation_Map:
 		return datamodel.Kind_Map
-	case schema.StructRepresentation_Tuple:
+	case schema.StructRepresentation_Tuple, schema.StructRepresentation_ListPairs:
 		return datamodel.Kind_List
 	case schema.UnionRepresentation_Keyed:
 		return datamodel.Kind_Map
@@ -174,6 +174,26 @@ func (w *_nodeRepr) LookupByIndex(idx int64) (datamodel.Node, error) {
 			return nil, err
 		}
 		return reprNode(v), nil
+	case schema.StructRepresentation_ListPairs:
+		fields := w.schemaType.(*schema.TypeStruct).Fields()
+		if idx < 0 || int(idx) >= len(fields) {
+			return nil, datamodel.ErrNotExists{Segment: datamodel.PathSegmentOfInt(idx)}
+		}
+		var curField int64
+		for _, field := range fields {
+			value, err := (*_node)(w).LookupByString(field.Name())
+			if err != nil {
+				return nil, err
+			}
+			if value.IsAbsent() {
+				continue
+			}
+			if curField == idx {
+				return buildListpairsField(basicnode.NewString(field.Name()), reprNode(value))
+			}
+			curField++
+		}
+		return nil, datamodel.ErrNotExists{Segment: datamodel.PathSegmentOfInt(idx)}
 	default:
 		v, err := (*_node)(w).LookupByIndex(idx)
 		if err != nil {
@@ -272,6 +292,11 @@ func (w *_nodeRepr) ListIterator() datamodel.ListIterator {
 		iter := _tupleIteratorRepr{cfg: w.cfg, schemaType: typ, fields: typ.Fields(), val: w.val}
 		iter.reprEnd = int(w.lengthMinusTrailingAbsents())
 		return &iter
+	case schema.StructRepresentation_ListPairs:
+		typ := w.schemaType.(*schema.TypeStruct)
+		iter := _listpairsIteratorRepr{cfg: w.cfg, schemaType: typ, fields: typ.Fields(), val: w.val}
+		iter.reprEnd = int(w.lengthMinusTrailingAbsents())
+		return &iter
 	default:
 		iter, _ := (*_node)(w).ListIterator().(*_listIterator)
 		if iter == nil {
@@ -319,21 +344,76 @@ type _tupleIteratorRepr struct {
 }
 
 func (w *_tupleIteratorRepr) Next() (index int64, value datamodel.Node, _ error) {
-_skipAbsent:
-	_, value, err := (*_structIterator)(w).Next()
-	if err != nil {
-		return 0, nil, err
-	}
-	if w.nextIndex > w.reprEnd {
-		goto _skipAbsent
+	for {
+		idx := w.nextIndex
+		_, value, err := (*_structIterator)(w).Next()
+		if err != nil {
+			return 0, nil, err
+		}
+		if w.nextIndex <= w.reprEnd {
+			return int64(idx), reprNode(value), nil
+		}
 	}
-	return int64(w.nextIndex), reprNode(value), nil
 }
 
 func (w *_tupleIteratorRepr) Done() bool {
 	return w.nextIndex >= w.reprEnd
 }
 
+type _listpairsIteratorRepr struct {
+	cfg        config
+	schemaType *schema.TypeStruct
+	fields     []schema.StructField
+	val        reflect.Value // non-pointer
+	nextIndex  int
+
+	// these are only used in repr.go
+	reprEnd int
+}
+
+func (w *_listpairsIteratorRepr) Next() (index int64, value datamodel.Node, _ error) {
+	for {
+		if w.Done() {
+			return 0, nil, datamodel.ErrIteratorOverread{}
+		}
+		idx := w.nextIndex
+		key, value, err := (*_structIterator)(w).Next()
+		if err != nil {
+			return 0, nil, err
+		}
+		if value.IsAbsent() || w.nextIndex > w.reprEnd {
+			continue
+		}
+		field, err := buildListpairsField(key, reprNode(value))
+		if err != nil {
+			return 0, nil, err
+		}
+		return int64(idx), field, nil
+	}
+}
+
+func (w *_listpairsIteratorRepr) Done() bool {
+	return w.nextIndex >= w.reprEnd
+}
+
+func buildListpairsField(key, value datamodel.Node) (datamodel.Node, error) {
+	nb := basicnode.Prototype.List.NewBuilder()
+	la, err := nb.BeginList(2)
+	if err != nil {
+		return nil, err
+	}
+	if err := la.AssembleValue().AssignNode(key); err != nil {
+		return nil, err
+	}
+	if err := la.AssembleValue().AssignNode(value); err != nil {
+		return nil, err
+	}
+	if err := la.Finish(); err != nil {
+		return nil, err
+	}
+	return nb.Build(), nil
+}
+
 func (w *_nodeRepr) lengthMinusTrailingAbsents() int64 {
 	fields := w.schemaType.(*schema.TypeStruct).Fields()
 	for i := len(fields) - 1; i >= 0; i-- {
@@ -353,6 +433,8 @@ func (w *_nodeRepr) Length() int64 {
 		return w.lengthMinusAbsents()
 	case schema.StructRepresentation_Tuple:
 		return w.lengthMinusTrailingAbsents()
+	case schema.StructRepresentation_ListPairs:
+		return w.lengthMinusAbsents()
 	case schema.UnionRepresentation_Keyed:
 		return (*_node)(w).Length()
 	case schema.UnionRepresentation_Kinded:
@@ -625,7 +707,7 @@ func (w *_assemblerRepr) BeginList(sizeHint int64) (datamodel.ListAssembler, err
 	switch stg := reprStrategy(w.schemaType).(type) {
 	case schema.UnionRepresentation_Kinded:
 		return w.asKinded(stg, datamodel.Kind_List).BeginList(sizeHint)
-	case schema.StructRepresentation_Tuple:
+	case schema.StructRepresentation_Tuple, schema.StructRepresentation_ListPairs:
 		asm, err := (*_assembler)(w).BeginMap(sizeHint)
 		if err != nil {
 			return nil, err
@@ -860,7 +942,7 @@ func (w *_structAssemblerRepr) AssembleKey() datamodel.NodeAssembler {
 			AppropriateKind: datamodel.KindSet_JustMap,
 			ActualKind:      datamodel.Kind_String,
 		}}
-	case schema.StructRepresentation_Tuple:
+	case schema.StructRepresentation_Tuple, schema.StructRepresentation_ListPairs:
 		return _errorAssembler{datamodel.ErrWrongKind{
 			TypeName:        w.schemaType.Name() + ".Repr",
 			MethodName:      "AssembleKey",
@@ -974,14 +1056,16 @@ func (w *_listStructAssemblerRepr) AssembleValue() datamodel.NodeAssembler {
 		}
 		entryAsm = assemblerRepr(entryAsm)
 		return entryAsm
+	case schema.StructRepresentation_ListPairs:
+		return &_listpairsFieldAssemblerRepr{parent: (*_structAssembler)(w)}
 	default:
 		return _errorAssembler{fmt.Errorf("bindnode AssembleValue TODO: %T", stg)}
 	}
 }
 
 func (w *_listStructAssemblerRepr) Finish() error {
 	switch stg := reprStrategy(w.schemaType).(type) {
-	case schema.StructRepresentation_Tuple:
+	case schema.StructRepresentation_Tuple, schema.StructRepresentation_ListPairs:
 		return (*_structAssembler)(w).Finish()
 	default:
 		return fmt.Errorf("bindnode Finish TODO: %T", stg)
@@ -992,6 +1076,112 @@ func (w *_listStructAssemblerRepr) ValuePrototype(idx int64) datamodel.NodeProto
 	panic("bindnode TODO: list ValuePrototype")
 }
 
+type _listpairsFieldAssemblerRepr struct {
+	parent *_structAssembler
+}
+
+func (w _listpairsFieldAssemblerRepr) BeginMap(int64) (datamodel.MapAssembler, error) {
+	return nil, datamodel.ErrWrongKind{
+		TypeName:        w.parent.schemaType.Name(),
+		MethodName:      "BeginMap",
+		AppropriateKind: datamodel.KindSet_JustList,
+		ActualKind:      datamodel.Kind_Map,
+	}
+}
+func (w *_listpairsFieldAssemblerRepr) BeginList(int64) (datamodel.ListAssembler, error) {
+	return &_listpairsFieldListAssemblerRepr{parent: w.parent}, nil
+}
+func (w _listpairsFieldAssemblerRepr) AssignNull() error {
+	return datamodel.ErrWrongKind{
+		TypeName:        w.parent.schemaType.Name(),
+		MethodName:      "AssignNull",
+		AppropriateKind: datamodel.KindSet_JustList,
+		ActualKind:      datamodel.Kind_Map,
+	}
+}
+func (w _listpairsFieldAssemblerRepr) AssignBool(bool) error {
+	return datamodel.ErrWrongKind{
+		TypeName:        w.parent.schemaType.Name(),
+		MethodName:      "AssignBool",
+		AppropriateKind: datamodel.KindSet_JustList,
+		ActualKind:      datamodel.Kind_Map,
+	}
+}
+func (w _listpairsFieldAssemblerRepr) AssignInt(int64) error {
+	return datamodel.ErrWrongKind{
+		TypeName:        w.parent.schemaType.Name(),
+		MethodName:      "AssignInt",
+		AppropriateKind: datamodel.KindSet_JustList,
+		ActualKind:      datamodel.Kind_Map,
+	}
+}
+func (w _listpairsFieldAssemblerRepr) AssignFloat(float64) error {
+	return datamodel.ErrWrongKind{
+		TypeName:        w.parent.schemaType.Name(),
+		MethodName:      "AssignFloat",
+		AppropriateKind: datamodel.KindSet_JustList,
+		ActualKind:      datamodel.Kind_Map,
+	}
+}
+func (w _listpairsFieldAssemblerRepr) AssignString(string) error {
+	return datamodel.ErrWrongKind{
+		TypeName:        w.parent.schemaType.Name(),
+		MethodName:      "AssignString",
+		AppropriateKind: datamodel.KindSet_JustList,
+		ActualKind:      datamodel.Kind_Map,
+	}
+}
+func (w _listpairsFieldAssemblerRepr) AssignBytes([]byte) error {
+	return datamodel.ErrWrongKind{
+		TypeName:        w.parent.schemaType.Name(),
+		MethodName:      "AssignBytes",
+		AppropriateKind: datamodel.KindSet_JustList,
+		ActualKind:      datamodel.Kind_Map,
+	}
+}
+func (w _listpairsFieldAssemblerRepr) AssignLink(datamodel.Link) error {
+	return datamodel.ErrWrongKind{
+		TypeName:        w.parent.schemaType.Name(),
+		MethodName:      "AssignLink",
+		AppropriateKind: datamodel.KindSet_JustList,
+		ActualKind:      datamodel.Kind_Map,
+	}
+}
+
+func (w *_listpairsFieldAssemblerRepr) AssignNode(n datamodel.Node) error {
+	return datamodel.Copy(n, w)
+}
+
+func (w _listpairsFieldAssemblerRepr) Prototype() datamodel.NodePrototype {
+	panic("bindnode TODO: listpairs field Prototype")
+}
+
+type _listpairsFieldListAssemblerRepr struct {
+	parent *_structAssembler
+	idx    int
+}
+
+func (w *_listpairsFieldListAssemblerRepr) AssembleValue() datamodel.NodeAssembler {
+	w.idx++
+	switch w.idx {
+	case 1:
+		return w.parent.AssembleKey()
+	case 2:
+		asm := w.parent.AssembleValue()
+		return assemblerRepr(asm.(*_assembler))
+	default:
+		return _errorAssembler{fmt.Errorf("bindnode: too many values in listpairs field")}
+	}
+}
+
+func (w *_listpairsFieldListAssemblerRepr) Finish() error {
+	return nil
+}
+
+func (w *_listpairsFieldListAssemblerRepr) ValuePrototype(idx int64) datamodel.NodePrototype {
+	panic("bindnode TODO: listpairs field ValuePrototype")
+}
+
 // Note that lists do not have any representation strategy right now.
 type _listAssemblerRepr _listAssembler
 
@@ -1064,20 +1254,21 @@ type _structIteratorRepr _structIterator
 func (w *_structIteratorRepr) Next() (key, value datamodel.Node, _ error) {
 	switch stg := reprStrategy(w.schemaType).(type) {
 	case schema.StructRepresentation_Map:
-	_skipAbsent:
-		key, value, err := (*_structIterator)(w).Next()
-		if err != nil {
-			return nil, nil, err
-		}
-		if value.IsAbsent() {
-			goto _skipAbsent
-		}
-		keyStr, _ := key.AsString()
-		mappedKey := outboundMappedKey(stg, keyStr)
-		if mappedKey != keyStr {
-			key = basicnode.NewString(mappedKey)
+		for {
+			key, value, err := (*_structIterator)(w).Next()
+			if err != nil {
+				return nil, nil, err
+			}
+			if value.IsAbsent() {
+				continue
+			}
+			keyStr, _ := key.AsString()
+			mappedKey := outboundMappedKey(stg, keyStr)
+			if mappedKey != keyStr {
+				key = basicnode.NewString(mappedKey)
+			}
+			return key, reprNode(value), nil
 		}
-		return key, reprNode(value), nil
 	default:
 		return nil, nil, fmt.Errorf("bindnode Next TODO: %T", stg)
 	}

node/tests/schema.go

@@ -19,6 +19,7 @@ var allSchemaTests = []struct {
 	{"StructNesting", SchemaTestStructNesting},
 	{"StructReprStringjoin", SchemaTestStructReprStringjoin},
 	{"StructReprTuple", SchemaTestStructReprTuple},
+	{"StructReprListPairs", SchemaTestStructReprListPairs},
 	{"StructsContainingMaybe", SchemaTestStructsContainingMaybe},
 	{"UnionKeyed", SchemaTestUnionKeyed},
 	{"UnionKeyedComplexChildren", SchemaTestUnionKeyedComplexChildren},