Actually handle null values.

When calling `tftypes.Value.As` actually handle null values. If casting
to a pointer to a pointer, null values set the pointer to nil. If casting
to just a pointer, null values set the variable to its empty value,
because we can't safely assume we can store nil; the practice of calling
`Value.As(&dst)` is too common, in which case `dst` wouldn't retain the
nil the way users would expect. So we require a pointer to a pointer to
be able to surface the nil value.

Author: Paddy Carver

tfprotov5/tftypes/value.go

@@ -45,48 +45,95 @@ func (val Value) As(dst interface{}) error {
 	if ok {
 		return unmarshaler.UnmarshalTerraform5Type(val)
 	}
-	if val.IsNull() {
-		return fmt.Errorf("unmarshaling null values is not supported")
-	}
 	if !val.IsKnown() {
 		return fmt.Errorf("unmarshaling unknown values is not supported")
 	}
 	switch target := dst.(type) {
 	case *string:
+		if val.IsNull() {
+			*target = ""
+			return nil
+		}
 		v, ok := val.value.(string)
 		if !ok {
 			return fmt.Errorf("can't unmarshal %s into %T, expected string", val.typ, dst)
 		}
 		*target = v
 		return nil
+	case **string:
+		if val.IsNull() {
+			*target = nil
+			return nil
+		}
+		return val.As(*target)
 	case *big.Float:
+		if val.IsNull() {
+			target.Set(big.NewFloat(0))
+			return nil
+		}
 		v, ok := val.value.(*big.Float)
 		if !ok {
 			return fmt.Errorf("can't unmarshal %s into %T, expected *big.Float", val.typ, dst)
 		}
 		target.Set(v)
 		return nil
+	case **big.Float:
+		if val.IsNull() {
+			*target = nil
+			return nil
+		}
+		return val.As(*target)
 	case *bool:
+		if val.IsNull() {
+			*target = false
+			return nil
+		}
 		v, ok := val.value.(bool)
 		if !ok {
 			return fmt.Errorf("can't unmarshal %s into %T, expected boolean", val.typ, dst)
 		}
 		*target = v
 		return nil
+	case **bool:
+		if val.IsNull() {
+			*target = nil
+			return nil
+		}
+		return val.As(*target)
 	case *map[string]Value:
+		if val.IsNull() {
+			*target = map[string]Value{}
+			return nil
+		}
 		v, ok := val.value.(map[string]Value)
 		if !ok {
 			return fmt.Errorf("can't unmarshal %s into %T, expected map[string]tftypes.Value", val.typ, dst)
 		}
 		*target = v
 		return nil
+	case **map[string]Value:
+		if val.IsNull() {
+			*target = nil
+			return nil
+		}
+		return val.As(*target)
 	case *[]Value:
+		if val.IsNull() {
+			*target = []Value{}
+			return nil
+		}
 		v, ok := val.value.([]Value)
 		if !ok {
 			return fmt.Errorf("can't unmarshal %s into %T expected []tftypes.Value", val.typ, dst)
 		}
 		*target = v
 		return nil
+	case **[]Value:
+		if val.IsNull() {
+			*target = nil
+			return nil
+		}
+		return val.As(*target)
 	}
 	return fmt.Errorf("can't unmarshal into %T, needs UnmarshalTerraform5Type method", dst)
 }