A null dynamic value is a known value when comparing equality

cty/value.go

@@ -106,3 +106,30 @@ func (val Value) IsWhollyKnown() bool {
 		return true
 	}
 }
+
+// HasDynamicValues 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 {
+	// a null dynamic type is known
+	if val.IsNull() {
+		return false
+	}
+
+	// an unknown DynamicPseudoType is a DynamicVal, but we don't want to
+	// check that value for equality here, since this method is used within the
+	// equality check.
+	if val.ty == DynamicPseudoType {
+		return true
+	}
+
+	if val.CanIterateElements() {
+		for it := val.ElementIterator(); it.Next(); {
+			_, ev := it.Element()
+			if ev.HasDynamicValues() {
+				return true
+			}
+		}
+	}
+	return false
+}

cty/value_ops.go

@@ -133,9 +133,9 @@ func (val Value) Equals(other Value) Value {
 	case val.IsKnown() && !other.IsKnown():
 		switch {
 		case val.IsNull(), other.ty.HasDynamicTypes():
-			// If known is Null, we need to wait for the unkown value since
+			// If known is Null, we need to wait for the unknown value since
 			// nulls of any type are equal.
-			// An unkown with a dynamic type compares as unknown, which we need
+			// An unknown with a dynamic type compares as unknown, which we need
 			// to check before the type comparison below.
 			return UnknownVal(Bool)
 		case !val.ty.Equals(other.ty):
@@ -148,9 +148,9 @@ func (val Value) Equals(other Value) Value {
 	case other.IsKnown() && !val.IsKnown():
 		switch {
 		case other.IsNull(), val.ty.HasDynamicTypes():
-			// If known is Null, we need to wait for the unkown value since
+			// If known is Null, we need to wait for the unknown value since
 			// nulls of any type are equal.
-			// An unkown with a dynamic type compares as unknown, which we need
+			// An unknown with a dynamic type compares as unknown, which we need
 			// to check before the type comparison below.
 			return UnknownVal(Bool)
 		case !other.ty.Equals(val.ty):
@@ -171,7 +171,15 @@ func (val Value) Equals(other Value) Value {
 		return BoolVal(false)
 	}
 
-	if val.ty.HasDynamicTypes() || other.ty.HasDynamicTypes() {
+	// Check if there are any nested dynamic values making this comparison
+	// unknown.
+	if val.HasDynamicValues() || other.HasDynamicValues() {
+		// 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 {
+			return BoolVal(false)
+		}
+
 		return UnknownVal(Bool)
 	}
 

cty/value_ops_test.go

@@ -633,6 +633,60 @@ func TestValueEquals(t *testing.T) {
 			NumberIntVal(1),
 			False, // because no string value -- even null -- can be equal to a non-null number
 		},
+		{
+			ObjectVal(map[string]Value{
+				"a": StringVal("a"),
+			}),
+			// A null value is always known
+			ObjectVal(map[string]Value{
+				"a": NullVal(DynamicPseudoType),
+			}),
+			BoolVal(false),
+		},
+		{
+			ObjectVal(map[string]Value{
+				"a": NullVal(DynamicPseudoType),
+			}),
+			ObjectVal(map[string]Value{
+				"a": NullVal(DynamicPseudoType),
+			}),
+			BoolVal(true),
+		},
+		{
+			ObjectVal(map[string]Value{
+				"a": StringVal("a"),
+				"b": UnknownVal(Number),
+			}),
+			// While we have a dynamic type, the different object types should
+			// still compare false
+			ObjectVal(map[string]Value{
+				"a": NullVal(DynamicPseudoType),
+				"c": UnknownVal(Number),
+			}),
+			BoolVal(false),
+		},
+		{
+			ObjectVal(map[string]Value{
+				"a": StringVal("a"),
+				"b": UnknownVal(Number),
+			}),
+			// While we have a dynamic type, the different object types should
+			// still compare false
+			ObjectVal(map[string]Value{
+				"a": DynamicVal,
+				"c": UnknownVal(Number),
+			}),
+			BoolVal(false),
+		},
+		{
+			ObjectVal(map[string]Value{
+				"a": NullVal(DynamicPseudoType),
+			}),
+			ObjectVal(map[string]Value{
+				"a": DynamicVal,
+			}),
+			UnknownVal(Bool),
+		},
 
 		// Marks
 		{
@@ -2435,3 +2489,78 @@ func TestValueGoString(t *testing.T) {
 		})
 	}
 }
+
+func TestHasDynamicValues(t *testing.T) {
+	tests := []struct {
+		Value Value
+		Want  bool
+	}{
+		{
+			Value: DynamicVal,
+			Want:  true,
+		},
+		{
+			Value: ObjectVal(map[string]Value{
+				"dyn": DynamicVal,
+			}),
+			Want: true,
+		},
+		{
+			Value: NullVal(Object(map[string]Type{
+				"dyn": DynamicPseudoType,
+			})),
+			Want: false,
+		},
+		{
+			Value: TupleVal([]Value{
+				StringVal("a"),
+				NullVal(DynamicPseudoType),
+			}),
+			Want: false,
+		},
+		{
+			Value: ListVal([]Value{
+				ObjectVal(map[string]Value{
+					"null": NullVal(DynamicPseudoType),
+				}),
+			}),
+			Want: false,
+		},
+		{
+			Value: ListVal([]Value{
+				NullVal(Object(map[string]Type{
+					"dyn": DynamicPseudoType,
+				})),
+			}),
+			Want: false,
+		},
+		{
+			Value: ObjectVal(map[string]Value{
+				"tuple": TupleVal([]Value{
+					StringVal("a"),
+					NullVal(DynamicPseudoType),
+				}),
+			}),
+			Want: false,
+		},
+		{
+			Value: ObjectVal(map[string]Value{
+				"tuple": TupleVal([]Value{
+					ObjectVal(map[string]Value{
+						"dyn": DynamicVal,
+					}),
+				}),
+			}),
+			Want: true,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.Value.GoString(), func(t *testing.T) {
+			got := test.Value.HasDynamicValues()
+			want := test.Want
+			if got != want {
+				t.Errorf("wrong result\ngot:  %v\nwant: %v", got, want)
+			}
+		})
+	}
+}