Flesh out the As method.

The As method on tftypes.Values was essentially useless, because As is
the only way to get to the underlying Go types beneath a Value, but As
takes a Value as its argument, and As is the only thing you can call on
a Value. So there was nothing you could actually do inside your
Unmarshaler method because As only supported Unmarshalers. So As would
call your Unmarshaler which could only call As which could only call
your Unmarshaler and so on and so forth.

This implements some basic Go type support for the canonical Go
representations of all the tftypes Types, so we can get to them in our
Unmarshaler methods or just use them with As directly.

Author: Paddy Carver

tfprotov5/tftypes/value.go

@@ -3,6 +3,7 @@ package tftypes
 import (
 	"bytes"
 	"fmt"
+	"math/big"
 
 	"github.com/vmihailenco/msgpack"
 )
@@ -39,13 +40,50 @@ func NewValue(t Type, val interface{}) Value {
 	}
 }
 
-func (v Value) As(dst interface{}) error {
+func (val Value) As(dst interface{}) error {
 	unmarshaler, ok := dst.(Unmarshaler)
-	if !ok {
-		// TODO: let's do unmarshaling to builtin types out of the box
-		return fmt.Errorf("can't unmarshal into %T, needs UnmarshalTerraform5Type method", dst)
+	if ok {
+		return unmarshaler.UnmarshalTerraform5Type(val)
 	}
-	return unmarshaler.UnmarshalTerraform5Type(v)
+	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:
+		v, ok := val.value.(string)
+		if !ok {
+			return fmt.Errorf("can't unmarshal %s into %T, expected string", val.typ, dst)
+		}
+		*target = v
+	case *big.Float:
+		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)
+	case *bool:
+		v, ok := val.value.(bool)
+		if !ok {
+			return fmt.Errorf("can't unmarshal %s into %T, expected boolean", val.typ, dst)
+		}
+		*target = v
+	case *map[string]Value:
+		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
+	case *[]Value:
+		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 fmt.Errorf("can't unmarshal into %T, needs UnmarshalTerraform5Type method", dst)
 }
 
 func (v Value) Is(t Type) bool {