dyn: Allow interpolation for non-string primitive (#3522)

## Why
Terraform supports that, so to match $resources resolution we need to
support it as well. Also, it's natural for interpolation to support
types that have string representation.

## Tests
Existing unit test, new acceptance test for $var case. In my remote
state PR, I have acc test for $resources case as well.

Author: denik

acceptance/bundle/variables/int/databricks.yml

@@ -0,0 +1,5 @@
+variables:
+  foo:
+    default: 25
+  bar:
+    default: "${var.foo}+${var.foo}"

acceptance/bundle/variables/int/out.test.toml

@@ -0,0 +1,5 @@
+Local = true
+Cloud = false
+
+[EnvMatrix]
+  DATABRICKS_CLI_DEPLOYMENT = ["terraform", "direct-exp"]

acceptance/bundle/variables/int/output.txt

@@ -0,0 +1,10 @@
+{
+  "bar": {
+    "default": "25+25",
+    "value": "25+25"
+  },
+  "foo": {
+    "default": 25,
+    "value": 25
+  }
+}

acceptance/bundle/variables/int/script

@@ -0,0 +1 @@
+$CLI bundle validate -o json | jq .variables

libs/dyn/dynvar/resolve.go

@@ -167,10 +167,13 @@ func (r *resolver) resolveRef(ref Ref, seen []string) (dyn.Value, error) {
 		// Try to turn the resolved value into a string.
 		s, ok := resolved[j].AsString()
 		if !ok {
-			return dyn.InvalidValue, fmt.Errorf(
-				"cannot interpolate non-string value: %s",
-				ref.Matches[j][0],
-			)
+			// Only allow primitive types to be converted to string.
+			switch resolved[j].Kind() {
+			case dyn.KindString, dyn.KindBool, dyn.KindInt, dyn.KindFloat, dyn.KindTime, dyn.KindNil:
+				s = fmt.Sprint(resolved[j].AsAny())
+			default:
+				return dyn.InvalidValue, fmt.Errorf("cannot interpolate non-primitive value of type %s into string", resolved[j].Kind())
+			}
 		}
 
 		ref.Str = strings.Replace(ref.Str, ref.Matches[j][0], s, 1)

libs/dyn/dynvar/resolve_test.go

@@ -107,15 +107,56 @@ func TestResolveWithStringConcatenation(t *testing.T) {
 	assert.Equal(t, "aba", getByPath(t, out, "c").MustString())
 }
 
-func TestResolveWithTypeRetentionFailure(t *testing.T) {
+func TestResolveWithTypeInterpolation(t *testing.T) {
 	in := dyn.V(map[string]dyn.Value{
-		"a": dyn.V(1),
-		"b": dyn.V(2),
-		"c": dyn.V("${a} ${b}"),
+		"a":          dyn.V(1),
+		"b":          dyn.V(2),
+		"c":          dyn.V("${a} ${b}"),
+		"float_val":  dyn.V(3.14),
+		"bool_true":  dyn.V(true),
+		"bool_false": dyn.V(false),
+		"time_val":   dyn.V(dyn.MustTime("2024-01-01")),
+		"nil_val":    dyn.NilValue,
+		// Test interpolation of different types in string templates
+		"float_interp":      dyn.V("Value: ${float_val}"),
+		"bool_true_interp":  dyn.V("Enabled: ${bool_true}"),
+		"bool_false_interp": dyn.V("Disabled: ${bool_false}"),
+		"time_interp":       dyn.V("Date: ${time_val}"),
+		"nil_interp":        dyn.V("Null: ${nil_val}"),
 	})
 
-	_, err := dynvar.Resolve(in, dynvar.DefaultLookup(in))
-	require.ErrorContains(t, err, "cannot interpolate non-string value: ${a}")
+	out, err := dynvar.Resolve(in, dynvar.DefaultLookup(in))
+	require.NoError(t, err)
+
+	// Integer interpolation
+	assert.EqualValues(t, "1 2", getByPath(t, out, "c").MustString())
+
+	// Float interpolation
+	assert.EqualValues(t, "Value: 3.14", getByPath(t, out, "float_interp").MustString())
+
+	// Bool interpolation
+	assert.EqualValues(t, "Enabled: true", getByPath(t, out, "bool_true_interp").MustString())
+	assert.EqualValues(t, "Disabled: false", getByPath(t, out, "bool_false_interp").MustString())
+
+	// Time interpolation should convert to string representation of time.Time
+	// Note: time.Time string representation includes timezone info
+	timeResult := getByPath(t, out, "time_interp").MustString()
+	assert.Contains(t, timeResult, "Date: 2024-01-01")
+	assert.Contains(t, timeResult, "00:00:00")
+
+	// Nil interpolation
+	assert.EqualValues(t, "Null: <nil>", getByPath(t, out, "nil_interp").MustString())
+}
+
+func TestResolveWithTypeRetentionFailure(t *testing.T) {
+	// Test that mapping interpolation fails with an error
+	mappingTest := dyn.V(map[string]dyn.Value{
+		"mapping": dyn.V(map[string]dyn.Value{"key": dyn.V("value")}),
+		"interp":  dyn.V("Config: ${mapping}"),
+	})
+	_, err := dynvar.Resolve(mappingTest, dynvar.DefaultLookup(mappingTest))
+	require.Error(t, err)
+	assert.Equal(t, "cannot interpolate non-primitive value of type map into string", err.Error())
 }
 
 func TestResolveWithTypeRetention(t *testing.T) {