Merge pull request #43738 from marcinbelczewski/b-autoflex-fields-matchin-never-reaches-suffix-check

fix: avoid short-circuiting suffix match when prefix option is set in findFieldFuzzy

Author: ewbankkit

internal/framework/flex/auto_expand.go

@@ -1165,7 +1165,7 @@ func expandStruct(ctx context.Context, sourcePath path.Path, from any, targetPat
 		fromFieldName := fromField.Name
 		_, fromFieldOpts := autoflexTags(fromField)
 
-		toField, ok := findFieldFuzzy(ctx, fromFieldName, typeFrom, typeTo, flexer)
+		toField, ok := (&fuzzyFieldFinder{}).findField(ctx, fromFieldName, typeFrom, typeTo, flexer)
 		if !ok {
 			// Corresponding field not found in to.
 			tflog.SubsystemDebug(ctx, subsystemName, "No corresponding field", map[string]any{

internal/framework/flex/auto_expand_test.go

@@ -5958,3 +5958,88 @@ func runAutoExpandTestCases(t *testing.T, testCases autoFlexTestCases) {
 		})
 	}
 }
+
+func TestFindFieldFuzzy_Combinations(t *testing.T) {
+	t.Parallel()
+
+	type builder func() (typeFrom reflect.Type, typeTo reflect.Type, fieldNameFrom string, expectedFieldName string)
+
+	cases := map[string]struct {
+		prefix string
+		suffix string
+		build  builder
+	}{
+		// 1) suffix-only on target; source has neither
+		"suffix on target only (prefix configured but not applied)": {
+			prefix: "Cluster",
+			suffix: "Input",
+			build: func() (reflect.Type, reflect.Type, string, string) {
+				type source struct{ ExecutionConfig string }
+				type target struct{ ExecutionConfigInput string }
+				return reflect.TypeFor[source](), reflect.TypeFor[target](), "ExecutionConfig", "ExecutionConfigInput"
+			},
+		},
+		// 2) trim prefix on source, then add suffix
+		"trim prefix on source then add suffix": {
+			prefix: "Cluster",
+			suffix: "Input",
+			build: func() (reflect.Type, reflect.Type, string, string) {
+				type source struct{ ClusterExecutionConfig string }
+				type target struct{ ExecutionConfigInput string }
+				return reflect.TypeFor[source](), reflect.TypeFor[target](), "ClusterExecutionConfig", "ExecutionConfigInput"
+			},
+		},
+		// 3) add prefix and suffix on target (source has neither)
+		"add prefix and suffix on target": {
+			prefix: "Cluster",
+			suffix: "Input",
+			build: func() (reflect.Type, reflect.Type, string, string) {
+				type source struct{ ExecutionConfig string }
+				type target struct{ ClusterExecutionConfigInput string }
+				return reflect.TypeFor[source](), reflect.TypeFor[target](), "ExecutionConfig", "ClusterExecutionConfigInput"
+			},
+		},
+		// 4) trim suffix on source (target has neither)
+		"trim suffix on source": {
+			prefix: "Cluster",
+			suffix: "Input",
+			build: func() (reflect.Type, reflect.Type, string, string) {
+				type source struct{ ExecutionConfigInput string }
+				type target struct{ ExecutionConfig string }
+				return reflect.TypeFor[source](), reflect.TypeFor[target](), "ExecutionConfigInput", "ExecutionConfig"
+			},
+		},
+		// 5) trim both on source (target has neither)
+		"trim both prefix and suffix on source": {
+			prefix: "Cluster",
+			suffix: "Input",
+			build: func() (reflect.Type, reflect.Type, string, string) {
+				type source struct{ ClusterExecutionConfigInput string }
+				type target struct{ ExecutionConfig string }
+				return reflect.TypeFor[source](), reflect.TypeFor[target](), "ClusterExecutionConfigInput", "ExecutionConfig"
+			},
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			typeFrom, typeTo, fieldNameFrom, expected := tc.build()
+			ctx := context.Background()
+			opts := []AutoFlexOptionsFunc{
+				WithFieldNamePrefix(tc.prefix),
+				WithFieldNameSuffix(tc.suffix),
+			}
+			flexer := newAutoExpander(opts)
+
+			field, found := (&fuzzyFieldFinder{}).findField(ctx, fieldNameFrom, typeFrom, typeTo, flexer)
+			if !found {
+				t.Fatalf("expected to find field, but found==false")
+			}
+			if field.Name != expected {
+				t.Fatalf("expected field name %q, got %q", expected, field.Name)
+			}
+		})
+	}
+}

internal/framework/flex/auto_flatten.go

@@ -1512,7 +1512,7 @@ func flattenStruct(ctx context.Context, sourcePath path.Path, from any, targetPa
 	for fromField := range flattenSourceFields(ctx, typeFrom, flexer.getOptions()) {
 		fromFieldName := fromField.Name
 
-		toField, ok := findFieldFuzzy(ctx, fromFieldName, typeFrom, typeTo, flexer)
+		toField, ok := (&fuzzyFieldFinder{}).findField(ctx, fromFieldName, typeFrom, typeTo, flexer)
 		if !ok {
 			// Corresponding field not found in to.
 			tflog.SubsystemDebug(ctx, subsystemName, "No corresponding field", map[string]any{

internal/framework/flex/autoflex.go

@@ -17,12 +17,7 @@ import (
 	tfreflect "github.com/hashicorp/terraform-provider-aws/internal/reflect"
 )
 
-type fieldNamePrefixCtxKey string
-
 const (
-	fieldNamePrefixRecurse fieldNamePrefixCtxKey = "FIELD_NAME_PREFIX_RECURSE"
-	fieldNameSuffixRecurse fieldNamePrefixCtxKey = "FIELD_NAME_SUFFIX_RECURSE"
-
 	mapBlockKeyFieldName = "MapBlockKey"
 )
 
@@ -74,7 +69,12 @@ var (
 	plural = pluralize.NewClient()
 )
 
-func findFieldFuzzy(ctx context.Context, fieldNameFrom string, typeFrom reflect.Type, typeTo reflect.Type, flexer autoFlexer) (reflect.StructField, bool) {
+type fuzzyFieldFinder struct {
+	prefixRecursionDepth int
+	suffixRecursionDepth int
+}
+
+func (fff *fuzzyFieldFinder) findField(ctx context.Context, fieldNameFrom string, typeFrom reflect.Type, typeTo reflect.Type, flexer autoFlexer) (reflect.StructField, bool) { //nolint:unparam
 	// first precedence is exact match (case sensitive)
 	if fieldTo, ok := typeTo.FieldByName(fieldNameFrom); ok {
 		return fieldTo, true
@@ -117,26 +117,38 @@ func findFieldFuzzy(ctx context.Context, fieldNameFrom string, typeFrom reflect.
 	// fourth precedence is using field name prefix
 	if v := opts.fieldNamePrefix; v != "" {
 		v = strings.ReplaceAll(v, " ", "")
-		if ctx.Value(fieldNamePrefixRecurse) == nil {
+		if fff.prefixRecursionDepth == 0 {
 			// so it will only recurse once
-			ctx = context.WithValue(ctx, fieldNamePrefixRecurse, true)
+			fff.prefixRecursionDepth++
 			if trimmed, ok := strings.CutPrefix(fieldNameFrom, v); ok {
-				return findFieldFuzzy(ctx, trimmed, typeFrom, typeTo, flexer)
+				if fieldTo, ok := fff.findField(ctx, trimmed, typeFrom, typeTo, flexer); ok {
+					fff.prefixRecursionDepth--
+					return fieldTo, true
+				}
+			} else {
+				if fieldTo, ok := fff.findField(ctx, v+fieldNameFrom, typeFrom, typeTo, flexer); ok {
+					fff.prefixRecursionDepth--
+					return fieldTo, true
+				}
 			}
-			return findFieldFuzzy(ctx, v+fieldNameFrom, typeFrom, typeTo, flexer)
+			// no match via prefix mutation; fall through to suffix handling on the original name
 		}
 	}
 
 	// fifth precedence is using field name suffix
 	if v := opts.fieldNameSuffix; v != "" {
 		v = strings.ReplaceAll(v, " ", "")
-		if ctx.Value(fieldNameSuffixRecurse) == nil {
+		if fff.suffixRecursionDepth == 0 {
 			// so it will only recurse once
-			ctx = context.WithValue(ctx, fieldNameSuffixRecurse, true)
+			fff.suffixRecursionDepth++
 			if strings.HasSuffix(fieldNameFrom, v) {
-				return findFieldFuzzy(ctx, strings.TrimSuffix(fieldNameFrom, v), typeFrom, typeTo, flexer)
+				fieldTo, ok := fff.findField(ctx, strings.TrimSuffix(fieldNameFrom, v), typeFrom, typeTo, flexer)
+				fff.suffixRecursionDepth--
+				return fieldTo, ok
 			}
-			return findFieldFuzzy(ctx, fieldNameFrom+v, typeFrom, typeTo, flexer)
+			fieldTo, ok := fff.findField(ctx, fieldNameFrom+v, typeFrom, typeTo, flexer)
+			fff.suffixRecursionDepth--
+			return fieldTo, ok
 		}
 	}