hashicorp · Mar 6, 2025 · Mar 6, 2025 · Mar 6, 2025 · Mar 17, 2025 · Mar 17, 2025
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,7 +1,16 @@
+# 1.5.0 (March 17, 2025)
+
+* `cty`: New `Value.HasWhollyKnownType` method, for testing whether a value's type could potentially change if any unknown values it was constructed from were to become known. ([#55](https://github.com/zclconf/go-cty/pull/55))
+* `convert`: Fix incorrect panic when converting a tuple with a dynamic-typed null member into a list or set, due to overly-liberal type unification. ([#56](https://github.com/zclconf/go-cty/pull/56))
+
+# 1.4.2 (Unreleased)
+
+* `function/stdlib`: The `jsonencode` function will now correctly accept a null as its argument, and produce the JSON representation `"null"` rather than returning an error. ([#54](https://github.com/zclconf/go-cty/pull/54))
+* `convert`: Don't panic when asked to convert a tuple of objects to a list type constraint containing a nested `cty.DynamicPseudoType`. ([#53](https://github.com/zclconf/go-cty/pull/53))
+
 # 1.4.1 (March 5, 2025)
 
 * `function/stdlib`: Fix various panics related to sets with unknown element types in the set-manipulation functions. ([#52](https://github.com/zclconf/go-cty/pull/52))
-* `convert`: Don't panic when asked to convert a tuple of objects to a list type constraint containing a nested `cty.DynamicPseudoType`. ([#53](https://github.com/zclconf/go-cty/pull/53))
 * `json`: Remove `json.UnmarshalDynamicWithImpliedType` function that was only available in hashicorp/go-cty 1.4.1 pseudo-versions. ([#6](https://github.com/hashicorp/go-cty/pull/6))
 
 # 1.4.0 (April 7, 2020)

diff --git a/cty/convert/conversion_collection.go b/cty/convert/conversion_collection.go
@@ -156,34 +156,45 @@ func conversionCollectionToMap(ety cty.Type, conv conversion) conversion {
 // given tuple type and return a set of the given element type.
 //
 // Will panic if the given tupleType isn't actually a tuple type.
-func conversionTupleToSet(tupleType cty.Type, listEty cty.Type, unsafe bool) conversion {
+func conversionTupleToSet(tupleType cty.Type, setEty cty.Type, unsafe bool) conversion {
 	tupleEtys := tupleType.TupleElementTypes()
 
 	if len(tupleEtys) == 0 {
 		// Empty tuple short-circuit
 		return func(val cty.Value, path cty.Path) (cty.Value, error) {
-			return cty.SetValEmpty(listEty), nil
+			return cty.SetValEmpty(setEty), nil
 		}
 	}
 
-	if listEty == cty.DynamicPseudoType {
+	if setEty == cty.DynamicPseudoType {
 		// This is a special case where the caller wants us to find
 		// a suitable single type that all elements can convert to, if
 		// possible.
-		listEty, _ = unify(tupleEtys, unsafe)
-		if listEty == cty.NilType {
+		setEty, _ = unify(tupleEtys, unsafe)
+		if setEty == cty.NilType {
 			return nil
 		}
+
+		// If the set element type after unification is still the dynamic
+		// type, the only way this can result in a valid set is if all values
+		// are of dynamic type
+		if setEty == cty.DynamicPseudoType {
+			for _, tupleEty := range tupleEtys {
+				if !tupleEty.Equals(cty.DynamicPseudoType) {
+					return nil
+				}
+			}
+		}
 	}
 
 	elemConvs := make([]conversion, len(tupleEtys))
 	for i, tupleEty := range tupleEtys {
-		if tupleEty.Equals(listEty) {
+		if tupleEty.Equals(setEty) {
 			// no conversion required
 			continue
 		}
 
-		elemConvs[i] = getConversion(tupleEty, listEty, unsafe)
+		elemConvs[i] = getConversion(tupleEty, setEty, unsafe)
 		if elemConvs[i] == nil {
 			// If any of our element conversions are impossible, then the our
 			// whole conversion is impossible.
@@ -244,6 +255,17 @@ func conversionTupleToList(tupleType cty.Type, listEty cty.Type, unsafe bool) co
 		if listEty == cty.NilType {
 			return nil
 		}
+
+		// If the list element type after unification is still the dynamic
+		// type, the only way this can result in a valid list is if all values
+		// are of dynamic type
+		if listEty == cty.DynamicPseudoType {
+			for _, tupleEty := range tupleEtys {
+				if !tupleEty.Equals(cty.DynamicPseudoType) {
+					return nil
+				}
+			}
+		}
 	}
 
 	elemConvs := make([]conversion, len(tupleEtys))
@@ -265,6 +287,7 @@ func conversionTupleToList(tupleType cty.Type, listEty cty.Type, unsafe bool) co
 	// element conversions in elemConvs
 	return func(val cty.Value, path cty.Path) (cty.Value, error) {
 		elems := make([]cty.Value, 0, len(elemConvs))
+		elemTys := make([]cty.Type, 0, len(elems))
 		elemPath := append(path.Copy(), nil)
 		i := int64(0)
 		it := val.ElementIterator()
@@ -284,10 +307,15 @@ func conversionTupleToList(tupleType cty.Type, listEty cty.Type, unsafe bool) co
 				}
 			}
 			elems = append(elems, val)
+			elemTys = append(elemTys, val.Type())
 
 			i++
 		}
 
+		elems, err := conversionUnifyListElements(elems, elemPath, unsafe)
+		if err != nil {
+			return cty.NilVal, err
+		}
 		return cty.ListVal(elems), nil
 	}
 }
@@ -441,6 +469,7 @@ func conversionUnifyCollectionElements(elems map[string]cty.Value, path cty.Path
 	}
 	unifiedType, _ := unify(elemTypes, unsafe)
 	if unifiedType == cty.NilType {
+		return nil, path.NewErrorf("collection elements cannot be unified")
 	}
 
 	unifiedElems := make(map[string]cty.Value)
@@ -486,3 +515,37 @@ func conversionCheckMapElementTypes(elems map[string]cty.Value, path cty.Path) e
 
 	return nil
 }
+
+func conversionUnifyListElements(elems []cty.Value, path cty.Path, unsafe bool) ([]cty.Value, error) {
+	elemTypes := make([]cty.Type, len(elems))
+	for i, elem := range elems {
+		elemTypes[i] = elem.Type()
+	}
+	unifiedType, _ := unify(elemTypes, unsafe)
+	if unifiedType == cty.NilType {
+		return nil, path.NewErrorf("collection elements cannot be unified")
+	}
+
+	ret := make([]cty.Value, len(elems))
+	elemPath := append(path.Copy(), nil)
+
+	for i, elem := range elems {
+		if elem.Type().Equals(unifiedType) {
+			ret[i] = elem
+			continue
+		}
+		conv := getConversion(elem.Type(), unifiedType, unsafe)
+		if conv == nil {
+		}
+		elemPath[len(elemPath)-1] = cty.IndexStep{
+			Key: cty.NumberIntVal(int64(i)),
+		}
+		val, err := conv(elem, elemPath)
+		if err != nil {
+			return nil, err
+		}
+		ret[i] = val
+	}
+
+	return ret, nil
+}
diff --git a/cty/convert/public_test.go b/cty/convert/public_test.go
@@ -649,6 +649,123 @@ func TestConvert(t *testing.T) {
 				"b": cty.MapValEmpty(cty.String),
 			}),
 		},
+		// https://github.com/hashicorp/terraform/issues/21588:
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.ObjectVal(map[string]cty.Value{
+					"a": cty.EmptyObjectVal,
+					"b": cty.NumberIntVal(2),
+				}),
+				cty.ObjectVal(map[string]cty.Value{
+					"a": cty.ObjectVal(map[string]cty.Value{"var1": cty.StringVal("val1")}),
+					"b": cty.StringVal("2"),
+				}),
+			}),
+			Type: cty.List(cty.Object(map[string]cty.Type{
+				"a": cty.DynamicPseudoType,
+				"b": cty.String,
+			})),
+			Want: cty.ListVal([]cty.Value{
+				cty.ObjectVal(map[string]cty.Value{
+					"a": cty.MapValEmpty(cty.String),
+					"b": cty.StringVal("2"),
+				}),
+				cty.ObjectVal(map[string]cty.Value{
+					"a": cty.MapVal(map[string]cty.Value{"var1": cty.StringVal("val1")}),
+					"b": cty.StringVal("2"),
+				}),
+			}),
+			WantError: false,
+		},
+		// https://github.com/hashicorp/terraform/issues/24377:
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.ListVal([]cty.Value{cty.StringVal("a")}),
+				cty.StringVal("b"),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			Type:      cty.Set(cty.DynamicPseudoType),
+			WantError: true,
+		},
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.ListVal([]cty.Value{cty.StringVal("a")}),
+				cty.StringVal("b"),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			Type:      cty.List(cty.DynamicPseudoType),
+			WantError: true,
+		},
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.ListVal([]cty.Value{cty.StringVal("a")}),
+				cty.StringVal("b"),
+			}),
+			Type:      cty.Set(cty.DynamicPseudoType),
+			WantError: true,
+		},
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.ListVal([]cty.Value{cty.StringVal("a")}),
+				cty.StringVal("b"),
+			}),
+			Type:      cty.List(cty.DynamicPseudoType),
+			WantError: true,
+		},
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.StringVal("a"),
+				cty.NumberIntVal(9),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			Type: cty.Set(cty.DynamicPseudoType),
+			Want: cty.SetVal([]cty.Value{
+				cty.StringVal("a"),
+				cty.StringVal("9"),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			WantError: false,
+		},
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.StringVal("a"),
+				cty.NumberIntVal(9),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			Type: cty.List(cty.DynamicPseudoType),
+			Want: cty.ListVal([]cty.Value{
+				cty.StringVal("a"),
+				cty.StringVal("9"),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			WantError: false,
+		},
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.NullVal(cty.DynamicPseudoType),
+				cty.NullVal(cty.DynamicPseudoType),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			Type: cty.Set(cty.DynamicPseudoType),
+			Want: cty.SetVal([]cty.Value{
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			WantError: false,
+		},
+		{
+			Value: cty.TupleVal([]cty.Value{
+				cty.NullVal(cty.DynamicPseudoType),
+				cty.NullVal(cty.DynamicPseudoType),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			Type: cty.List(cty.DynamicPseudoType),
+			Want: cty.ListVal([]cty.Value{
+				cty.NullVal(cty.DynamicPseudoType),
+				cty.NullVal(cty.DynamicPseudoType),
+				cty.NullVal(cty.DynamicPseudoType),
+			}),
+			WantError: false,
+		},
 	}
 
 	for _, test := range tests {

diff --git a/cty/function/stdlib/json.go b/cty/function/stdlib/json.go
@@ -12,6 +12,7 @@ var JSONEncodeFunc = function.New(&function.Spec{
 			Name:             "val",
 			Type:             cty.DynamicPseudoType,
 			AllowDynamicType: true,
+			AllowNull:        true,
 		},
 	},
 	Type: function.StaticReturnType(cty.String),
@@ -24,6 +25,10 @@ var JSONEncodeFunc = function.New(&function.Spec{
 			return cty.UnknownVal(retType), nil
 		}
 
+		if val.IsNull() {
+			return cty.StringVal("null"), nil
+		}
+
 		buf, err := json.Marshal(val, val.Type())
 		if err != nil {
 			return cty.NilVal, err

diff --git a/cty/function/stdlib/json_test.go b/cty/function/stdlib/json_test.go
@@ -52,6 +52,10 @@ func TestJSONEncode(t *testing.T) {
 			cty.DynamicVal,
 			cty.UnknownVal(cty.String),
 		},
+		{
+			cty.NullVal(cty.String),
+			cty.StringVal("null"),
+		},
 	}
 
 	for _, test := range tests {

diff --git a/cty/set_internals_test.go b/cty/set_internals_test.go
@@ -5,7 +5,7 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/zclconf/go-cty/cty/set"
+	"github.com/hashicorp/go-cty/cty/set"
 )
 
 func TestSetHashBytes(t *testing.T) {

diff --git a/cty/type.go b/cty/type.go
@@ -87,7 +87,7 @@ func (t Type) HasDynamicTypes() bool {
 	case t.IsPrimitiveType():
 		return false
 	case t.IsCollectionType():
-		return false
+		return t.ElementType().HasDynamicTypes()
 	case t.IsObjectType():
 		attrTypes := t.AttributeTypes()
 		for _, at := range attrTypes {

diff --git a/cty/type_test.go b/cty/type_test.go
@@ -0,0 +1,56 @@
+package cty
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestHasDynamicTypes(t *testing.T) {
+	tests := []struct {
+		ty       Type
+		expected bool
+	}{
+		{
+			DynamicPseudoType,
+			true,
+		},
+		{
+			List(DynamicPseudoType),
+			true,
+		},
+		{
+			Tuple([]Type{String, DynamicPseudoType}),
+			true,
+		},
+		{
+			Object(map[string]Type{
+				"a":       String,
+				"unknown": DynamicPseudoType,
+			}),
+			true,
+		},
+		{
+			List(Object(map[string]Type{
+				"a":       String,
+				"unknown": DynamicPseudoType,
+			})),
+			true,
+		},
+		{
+			Tuple([]Type{Object(map[string]Type{
+				"a":       String,
+				"unknown": DynamicPseudoType,
+			})}),
+			true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("%#v.HasDynamicTypes()", test.ty), func(t *testing.T) {
+			got := test.ty.HasDynamicTypes()
+			if got != test.expected {
+				t.Errorf("Equals returned %#v; want %#v", got, test.expected)
+			}
+		})
+	}
+}