A null dynamic value is a known value when comparing equality

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 {

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)
+			}
+		})
+	}
+}

cty/value.go

@@ -107,10 +107,10 @@ func (val Value) IsWhollyKnown() bool {
 	}
 }
 
-// HasDynamicValues checks if the value is dynamic, or contains any nested
+// HasWhollyKnownType checks if the value is dynamic, or contains any nested
 // DynamicVal. This implies that both the value is not known, and the final
 // type may change.
-func (val Value) HasDynamicValues() bool {
+func (val Value) HasWhollyKnownType() bool {
 	// a null dynamic type is known
 	if val.IsNull() {
 		return false
@@ -124,9 +124,15 @@ func (val Value) HasDynamicValues() bool {
 	}
 
 	if val.CanIterateElements() {
+		// if the value is not known, then we can look directly at the internal
+		// types
+		if !val.IsKnown() {
+			return val.ty.HasDynamicTypes()
+		}
+
 		for it := val.ElementIterator(); it.Next(); {
 			_, ev := it.Element()
-			if ev.HasDynamicValues() {
+			if ev.HasWhollyKnownType() {
 				return true
 			}
 		}

cty/value_ops.go

@@ -173,7 +173,7 @@ func (val Value) Equals(other Value) Value {
 
 	// Check if there are any nested dynamic values making this comparison
 	// unknown.
-	if val.HasDynamicValues() || other.HasDynamicValues() {
+	if val.HasWhollyKnownType() || other.HasWhollyKnownType() {
 		// Even if we have dynamic values, we can still determine inequality if
 		// there is no way the types could later conform.
 		if val.ty.TestConformance(other.ty) != nil && other.ty.TestConformance(val.ty) != nil {

cty/value_ops_test.go

@@ -687,6 +687,26 @@ func TestValueEquals(t *testing.T) {
 			}),
 			UnknownVal(Bool),
 		},
+		{
+			ObjectVal(map[string]Value{
+				"a": NullVal(List(String)),
+			}),
+			// While the unknown val does contain dynamic types, the overall
+			// container types can't conform.
+			ObjectVal(map[string]Value{
+				"a": UnknownVal(List(List(DynamicPseudoType))),
+			}),
+			BoolVal(false),
+		},
+		{
+			ObjectVal(map[string]Value{
+				"a": NullVal(List(List(String))),
+			}),
+			ObjectVal(map[string]Value{
+				"a": UnknownVal(List(List(DynamicPseudoType))),
+			}),
+			UnknownVal(Bool),
+		},
 
 		// Marks
 		{
@@ -2490,7 +2510,7 @@ func TestValueGoString(t *testing.T) {
 	}
 }
 
-func TestHasDynamicValues(t *testing.T) {
+func TestHasWhollyKnownType(t *testing.T) {
 	tests := []struct {
 		Value Value
 		Want  bool
@@ -2556,7 +2576,7 @@ func TestHasDynamicValues(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.Value.GoString(), func(t *testing.T) {
-			got := test.Value.HasDynamicValues()
+			got := test.Value.HasWhollyKnownType()
 			want := test.Want
 			if got != want {
 				t.Errorf("wrong result\ngot:  %v\nwant: %v", got, want)