Upgrade to 0.12

2 files changed, 31 insertions, 30 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/in.go b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
index 642501b..ca9de21 100644
--- a/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
@@ -5,6 +5,7 @@ import (
         "reflect"
 
         "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
         "github.com/zclconf/go-cty/cty/set"
 )
 
@@ -32,6 +33,11 @@ func ToCtyValue(val interface{}, ty cty.Type) (cty.Value, error) {
 }
 
 func toCtyValue(val reflect.Value, ty cty.Type, path cty.Path) (cty.Value, error) {
+        if val != (reflect.Value{}) && val.Type().AssignableTo(valueType) {
+                // If the source value is a cty.Value then we'll try to just pass
+                // through to the target type directly.
+                return toCtyPassthrough(val, ty, path)
+        }
 
         switch ty {
         case cty.Bool:
@@ -505,6 +511,20 @@ func toCtyDynamic(val reflect.Value, path cty.Path) (cty.Value, error) {
 
 }
 
+func toCtyPassthrough(wrappedVal reflect.Value, wantTy cty.Type, path cty.Path) (cty.Value, error) {
+        if wrappedVal = toCtyUnwrapPointer(wrappedVal); !wrappedVal.IsValid() {
+                return cty.NullVal(wantTy), nil
+        }
+
+        givenVal := wrappedVal.Interface().(cty.Value)
+
+        val, err := convert.Convert(givenVal, wantTy)
+        if err != nil {
+                return cty.NilVal, path.NewErrorf("unsuitable value: %s", err)
+        }
+        return val, nil
+}
+
 // toCtyUnwrapPointer is a helper for dealing with Go pointers. It has three
 // possible outcomes:
 //
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/out.go b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
index 99b65a7..e9c2599 100644
--- a/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
@@ -1,11 +1,10 @@
 package gocty
 
 import (
+        "math"
         "math/big"
         "reflect"
 
-        "math"
-
         "github.com/zclconf/go-cty/cty"
 )
 
@@ -112,11 +111,7 @@ func fromCtyBool(val cty.Value, target reflect.Value, path cty.Path) error {
         switch target.Kind() {
 
         case reflect.Bool:
-                if val.True() {
-                        target.Set(reflect.ValueOf(true))
-                } else {
-                        target.Set(reflect.ValueOf(false))
-                }
+                target.SetBool(val.True())
                 return nil
 
         default:
@@ -175,8 +170,7 @@ func fromCtyNumberInt(bf *big.Float, target reflect.Value, path cty.Path) error
                 return path.NewErrorf("value must be a whole number, between %d and %d", min, max)
         }
 
-        target.Set(reflect.ValueOf(iv).Convert(target.Type()))
-
+        target.SetInt(iv)
         return nil
 }
 
@@ -202,25 +196,13 @@ func fromCtyNumberUInt(bf *big.Float, target reflect.Value, path cty.Path) error
                 return path.NewErrorf("value must be a whole number, between 0 and %d inclusive", max)
         }
 
-        target.Set(reflect.ValueOf(iv).Convert(target.Type()))
-
+        target.SetUint(iv)
         return nil
 }
 
 func fromCtyNumberFloat(bf *big.Float, target reflect.Value, path cty.Path) error {
         switch target.Kind() {
-        case reflect.Float32:
-                fv, accuracy := bf.Float32()
-                if accuracy != big.Exact {
-                        // We allow the precision to be truncated as part of our conversion,
-                        // but we don't want to silently introduce infinities.
-                        if math.IsInf(float64(fv), 0) {
-                                return path.NewErrorf("value must be between %f and %f inclusive", -math.MaxFloat32, math.MaxFloat32)
-                        }
-                }
-                target.Set(reflect.ValueOf(fv))
-                return nil
-        case reflect.Float64:
+        case reflect.Float32, reflect.Float64:
                 fv, accuracy := bf.Float64()
                 if accuracy != big.Exact {
                         // We allow the precision to be truncated as part of our conversion,
@@ -229,7 +211,7 @@ func fromCtyNumberFloat(bf *big.Float, target reflect.Value, path cty.Path) erro
                                 return path.NewErrorf("value must be between %f and %f inclusive", -math.MaxFloat64, math.MaxFloat64)
                         }
                 }
-                target.Set(reflect.ValueOf(fv))
+                target.SetFloat(fv)
                 return nil
         default:
                 panic("unsupported kind of float")
@@ -239,17 +221,17 @@ func fromCtyNumberFloat(bf *big.Float, target reflect.Value, path cty.Path) erro
 func fromCtyNumberBig(bf *big.Float, target reflect.Value, path cty.Path) error {
         switch {
 
-        case bigFloatType.AssignableTo(target.Type()):
+        case bigFloatType.ConvertibleTo(target.Type()):
                 // Easy!
-                target.Set(reflect.ValueOf(bf).Elem())
+                target.Set(reflect.ValueOf(bf).Elem().Convert(target.Type()))
                 return nil
 
-        case bigIntType.AssignableTo(target.Type()):
+        case bigIntType.ConvertibleTo(target.Type()):
                 bi, accuracy := bf.Int(nil)
                 if accuracy != big.Exact {
                         return path.NewErrorf("value must be a whole number")
                 }
-                target.Set(reflect.ValueOf(bi).Elem())
+                target.Set(reflect.ValueOf(bi).Elem().Convert(target.Type()))
                 return nil
 
         default:
@@ -259,9 +241,8 @@ func fromCtyNumberBig(bf *big.Float, target reflect.Value, path cty.Path) error
 
 func fromCtyString(val cty.Value, target reflect.Value, path cty.Path) error {
         switch target.Kind() {
-
         case reflect.String:
-                target.Set(reflect.ValueOf(val.AsString()))
+                target.SetString(val.AsString())
                 return nil
 
         default: