move lib/go/gremlin to ent/dialect (#1192)

Summary:
Pull Request resolved: https://github.com/facebookexternal/fbc/pull/1192

Pull Request resolved: https://github.com/facebookincubator/ent/pull/11

Reviewed By: alexsn

Differential Revision: D16377224

fbshipit-source-id: 07ca7436eb9b64fbe2299568560b91466b2417ba

dialect/gremlin/encoding/graphson/interface.go

@@ -0,0 +1,149 @@
+package graphson
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"unsafe"
+
+	"github.com/json-iterator/go"
+	"github.com/modern-go/reflect2"
+	"github.com/pkg/errors"
+)
+
+// DecoratorOfInterface decorates a value decoder of an interface type.
+func (decodeExtension) DecoratorOfInterface(typ reflect2.Type, dec jsoniter.ValDecoder) jsoniter.ValDecoder {
+	if _, ok := typ.(*reflect2.UnsafeEFaceType); ok {
+		return efaceDecoder{typ, dec}
+	}
+	return dec
+}
+
+type efaceDecoder struct {
+	typ reflect2.Type
+	jsoniter.ValDecoder
+}
+
+func (dec efaceDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	switch next := iter.WhatIsNext(); next {
+	case jsoniter.StringValue, jsoniter.BoolValue, jsoniter.NilValue:
+		dec.ValDecoder.Decode(ptr, iter)
+	case jsoniter.ObjectValue:
+		dec.decode(ptr, iter)
+	default:
+		iter.ReportError("decode empty interface", fmt.Sprintf("unexpected value type: %d", next))
+	}
+}
+
+func (dec efaceDecoder) decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	data := iter.SkipAndReturnBytes()
+	if iter.Error != nil && iter.Error != io.EOF {
+		return
+	}
+
+	rtype, err := dec.reflectBytes(data)
+	if err != nil {
+		iter.ReportError("decode empty interface", err.Error())
+		return
+	}
+
+	it := config.BorrowIterator(data)
+	defer config.ReturnIterator(it)
+
+	var val interface{}
+	if rtype != nil {
+		val = rtype.New()
+		it.ReadVal(val)
+		val = rtype.Indirect(val)
+	} else {
+		if jsoniter.Get(data, TypeKey).LastError() == nil {
+			vk := jsoniter.Get(data, ValueKey)
+			if vk.LastError() == nil {
+				val = vk.GetInterface()
+			}
+		}
+		if val == nil {
+			val = it.Read()
+		}
+	}
+
+	if it.Error != nil && it.Error != io.EOF {
+		iter.ReportError("decode empty interface", it.Error.Error())
+		return
+	}
+
+	// nolint: gas
+	dec.typ.UnsafeSet(ptr, unsafe.Pointer(&val))
+}
+
+func (dec efaceDecoder) reflectBytes(data []byte) (reflect2.Type, error) {
+	typ := Type(jsoniter.Get(data, TypeKey).ToString())
+	rtype := dec.reflectType(typ)
+	if rtype != nil {
+		return rtype, nil
+	}
+
+	switch typ {
+	case listType:
+		return dec.reflectSlice(data)
+	case mapType:
+		return dec.reflectMap(data)
+	default:
+		return nil, nil
+	}
+}
+
+func (efaceDecoder) reflectType(typ Type) reflect2.Type {
+	switch typ {
+	case doubleType:
+		return reflect2.TypeOf(float64(0))
+	case floatType:
+		return reflect2.TypeOf(float32(0))
+	case byteType:
+		return reflect2.TypeOf(uint8(0))
+	case int16Type:
+		return reflect2.TypeOf(int16(0))
+	case int32Type:
+		return reflect2.TypeOf(int32(0))
+	case int64Type, bigIntegerType:
+		return reflect2.TypeOf(int64(0))
+	case byteBufferType:
+		return reflect2.TypeOf([]byte{})
+	default:
+		return nil
+	}
+}
+
+func (efaceDecoder) reflectSlice(data []byte) (reflect2.Type, error) {
+	var elem interface{}
+	if err := Unmarshal(data, &[...]*interface{}{&elem}); err != nil {
+		return nil, errors.Wrap(err, "cannot read first list element")
+	}
+
+	if elem == nil {
+		return reflect2.TypeOf([]interface{}{}), nil
+	}
+
+	sliceType := reflect.SliceOf(reflect.TypeOf(elem))
+	return reflect2.Type2(sliceType), nil
+}
+
+func (efaceDecoder) reflectMap(data []byte) (reflect2.Type, error) {
+	var key, elem interface{}
+	if err := Unmarshal(
+		bytes.Replace(data, []byte(mapType), []byte(listType), 1),
+		&[...]*interface{}{&key, &elem},
+	); err != nil {
+		return nil, errors.Wrap(err, "cannot unmarshal first map item")
+	}
+
+	if key == nil {
+		return reflect2.TypeOf(map[interface{}]interface{}{}), nil
+	} else if elem == nil {
+		return nil, errors.New("expect map element, but found only key")
+	}
+
+	mapType := reflect.MapOf(reflect.TypeOf(key), reflect.TypeOf(elem))
+	return reflect2.Type2(mapType), nil
+}