package gocty import ( "math/big" "reflect" "github.com/zclconf/go-cty/cty" "github.com/zclconf/go-cty/cty/set" ) // ToCtyValue produces a cty.Value from a Go value. The result will conform // to the given type, or an error will be returned if this is not possible. // // The target type serves as a hint to resolve ambiguities in the mapping. // For example, the Go type set.Set tells us that the value is a set but // does not describe the set's element type. This also allows for convenient // conversions, such as populating a set from a slice rather than having to // first explicitly instantiate a set.Set. // // The audience of this function is assumed to be the developers of Go code // that is integrating with cty, and thus the error messages it returns are // presented from Go's perspective. These messages are thus not appropriate // for display to end-users. An error returned from ToCtyValue represents a // bug in the calling program, not user error. func ToCtyValue(val interface{}, ty cty.Type) (cty.Value, error) { // 'path' starts off as empty but will grow for each level of recursive // call we make, so by the time toCtyValue returns it is likely to have // unused capacity on the end of it, depending on how deeply-recursive // the given Type is. path := make(cty.Path, 0) return toCtyValue(reflect.ValueOf(val), ty, path) } func toCtyValue(val reflect.Value, ty cty.Type, path cty.Path) (cty.Value, error) { switch ty { case cty.Bool: return toCtyBool(val, path) case cty.Number: return toCtyNumber(val, path) case cty.String: return toCtyString(val, path) case cty.DynamicPseudoType: return toCtyDynamic(val, path) } switch { case ty.IsListType(): return toCtyList(val, ty.ElementType(), path) case ty.IsMapType(): return toCtyMap(val, ty.ElementType(), path) case ty.IsSetType(): return toCtySet(val, ty.ElementType(), path) case ty.IsObjectType(): return toCtyObject(val, ty.AttributeTypes(), path) case ty.IsTupleType(): return toCtyTuple(val, ty.TupleElementTypes(), path) case ty.IsCapsuleType(): return toCtyCapsule(val, ty, path) } // We should never fall out here return cty.NilVal, path.NewErrorf("unsupported target type %#v", ty) } func toCtyBool(val reflect.Value, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.Bool), nil } switch val.Kind() { case reflect.Bool: return cty.BoolVal(val.Bool()), nil default: return cty.NilVal, path.NewErrorf("can't convert Go %s to bool", val.Kind()) } } func toCtyNumber(val reflect.Value, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.Number), nil } switch val.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return cty.NumberIntVal(val.Int()), nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return cty.NumberUIntVal(val.Uint()), nil case reflect.Float32, reflect.Float64: return cty.NumberFloatVal(val.Float()), nil case reflect.Struct: if val.Type().AssignableTo(bigIntType) { bigInt := val.Interface().(big.Int) bigFloat := (&big.Float{}).SetInt(&bigInt) val = reflect.ValueOf(*bigFloat) } if val.Type().AssignableTo(bigFloatType) { bigFloat := val.Interface().(big.Float) return cty.NumberVal(&bigFloat), nil } fallthrough default: return cty.NilVal, path.NewErrorf("can't convert Go %s to number", val.Kind()) } } func toCtyString(val reflect.Value, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.String), nil } switch val.Kind() { case reflect.String: return cty.StringVal(val.String()), nil default: return cty.NilVal, path.NewErrorf("can't convert Go %s to string", val.Kind()) } } func toCtyList(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.List(ety)), nil } switch val.Kind() { case reflect.Slice: if val.IsNil() { return cty.NullVal(cty.List(ety)), nil } fallthrough case reflect.Array: if val.Len() == 0 { return cty.ListValEmpty(ety), nil } // While we work on our elements we'll temporarily grow // path to give us a place to put our index step. path = append(path, cty.PathStep(nil)) vals := make([]cty.Value, val.Len()) for i := range vals { var err error path[len(path)-1] = cty.IndexStep{ Key: cty.NumberIntVal(int64(i)), } vals[i], err = toCtyValue(val.Index(i), ety, path) if err != nil { return cty.NilVal, err } } // Discard our extra path segment, retaining it as extra capacity // for future appending to the path. path = path[:len(path)-1] return cty.ListVal(vals), nil default: return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.List(ety)) } } func toCtyMap(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.Map(ety)), nil } switch val.Kind() { case reflect.Map: if val.IsNil() { return cty.NullVal(cty.Map(ety)), nil } if val.Len() == 0 { return cty.MapValEmpty(ety), nil } keyType := val.Type().Key() if keyType.Kind() != reflect.String { return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType) } // While we work on our elements we'll temporarily grow // path to give us a place to put our index step. path = append(path, cty.PathStep(nil)) vals := make(map[string]cty.Value, val.Len()) for _, kv := range val.MapKeys() { k := kv.String() var err error path[len(path)-1] = cty.IndexStep{ Key: cty.StringVal(k), } vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), ety, path) if err != nil { return cty.NilVal, err } } // Discard our extra path segment, retaining it as extra capacity // for future appending to the path. path = path[:len(path)-1] return cty.MapVal(vals), nil default: return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Map(ety)) } } func toCtySet(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.Set(ety)), nil } var vals []cty.Value switch val.Kind() { case reflect.Slice: if val.IsNil() { return cty.NullVal(cty.Set(ety)), nil } fallthrough case reflect.Array: if val.Len() == 0 { return cty.SetValEmpty(ety), nil } vals = make([]cty.Value, val.Len()) for i := range vals { var err error vals[i], err = toCtyValue(val.Index(i), ety, path) if err != nil { return cty.NilVal, err } } case reflect.Struct: if !val.Type().AssignableTo(setType) { return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Type(), cty.Set(ety)) } rawSet := val.Interface().(set.Set) inVals := rawSet.Values() if len(inVals) == 0 { return cty.SetValEmpty(ety), nil } vals = make([]cty.Value, len(inVals)) for i := range inVals { var err error vals[i], err = toCtyValue(reflect.ValueOf(inVals[i]), ety, path) if err != nil { return cty.NilVal, err } } default: return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Set(ety)) } return cty.SetVal(vals), nil } func toCtyObject(val reflect.Value, attrTypes map[string]cty.Type, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.Object(attrTypes)), nil } switch val.Kind() { case reflect.Map: if val.IsNil() { return cty.NullVal(cty.Object(attrTypes)), nil } keyType := val.Type().Key() if keyType.Kind() != reflect.String { return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType) } if len(attrTypes) == 0 { return cty.EmptyObjectVal, nil } // While we work on our elements we'll temporarily grow // path to give us a place to put our GetAttr step. path = append(path, cty.PathStep(nil)) haveKeys := make(map[string]struct{}, val.Len()) for _, kv := range val.MapKeys() { haveKeys[kv.String()] = struct{}{} } vals := make(map[string]cty.Value, len(attrTypes)) for k, at := range attrTypes { var err error path[len(path)-1] = cty.GetAttrStep{ Name: k, } if _, have := haveKeys[k]; !have { vals[k] = cty.NullVal(at) continue } vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), at, path) if err != nil { return cty.NilVal, err } } // Discard our extra path segment, retaining it as extra capacity // for future appending to the path. path = path[:len(path)-1] return cty.ObjectVal(vals), nil case reflect.Struct: if len(attrTypes) == 0 { return cty.EmptyObjectVal, nil } // While we work on our elements we'll temporarily grow // path to give us a place to put our GetAttr step. path = append(path, cty.PathStep(nil)) attrFields := structTagIndices(val.Type()) vals := make(map[string]cty.Value, len(attrTypes)) for k, at := range attrTypes { path[len(path)-1] = cty.GetAttrStep{ Name: k, } if fieldIdx, have := attrFields[k]; have { var err error vals[k], err = toCtyValue(val.Field(fieldIdx), at, path) if err != nil { return cty.NilVal, err } } else { vals[k] = cty.NullVal(at) } } // Discard our extra path segment, retaining it as extra capacity // for future appending to the path. path = path[:len(path)-1] return cty.ObjectVal(vals), nil default: return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Object(attrTypes)) } } func toCtyTuple(val reflect.Value, elemTypes []cty.Type, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.Tuple(elemTypes)), nil } switch val.Kind() { case reflect.Slice: if val.IsNil() { return cty.NullVal(cty.Tuple(elemTypes)), nil } if val.Len() != len(elemTypes) { return cty.NilVal, path.NewErrorf("wrong number of elements %d; need %d", val.Len(), len(elemTypes)) } if len(elemTypes) == 0 { return cty.EmptyTupleVal, nil } // While we work on our elements we'll temporarily grow // path to give us a place to put our Index step. path = append(path, cty.PathStep(nil)) vals := make([]cty.Value, len(elemTypes)) for i, ety := range elemTypes { var err error path[len(path)-1] = cty.IndexStep{ Key: cty.NumberIntVal(int64(i)), } vals[i], err = toCtyValue(val.Index(i), ety, path) if err != nil { return cty.NilVal, err } } // Discard our extra path segment, retaining it as extra capacity // for future appending to the path. path = path[:len(path)-1] return cty.TupleVal(vals), nil case reflect.Struct: fieldCount := val.Type().NumField() if fieldCount != len(elemTypes) { return cty.NilVal, path.NewErrorf("wrong number of struct fields %d; need %d", fieldCount, len(elemTypes)) } if len(elemTypes) == 0 { return cty.EmptyTupleVal, nil } // While we work on our elements we'll temporarily grow // path to give us a place to put our Index step. path = append(path, cty.PathStep(nil)) vals := make([]cty.Value, len(elemTypes)) for i, ety := range elemTypes { var err error path[len(path)-1] = cty.IndexStep{ Key: cty.NumberIntVal(int64(i)), } vals[i], err = toCtyValue(val.Field(i), ety, path) if err != nil { return cty.NilVal, err } } // Discard our extra path segment, retaining it as extra capacity // for future appending to the path. path = path[:len(path)-1] return cty.TupleVal(vals), nil default: return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Tuple(elemTypes)) } } func toCtyCapsule(val reflect.Value, capsuleType cty.Type, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(capsuleType), nil } if val.Kind() != reflect.Ptr { if !val.CanAddr() { return cty.NilVal, path.NewErrorf("source value for capsule %#v must be addressable", capsuleType) } val = val.Addr() } if !val.Type().Elem().AssignableTo(capsuleType.EncapsulatedType()) { return cty.NilVal, path.NewErrorf("value of type %T not compatible with capsule %#v", val.Interface(), capsuleType) } return cty.CapsuleVal(capsuleType, val.Interface()), nil } func toCtyDynamic(val reflect.Value, path cty.Path) (cty.Value, error) { if val = toCtyUnwrapPointer(val); !val.IsValid() { return cty.NullVal(cty.DynamicPseudoType), nil } switch val.Kind() { case reflect.Struct: if !val.Type().AssignableTo(valueType) { return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Type()) } return val.Interface().(cty.Value), nil default: return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Kind()) } } // toCtyUnwrapPointer is a helper for dealing with Go pointers. It has three // possible outcomes: // // - Given value isn't a pointer, so it's just returned as-is. // - Given value is a non-nil pointer, in which case it is dereferenced // and the result returned. // - Given value is a nil pointer, in which case an invalid value is returned. // // For nested pointer types, like **int, they are all dereferenced in turn // until a non-pointer value is found, or until a nil pointer is encountered. func toCtyUnwrapPointer(val reflect.Value) reflect.Value { for val.Kind() == reflect.Ptr || val.Kind() == reflect.Interface { if val.IsNil() { return reflect.Value{} } val = val.Elem() } return val }