Handle double and long shape types in setSDKForScalar for list members (#683)

## Fix: handle `double` and `long` shape types in `setSDKForScalar` for list members

### Issue

The QuickSight controller analysis resource fails to compile with errors like:

```
pkg/resource/analysis/sdk.go:6223:30: cannot use f2f6elemf1f0f1iter
  (variable of type *float64) as float64 value in assignment
```

This affects all `[]float64` list fields in the CRD-to-SDK conversion path, producing 10+ compile errors across the Analysis resource's `sdk.go`.

### Root Cause

`setSDKForScalar` in `pkg/generate/code/set_sdk.go` has an `intOrFloat` map that handles narrowing conversions for `"integer"` (int64→int32) and `"float"` (float64→float32) shape types. These types need range checks and casts because the CRD uses 64-bit types while the SDK uses 32-bit types.

However, `"double"` (float64) and `"long"` (int64) shape types were not handled. When these appear as list members:

- CRD type: `[]*float64` — loop iterator is `*float64`
- SDK type: `[]float64` — target element is `float64`

The code fell through to the default `else` branch which strips the `*` dereference via `strings.TrimPrefix(setTo, "*")`, generating `elem = iter` instead of `elem = *iter`.

### Fix

Added an explicit branch for `"double"` and `"long"` types in `setSDKForScalar`. Unlike `"integer"`/`"float"`, these are already native 64-bit Go types, so no range check or narrowing cast is needed — just correct pointer dereference in list context.

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

Author: gustavodiaz7722

pkg/generate/code/set_sdk.go

@@ -1765,6 +1765,16 @@ func setSDKForScalar(
 		}
 		out += fmt.Sprintf("%stemp := int32(%s)\n", indent, setTo)
 		out += fmt.Sprintf("%s%s = &temp\n", indent, targetVarPath)
+	} else if shape.Type == "double" || shape.Type == "long" {
+		targetVarPath := targetVarName
+		if targetFieldName != "" {
+			targetVarPath += "." + targetFieldName
+		}
+		if isListMember {
+			out += fmt.Sprintf("%s%s = %s\n", indent, targetVarPath, setTo)
+		} else {
+			out += fmt.Sprintf("%s%s = %s\n", indent, targetVarPath, strings.TrimPrefix(setTo, "*"))
+		}
 	} else {
 
 		targetVarPath := targetVarName

pkg/generate/code/set_sdk_test.go

@@ -6656,3 +6656,55 @@ func TestSetSDK_QuickSight_DataSet_Update(t *testing.T) {
 	// should also use value-type access
 	assert.NotContains(got, "= &f6elemf0f0f0iter.Time")
 }
+
+// TestSetSDK_QuickSight_Analysis_Create tests that the SetSDK code generation
+// for the QuickSight Analysis resource correctly handles "double" type list
+// members. The Analysis Definition contains DecimalParameterDeclaration with
+// DefaultValues.StaticValues which is []float64 in the SDK but []*float64 in
+// the CRD. The generated code must dereference the CRD pointer element (*iter)
+// when assigning to the SDK value element.
+func TestSetSDK_QuickSight_Analysis_Create(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+
+	g := testutil.NewModelForService(t, "quicksight")
+
+	crd := testutil.GetCRDByName(t, g, "Analysis")
+	require.NotNil(crd)
+	assert.NotNil(crd.Ops.Create)
+
+	got, err := code.SetSDK(crd.Config(), crd, model.OpTypeCreate, "r.ko", "res", 1)
+	require.NoError(err)
+
+	// --- Double list members (DecimalParameterDeclaration.DefaultValues.StaticValues) ---
+	// The StaticValues field is []float64 in the SDK (value type) but
+	// []*float64 in the CRD (pointer type). When iterating over the CRD
+	// slice, the loop variable is *float64 and must be dereferenced to
+	// assign to the SDK's float64 element variable.
+	assert.Contains(got, "[]float64{}")
+	// The dereference must be present: elem = *iter
+	assert.Contains(got, "= *f2f6elemf1f0f1iter")
+	// Must NOT have the broken non-dereferenced assignment
+	assert.NotContains(got, "= f2f6elemf1f0f1iter\n")
+}
+
+// TestSetSDK_QuickSight_Analysis_Update tests that the same double list
+// dereference fix applies to the Update operation.
+func TestSetSDK_QuickSight_Analysis_Update(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+
+	g := testutil.NewModelForService(t, "quicksight")
+
+	crd := testutil.GetCRDByName(t, g, "Analysis")
+	require.NotNil(crd)
+	assert.NotNil(crd.Ops.Update)
+
+	got, err := code.SetSDK(crd.Config(), crd, model.OpTypeUpdate, "r.ko", "res", 1)
+	require.NoError(err)
+
+	// Same pattern as Create: double list elements must be dereferenced
+	assert.Contains(got, "[]float64{}")
+	assert.Contains(got, "= *f2f6elemf1f0f1iter")
+	assert.NotContains(got, "= f2f6elemf1f0f1iter\n")
+}

pkg/generate/code/set_sdk_whitebox_test.go

@@ -115,6 +115,70 @@ func TestSetSDKForScalar(t *testing.T) {
 	res.Temperature = &temperatureCopy
 `,
 		},
+		{
+			// "double" maps to float64 natively — no range check or cast
+			// needed. In non-list context, the CRD source is *float64 and
+			// the SDK target is *float64, so we strip the dereference.
+			name:            "double scalar non-list",
+			targetFieldName: "Value",
+			targetVarName:   "res",
+			targetVarType:   "structure",
+			sourceFieldPath: "Value",
+			sourceVarName:   "ko.Spec.Value",
+			isListMember:    false,
+			shapeRef: &awssdkmodel.ShapeRef{
+				Shape: &awssdkmodel.Shape{
+					Type: "double",
+				},
+				OriginalMemberName: "Value",
+			},
+			indentLevel: 1,
+			expected:    "\tres.Value = ko.Spec.Value\n",
+		},
+		{
+			// In a list context, the CRD source element is *float64 but
+			// the SDK target element is float64 (value type). The generated
+			// code must dereference with *.
+			name:            "double scalar list member",
+			targetFieldName: "",
+			targetVarName:   "f0elem",
+			targetVarType:   "",
+			sourceFieldPath: "Values",
+			sourceVarName:   "f0iter",
+			isListMember:    true,
+			shapeRef: &awssdkmodel.ShapeRef{
+				Shape: &awssdkmodel.Shape{
+					Type:      "double",
+					ShapeName: "Double",
+				},
+				OriginalMemberName: "Values",
+				OrigShapeName:      "Double",
+			},
+			indentLevel: 1,
+			expected:    "\tf0elem = *f0iter\n",
+		},
+		{
+			// "long" maps to int64 natively — no range check or cast needed.
+			// In a list context, the CRD source element is *int64 but the
+			// SDK target element is int64 (value type). Must dereference.
+			name:            "long scalar list member",
+			targetFieldName: "",
+			targetVarName:   "f0elem",
+			targetVarType:   "",
+			sourceFieldPath: "Values",
+			sourceVarName:   "f0iter",
+			isListMember:    true,
+			shapeRef: &awssdkmodel.ShapeRef{
+				Shape: &awssdkmodel.Shape{
+					Type:      "long",
+					ShapeName: "Long",
+				},
+				OriginalMemberName: "Values",
+				OrigShapeName:      "Long",
+			},
+			indentLevel: 1,
+			expected:    "\tf0elem = *f0iter\n",
+		},
 	}
 
 	for _, tc := range testCases {