vdl/vdltest/mimic_value.go

// Copyright 2016 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vdltest

import (
	"fmt"
	"math"

	"v.io/v23/vdl"
)

const (
	// TODO(toddw): Move these constants to a common place, they already exist in
	// the vdl and vom packages.  Also think about how to factor out the number
	// conversion logic.
	float64MaxInt = (1 << 53)
	float64MinInt = -(1 << 53)
	float32MaxInt = (1 << 24)
	float32MinInt = -(1 << 24)
)

// MimicValue returns a value of type tt that, when converted to the type of the
// base value, results in exactly the base value.  If tt is Any, the type of the
// returned value is the type of the base value.
//
// Returns nil if no such value is possible.  E.g. if tt is uint32 and base is
// int32(-1), no value of type tt can be converted to the base value.
func MimicValue(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	// Handle nil first, to get rid of pesky corner cases.  After this is done,
	// we've flattened the base value to its non-nil element.
	if base.Kind() == vdl.Any && !base.IsNil() {
		base = base.Elem()
	}
	if base.IsNil() {
		return mimicNilValue(tt, base)
	}
	// Now we know we're dealing with a non-nil base.  Flatten tt to a non-any
	// non-optional type.
	if tt == vdl.AnyType {
		// If we're asked to build a value of any type, we must build exactly the
		// same type as the base.  It's not good enough to build a value of a
		// compatible type; if the base itself is an any type, it must be populated
		// with a value of the exact type.
		tt = base.Type()
	}
	value := mimicNonNilValue(tt.NonOptional(), base.NonOptional())
	if value == nil {
		return nil
	}
	if tt.Kind() == vdl.Optional {
		value = vdl.OptionalValue(value)
	}
	return value
}

// mimicNilValue implements MimicValue for nil base values.
//
// REQUIRES: base.IsNil() is true
func mimicNilValue(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	switch {
	case tt == vdl.AnyType:
		// We can convert from any(nil) to all nil base values.
		return vdl.ZeroValue(vdl.AnyType)
	case tt.Kind() != vdl.Optional:
		// Can't convert from a non-any non-optional type to a nil value.
		return nil
	}
	// Now we know that tt is optional, and base is either any(nil) or
	// optional(nil).
	switch {
	case base.Type() == vdl.AnyType:
		// Can't convert from optional(nil) to any(nil).
		return nil
	case !vdl.Compatible2(tt, base.Type()):
		// Can't convert incompatible optional types.
		return nil
	}
	// Now we know that tt and base are both optional and compatible.
	return vdl.ZeroValue(tt)
}

// mimicNonNilValue implements MimicValue for non-nil base values.
//
// REQUIRES: tt and base cannot be Optional or Any.
func mimicNonNilValue(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	if !vdl.Compatible2(tt, base.Type()) {
		return nil
	}
	switch tt.Kind() {
	case vdl.Bool:
		return vdl.BoolValue(tt, base.Bool())
	case vdl.String:
		return vdl.StringValue(tt, stringOrEnumLabel(base))
	case vdl.Enum:
		index := tt.EnumIndex(stringOrEnumLabel(base))
		if index == -1 {
			return nil
		}
		return vdl.EnumValue(tt, index)
	case vdl.TypeObject:
		return base // TypeObject is only convertible from itself.
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
		return mimicUint(tt, base)
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
		return mimicInt(tt, base)
	case vdl.Float32, vdl.Float64:
		return mimicFloat(tt, base)
	case vdl.Array, vdl.List:
		return mimicArrayList(tt, base)
	case vdl.Set:
		return mimicSet(tt, base)
	case vdl.Map:
		return mimicMap(tt, base)
	case vdl.Struct:
		return mimicStruct(tt, base)
	case vdl.Union:
		return mimicUnion(tt, base)
	}
	panic(fmt.Errorf("vdltest: mimicNonNilValue unhandled type %v", tt))
}

func stringOrEnumLabel(vv *vdl.Value) string {
	if vv.Kind() == vdl.String {
		return vv.RawString()
	}
	return vv.EnumLabel()
}

func mimicUint(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	bitlen := uint(tt.Kind().BitLen())
	var x uint64
	switch base.Kind() {
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
		x = base.Uint()
		if shift := 64 - bitlen; x != (x<<shift)>>shift {
			return nil
		}
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
		ix := base.Int()
		x = uint64(ix)
		if shift := 64 - bitlen; ix < 0 || x != (x<<shift)>>shift {
			return nil
		}
	case vdl.Float32, vdl.Float64:
		fx := base.Float()
		x = uint64(fx)
		if shift := 64 - bitlen; fx != float64(x) || x != (x<<shift)>>shift {
			return nil
		}
	}
	return vdl.UintValue(tt, x)
}

func mimicInt(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	bitlen := uint(tt.Kind().BitLen())
	var x int64
	switch base.Kind() {
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
		ux := base.Uint()
		x = int64(ux)
		// The shift uses 65 since the topmost bit is the sign bit.  E.g. 32 bit
		// numbers should be shifted by 33 rather than 32.
		if shift := 65 - bitlen; x < 0 || ux != (ux<<shift)>>shift {
			return nil
		}
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
		x = base.Int()
		if shift := 64 - bitlen; x != (x<<shift)>>shift {
			return nil
		}
	case vdl.Float32, vdl.Float64:
		fx := base.Float()
		x = int64(fx)
		if shift := 64 - bitlen; fx != float64(x) || x != (x<<shift)>>shift {
			return nil
		}
	}
	return vdl.IntValue(tt, x)
}

func mimicFloat(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	bitlen := uint(tt.Kind().BitLen())
	var x float64
	switch base.Kind() {
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
		ux := base.Uint()
		x = float64(ux)
		var max uint64
		if bitlen > 32 {
			max = float64MaxInt
		} else {
			max = float32MaxInt
		}
		if ux > max {
			return nil
		}
	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
		ix := base.Int()
		x = float64(ix)
		var min, max int64
		if bitlen > 32 {
			min, max = float64MinInt, float64MaxInt
		} else {
			min, max = float32MinInt, float32MaxInt
		}
		if ix < min || ix > max {
			return nil
		}
	case vdl.Float32:
		x = base.Float()
	case vdl.Float64:
		x = base.Float()
		if tt.Kind() == vdl.Float32 {
			// We're trying to mimic a base float64 value with a float32 value.  Make
			// sure we won't lose precision.
			//
			// Float64 has 1 sign bit, 11 exponent bits, and 52 fraction bits.
			// Float32 has 1 sign bit, 8 exponent bits, and 23 fraction bits.
			//
			// The offsetExp is offset by 1023.  Some special values:
			//   offsetExp == 0   && frac == 0 : Negative 0
			//   offsetExp == 0   && frac > 0  : Subnormal number
			//   offsetExp == 7ff && frac == 0 : Inf
			//   offsetExp == 7ff && frac > 0  : NaN
			//
			// https://en.wikipedia.org/wiki/Double-precision_floating-point_format
			// https://en.wikipedia.org/wiki/Single-precision_floating-point_format
			bits := math.Float64bits(x)
			offsetExp := bits >> 52 & ((1 << 11) - 1)
			frac := bits & ((1 << 52) - 1)
			switch exp := int(offsetExp) - 1023; {
			case offsetExp == 0 && frac > 0:
				// Float64 subnormals can't be represented by float32.
				return nil
			case exp < -0xff || exp > 0xff:
				// Float64 with >8 exponent bits can't be represented by float32.
				// TODO(toddw): Handle Inf and Nan in vdl float consts.
				return nil
			case frac&((1<<23)-1) != 0:
				// Float64 with >23 fraction bits can't be represented by float32.
				return nil
			}
		}
	}
	return vdl.FloatValue(tt, x)
}

func mimicArrayList(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	value := vdl.ZeroValue(tt)
	switch tt.Kind() {
	case vdl.Array:
		if tt.Len() != base.Len() {
			return nil
		}
	case vdl.List:
		value.AssignLen(base.Len())
	}
	for ix := 0; ix < base.Len(); ix++ {
		elem := MimicValue(tt.Elem(), base.Index(ix))
		if elem == nil {
			return nil
		}
		value.AssignIndex(ix, elem)
	}
	return value
}

func mimicSet(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	value := vdl.ZeroValue(tt)
	for _, baseKey := range base.Keys() {
		key := MimicValue(tt.Key(), baseKey)
		if key == nil {
			return nil
		}
		value.AssignSetKey(key)
	}
	return value
}

func mimicMap(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	value := vdl.ZeroValue(tt)
	for _, baseKey := range base.Keys() {
		key := MimicValue(tt.Key(), baseKey)
		if key == nil {
			return nil
		}
		elem := MimicValue(tt.Elem(), base.MapIndex(baseKey))
		if elem == nil {
			return nil
		}
		value.AssignMapIndex(key, elem)
	}
	return value
}

func mimicStruct(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	value := vdl.ZeroValue(tt)
	for ix := 0; ix < base.Type().NumField(); ix++ {
		baseField := base.StructField(ix)
		if baseField.IsZero() {
			// Skip zero base fields.  It's fine for the base field to be missing from
			// tt, as long as the base field is zero, since Convert(dst, src) sets all
			// dst (which has type base.Type) fields to zero before setting each
			// matching field in src (which has type tt).
			continue
		}
		ttField, ttIndex := tt.FieldByName(base.Type().Field(ix).Name)
		if ttIndex == -1 {
			// This is a non-zero base field that doesn't exist in tt.  There's no way
			// to create a value of type tt that converts to exactly the base value.
			return nil
		}
		field := MimicValue(ttField.Type, baseField)
		if field == nil {
			return nil
		}
		value.AssignField(ttIndex, field)
	}
	return value
}

func mimicUnion(tt *vdl.Type, base *vdl.Value) *vdl.Value {
	baseIndex, baseField := base.UnionField()
	ttField, ttIndex := tt.FieldByName(base.Type().Field(baseIndex).Name)
	if ttIndex == -1 {
		// The base field doesn't exist in tt.  There's no way to create a value of
		// type tt that converts to exactly the base value.
		return nil
	}
	field := MimicValue(ttField.Type, baseField)
	if field == nil {
		return nil
	}
	return vdl.UnionValue(tt, ttIndex, field)
}