tftypes: Change (AttributePath).WithElementKeyInt() method parameter to int

.changelog/101.txt

@@ -0,0 +1,3 @@
+```release-note:breaking-change
+tftypes: `(AttributePath).WithElementKeyInt()` now has an `int` parameter instead of `int64`. Using `(AttributePath).WithElementKeyInt()` within `for ... range` loops no longer requires `int64()` conversion.
+```

tftypes/attribute_path.go

@@ -149,7 +149,7 @@ func (a *AttributePath) WithElementKeyString(key string) *AttributePath {
 
 // WithElementKeyInt adds an ElementKeyInt step to `a`, using `key` as the
 // element's key. `a` is copied, not modified.
-func (a *AttributePath) WithElementKeyInt(key int64) *AttributePath {
+func (a *AttributePath) WithElementKeyInt(key int) *AttributePath {
 	steps := a.Steps()
 	return &AttributePath{
 		steps: append(steps, ElementKeyInt(key)),

tftypes/list.go

@@ -71,9 +71,9 @@ func valueFromList(typ Type, in interface{}) (Value, error) {
 		var valType Type
 		for pos, v := range value {
 			if v.Type().Is(DynamicPseudoType) && v.IsKnown() {
-				return Value{}, NewAttributePath().WithElementKeyInt(int64(pos)).NewErrorf("invalid value %s for %s", v, v.Type())
+				return Value{}, NewAttributePath().WithElementKeyInt(pos).NewErrorf("invalid value %s for %s", v, v.Type())
 			} else if !v.Type().Is(DynamicPseudoType) && !v.Type().UsableAs(typ) {
-				return Value{}, NewAttributePath().WithElementKeyInt(int64(pos)).NewErrorf("can't use %s as %s", v.Type(), typ)
+				return Value{}, NewAttributePath().WithElementKeyInt(pos).NewErrorf("can't use %s as %s", v.Type(), typ)
 			}
 			if valType == nil {
 				valType = v.Type()

tftypes/tuple.go

@@ -110,9 +110,9 @@ func valueFromTuple(types []Type, in interface{}) (Value, error) {
 			for pos, v := range value {
 				typ := types[pos]
 				if v.Type().Is(DynamicPseudoType) && v.IsKnown() {
-					return Value{}, NewAttributePath().WithElementKeyInt(int64(pos)).NewErrorf("invalid value %s for %s", v, v.Type())
+					return Value{}, NewAttributePath().WithElementKeyInt(pos).NewErrorf("invalid value %s for %s", v, v.Type())
 				} else if !v.Type().Is(DynamicPseudoType) && !v.Type().UsableAs(typ) {
-					return Value{}, NewAttributePath().WithElementKeyInt(int64(pos)).NewErrorf("can't use %s as %s", v.Type(), typ)
+					return Value{}, NewAttributePath().WithElementKeyInt(pos).NewErrorf("can't use %s as %s", v.Type(), typ)
 				}
 			}
 		}

tftypes/value_json.go

@@ -216,7 +216,7 @@ func jsonUnmarshalList(buf []byte, elementType Type, p *AttributePath) (Value, e
 	// distinction, so we'll allow it.
 	vals := []Value{}
 
-	var idx int64
+	var idx int
 	for dec.More() {
 		innerPath := p.WithElementKeyInt(idx)
 		// update the index
@@ -396,9 +396,9 @@ func jsonUnmarshalTuple(buf []byte, elementTypes []Type, p *AttributePath) (Valu
 	types := []Type{}
 	vals := []Value{}
 
-	var idx int64
+	var idx int
 	for dec.More() {
-		if idx >= int64(len(elementTypes)) {
+		if idx >= len(elementTypes) {
 			return Value{}, p.NewErrorf("too many tuple elements (only have types for %d)", len(elementTypes))
 		}
 

tftypes/value_msgpack.go

@@ -150,7 +150,7 @@ func msgpackUnmarshalList(dec *msgpack.Decoder, typ Type, path *AttributePath) (
 
 	vals := make([]Value, 0, length)
 	for i := 0; i < length; i++ {
-		innerPath := path.WithElementKeyInt(int64(i))
+		innerPath := path.WithElementKeyInt(i)
 		val, err := msgpackUnmarshal(dec, typ, innerPath)
 		if err != nil {
 			return Value{}, err
@@ -190,7 +190,7 @@ func msgpackUnmarshalSet(dec *msgpack.Decoder, typ Type, path *AttributePath) (V
 
 	vals := make([]Value, 0, length)
 	for i := 0; i < length; i++ {
-		innerPath := path.WithElementKeyInt(int64(i))
+		innerPath := path.WithElementKeyInt(i)
 		val, err := msgpackUnmarshal(dec, typ, innerPath)
 		if err != nil {
 			return Value{}, err
@@ -278,7 +278,7 @@ func msgpackUnmarshalTuple(dec *msgpack.Decoder, types []Type, path *AttributePa
 	elTypes := make([]Type, 0, length)
 	vals := make([]Value, 0, length)
 	for i := 0; i < length; i++ {
-		innerPath := path.WithElementKeyInt(int64(i))
+		innerPath := path.WithElementKeyInt(i)
 		typ := types[i]
 		val, err := msgpackUnmarshal(dec, typ, innerPath)
 		if err != nil {
@@ -489,7 +489,7 @@ func marshalMsgPackList(val Value, typ Type, p *AttributePath, enc *msgpack.Enco
 		return p.NewErrorf("error encoding list length: %w", err)
 	}
 	for pos, i := range l {
-		err := marshalMsgPack(i, typ.(List).ElementType, p.WithElementKeyInt(int64(pos)), enc)
+		err := marshalMsgPack(i, typ.(List).ElementType, p.WithElementKeyInt(pos), enc)
 		if err != nil {
 			return err
 		}
@@ -549,7 +549,7 @@ func marshalMsgPackTuple(val Value, typ Type, p *AttributePath, enc *msgpack.Enc
 	}
 	for pos, v := range t {
 		ty := types[pos]
-		err := marshalMsgPack(v, ty, p.WithElementKeyInt(int64(pos)), enc)
+		err := marshalMsgPack(v, ty, p.WithElementKeyInt(pos), enc)
 		if err != nil {
 			return err
 		}

tftypes/walk.go

@@ -67,7 +67,7 @@ func walk(path *AttributePath, val Value, cb func(*AttributePath, Value) (bool,
 			if ty.Is(Set{}) {
 				path = path.WithElementKeyValue(el)
 			} else {
-				path = path.WithElementKeyInt(int64(pos))
+				path = path.WithElementKeyInt(pos)
 			}
 			err = walk(path, el, cb)
 			if err != nil {
@@ -133,7 +133,7 @@ func transform(path *AttributePath, val Value, cb func(*AttributePath, Value) (V
 				if ty.Is(Set{}) {
 					path = path.WithElementKeyValue(el)
 				} else {
-					path = path.WithElementKeyInt(int64(pos))
+					path = path.WithElementKeyInt(pos)
 				}
 				newEl, err := transform(path, el, cb)
 				if err != nil {