node/bindnode: redesign the shape of unions in Go

node/bindnode/api.go

@@ -21,6 +21,7 @@ import (
 // the other provided type. For example, we can infer an unnamed Go struct type
 // for a schema struct tyep, and we can infer a schema Int type for a Go int64
 // type. The inferring logic is still a work in progress and subject to change.
+// At this time, inferring IPLD Unions and Enums from Go types is not supported.
 //
 // When supplying a non-nil ptrType, Prototype only obtains the Go pointer type
 // from it, so its underlying value will typically be nil. For example:

node/bindnode/example_test.go

@@ -1,6 +1,7 @@
 package bindnode_test
 
 import (
+	"fmt"
 	"os"
 
 	ipld "github.com/ipld/go-ipld-prime"
@@ -99,3 +100,60 @@ func ExamplePrototype_onlySchema() {
 	// Output:
 	// {"Friends":["Sarah","Alex"],"Name":"Michael"}
 }
+
+func ExamplePrototype_union() {
+	ts := schema.TypeSystem{}
+	ts.Init()
+	ts.Accumulate(schema.SpawnString("String"))
+	ts.Accumulate(schema.SpawnInt("Int"))
+	ts.Accumulate(schema.SpawnUnion("StringOrInt",
+		[]schema.TypeName{
+			"String",
+			"Int",
+		},
+		schema.SpawnUnionRepresentationKeyed(map[string]schema.TypeName{
+			"hasString": "String",
+			"hasInt":    "Int",
+		}),
+	))
+
+	schemaType := ts.TypeByName("StringOrInt")
+
+	type CustomIntType int64
+	type StringOrInt struct {
+		String *string
+		Int    *CustomIntType // We can use custom types, too.
+	}
+
+	proto := bindnode.Prototype((*StringOrInt)(nil), schemaType)
+
+	node, err := qp.BuildMap(proto.Representation(), -1, func(ma ipld.MapAssembler) {
+		qp.MapEntry(ma, "hasInt", qp.Int(123))
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Print("Type level DAG-JSON: ")
+	dagjson.Encode(node, os.Stdout)
+	fmt.Println()
+
+	fmt.Print("Representation level DAG-JSON: ")
+	nodeRepr := node.(schema.TypedNode).Representation()
+	dagjson.Encode(nodeRepr, os.Stdout)
+	fmt.Println()
+
+	// Inspect what the underlying Go value contains.
+	union := bindnode.Unwrap(node).(*StringOrInt)
+	switch {
+	case union.String != nil:
+		fmt.Printf("Go StringOrInt.String: %v\n", *union.String)
+	case union.Int != nil:
+		fmt.Printf("Go StringOrInt.Int: %v\n", *union.Int)
+	}
+
+	// Output:
+	// Type level DAG-JSON: {"Int":123}
+	// Representation level DAG-JSON: {"hasInt":123}
+	// Go StringOrInt.Int: 123
+}

node/bindnode/infer.go

@@ -89,12 +89,21 @@ func inferGoType(typ schema.Type) reflect.Type {
 		}
 		return reflect.SliceOf(etyp)
 	case *schema.TypeUnion:
-		// We need an extra field to record what member we stored.
-		type goUnion struct {
-			Index int // 0..len(typ.Members)-1
-			Value interface{}
+		// type goUnion struct {
+		// 	Type1 *Type1
+		// 	Type2 *Type2
+		// 	...
+		// }
+		members := typ.Members()
+		fieldsGo := make([]reflect.StructField, len(members))
+		for i, ftyp := range members {
+			ftypGo := inferGoType(ftyp)
+			fieldsGo[i] = reflect.StructField{
+				Name: fieldNameFromSchema(string(ftyp.Name())),
+				Type: reflect.PtrTo(ftypGo),
+			}
 		}
-		return reflect.TypeOf(goUnion{})
+		return reflect.StructOf(fieldsGo)
 	}
 	panic(fmt.Sprintf("%T\n", typ))
 }

node/bindnode/node.go

@@ -162,11 +162,11 @@ func (w *_node) LookupByString(key string) (ipld.Node, error) {
 		if mtyp == nil { // not found
 			return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)}
 		}
-		haveIdx := int(w.val.FieldByName("Index").Int())
+		// TODO: we could look up the right Go field straight away via idx.
+		haveIdx, mval := unionMember(w.val)
 		if haveIdx != idx { // mismatching type
 			return nil, ipld.ErrNotExists{Segment: ipld.PathSegmentOfString(key)}
 		}
-		mval := w.val.FieldByName("Value").Elem()
 		node := &_node{
 			schemaType: mtyp,
 			val:        mval,
@@ -180,6 +180,28 @@ func (w *_node) LookupByString(key string) (ipld.Node, error) {
 	}
 }
 
+var invalidValue reflect.Value
+
+func unionMember(val reflect.Value) (int, reflect.Value) {
+	// The first non-nil field is a match.
+	for i := 0; i < val.NumField(); i++ {
+		elemVal := val.Field(i)
+		if elemVal.IsNil() {
+			continue
+		}
+		return i, elemVal.Elem()
+	}
+	return -1, invalidValue
+}
+
+func unionSetMember(val reflect.Value, memberIdx int, memberPtr reflect.Value) {
+	// Reset the entire union struct to zero, to clear any non-nil pointers.
+	val.Set(reflect.Zero(val.Type()))
+
+	// Set the index pointer to the given value.
+	val.Field(memberIdx).Set(memberPtr)
+}
+
 func (w *_node) LookupByIndex(idx int64) (ipld.Node, error) {
 	switch typ := w.schemaType.(type) {
 	case *schema.TypeList:
@@ -917,17 +939,17 @@ func (w *_unionAssembler) AssembleValue() ipld.NodeAssembler {
 		// 	Key:      basicnode.NewString(name),
 		// }
 	}
-	goType := inferGoType(mtyp) // TODO: do this upfront
-	val := reflect.New(goType).Elem()
+
+	goType := w.val.Field(idx).Type().Elem()
+	valPtr := reflect.New(goType)
 	finish := func() error {
 		// fmt.Println(kval.Interface(), val.Interface())
-		w.val.FieldByName("Index").SetInt(int64(idx))
-		w.val.FieldByName("Value").Set(val)
+		unionSetMember(w.val, idx, valPtr)
 		return nil
 	}
 	return &_assembler{
 		schemaType: mtyp,
-		val:        val,
+		val:        valPtr.Elem(),
 		finish:     finish,
 	}
 }
@@ -1076,9 +1098,8 @@ func (w *_unionIterator) Next() (key, value ipld.Node, _ error) {
 	}
 	w.done = true
 
-	haveIdx := int(w.val.FieldByName("Index").Int())
+	haveIdx, mval := unionMember(w.val)
 	mtyp := w.members[haveIdx]
-	mval := w.val.FieldByName("Value").Elem()
 
 	node := &_node{
 		schemaType: mtyp,

node/bindnode/repr.go

@@ -52,7 +52,7 @@ func (w *_nodeRepr) Kind() ipld.Kind {
 	case schema.UnionRepresentation_Keyed:
 		return ipld.Kind_Map
 	case schema.UnionRepresentation_Kinded:
-		haveIdx := int(w.val.FieldByName("Index").Int())
+		haveIdx, _ := unionMember(w.val)
 		mtyp := w.schemaType.(*schema.TypeUnion).Members()[haveIdx]
 		return mtyp.TypeKind().ActsLike()
 	case schema.UnionRepresentation_Stringprefix:
@@ -108,12 +108,12 @@ func inboundMappedType(typ *schema.TypeUnion, stg schema.UnionRepresentation_Key
 func (w *_nodeRepr) asKinded(stg schema.UnionRepresentation_Kinded, kind ipld.Kind) *_nodeRepr {
 	name := stg.GetMember(kind)
 	members := w.schemaType.(*schema.TypeUnion).Members()
-	for _, member := range members {
+	for i, member := range members {
 		if member.Name() != name {
 			continue
 		}
 		w2 := *w
-		w2.val = w.val.FieldByName("Value").Elem()
+		w2.val = w.val.Field(i).Elem()
 		w2.schemaType = member
 		return &w2
 	}
@@ -340,11 +340,11 @@ func (w *_nodeRepr) AsString() (string, error) {
 		}
 		return b.String(), nil
 	case schema.UnionRepresentation_Stringprefix:
-		haveIdx := int(w.val.FieldByName("Index").Int())
+		haveIdx, mval := unionMember(w.val)
 		mtyp := w.schemaType.(*schema.TypeUnion).Members()[haveIdx]
 
 		w2 := *w
-		w2.val = w.val.FieldByName("Value").Elem()
+		w2.val = mval
 		w2.schemaType = mtyp
 		s, err := w2.AsString()
 		if err != nil {
@@ -432,8 +432,9 @@ func (w *_assemblerRepr) asKinded(stg schema.UnionRepresentation_Kinded, kind ip
 			continue
 		}
 		w2 := *w
-		goType := inferGoType(member) // TODO: do this upfront
-		w2.val = reflect.New(goType).Elem()
+		goType := w.val.Field(idx).Type().Elem()
+		valPtr := reflect.New(goType)
+		w2.val = valPtr.Elem()
 		w2.schemaType = member
 
 		// Layer a new finish func on top, to set Index/Value.
@@ -443,8 +444,7 @@ func (w *_assemblerRepr) asKinded(stg schema.UnionRepresentation_Kinded, kind ip
 					return err
 				}
 			}
-			w.val.FieldByName("Index").SetInt(int64(idx))
-			w.val.FieldByName("Value").Set(w2.val)
+			unionSetMember(w.val, idx, valPtr)
 			return nil
 		}
 		return &w2
@@ -557,8 +557,9 @@ func (w *_assemblerRepr) AssignString(s string) error {
 			if member.Name() != name {
 				continue
 			}
-			w.val.FieldByName("Index").SetInt(int64(idx))
-			w.val.FieldByName("Value").Set(reflect.ValueOf(s))
+			valPtr := reflect.New(goTypeString)
+			valPtr.Elem().SetString(s)
+			unionSetMember(w.val, idx, valPtr)
 			return nil
 		}
 		panic("TODO: GetMember result is missing?")
@@ -575,17 +576,17 @@ func (w *_assemblerRepr) AssignString(s string) error {
 			}
 
 			w2 := *w
-			goType := inferGoType(member) // TODO: do this upfront
-			w2.val = reflect.New(goType).Elem()
+			goType := w.val.Field(idx).Type().Elem()
+			valPtr := reflect.New(goType)
+			w2.val = valPtr.Elem()
 			w2.schemaType = member
 			w2.finish = func() error {
 				if w.finish != nil {
 					if err := w.finish(); err != nil {
 						return err
 					}
 				}
-				w.val.FieldByName("Index").SetInt(int64(idx))
-				w.val.FieldByName("Value").Set(w2.val)
+				unionSetMember(w.val, idx, valPtr)
 				return nil
 			}