Add the ability to do a deep comparison in Is.

When comparing tftypes.Types using the Is method, we didn't used to
check if aggregate types were truly equal, with all their element or
attribute types matching. This was because we wanted to be able to
detect when something was an object, without caring about which
attributes or types of attributes it had, for e.g. casting purposes.

This enhancement checks if the type a type is being compared to has any
element or attribute types set. If so, the type will be deeply compared
against it, with all attribute and alement types needing to match. If
not, the old behavior will continue to work. This lets us do the
following:

```go
typ1 := tftypes.Object{
	AttributeTypes: map[string]tftypes.Type{
		"foo": tftypes.String,
		"bar": tftypes.Number,
		"quux": tftypes.List{
			ElementTypes: tftypes.String,
		},
	},
}

typ1.Is(tftypes.Object{}) // true
typ1.Is(tftypes.Object{
	AttributeTypes: map[string]tftypes.Type{
		"foo": tftypes.String,
		"bar": tftypes.Number,
		"quux": tftypes.List{
			ElementTypes: tftypes.String,
		},
	},
}) // true
typ1.Is(tftypes.Object{
	AttributeTypes: map[string]tftypes.Type{
		"foo": tftypes.String,
		"bar": tftypes.Number,
		"quux": tftypes.List{},
	},
}) // true
typ1.Is(tftypes.Object{
	AttributeTypes: map[string]tftypes.Type{
		"foo": tftypes.String,
		"bar": tftypes.Number,
	},
}) // false
typ1.Is(tftypes.Object{
	AttributeTypes: map[string]tftypes.Type{
		"foo": tftypes.String,
		"bar": tftypes.Number,
		"quux": tftypes.List{
			ElementTypes: tftypes.Number,
		},
	},
}) // false
typ1.Is(tftypes.Object{
	AttributeTypes: map[string]tftypes.Type{
		"foo": tftypes.String,
		"bar": tftypes.String,
		"quux": tftypes.List{
			ElementTypes: tftypes.String,
		},
	},
}) // false
```

and so on.

Author: Paddy Carver

tfprotov5/tftypes/list.go

@@ -7,7 +7,13 @@ type List struct {
 }
 
 func (l List) Is(t Type) bool {
-	_, ok := t.(List)
+	v, ok := t.(List)
+	if !ok {
+		return false
+	}
+	if v.ElementType != nil {
+		return l.ElementType.Is(v.ElementType)
+	}
 	return ok
 }
 

tfprotov5/tftypes/map.go

@@ -7,7 +7,13 @@ type Map struct {
 }
 
 func (m Map) Is(t Type) bool {
-	_, ok := t.(Map)
+	v, ok := t.(Map)
+	if !ok {
+		return false
+	}
+	if m.AttributeType != nil {
+		return m.AttributeType.Is(v.AttributeType)
+	}
 	return ok
 }
 

tfprotov5/tftypes/object.go

@@ -7,7 +7,23 @@ type Object struct {
 }
 
 func (o Object) Is(t Type) bool {
-	_, ok := t.(Object)
+	v, ok := t.(Object)
+	if !ok {
+		return false
+	}
+	if v.AttributeTypes != nil {
+		if len(o.AttributeTypes) != len(v.AttributeTypes) {
+			return false
+		}
+		for k, typ := range o.AttributeTypes {
+			if _, ok := v.AttributeTypes[k]; !ok {
+				return false
+			}
+			if !typ.Is(v.AttributeTypes[k]) {
+				return false
+			}
+		}
+	}
 	return ok
 }
 

tfprotov5/tftypes/set.go

@@ -7,7 +7,13 @@ type Set struct {
 }
 
 func (s Set) Is(t Type) bool {
-	_, ok := t.(Set)
+	v, ok := t.(Set)
+	if !ok {
+		return false
+	}
+	if v.ElementType != nil {
+		return s.ElementType.Is(v.ElementType)
+	}
 	return ok
 }
 

tfprotov5/tftypes/tuple.go

@@ -7,7 +7,20 @@ type Tuple struct {
 }
 
 func (tu Tuple) Is(t Type) bool {
-	_, ok := t.(Tuple)
+	v, ok := t.(Tuple)
+	if !ok {
+		return false
+	}
+	if v.ElementTypes != nil {
+		if len(v.ElementTypes) != len(tu.ElementTypes) {
+			return false
+		}
+		for pos, typ := range tu.ElementTypes {
+			if !typ.Is(v.ElementTypes[pos]) {
+				return false
+			}
+		}
+	}
 	return ok
 }