Supported nested union fields (#689)

Issue #, if available:

Description of changes:
This PR adds support for nested union types to the code-generator. Prior to this change if a `union` shape contained a member that was itself a `union` the code-generator would produce non-compiling code in two ways:

1. When setting the values from the API response the generated code would not use a type switch for the nested union member and attempt directly access fields as if they were a `structure`.
2. When setting the SDK payload the generated code would attempt to dereference the union member.

To address this this PR applies two fixes.
1. In `setResourceForUnion` check if the member is a union and force `Shape.Type` to `union` before recursing
2. In `setSDKForUnion` prevent dereference of member value if member is a union itself.

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

Author: knottnt

pkg/generate/code/set_resource.go

@@ -2473,6 +2473,9 @@ func setResourceForUnion(
 		if sourceMemberShapeRef == nil {
 			continue
 		}
+		if sourceMemberShapeRef.Shape.RealType == "union" {
+			sourceMemberShapeRef.Shape.Type = "union"
+		}
 
 		sourceMemberIndex, err := GetMemberIndex(sourceShape, targetMemberName)
 		if err != nil {
@@ -2561,6 +2564,9 @@ func setResourceForUnion(
 				true,
 			)
 		}
+		if sourceMemberShapeRef.Shape.RealType == "union" {
+			sourceMemberShapeRef.Shape.Type = "structure"
+		}
 		out += fmt.Sprintf("%s\t}\n", indent)
 	}
 	out += fmt.Sprintf("%s}\n", indent)

pkg/generate/code/set_resource_test.go

@@ -5524,3 +5524,58 @@ func TestSetResource_QuickSight_DataSet_ReadOne(t *testing.T) {
 	// not &.Time (pointer type).
 	assert.Contains(got, "f6elemf0f0f0elem = f6elemf0f0f0iter.Time")
 }
+
+// TestSetResource_BedrockAgentCoreControl_GatewayTarget_NestedUnionTypeSwitch
+// tests that when a union type (TargetConfiguration) contains a member whose
+// Value is itself a union type (McpTargetConfiguration), the generated
+// set-output code uses a type switch on the nested union interface instead of
+// directly accessing struct fields.
+//
+// Before the fix, the generated code accessed f12f0.Value.ApiGateway,
+// f12f0.Value.Lambda, etc. directly — but f12f0.Value is of type
+// McpTargetConfiguration (an interface), which has no such fields. The fix
+// ensures a proper `switch f12f0.Value.(type)` is generated.
+func TestSetResource_BedrockAgentCoreControl_GatewayTarget_NestedUnionTypeSwitch(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+
+	g := testutil.NewModelForServiceWithOptions(t, "bedrock-agentcore-control", &testutil.TestingModelOptions{
+		GeneratorConfigFile: "generator-with-nested-union.yaml",
+	})
+
+	crd := testutil.GetCRDByName(t, g, "GatewayTarget")
+	require.NotNil(crd)
+	assert.NotNil(crd.Ops.ReadOne)
+
+	got, err := code.SetResource(crd.Config(), crd, model.OpTypeGet, "resp", "ko", 1)
+	require.NoError(err)
+
+	// --- Outer union: TargetConfiguration ---
+	// The outer union should use a type switch
+	assert.Contains(got, "switch resp.TargetConfiguration.(type) {")
+	assert.Contains(got, "case *svcsdktypes.TargetConfigurationMemberMcp:")
+
+	// --- Nested union: McpTargetConfiguration ---
+	// The nested union inside TargetConfigurationMemberMcp.Value should also
+	// use a type switch, NOT direct field access
+	assert.Contains(got, "switch f12f0.Value.(type) {")
+	assert.Contains(got, "case *svcsdktypes.McpTargetConfigurationMemberApiGateway:")
+	assert.Contains(got, "case *svcsdktypes.McpTargetConfigurationMemberLambda:")
+	assert.Contains(got, "case *svcsdktypes.McpTargetConfigurationMemberMcpServer:")
+	assert.Contains(got, "case *svcsdktypes.McpTargetConfigurationMemberOpenApiSchema:")
+	assert.Contains(got, "case *svcsdktypes.McpTargetConfigurationMemberSmithyModel:")
+
+	// Ensure we do NOT get direct field access on the union interface
+	// (this was the original compiler error)
+	assert.NotContains(got, "f12f0.Value.ApiGateway")
+	assert.NotContains(got, "f12f0.Value.Lambda")
+	assert.NotContains(got, "f12f0.Value.McpServer")
+	assert.NotContains(got, "f12f0.Value.OpenApiSchema")
+	assert.NotContains(got, "f12f0.Value.SmithyModel")
+
+	// Doubly-nested unions (e.g., ApiSchemaConfiguration inside OpenApiSchema
+	// member) should also use type switches
+	assert.Contains(got, "switch f12f0f0f3.Value.(type) {")
+	assert.Contains(got, "case *svcsdktypes.ApiSchemaConfigurationMemberInlinePayload:")
+	assert.Contains(got, "case *svcsdktypes.ApiSchemaConfigurationMemberS3:")
+}

pkg/generate/code/set_sdk.go

@@ -1937,7 +1937,11 @@ func setSDKForUnion(
 					return "", err
 				}
 				out += containerOut
-				if memberShape.Type == "list" {
+				// TODO (knottnt) refactor union Shape.Type handling
+				// Union type check is coupled to mutating Shape.Type in prior recursions.
+				// While this does work and test coverage validates the behavior this pattern of
+				// assign Shape.Type to union is confusing and makes function logic difficult to follow.
+				if memberShape.Type == "list" || memberShape.Type == "union" {
 					out += fmt.Sprintf("%s\t%s.Value = %s\n", indent, elemVarName, indexedVarName)
 				} else {
 					out += fmt.Sprintf("%s\t%s.Value = *%s\n", indent, elemVarName, indexedVarName)

pkg/generate/code/set_sdk_test.go

@@ -6708,3 +6708,64 @@ func TestSetSDK_QuickSight_Analysis_Update(t *testing.T) {
 	assert.Contains(got, "= *f2f6elemf1f0f1iter")
 	assert.NotContains(got, "= f2f6elemf1f0f1iter\n")
 }
+
+// TestSetSDK_BedrockAgentCoreControl_GatewayTarget_NestedUnionNoDereference
+// tests that when a union type (TargetConfiguration) contains a member whose
+// Value is itself a union type (McpTargetConfiguration), the generated code:
+//   - Declares the nested union as a var (interface), not a struct pointer
+//   - Uses Member* wrapper types for each variant of the nested union
+//   - Does NOT dereference the nested union interface when assigning to
+//     the parent's .Value (interfaces are not pointers)
+//
+// This was a compiler error before the fix: "cannot indirect f5f0 (variable
+// of interface type McpTargetConfiguration)"
+func TestSetSDK_BedrockAgentCoreControl_GatewayTarget_NestedUnionNoDereference(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+
+	g := testutil.NewModelForServiceWithOptions(t, "bedrock-agentcore-control", &testutil.TestingModelOptions{
+		GeneratorConfigFile: "generator-with-nested-union.yaml",
+	})
+
+	crd := testutil.GetCRDByName(t, g, "GatewayTarget")
+	require.NotNil(crd)
+	assert.NotNil(crd.Ops.Create)
+
+	got, err := code.SetSDK(crd.Config(), crd, model.OpTypeCreate, "r.ko", "res", 1)
+	require.NoError(err)
+
+	// --- Outer union: TargetConfiguration ---
+	// The outer union variable should be declared as an interface type
+	assert.Contains(got, "var f7 svcsdktypes.TargetConfiguration")
+	assert.NotContains(got, "f7 := &svcsdktypes.TargetConfiguration{}")
+
+	// --- Nested union: McpTargetConfiguration ---
+	// The nested union inside TargetConfigurationMemberMcp should also be
+	// declared as an interface variable, not a struct pointer
+	assert.Contains(got, "var f7f0 svcsdktypes.McpTargetConfiguration")
+	assert.NotContains(got, "f7f0 := &svcsdktypes.McpTargetConfiguration{}")
+
+	// Each nested union member should use the Member* wrapper type
+	assert.Contains(got, "f7f0f0Parent := &svcsdktypes.McpTargetConfigurationMemberApiGateway{}")
+	assert.Contains(got, "f7f0f1Parent := &svcsdktypes.McpTargetConfigurationMemberLambda{}")
+	assert.Contains(got, "f7f0f2Parent := &svcsdktypes.McpTargetConfigurationMemberMcpServer{}")
+	assert.Contains(got, "f7f0f3Parent := &svcsdktypes.McpTargetConfigurationMemberOpenApiSchema{}")
+	assert.Contains(got, "f7f0f4Parent := &svcsdktypes.McpTargetConfigurationMemberSmithyModel{}")
+
+	// The nested union (McpTargetConfiguration) must NOT be dereferenced when
+	// assigned to the parent wrapper's .Value field. Interfaces cannot be
+	// dereferenced with *.
+	assert.Contains(got, "f7f0Parent.Value = f7f0\n")
+	assert.NotContains(got, "f7f0Parent.Value = *f7f0\n")
+
+	// Similarly, doubly-nested unions (ApiSchemaConfiguration inside
+	// McpTargetConfiguration) must not be dereferenced
+	assert.Contains(got, "f7f0f3Parent.Value = f7f0f3\n")
+	assert.NotContains(got, "f7f0f3Parent.Value = *f7f0f3\n")
+	assert.Contains(got, "f7f0f4Parent.Value = f7f0f4\n")
+	assert.NotContains(got, "f7f0f4Parent.Value = *f7f0f4\n")
+
+	// Non-union struct members inside the nested union SHOULD still be
+	// dereferenced (e.g., ApiGatewayTargetConfiguration is a regular struct)
+	assert.Contains(got, "f7f0f0Parent.Value = *f7f0f0\n")
+}