update to tuple index

Author: austinvalle

internal/reflect/slice.go

@@ -139,8 +139,7 @@ func reflectSlice(ctx context.Context, typ attr.Type, val tftypes.Value, target
 			targetValue := reflect.Zero(elemType)
 
 			// update our path so we can have nice errors
-			// utilizing `AtListIndex` because tuple paths are also based on the underlying `PathStepElementKeyInt`
-			valPath := path.AtListIndex(pos)
+			valPath := path.AtTupleIndex(pos)
 
 			// reflect the value into our new target
 			val, valDiags := BuildValue(ctx, elemAttrType, value, targetValue, opts, valPath)
@@ -280,8 +279,7 @@ func FromSlice(ctx context.Context, typ attr.Type, val reflect.Value, path path.
 		}
 
 		for i := 0; i < val.Len(); i++ {
-			// utilizing `AtListIndex` because tuple paths are also based on the underlying `PathStepElementKeyInt`
-			valPath := path.AtListIndex(i)
+			valPath := path.AtTupleIndex(i)
 
 			val, valDiags := FromValue(ctx, elemAttrType, val.Index(i).Interface(), valPath)
 			diags.Append(valDiags...)

path/path.go

@@ -52,6 +52,18 @@ func (p Path) AtListIndex(index int) Path {
 	return copiedPath
 }
 
+// AtTupleIndex returns a copied path with a new tuple index step at the end.
+// The returned path is safe to modify without affecting the original.
+//
+// Tuple indices are 0-based. The first element of a tuple is 0.
+func (p Path) AtTupleIndex(index int) Path {
+	copiedPath := p.Copy()
+
+	copiedPath.steps.Append(PathStepElementKeyInt(index))
+
+	return copiedPath
+}
+
 // AtMapKey returns a copied path with a new map key step at the end.
 // The returned path is safe to modify without affecting the original.
 func (p Path) AtMapKey(key string) Path {

path/path_test.go

@@ -52,6 +52,46 @@ func TestPathAtListIndex(t *testing.T) {
 	}
 }
 
+func TestPathAtTupleIndex(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		path     path.Path
+		index    int
+		expected path.Path
+	}{
+		"empty": {
+			path:     path.Empty(),
+			index:    1,
+			expected: path.Empty().AtTupleIndex(1),
+		},
+		"shallow": {
+			path:     path.Root("test"),
+			index:    1,
+			expected: path.Root("test").AtTupleIndex(1),
+		},
+		"deep": {
+			path:     path.Root("test1").AtTupleIndex(0).AtName("test2"),
+			index:    1,
+			expected: path.Root("test1").AtTupleIndex(0).AtName("test2").AtTupleIndex(1),
+		},
+	}
+
+	for name, testCase := range testCases {
+		name, testCase := name, testCase
+
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			got := testCase.path.AtTupleIndex(testCase.index)
+
+			if diff := cmp.Diff(got, testCase.expected); diff != "" {
+				t.Errorf("unexpected difference: %s", diff)
+			}
+		})
+	}
+}
+
 func TestPathAtMapKey(t *testing.T) {
 	t.Parallel()