Upgrade to 0.12

46 files changed, 2965 insertions, 183 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/capsule.go b/vendor/github.com/zclconf/go-cty/cty/capsule.go
index 4fce92a..d273d14 100644
--- a/vendor/github.com/zclconf/go-cty/cty/capsule.go
+++ b/vendor/github.com/zclconf/go-cty/cty/capsule.go
@@ -19,7 +19,7 @@ func (t *capsuleType) Equals(other Type) bool {
         return false
 }
 
-func (t *capsuleType) FriendlyName() string {
+func (t *capsuleType) FriendlyName(mode friendlyTypeNameMode) string {
         return t.Name
 }
 
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
index 7bfcc08..f9aacb4 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
@@ -17,6 +17,10 @@ func getConversion(in cty.Type, out cty.Type, unsafe bool) conversion {
         // Wrap the conversion in some standard checks that we don't want to
         // have to repeat in every conversion function.
         return func(in cty.Value, path cty.Path) (cty.Value, error) {
+                if out == cty.DynamicPseudoType {
+                        // Conversion to DynamicPseudoType always just passes through verbatim.
+                        return in, nil
+                }
                 if !in.IsKnown() {
                         return cty.UnknownVal(out), nil
                 }
@@ -57,6 +61,12 @@ func getConversionKnown(in cty.Type, out cty.Type, unsafe bool) conversion {
                 }
                 return nil
 
+        case out.IsObjectType() && in.IsObjectType():
+                return conversionObjectToObject(in, out, unsafe)
+
+        case out.IsTupleType() && in.IsTupleType():
+                return conversionTupleToTuple(in, out, unsafe)
+
         case out.IsListType() && (in.IsListType() || in.IsSetType()):
                 inEty := in.ElementType()
                 outEty := out.ElementType()
@@ -93,10 +103,23 @@ func getConversionKnown(in cty.Type, out cty.Type, unsafe bool) conversion {
                 }
                 return conversionCollectionToSet(outEty, convEty)
 
+        case out.IsMapType() && in.IsMapType():
+                inEty := in.ElementType()
+                outEty := out.ElementType()
+                convEty := getConversion(inEty, outEty, unsafe)
+                if convEty == nil {
+                        return nil
+                }
+                return conversionCollectionToMap(outEty, convEty)
+
         case out.IsListType() && in.IsTupleType():
                 outEty := out.ElementType()
                 return conversionTupleToList(in, outEty, unsafe)
 
+        case out.IsSetType() && in.IsTupleType():
+                outEty := out.ElementType()
+                return conversionTupleToSet(in, outEty, unsafe)
+
         case out.IsMapType() && in.IsObjectType():
                 outEty := out.ElementType()
                 return conversionObjectToMap(in, outEty, unsafe)
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
index eace85d..3039ba2 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
@@ -84,6 +84,120 @@ func conversionCollectionToSet(ety cty.Type, conv conversion) conversion {
         }
 }
 
+// conversionCollectionToMap returns a conversion that will apply the given
+// conversion to all of the elements of a collection (something that supports
+// ForEachElement and LengthInt) and then returns the result as a map.
+//
+// "conv" can be nil if the elements are expected to already be of the
+// correct type and just need to be re-wrapped into a map.
+func conversionCollectionToMap(ety cty.Type, conv conversion) conversion {
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                elems := make(map[string]cty.Value, 0)
+                path = append(path, nil)
+                it := val.ElementIterator()
+                for it.Next() {
+                        key, val := it.Element()
+                        var err error
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: key,
+                        }
+
+                        keyStr, err := Convert(key, cty.String)
+                        if err != nil {
+                                // Should never happen, because keys can only be numbers or
+                                // strings and both can convert to string.
+                                return cty.DynamicVal, path.NewErrorf("cannot convert key type %s to string for map", key.Type().FriendlyName())
+                        }
+
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+
+                        elems[keyStr.AsString()] = val
+                }
+
+                if len(elems) == 0 {
+                        return cty.MapValEmpty(ety), nil
+                }
+
+                return cty.MapVal(elems), nil
+        }
+}
+
+// conversionTupleToSet returns a conversion that will take a value of the
+// given tuple type and return a set of the given element type.
+//
+// Will panic if the given tupleType isn't actually a tuple type.
+func conversionTupleToSet(tupleType cty.Type, listEty cty.Type, unsafe bool) conversion {
+        tupleEtys := tupleType.TupleElementTypes()
+
+        if len(tupleEtys) == 0 {
+                // Empty tuple short-circuit
+                return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                        return cty.SetValEmpty(listEty), nil
+                }
+        }
+
+        if listEty == cty.DynamicPseudoType {
+                // This is a special case where the caller wants us to find
+                // a suitable single type that all elements can convert to, if
+                // possible.
+                listEty, _ = unify(tupleEtys, unsafe)
+                if listEty == cty.NilType {
+                        return nil
+                }
+        }
+
+        elemConvs := make([]conversion, len(tupleEtys))
+        for i, tupleEty := range tupleEtys {
+                if tupleEty.Equals(listEty) {
+                        // no conversion required
+                        continue
+                }
+
+                elemConvs[i] = getConversion(tupleEty, listEty, unsafe)
+                if elemConvs[i] == nil {
+                        // If any of our element conversions are impossible, then the our
+                        // whole conversion is impossible.
+                        return nil
+                }
+        }
+
+        // If we fall out here then a conversion is possible, using the
+        // element conversions in elemConvs
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                elems := make([]cty.Value, 0, len(elemConvs))
+                path = append(path, nil)
+                i := int64(0)
+                it := val.ElementIterator()
+                for it.Next() {
+                        _, val := it.Element()
+                        var err error
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(i),
+                        }
+
+                        conv := elemConvs[i]
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+                        elems = append(elems, val)
+
+                        i++
+                }
+
+                return cty.SetVal(elems), nil
+        }
+}
+
 // conversionTupleToList returns a conversion that will take a value of the
 // given tuple type and return a list of the given element type.
 //
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
new file mode 100644
index 0000000..62dabb8
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
@@ -0,0 +1,76 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// conversionObjectToObject returns a conversion that will make the input
+// object type conform to the output object type, if possible.
+//
+// Conversion is possible only if the output type is a subset of the input
+// type, meaning that each attribute of the output type has a corresponding
+// attribute in the input type where a recursive conversion is available.
+//
+// Shallow object conversions work the same for both safe and unsafe modes,
+// but the safety flag is passed on to recursive conversions and may thus
+// limit the above definition of "subset".
+func conversionObjectToObject(in, out cty.Type, unsafe bool) conversion {
+        inAtys := in.AttributeTypes()
+        outAtys := out.AttributeTypes()
+        attrConvs := make(map[string]conversion)
+
+        for name, outAty := range outAtys {
+                inAty, exists := inAtys[name]
+                if !exists {
+                        // No conversion is available, then.
+                        return nil
+                }
+
+                if inAty.Equals(outAty) {
+                        // No conversion needed, but we'll still record the attribute
+                        // in our map for later reference.
+                        attrConvs[name] = nil
+                        continue
+                }
+
+                attrConvs[name] = getConversion(inAty, outAty, unsafe)
+                if attrConvs[name] == nil {
+                        // If a recursive conversion isn't available, then our top-level
+                        // configuration is impossible too.
+                        return nil
+                }
+        }
+
+        // If we get here then a conversion is possible, using the attribute
+        // conversions given in attrConvs.
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                attrVals := make(map[string]cty.Value, len(attrConvs))
+                path = append(path, nil)
+                pathStep := &path[len(path)-1]
+
+                for it := val.ElementIterator(); it.Next(); {
+                        nameVal, val := it.Element()
+                        var err error
+
+                        name := nameVal.AsString()
+                        *pathStep = cty.GetAttrStep{
+                                Name: name,
+                        }
+
+                        conv, exists := attrConvs[name]
+                        if !exists {
+                                continue
+                        }
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+
+                        attrVals[name] = val
+                }
+
+                return cty.ObjectVal(attrVals), nil
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
index e563ee3..e0dbf49 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
@@ -1,8 +1,6 @@
 package convert
 
 import (
-        "math/big"
-
         "github.com/zclconf/go-cty/cty"
 )
 
@@ -30,11 +28,11 @@ var primitiveConversionsSafe = map[cty.Type]map[cty.Type]conversion{
 var primitiveConversionsUnsafe = map[cty.Type]map[cty.Type]conversion{
         cty.String: {
                 cty.Number: func(val cty.Value, path cty.Path) (cty.Value, error) {
-                        f, _, err := big.ParseFloat(val.AsString(), 10, 512, big.ToNearestEven)
+                        v, err := cty.ParseNumberVal(val.AsString())
                         if err != nil {
                                 return cty.NilVal, path.NewErrorf("a number is required")
                         }
-                        return cty.NumberVal(f), nil
+                        return v, nil
                 },
                 cty.Bool: func(val cty.Value, path cty.Path) (cty.Value, error) {
                         switch val.AsString() {
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_tuple.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_tuple.go
new file mode 100644
index 0000000..592980a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_tuple.go
@@ -0,0 +1,71 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// conversionTupleToTuple returns a conversion that will make the input
+// tuple type conform to the output tuple type, if possible.
+//
+// Conversion is possible only if the two tuple types have the same number
+// of elements and the corresponding elements by index can be converted.
+//
+// Shallow tuple conversions work the same for both safe and unsafe modes,
+// but the safety flag is passed on to recursive conversions and may thus
+// limit which element type conversions are possible.
+func conversionTupleToTuple(in, out cty.Type, unsafe bool) conversion {
+        inEtys := in.TupleElementTypes()
+        outEtys := out.TupleElementTypes()
+
+        if len(inEtys) != len(outEtys) {
+                return nil // no conversion is possible
+        }
+
+        elemConvs := make([]conversion, len(inEtys))
+
+        for i, outEty := range outEtys {
+                inEty := inEtys[i]
+
+                if inEty.Equals(outEty) {
+                        // No conversion needed, so we can leave this one nil.
+                        continue
+                }
+
+                elemConvs[i] = getConversion(inEty, outEty, unsafe)
+                if elemConvs[i] == nil {
+                        // If a recursive conversion isn't available, then our top-level
+                        // configuration is impossible too.
+                        return nil
+                }
+        }
+
+        // If we get here then a conversion is possible, using the element
+        // conversions given in elemConvs.
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                elemVals := make([]cty.Value, len(elemConvs))
+                path = append(path, nil)
+                pathStep := &path[len(path)-1]
+
+                i := 0
+                for it := val.ElementIterator(); it.Next(); i++ {
+                        _, val := it.Element()
+                        var err error
+
+                        *pathStep = cty.IndexStep{
+                                Key: cty.NumberIntVal(int64(i)),
+                        }
+
+                        conv := elemConvs[i]
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+
+                        elemVals[i] = val
+                }
+
+                return cty.TupleVal(elemVals), nil
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/mismatch_msg.go b/vendor/github.com/zclconf/go-cty/cty/convert/mismatch_msg.go
new file mode 100644
index 0000000..581304e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/mismatch_msg.go
@@ -0,0 +1,220 @@
+package convert
+
+import (
+        "bytes"
+        "fmt"
+        "sort"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// MismatchMessage is a helper to return an English-language description of
+// the differences between got and want, phrased as a reason why got does
+// not conform to want.
+//
+// This function does not itself attempt conversion, and so it should generally
+// be used only after a conversion has failed, to report the conversion failure
+// to an English-speaking user. The result will be confusing got is actually
+// conforming to or convertable to want.
+//
+// The shorthand helper function Convert uses this function internally to
+// produce its error messages, so callers of that function do not need to
+// also use MismatchMessage.
+//
+// This function is similar to Type.TestConformance, but it is tailored to
+// describing conversion failures and so the messages it generates relate
+// specifically to the conversion rules implemented in this package.
+func MismatchMessage(got, want cty.Type) string {
+        switch {
+
+        case got.IsObjectType() && want.IsObjectType():
+                // If both types are object types then we may be able to say something
+                // about their respective attributes.
+                return mismatchMessageObjects(got, want)
+
+        case got.IsTupleType() && want.IsListType() && want.ElementType() == cty.DynamicPseudoType:
+                // If conversion from tuple to list failed then it's because we couldn't
+                // find a common type to convert all of the tuple elements to.
+                return "all list elements must have the same type"
+
+        case got.IsTupleType() && want.IsSetType() && want.ElementType() == cty.DynamicPseudoType:
+                // If conversion from tuple to set failed then it's because we couldn't
+                // find a common type to convert all of the tuple elements to.
+                return "all set elements must have the same type"
+
+        case got.IsObjectType() && want.IsMapType() && want.ElementType() == cty.DynamicPseudoType:
+                // If conversion from object to map failed then it's because we couldn't
+                // find a common type to convert all of the object attributes to.
+                return "all map elements must have the same type"
+
+        case (got.IsTupleType() || got.IsObjectType()) && want.IsCollectionType():
+                return mismatchMessageCollectionsFromStructural(got, want)
+
+        case got.IsCollectionType() && want.IsCollectionType():
+                return mismatchMessageCollectionsFromCollections(got, want)
+
+        default:
+                // If we have nothing better to say, we'll just state what was required.
+                return want.FriendlyNameForConstraint() + " required"
+        }
+}
+
+func mismatchMessageObjects(got, want cty.Type) string {
+        // Per our conversion rules, "got" is allowed to be a superset of "want",
+        // and so we'll produce error messages here under that assumption.
+        gotAtys := got.AttributeTypes()
+        wantAtys := want.AttributeTypes()
+
+        // If we find missing attributes then we'll report those in preference,
+        // but if not then we will report a maximum of one non-conforming
+        // attribute, just to keep our messages relatively terse.
+        // We'll also prefer to report a recursive type error from an _unsafe_
+        // conversion over a safe one, because these are subjectively more
+        // "serious".
+        var missingAttrs []string
+        var unsafeMismatchAttr string
+        var safeMismatchAttr string
+
+        for name, wantAty := range wantAtys {
+                gotAty, exists := gotAtys[name]
+                if !exists {
+                        missingAttrs = append(missingAttrs, name)
+                        continue
+                }
+
+                // We'll now try to convert these attributes in isolation and
+                // see if we have a nested conversion error to report.
+                // We'll try an unsafe conversion first, and then fall back on
+                // safe if unsafe is possible.
+
+                // If we already have an unsafe mismatch attr error then we won't bother
+                // hunting for another one.
+                if unsafeMismatchAttr != "" {
+                        continue
+                }
+                if conv := GetConversionUnsafe(gotAty, wantAty); conv == nil {
+                        unsafeMismatchAttr = fmt.Sprintf("attribute %q: %s", name, MismatchMessage(gotAty, wantAty))
+                }
+
+                // If we already have a safe mismatch attr error then we won't bother
+                // hunting for another one.
+                if safeMismatchAttr != "" {
+                        continue
+                }
+                if conv := GetConversion(gotAty, wantAty); conv == nil {
+                        safeMismatchAttr = fmt.Sprintf("attribute %q: %s", name, MismatchMessage(gotAty, wantAty))
+                }
+        }
+
+        // We should now have collected at least one problem. If we have more than
+        // one then we'll use our preference order to decide what is most important
+        // to report.
+        switch {
+
+        case len(missingAttrs) != 0:
+                sort.Strings(missingAttrs)
+                switch len(missingAttrs) {
+                case 1:
+                        return fmt.Sprintf("attribute %q is required", missingAttrs[0])
+                case 2:
+                        return fmt.Sprintf("attributes %q and %q are required", missingAttrs[0], missingAttrs[1])
+                default:
+                        sort.Strings(missingAttrs)
+                        var buf bytes.Buffer
+                        for _, name := range missingAttrs[:len(missingAttrs)-1] {
+                                fmt.Fprintf(&buf, "%q, ", name)
+                        }
+                        fmt.Fprintf(&buf, "and %q", missingAttrs[len(missingAttrs)-1])
+                        return fmt.Sprintf("attributes %s are required", buf.Bytes())
+                }
+
+        case unsafeMismatchAttr != "":
+                return unsafeMismatchAttr
+
+        case safeMismatchAttr != "":
+                return safeMismatchAttr
+
+        default:
+                // We should never get here, but if we do then we'll return
+                // just a generic message.
+                return "incorrect object attributes"
+        }
+}
+
+func mismatchMessageCollectionsFromStructural(got, want cty.Type) string {
+        // First some straightforward cases where the kind is just altogether wrong.
+        switch {
+        case want.IsListType() && !got.IsTupleType():
+                return want.FriendlyNameForConstraint() + " required"
+        case want.IsSetType() && !got.IsTupleType():
+                return want.FriendlyNameForConstraint() + " required"
+        case want.IsMapType() && !got.IsObjectType():
+                return want.FriendlyNameForConstraint() + " required"
+        }
+
+        // If the kinds are matched well enough then we'll move on to checking
+        // individual elements.
+        wantEty := want.ElementType()
+        switch {
+        case got.IsTupleType():
+                for i, gotEty := range got.TupleElementTypes() {
+                        if gotEty.Equals(wantEty) {
+                                continue // exact match, so no problem
+                        }
+                        if conv := getConversion(gotEty, wantEty, true); conv != nil {
+                                continue // conversion is available, so no problem
+                        }
+                        return fmt.Sprintf("element %d: %s", i, MismatchMessage(gotEty, wantEty))
+                }
+
+                // If we get down here then something weird is going on but we'll
+                // return a reasonable fallback message anyway.
+                return fmt.Sprintf("all elements must be %s", wantEty.FriendlyNameForConstraint())
+
+        case got.IsObjectType():
+                for name, gotAty := range got.AttributeTypes() {
+                        if gotAty.Equals(wantEty) {
+                                continue // exact match, so no problem
+                        }
+                        if conv := getConversion(gotAty, wantEty, true); conv != nil {
+                                continue // conversion is available, so no problem
+                        }
+                        return fmt.Sprintf("element %q: %s", name, MismatchMessage(gotAty, wantEty))
+                }
+
+                // If we get down here then something weird is going on but we'll
+                // return a reasonable fallback message anyway.
+                return fmt.Sprintf("all elements must be %s", wantEty.FriendlyNameForConstraint())
+
+        default:
+                // Should not be possible to get here since we only call this function
+                // with got as structural types, but...
+                return want.FriendlyNameForConstraint() + " required"
+        }
+}
+
+func mismatchMessageCollectionsFromCollections(got, want cty.Type) string {
+        // First some straightforward cases where the kind is just altogether wrong.
+        switch {
+        case want.IsListType() && !(got.IsListType() || got.IsSetType()):
+                return want.FriendlyNameForConstraint() + " required"
+        case want.IsSetType() && !(got.IsListType() || got.IsSetType()):
+                return want.FriendlyNameForConstraint() + " required"
+        case want.IsMapType() && !got.IsMapType():
+                return want.FriendlyNameForConstraint() + " required"
+        }
+
+        // If the kinds are matched well enough then we'll check the element types.
+        gotEty := got.ElementType()
+        wantEty := want.ElementType()
+        noun := "element type"
+        switch {
+        case want.IsListType():
+                noun = "list element type"
+        case want.IsSetType():
+                noun = "set element type"
+        case want.IsMapType():
+                noun = "map element type"
+        }
+        return fmt.Sprintf("incorrect %s: %s", noun, MismatchMessage(gotEty, wantEty))
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/public.go b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
index 55f44ae..af19bdc 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/public.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
@@ -1,7 +1,7 @@
 package convert
 
 import (
-        "fmt"
+        "errors"
 
         "github.com/zclconf/go-cty/cty"
 )
@@ -46,7 +46,7 @@ func Convert(in cty.Value, want cty.Type) (cty.Value, error) {
 
         conv := GetConversionUnsafe(in.Type(), want)
         if conv == nil {
-                return cty.NilVal, fmt.Errorf("incorrect type; %s required", want.FriendlyName())
+                return cty.NilVal, errors.New(MismatchMessage(in.Type(), want))
         }
         return conv(in)
 }
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/unify.go b/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
index bd6736b..53ebbfe 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
@@ -21,6 +21,39 @@ func unify(types []cty.Type, unsafe bool) (cty.Type, []Conversion) {
                 return cty.NilType, nil
         }
 
+        // If all of the given types are of the same structural kind, we may be
+        // able to construct a new type that they can all be unified to, even if
+        // that is not one of the given types. We must try this before the general
+        // behavior below because in unsafe mode we can convert an object type to
+        // a subset of that type, which would be a much less useful conversion for
+        // unification purposes.
+        {
+                objectCt := 0
+                tupleCt := 0
+                dynamicCt := 0
+                for _, ty := range types {
+                        switch {
+                        case ty.IsObjectType():
+                                objectCt++
+                        case ty.IsTupleType():
+                                tupleCt++
+                        case ty == cty.DynamicPseudoType:
+                                dynamicCt++
+                        default:
+                                break
+                        }
+                }
+                switch {
+                case objectCt > 0 && (objectCt+dynamicCt) == len(types):
+                        return unifyObjectTypes(types, unsafe, dynamicCt > 0)
+                case tupleCt > 0 && (tupleCt+dynamicCt) == len(types):
+                        return unifyTupleTypes(types, unsafe, dynamicCt > 0)
+                case objectCt > 0 && tupleCt > 0:
+                        // Can never unify object and tuple types since they have incompatible kinds
+                        return cty.NilType, nil
+                }
+        }
+
         prefOrder := sortTypes(types)
 
         // sortTypes gives us an order where earlier items are preferable as
@@ -58,9 +91,224 @@ Preferences:
                 return wantType, conversions
         }
 
-        // TODO: For structural types, try to invent a new type that they
-        // can all be unified to, by unifying their respective attributes.
-
         // If we fall out here, no unification is possible
         return cty.NilType, nil
 }
+
+func unifyObjectTypes(types []cty.Type, unsafe bool, hasDynamic bool) (cty.Type, []Conversion) {
+        // If we had any dynamic types in the input here then we can't predict
+        // what path we'll take through here once these become known types, so
+        // we'll conservatively produce DynamicVal for these.
+        if hasDynamic {
+                return unifyAllAsDynamic(types)
+        }
+
+        // There are two different ways we can succeed here:
+        // - If all of the given object types have the same set of attribute names
+        //   and the corresponding types are all unifyable, then we construct that
+        //   type.
+        // - If the given object types have different attribute names or their
+        //   corresponding types are not unifyable, we'll instead try to unify
+        //   all of the attribute types together to produce a map type.
+        //
+        // Our unification behavior is intentionally stricter than our conversion
+        // behavior for subset object types because user intent is different with
+        // unification use-cases: it makes sense to allow {"foo":true} to convert
+        // to emptyobjectval, but unifying an object with an attribute with the
+        // empty object type should be an error because unifying to the empty
+        // object type would be suprising and useless.
+
+        firstAttrs := types[0].AttributeTypes()
+        for _, ty := range types[1:] {
+                thisAttrs := ty.AttributeTypes()
+                if len(thisAttrs) != len(firstAttrs) {
+                        // If number of attributes is different then there can be no
+                        // object type in common.
+                        return unifyObjectTypesToMap(types, unsafe)
+                }
+                for name := range thisAttrs {
+                        if _, ok := firstAttrs[name]; !ok {
+                                // If attribute names don't exactly match then there can be
+                                // no object type in common.
+                                return unifyObjectTypesToMap(types, unsafe)
+                        }
+                }
+        }
+
+        // If we get here then we've proven that all of the given object types
+        // have exactly the same set of attribute names, though the types may
+        // differ.
+        retAtys := make(map[string]cty.Type)
+        atysAcross := make([]cty.Type, len(types))
+        for name := range firstAttrs {
+                for i, ty := range types {
+                        atysAcross[i] = ty.AttributeType(name)
+                }
+                retAtys[name], _ = unify(atysAcross, unsafe)
+                if retAtys[name] == cty.NilType {
+                        // Cannot unify this attribute alone, which means that unification
+                        // of everything down to a map type can't be possible either.
+                        return cty.NilType, nil
+                }
+        }
+        retTy := cty.Object(retAtys)
+
+        conversions := make([]Conversion, len(types))
+        for i, ty := range types {
+                if ty.Equals(retTy) {
+                        continue
+                }
+                if unsafe {
+                        conversions[i] = GetConversionUnsafe(ty, retTy)
+                } else {
+                        conversions[i] = GetConversion(ty, retTy)
+                }
+                if conversions[i] == nil {
+                        // Shouldn't be reachable, since we were able to unify
+                        return unifyObjectTypesToMap(types, unsafe)
+                }
+        }
+
+        return retTy, conversions
+}
+
+func unifyObjectTypesToMap(types []cty.Type, unsafe bool) (cty.Type, []Conversion) {
+        // This is our fallback case for unifyObjectTypes, where we see if we can
+        // construct a map type that can accept all of the attribute types.
+
+        var atys []cty.Type
+        for _, ty := range types {
+                for _, aty := range ty.AttributeTypes() {
+                        atys = append(atys, aty)
+                }
+        }
+
+        ety, _ := unify(atys, unsafe)
+        if ety == cty.NilType {
+                return cty.NilType, nil
+        }
+
+        retTy := cty.Map(ety)
+        conversions := make([]Conversion, len(types))
+        for i, ty := range types {
+                if ty.Equals(retTy) {
+                        continue
+                }
+                if unsafe {
+                        conversions[i] = GetConversionUnsafe(ty, retTy)
+                } else {
+                        conversions[i] = GetConversion(ty, retTy)
+                }
+                if conversions[i] == nil {
+                        return cty.NilType, nil
+                }
+        }
+        return retTy, conversions
+}
+
+func unifyTupleTypes(types []cty.Type, unsafe bool, hasDynamic bool) (cty.Type, []Conversion) {
+        // If we had any dynamic types in the input here then we can't predict
+        // what path we'll take through here once these become known types, so
+        // we'll conservatively produce DynamicVal for these.
+        if hasDynamic {
+                return unifyAllAsDynamic(types)
+        }
+
+        // There are two different ways we can succeed here:
+        // - If all of the given tuple types have the same sequence of element types
+        //   and the corresponding types are all unifyable, then we construct that
+        //   type.
+        // - If the given tuple types have different element types or their
+        //   corresponding types are not unifyable, we'll instead try to unify
+        //   all of the elements types together to produce a list type.
+
+        firstEtys := types[0].TupleElementTypes()
+        for _, ty := range types[1:] {
+                thisEtys := ty.TupleElementTypes()
+                if len(thisEtys) != len(firstEtys) {
+                        // If number of elements is different then there can be no
+                        // tuple type in common.
+                        return unifyTupleTypesToList(types, unsafe)
+                }
+        }
+
+        // If we get here then we've proven that all of the given tuple types
+        // have the same number of elements, though the types may differ.
+        retEtys := make([]cty.Type, len(firstEtys))
+        atysAcross := make([]cty.Type, len(types))
+        for idx := range firstEtys {
+                for tyI, ty := range types {
+                        atysAcross[tyI] = ty.TupleElementTypes()[idx]
+                }
+                retEtys[idx], _ = unify(atysAcross, unsafe)
+                if retEtys[idx] == cty.NilType {
+                        // Cannot unify this element alone, which means that unification
+                        // of everything down to a map type can't be possible either.
+                        return cty.NilType, nil
+                }
+        }
+        retTy := cty.Tuple(retEtys)
+
+        conversions := make([]Conversion, len(types))
+        for i, ty := range types {
+                if ty.Equals(retTy) {
+                        continue
+                }
+                if unsafe {
+                        conversions[i] = GetConversionUnsafe(ty, retTy)
+                } else {
+                        conversions[i] = GetConversion(ty, retTy)
+                }
+                if conversions[i] == nil {
+                        // Shouldn't be reachable, since we were able to unify
+                        return unifyTupleTypesToList(types, unsafe)
+                }
+        }
+
+        return retTy, conversions
+}
+
+func unifyTupleTypesToList(types []cty.Type, unsafe bool) (cty.Type, []Conversion) {
+        // This is our fallback case for unifyTupleTypes, where we see if we can
+        // construct a list type that can accept all of the element types.
+
+        var etys []cty.Type
+        for _, ty := range types {
+                for _, ety := range ty.TupleElementTypes() {
+                        etys = append(etys, ety)
+                }
+        }
+
+        ety, _ := unify(etys, unsafe)
+        if ety == cty.NilType {
+                return cty.NilType, nil
+        }
+
+        retTy := cty.List(ety)
+        conversions := make([]Conversion, len(types))
+        for i, ty := range types {
+                if ty.Equals(retTy) {
+                        continue
+                }
+                if unsafe {
+                        conversions[i] = GetConversionUnsafe(ty, retTy)
+                } else {
+                        conversions[i] = GetConversion(ty, retTy)
+                }
+                if conversions[i] == nil {
+                        // Shouldn't be reachable, since we were able to unify
+                        return unifyObjectTypesToMap(types, unsafe)
+                }
+        }
+        return retTy, conversions
+}
+
+func unifyAllAsDynamic(types []cty.Type) (cty.Type, []Conversion) {
+        conversions := make([]Conversion, len(types))
+        for i := range conversions {
+                conversions[i] = func(cty.Value) (cty.Value, error) {
+                        return cty.DynamicVal, nil
+                }
+        }
+        return cty.DynamicPseudoType, conversions
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/function.go b/vendor/github.com/zclconf/go-cty/cty/function/function.go
index 162f7bf..9e8bf33 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/function.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/function.go
@@ -143,7 +143,7 @@ func (f Function) ReturnTypeForValues(args []cty.Value) (ty cty.Type, err error)
                 val := posArgs[i]
 
                 if val.IsNull() && !spec.AllowNull {
-                        return cty.Type{}, NewArgErrorf(i, "must not be null")
+                        return cty.Type{}, NewArgErrorf(i, "argument must not be null")
                 }
 
                 // AllowUnknown is ignored for type-checking, since we expect to be
@@ -169,7 +169,7 @@ func (f Function) ReturnTypeForValues(args []cty.Value) (ty cty.Type, err error)
                         realI := i + len(posArgs)
 
                         if val.IsNull() && !spec.AllowNull {
-                                return cty.Type{}, NewArgErrorf(realI, "must not be null")
+                                return cty.Type{}, NewArgErrorf(realI, "argument must not be null")
                         }
 
                         if val.Type() == cty.DynamicPseudoType {
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
new file mode 100644
index 0000000..aa15b7b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
@@ -0,0 +1,385 @@
+package stdlib
+
+import (
+        "bufio"
+        "bytes"
+        "fmt"
+        "strings"
+        "time"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var FormatDateFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "format",
+                        Type: cty.String,
+                },
+                {
+                        Name: "time",
+                        Type: cty.String,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                formatStr := args[0].AsString()
+                timeStr := args[1].AsString()
+                t, err := parseTimestamp(timeStr)
+                if err != nil {
+                        return cty.DynamicVal, function.NewArgError(1, err)
+                }
+
+                var buf bytes.Buffer
+                sc := bufio.NewScanner(strings.NewReader(formatStr))
+                sc.Split(splitDateFormat)
+                const esc = '\''
+                for sc.Scan() {
+                        tok := sc.Bytes()
+
+                        // The leading byte signals the token type
+                        switch {
+                        case tok[0] == esc:
+                                if tok[len(tok)-1] != esc || len(tok) == 1 {
+                                        return cty.DynamicVal, function.NewArgErrorf(0, "unterminated literal '")
+                                }
+                                if len(tok) == 2 {
+                                        // Must be a single escaped quote, ''
+                                        buf.WriteByte(esc)
+                                } else {
+                                        // The content (until a closing esc) is printed out verbatim
+                                        // except that we must un-double any double-esc escapes in
+                                        // the middle of the string.
+                                        raw := tok[1 : len(tok)-1]
+                                        for i := 0; i < len(raw); i++ {
+                                                buf.WriteByte(raw[i])
+                                                if raw[i] == esc {
+                                                        i++ // skip the escaped quote
+                                                }
+                                        }
+                                }
+
+                        case startsDateFormatVerb(tok[0]):
+                                switch tok[0] {
+                                case 'Y':
+                                        y := t.Year()
+                                        switch len(tok) {
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", y%100)
+                                        case 4:
+                                                fmt.Fprintf(&buf, "%04d", y)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: year must either be \"YY\" or \"YYYY\"", tok)
+                                        }
+                                case 'M':
+                                        m := t.Month()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", m)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", m)
+                                        case 3:
+                                                buf.WriteString(m.String()[:3])
+                                        case 4:
+                                                buf.WriteString(m.String())
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: month must be \"M\", \"MM\", \"MMM\", or \"MMMM\"", tok)
+                                        }
+                                case 'D':
+                                        d := t.Day()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", d)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", d)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: day of month must either be \"D\" or \"DD\"", tok)
+                                        }
+                                case 'E':
+                                        d := t.Weekday()
+                                        switch len(tok) {
+                                        case 3:
+                                                buf.WriteString(d.String()[:3])
+                                        case 4:
+                                                buf.WriteString(d.String())
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: day of week must either be \"EEE\" or \"EEEE\"", tok)
+                                        }
+                                case 'h':
+                                        h := t.Hour()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", h)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", h)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: 24-hour must either be \"h\" or \"hh\"", tok)
+                                        }
+                                case 'H':
+                                        h := t.Hour() % 12
+                                        if h == 0 {
+                                                h = 12
+                                        }
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", h)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", h)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: 12-hour must either be \"H\" or \"HH\"", tok)
+                                        }
+                                case 'A', 'a':
+                                        if len(tok) != 2 {
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: must be \"%s%s\"", tok, tok[0:1], tok[0:1])
+                                        }
+                                        upper := tok[0] == 'A'
+                                        switch t.Hour() / 12 {
+                                        case 0:
+                                                if upper {
+                                                        buf.WriteString("AM")
+                                                } else {
+                                                        buf.WriteString("am")
+                                                }
+                                        case 1:
+                                                if upper {
+                                                        buf.WriteString("PM")
+                                                } else {
+                                                        buf.WriteString("pm")
+                                                }
+                                        }
+                                case 'm':
+                                        m := t.Minute()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", m)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", m)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: minute must either be \"m\" or \"mm\"", tok)
+                                        }
+                                case 's':
+                                        s := t.Second()
+                                        switch len(tok) {
+                                        case 1:
+                                                fmt.Fprintf(&buf, "%d", s)
+                                        case 2:
+                                                fmt.Fprintf(&buf, "%02d", s)
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: second must either be \"s\" or \"ss\"", tok)
+                                        }
+                                case 'Z':
+                                        // We'll just lean on Go's own formatter for this one, since
+                                        // the necessary information is unexported.
+                                        switch len(tok) {
+                                        case 1:
+                                                buf.WriteString(t.Format("Z07:00"))
+                                        case 3:
+                                                str := t.Format("-0700")
+                                                switch str {
+                                                case "+0000":
+                                                        buf.WriteString("UTC")
+                                                default:
+                                                        buf.WriteString(str)
+                                                }
+                                        case 4:
+                                                buf.WriteString(t.Format("-0700"))
+                                        case 5:
+                                                buf.WriteString(t.Format("-07:00"))
+                                        default:
+                                                return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: timezone must be Z, ZZZZ, or ZZZZZ", tok)
+                                        }
+                                default:
+                                        return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q", tok)
+                                }
+
+                        default:
+                                // Any other starting character indicates a literal sequence
+                                buf.Write(tok)
+                        }
+                }
+
+                return cty.StringVal(buf.String()), nil
+        },
+})
+
+// FormatDate reformats a timestamp given in RFC3339 syntax into another time
+// syntax defined by a given format string.
+//
+// The format string uses letter mnemonics to represent portions of the
+// timestamp, with repetition signifying length variants of each portion.
+// Single quote characters ' can be used to quote sequences of literal letters
+// that should not be interpreted as formatting mnemonics.
+//
+// The full set of supported mnemonic sequences is listed below:
+//
+//     YY       Year modulo 100 zero-padded to two digits, like "06".
+//     YYYY     Four (or more) digit year, like "2006".
+//     M        Month number, like "1" for January.
+//     MM       Month number zero-padded to two digits, like "01".
+//     MMM      English month name abbreviated to three letters, like "Jan".
+//     MMMM     English month name unabbreviated, like "January".
+//     D        Day of month number, like "2".
+//     DD       Day of month number zero-padded to two digits, like "02".
+//     EEE      English day of week name abbreviated to three letters, like "Mon".
+//     EEEE     English day of week name unabbreviated, like "Monday".
+//     h        24-hour number, like "2".
+//     hh       24-hour number zero-padded to two digits, like "02".
+//     H        12-hour number, like "2".
+//     HH       12-hour number zero-padded to two digits, like "02".
+//     AA       Hour AM/PM marker in uppercase, like "AM".
+//     aa       Hour AM/PM marker in lowercase, like "am".
+//     m        Minute within hour, like "5".
+//     mm       Minute within hour zero-padded to two digits, like "05".
+//     s        Second within minute, like "9".
+//     ss       Second within minute zero-padded to two digits, like "09".
+//     ZZZZ     Timezone offset with just sign and digit, like "-0800".
+//     ZZZZZ    Timezone offset with colon separating hours and minutes, like "-08:00".
+//     Z        Like ZZZZZ but with a special case "Z" for UTC.
+//     ZZZ      Like ZZZZ but with a special case "UTC" for UTC.
+//
+// The format syntax is optimized mainly for generating machine-oriented
+// timestamps rather than human-oriented timestamps; the English language
+// portions of the output reflect the use of English names in a number of
+// machine-readable date formatting standards. For presentation to humans,
+// a locale-aware time formatter (not included in this package) is a better
+// choice.
+//
+// The format syntax is not compatible with that of any other language, but
+// is optimized so that patterns for common standard date formats can be
+// recognized quickly even by a reader unfamiliar with the format syntax.
+func FormatDate(format cty.Value, timestamp cty.Value) (cty.Value, error) {
+        return FormatDateFunc.Call([]cty.Value{format, timestamp})
+}
+
+func parseTimestamp(ts string) (time.Time, error) {
+        t, err := time.Parse(time.RFC3339, ts)
+        if err != nil {
+                switch err := err.(type) {
+                case *time.ParseError:
+                        // If err is s time.ParseError then its string representation is not
+                        // appropriate since it relies on details of Go's strange date format
+                        // representation, which a caller of our functions is not expected
+                        // to be familiar with.
+                        //
+                        // Therefore we do some light transformation to get a more suitable
+                        // error that should make more sense to our callers. These are
+                        // still not awesome error messages, but at least they refer to
+                        // the timestamp portions by name rather than by Go's example
+                        // values.
+                        if err.LayoutElem == "" && err.ValueElem == "" && err.Message != "" {
+                                // For some reason err.Message is populated with a ": " prefix
+                                // by the time package.
+                                return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp%s", err.Message)
+                        }
+                        var what string
+                        switch err.LayoutElem {
+                        case "2006":
+                                what = "year"
+                        case "01":
+                                what = "month"
+                        case "02":
+                                what = "day of month"
+                        case "15":
+                                what = "hour"
+                        case "04":
+                                what = "minute"
+                        case "05":
+                                what = "second"
+                        case "Z07:00":
+                                what = "UTC offset"
+                        case "T":
+                                return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: missing required time introducer 'T'")
+                        case ":", "-":
+                                if err.ValueElem == "" {
+                                        return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: end of string where %q is expected", err.LayoutElem)
+                                } else {
+                                        return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: found %q where %q is expected", err.ValueElem, err.LayoutElem)
+                                }
+                        default:
+                                // Should never get here, because time.RFC3339 includes only the
+                                // above portions, but since that might change in future we'll
+                                // be robust here.
+                                what = "timestamp segment"
+                        }
+                        if err.ValueElem == "" {
+                                return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: end of string before %s", what)
+                        } else {
+                                return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: cannot use %q as %s", err.ValueElem, what)
+                        }
+                }
+                return time.Time{}, err
+        }
+        return t, nil
+}
+
+// splitDataFormat is a bufio.SplitFunc used to tokenize a date format.
+func splitDateFormat(data []byte, atEOF bool) (advance int, token []byte, err error) {
+        if len(data) == 0 {
+                return 0, nil, nil
+        }
+
+        const esc = '\''
+
+        switch {
+
+        case data[0] == esc:
+                // If we have another quote immediately after then this is a single
+                // escaped escape.
+                if len(data) > 1 && data[1] == esc {
+                        return 2, data[:2], nil
+                }
+
+                // Beginning of quoted sequence, so we will seek forward until we find
+                // the closing quote, ignoring escaped quotes along the way.
+                for i := 1; i < len(data); i++ {
+                        if data[i] == esc {
+                                if (i + 1) == len(data) {
+                                        // We need at least one more byte to decide if this is an
+                                        // escape or a terminator.
+                                        return 0, nil, nil
+                                }
+                                if data[i+1] == esc {
+                                        i++ // doubled-up quotes are an escape sequence
+                                        continue
+                                }
+                                // We've found the closing quote
+                                return i + 1, data[:i+1], nil
+                        }
+                }
+                // If we fall out here then we need more bytes to find the end,
+                // unless we're already at the end with an unclosed quote.
+                if atEOF {
+                        return len(data), data, nil
+                }
+                return 0, nil, nil
+
+        case startsDateFormatVerb(data[0]):
+                rep := data[0]
+                for i := 1; i < len(data); i++ {
+                        if data[i] != rep {
+                                return i, data[:i], nil
+                        }
+                }
+                if atEOF {
+                        return len(data), data, nil
+                }
+                // We need more data to decide if we've found the end
+                return 0, nil, nil
+
+        default:
+                for i := 1; i < len(data); i++ {
+                        if data[i] == esc || startsDateFormatVerb(data[i]) {
+                                return i, data[:i], nil
+                        }
+                }
+                // We might not actually be at the end of a literal sequence,
+                // but that doesn't matter since we'll concat them back together
+                // anyway.
+                return len(data), data, nil
+        }
+}
+
+func startsDateFormatVerb(b byte) bool {
+        return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
index fb24f20..664790b 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
@@ -84,6 +84,11 @@ var FormatListFunc = function.New(&function.Spec{
                         argTy := arg.Type()
                         switch {
                         case (argTy.IsListType() || argTy.IsSetType() || argTy.IsTupleType()) && !arg.IsNull():
+                                if !argTy.IsTupleType() && !arg.IsKnown() {
+                                        // We can't iterate this one at all yet then, so we can't
+                                        // yet produce a result.
+                                        return cty.UnknownVal(retType), nil
+                                }
                                 thisLen := arg.LengthInt()
                                 if iterLen == -1 {
                                         iterLen = thisLen
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
index 86876ba..32b1ac9 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
@@ -11,9 +11,10 @@ import (
         "unicode/utf8"
 
         "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
 )
 
-// line 20 "format_fsm.go"
+// line 21 "format_fsm.go"
 var _formatfsm_actions []byte = []byte{
         0, 1, 0, 1, 1, 1, 2, 1, 4,
         1, 5, 1, 6, 1, 7, 1, 8,
@@ -86,15 +87,16 @@ const formatfsm_error int = 0
 
 const formatfsm_en_main int = 8
 
-// line 19 "format_fsm.rl"
+// line 20 "format_fsm.rl"
 
 func formatFSM(format string, a []cty.Value) (string, error) {
         var buf bytes.Buffer
         data := format
         nextArg := 1 // arg numbers are 1-based
         var verb formatVerb
+        highestArgIdx := 0 // zero means "none", since arg numbers are 1-based
 
-        // line 153 "format_fsm.rl"
+        // line 159 "format_fsm.rl"
 
         // Ragel state
         p := 0          // "Pointer" into data
@@ -109,12 +111,12 @@ func formatFSM(format string, a []cty.Value) (string, error) {
         _ = te
         _ = eof
 
-        // line 121 "format_fsm.go"
+        // line 123 "format_fsm.go"
         {
                 cs = formatfsm_start
         }
 
-        // line 126 "format_fsm.go"
+        // line 128 "format_fsm.go"
         {
                 var _klen int
                 var _trans int
@@ -195,7 +197,7 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                         _acts++
                         switch _formatfsm_actions[_acts-1] {
                         case 0:
-                                // line 29 "format_fsm.rl"
+                                // line 31 "format_fsm.rl"
 
                                 verb = formatVerb{
                                         ArgNum: nextArg,
@@ -205,12 +207,12 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                                 ts = p
 
                         case 1:
-                                // line 38 "format_fsm.rl"
+                                // line 40 "format_fsm.rl"
 
                                 buf.WriteByte(data[p])
 
                         case 4:
-                                // line 49 "format_fsm.rl"
+                                // line 51 "format_fsm.rl"
 
                                 // We'll try to slurp a whole UTF-8 sequence here, to give the user
                                 // better feedback.
@@ -218,85 +220,89 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                                 return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
 
                         case 5:
-                                // line 56 "format_fsm.rl"
+                                // line 58 "format_fsm.rl"
 
                                 verb.Sharp = true
 
                         case 6:
-                                // line 59 "format_fsm.rl"
+                                // line 61 "format_fsm.rl"
 
                                 verb.Zero = true
 
                         case 7:
-                                // line 62 "format_fsm.rl"
+                                // line 64 "format_fsm.rl"
 
                                 verb.Minus = true
 
                         case 8:
-                                // line 65 "format_fsm.rl"
+                                // line 67 "format_fsm.rl"
 
                                 verb.Plus = true
 
                         case 9:
-                                // line 68 "format_fsm.rl"
+                                // line 70 "format_fsm.rl"
 
                                 verb.Space = true
 
                         case 10:
-                                // line 72 "format_fsm.rl"
+                                // line 74 "format_fsm.rl"
 
                                 verb.ArgNum = 0
 
                         case 11:
-                                // line 75 "format_fsm.rl"
+                                // line 77 "format_fsm.rl"
 
                                 verb.ArgNum = (10 * verb.ArgNum) + (int(data[p]) - '0')
 
                         case 12:
-                                // line 79 "format_fsm.rl"
+                                // line 81 "format_fsm.rl"
 
                                 verb.HasWidth = true
 
                         case 13:
-                                // line 82 "format_fsm.rl"
+                                // line 84 "format_fsm.rl"
 
                                 verb.Width = 0
 
                         case 14:
-                                // line 85 "format_fsm.rl"
+                                // line 87 "format_fsm.rl"
 
                                 verb.Width = (10 * verb.Width) + (int(data[p]) - '0')
 
                         case 15:
-                                // line 89 "format_fsm.rl"
+                                // line 91 "format_fsm.rl"
 
                                 verb.HasPrec = true
 
                         case 16:
-                                // line 92 "format_fsm.rl"
+                                // line 94 "format_fsm.rl"
 
                                 verb.Prec = 0
 
                         case 17:
-                                // line 95 "format_fsm.rl"
+                                // line 97 "format_fsm.rl"
 
                                 verb.Prec = (10 * verb.Prec) + (int(data[p]) - '0')
 
                         case 18:
-                                // line 99 "format_fsm.rl"
+                                // line 101 "format_fsm.rl"
 
                                 verb.Mode = rune(data[p])
                                 te = p + 1
                                 verb.Raw = data[ts:te]
                                 verb.Offset = ts
 
+                                if verb.ArgNum > highestArgIdx {
+                                        highestArgIdx = verb.ArgNum
+                                }
+
                                 err := formatAppend(&verb, &buf, a)
                                 if err != nil {
                                         return buf.String(), err
                                 }
                                 nextArg = verb.ArgNum + 1
 
-                                // line 324 "format_fsm.go"
+                                // line 330 "format_fsm.go"
                         }
                 }
 
@@ -319,22 +325,22 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                                 __acts++
                                 switch _formatfsm_actions[__acts-1] {
                                 case 2:
-                                        // line 42 "format_fsm.rl"
+                                        // line 44 "format_fsm.rl"
 
                                 case 3:
-                                        // line 45 "format_fsm.rl"
+                                        // line 47 "format_fsm.rl"
 
                                         return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
 
                                 case 4:
-                                        // line 49 "format_fsm.rl"
+                                        // line 51 "format_fsm.rl"
 
                                         // We'll try to slurp a whole UTF-8 sequence here, to give the user
                                         // better feedback.
                                         r, _ := utf8.DecodeRuneInString(data[p:])
                                         return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
 
-                                        // line 363 "format_fsm.go"
+                                        // line 369 "format_fsm.go"
                                 }
                         }
                 }
@@ -344,14 +350,24 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                 }
         }
 
-        // line 171 "format_fsm.rl"
+        // line 177 "format_fsm.rl"
 
         // If we fall out here without being in a final state then we've
         // encountered something that the scanner can't match, which should
         // be impossible (the scanner matches all bytes _somehow_) but we'll
         // flag it anyway rather than just losing data from the end.
         if cs < formatfsm_first_final {
-                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %i", p)
+                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %d", p)
+        }
+
+        if highestArgIdx < len(a) {
+                // Extraneous args are an error, to more easily detect mistakes
+                firstBad := highestArgIdx + 1
+                if highestArgIdx == 0 {
+                        // Custom error message for this case
+                        return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; no verbs in format string")
+                }
+                return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; only %d used by format string", highestArgIdx)
         }
 
         return buf.String(), nil
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
index 85d43bb..3c642d9 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
@@ -12,6 +12,7 @@ import (
         "unicode/utf8"
 
         "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
 )
 
 %%{
@@ -23,6 +24,7 @@ func formatFSM(format string, a []cty.Value) (string, error) {
         data := format
         nextArg := 1 // arg numbers are 1-based
         var verb formatVerb
+        highestArgIdx := 0 // zero means "none", since arg numbers are 1-based
 
         %%{
 
@@ -102,6 +104,10 @@ func formatFSM(format string, a []cty.Value) (string, error) {
                 verb.Raw = data[ts:te]
                 verb.Offset = ts
 
+                if verb.ArgNum > highestArgIdx {
+                        highestArgIdx = verb.ArgNum
+                }
+
                 err := formatAppend(&verb, &buf, a)
                 if err != nil {
                         return buf.String(), err
@@ -175,7 +181,17 @@ func formatFSM(format string, a []cty.Value) (string, error) {
         // be impossible (the scanner matches all bytes _somehow_) but we'll
         // flag it anyway rather than just losing data from the end.
         if cs < formatfsm_first_final {
-                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %i", p)
+                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %d", p)
+        }
+
+        if highestArgIdx < len(a) {
+                // Extraneous args are an error, to more easily detect mistakes
+                firstBad := highestArgIdx+1
+                if highestArgIdx == 0 {
+                        // Custom error message for this case
+                        return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; no verbs in format string")
+                }
+                return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; only %d used by format string", highestArgIdx)
         }
 
         return buf.String(), nil
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
new file mode 100644
index 0000000..2dd6348
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
@@ -0,0 +1,233 @@
+package stdlib
+
+import (
+        "fmt"
+        "regexp"
+        resyntax "regexp/syntax"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var RegexFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "pattern",
+                        Type: cty.String,
+                },
+                {
+                        Name: "string",
+                        Type: cty.String,
+                },
+        },
+        Type: func(args []cty.Value) (cty.Type, error) {
+                if !args[0].IsKnown() {
+                        // We can't predict our type without seeing our pattern
+                        return cty.DynamicPseudoType, nil
+                }
+
+                retTy, err := regexPatternResultType(args[0].AsString())
+                if err != nil {
+                        err = function.NewArgError(0, err)
+                }
+                return retTy, err
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                if retType == cty.DynamicPseudoType {
+                        return cty.DynamicVal, nil
+                }
+
+                re, err := regexp.Compile(args[0].AsString())
+                if err != nil {
+                        // Should never happen, since we checked this in the Type function above.
+                        return cty.NilVal, function.NewArgErrorf(0, "error parsing pattern: %s", err)
+                }
+                str := args[1].AsString()
+
+                captureIdxs := re.FindStringSubmatchIndex(str)
+                if captureIdxs == nil {
+                        return cty.NilVal, fmt.Errorf("pattern did not match any part of the given string")
+                }
+
+                return regexPatternResult(re, str, captureIdxs, retType), nil
+        },
+})
+
+var RegexAllFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "pattern",
+                        Type: cty.String,
+                },
+                {
+                        Name: "string",
+                        Type: cty.String,
+                },
+        },
+        Type: func(args []cty.Value) (cty.Type, error) {
+                if !args[0].IsKnown() {
+                        // We can't predict our type without seeing our pattern,
+                        // but we do know it'll always be a list of something.
+                        return cty.List(cty.DynamicPseudoType), nil
+                }
+
+                retTy, err := regexPatternResultType(args[0].AsString())
+                if err != nil {
+                        err = function.NewArgError(0, err)
+                }
+                return cty.List(retTy), err
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                ety := retType.ElementType()
+                if ety == cty.DynamicPseudoType {
+                        return cty.DynamicVal, nil
+                }
+
+                re, err := regexp.Compile(args[0].AsString())
+                if err != nil {
+                        // Should never happen, since we checked this in the Type function above.
+                        return cty.NilVal, function.NewArgErrorf(0, "error parsing pattern: %s", err)
+                }
+                str := args[1].AsString()
+
+                captureIdxsEach := re.FindAllStringSubmatchIndex(str, -1)
+                if len(captureIdxsEach) == 0 {
+                        return cty.ListValEmpty(ety), nil
+                }
+
+                elems := make([]cty.Value, len(captureIdxsEach))
+                for i, captureIdxs := range captureIdxsEach {
+                        elems[i] = regexPatternResult(re, str, captureIdxs, ety)
+                }
+                return cty.ListVal(elems), nil
+        },
+})
+
+// Regex is a function that extracts one or more substrings from a given
+// string by applying a regular expression pattern, describing the first
+// match.
+//
+// The return type depends on the composition of the capture groups (if any)
+// in the pattern:
+//
+//   - If there are no capture groups at all, the result is a single string
+//     representing the entire matched pattern.
+//   - If all of the capture groups are named, the result is an object whose
+//     keys are the named groups and whose values are their sub-matches, or
+//     null if a particular sub-group was inside another group that didn't
+//     match.
+//   - If none of the capture groups are named, the result is a tuple whose
+//     elements are the sub-groups in order and whose values are their
+//     sub-matches, or null if a particular sub-group was inside another group
+//     that didn't match.
+//   - It is invalid to use both named and un-named capture groups together in
+//     the same pattern.
+//
+// If the pattern doesn't match, this function returns an error. To test for
+// a match, call RegexAll and check if the length of the result is greater
+// than zero.
+func Regex(pattern, str cty.Value) (cty.Value, error) {
+        return RegexFunc.Call([]cty.Value{pattern, str})
+}
+
+// RegexAll is similar to Regex but it finds all of the non-overlapping matches
+// in the given string and returns a list of them.
+//
+// The result type is always a list, whose element type is deduced from the
+// pattern in the same way as the return type for Regex is decided.
+//
+// If the pattern doesn't match at all, this function returns an empty list.
+func RegexAll(pattern, str cty.Value) (cty.Value, error) {
+        return RegexAllFunc.Call([]cty.Value{pattern, str})
+}
+
+// regexPatternResultType parses the given regular expression pattern and
+// returns the structural type that would be returned to represent its
+// capture groups.
+//
+// Returns an error if parsing fails or if the pattern uses a mixture of
+// named and unnamed capture groups, which is not permitted.
+func regexPatternResultType(pattern string) (cty.Type, error) {
+        re, rawErr := regexp.Compile(pattern)
+        switch err := rawErr.(type) {
+        case *resyntax.Error:
+                return cty.NilType, fmt.Errorf("invalid regexp pattern: %s in %s", err.Code, err.Expr)
+        case error:
+                // Should never happen, since all regexp compile errors should
+                // be resyntax.Error, but just in case...
+                return cty.NilType, fmt.Errorf("error parsing pattern: %s", err)
+        }
+
+        allNames := re.SubexpNames()[1:]
+        var names []string
+        unnamed := 0
+        for _, name := range allNames {
+                if name == "" {
+                        unnamed++
+                } else {
+                        if names == nil {
+                                names = make([]string, 0, len(allNames))
+                        }
+                        names = append(names, name)
+                }
+        }
+        switch {
+        case unnamed == 0 && len(names) == 0:
+                // If there are no capture groups at all then we'll return just a
+                // single string for the whole match.
+                return cty.String, nil
+        case unnamed > 0 && len(names) > 0:
+                return cty.NilType, fmt.Errorf("invalid regexp pattern: cannot mix both named and unnamed capture groups")
+        case unnamed > 0:
+                // For unnamed captures, we return a tuple of them all in order.
+                etys := make([]cty.Type, unnamed)
+                for i := range etys {
+                        etys[i] = cty.String
+                }
+                return cty.Tuple(etys), nil
+        default:
+                // For named captures, we return an object using the capture names
+                // as keys.
+                atys := make(map[string]cty.Type, len(names))
+                for _, name := range names {
+                        atys[name] = cty.String
+                }
+                return cty.Object(atys), nil
+        }
+}
+
+func regexPatternResult(re *regexp.Regexp, str string, captureIdxs []int, retType cty.Type) cty.Value {
+        switch {
+        case retType == cty.String:
+                start, end := captureIdxs[0], captureIdxs[1]
+                return cty.StringVal(str[start:end])
+        case retType.IsTupleType():
+                captureIdxs = captureIdxs[2:] // index 0 is the whole pattern span, which we ignore by skipping one pair
+                vals := make([]cty.Value, len(captureIdxs)/2)
+                for i := range vals {
+                        start, end := captureIdxs[i*2], captureIdxs[i*2+1]
+                        if start < 0 || end < 0 {
+                                vals[i] = cty.NullVal(cty.String) // Did not match anything because containing group didn't match
+                                continue
+                        }
+                        vals[i] = cty.StringVal(str[start:end])
+                }
+                return cty.TupleVal(vals)
+        case retType.IsObjectType():
+                captureIdxs = captureIdxs[2:] // index 0 is the whole pattern span, which we ignore by skipping one pair
+                vals := make(map[string]cty.Value, len(captureIdxs)/2)
+                names := re.SubexpNames()[1:]
+                for i, name := range names {
+                        start, end := captureIdxs[i*2], captureIdxs[i*2+1]
+                        if start < 0 || end < 0 {
+                                vals[name] = cty.NullVal(cty.String) // Did not match anything because containing group didn't match
+                                continue
+                        }
+                        vals[name] = cty.StringVal(str[start:end])
+                }
+                return cty.ObjectVal(vals)
+        default:
+                // Should never happen
+                panic(fmt.Sprintf("invalid return type %#v", retType))
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
index e2c77c5..d3cc341 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
@@ -119,6 +119,75 @@ var ConcatFunc = function.New(&function.Spec{
         },
 })
 
+var RangeFunc = function.New(&function.Spec{
+        VarParam: &function.Parameter{
+                Name: "params",
+                Type: cty.Number,
+        },
+        Type: function.StaticReturnType(cty.List(cty.Number)),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                var start, end, step cty.Value
+                switch len(args) {
+                case 1:
+                        if args[0].LessThan(cty.Zero).True() {
+                                start, end, step = cty.Zero, args[0], cty.NumberIntVal(-1)
+                        } else {
+                                start, end, step = cty.Zero, args[0], cty.NumberIntVal(1)
+                        }
+                case 2:
+                        if args[1].LessThan(args[0]).True() {
+                                start, end, step = args[0], args[1], cty.NumberIntVal(-1)
+                        } else {
+                                start, end, step = args[0], args[1], cty.NumberIntVal(1)
+                        }
+                case 3:
+                        start, end, step = args[0], args[1], args[2]
+                default:
+                        return cty.NilVal, fmt.Errorf("must have one, two, or three arguments")
+                }
+
+                var vals []cty.Value
+
+                if step == cty.Zero {
+                        return cty.NilVal, function.NewArgErrorf(2, "step must not be zero")
+                }
+                down := step.LessThan(cty.Zero).True()
+
+                if down {
+                        if end.GreaterThan(start).True() {
+                                return cty.NilVal, function.NewArgErrorf(1, "end must be less than start when step is negative")
+                        }
+                } else {
+                        if end.LessThan(start).True() {
+                                return cty.NilVal, function.NewArgErrorf(1, "end must be greater than start when step is positive")
+                        }
+                }
+
+                num := start
+                for {
+                        if down {
+                                if num.LessThanOrEqualTo(end).True() {
+                                        break
+                                }
+                        } else {
+                                if num.GreaterThanOrEqualTo(end).True() {
+                                        break
+                                }
+                        }
+                        if len(vals) >= 1024 {
+                                // Artificial limit to prevent bad arguments from consuming huge amounts of memory
+                                return cty.NilVal, fmt.Errorf("more than 1024 values were generated; either decrease the difference between start and end or use a smaller step")
+                        }
+                        vals = append(vals, num)
+                        num = num.Add(step)
+                }
+                if len(vals) == 0 {
+                        return cty.ListValEmpty(cty.Number), nil
+                }
+                return cty.ListVal(vals), nil
+        },
+})
+
 // Concat takes one or more sequences (lists or tuples) and returns the single
 // sequence that results from concatenating them together in order.
 //
@@ -128,3 +197,22 @@ var ConcatFunc = function.New(&function.Spec{
 func Concat(seqs ...cty.Value) (cty.Value, error) {
         return ConcatFunc.Call(seqs)
 }
+
+// Range creates a list of numbers by starting from the given starting value,
+// then adding the given step value until the result is greater than or
+// equal to the given stopping value. Each intermediate result becomes an
+// element in the resulting list.
+//
+// When all three parameters are set, the order is (start, end, step). If
+// only two parameters are set, they are the start and end respectively and
+// step defaults to 1. If only one argument is set, it gives the end value
+// with start defaulting to 0 and step defaulting to 1.
+//
+// Because the resulting list must be fully buffered in memory, there is an
+// artificial cap of 1024 elements, after which this function will return
+// an error to avoid consuming unbounded amounts of memory. The Range function
+// is primarily intended for creating small lists of indices to iterate over,
+// so there should be no reason to generate huge lists with it.
+func Range(params ...cty.Value) (cty.Value, error) {
+        return RangeFunc.Call(params)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gob.go b/vendor/github.com/zclconf/go-cty/cty/gob.go
index 3d73199..a77dace 100644
--- a/vendor/github.com/zclconf/go-cty/cty/gob.go
+++ b/vendor/github.com/zclconf/go-cty/cty/gob.go
@@ -103,11 +103,11 @@ func (t *Type) GobDecode(buf []byte) error {
 // Capsule types cannot currently be gob-encoded, because they rely on pointer
 // equality and we have no way to recover the original pointer on decode.
 func (t *capsuleType) GobEncode() ([]byte, error) {
-        return nil, fmt.Errorf("cannot gob-encode capsule type %q", t.FriendlyName())
+        return nil, fmt.Errorf("cannot gob-encode capsule type %q", t.FriendlyName(friendlyTypeName))
 }
 
 func (t *capsuleType) GobDecode() ([]byte, error) {
-        return nil, fmt.Errorf("cannot gob-decode capsule type %q", t.FriendlyName())
+        return nil, fmt.Errorf("cannot gob-decode capsule type %q", t.FriendlyName(friendlyTypeName))
 }
 
 type gobValue struct {
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:
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
index 1a97306..0fa13f6 100644
--- a/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
@@ -138,7 +138,7 @@ func impliedObjectType(dec *json.Decoder) (cty.Type, error) {
 }
 
 func impliedTupleType(dec *json.Decoder) (cty.Type, error) {
-        // By the time we get in here, we've already consumed the { delimiter
+        // By the time we get in here, we've already consumed the [ delimiter
         // and so our next token should be the first value.
 
         var etys []cty.Type
@@ -150,10 +150,9 @@ func impliedTupleType(dec *json.Decoder) (cty.Type, error) {
                 }
 
                 if ttok, ok := tok.(json.Delim); ok {
-                        if rune(ttok) != ']' {
-                                return cty.NilType, fmt.Errorf("unexpected delimiter %q", ttok)
+                        if rune(ttok) == ']' {
+                                break
                         }
-                        break
                 }
 
                 ety, err := impliedTypeForTok(tok, dec)
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
index 155f0b8..3810645 100644
--- a/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
+++ b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
@@ -72,7 +72,7 @@ func unmarshalPrimitive(tok json.Token, t cty.Type, path cty.Path) (cty.Value, e
                 }
                 switch v := tok.(type) {
                 case string:
-                        val, err := convert.Convert(cty.StringVal(v), t)
+                        val, err := cty.ParseNumberVal(v)
                         if err != nil {
                                 return cty.NilVal, path.NewError(err)
                         }
diff --git a/vendor/github.com/zclconf/go-cty/cty/list_type.go b/vendor/github.com/zclconf/go-cty/cty/list_type.go
index eadc865..2ef02a1 100644
--- a/vendor/github.com/zclconf/go-cty/cty/list_type.go
+++ b/vendor/github.com/zclconf/go-cty/cty/list_type.go
@@ -33,8 +33,14 @@ func (t typeList) Equals(other Type) bool {
         return t.ElementTypeT.Equals(ot.ElementTypeT)
 }
 
-func (t typeList) FriendlyName() string {
-        return "list of " + t.ElementTypeT.FriendlyName()
+func (t typeList) FriendlyName(mode friendlyTypeNameMode) string {
+        elemName := t.ElementTypeT.friendlyNameMode(mode)
+        if mode == friendlyTypeConstraintName {
+                if t.ElementTypeT == DynamicPseudoType {
+                        elemName = "any single type"
+                }
+        }
+        return "list of " + elemName
 }
 
 func (t typeList) ElementType() Type {
diff --git a/vendor/github.com/zclconf/go-cty/cty/map_type.go b/vendor/github.com/zclconf/go-cty/cty/map_type.go
index ae9abae..82d36c6 100644
--- a/vendor/github.com/zclconf/go-cty/cty/map_type.go
+++ b/vendor/github.com/zclconf/go-cty/cty/map_type.go
@@ -33,8 +33,14 @@ func (t typeMap) Equals(other Type) bool {
         return t.ElementTypeT.Equals(ot.ElementTypeT)
 }
 
-func (t typeMap) FriendlyName() string {
-        return "map of " + t.ElementTypeT.FriendlyName()
+func (t typeMap) FriendlyName(mode friendlyTypeNameMode) string {
+        elemName := t.ElementTypeT.friendlyNameMode(mode)
+        if mode == friendlyTypeConstraintName {
+                if t.ElementTypeT == DynamicPseudoType {
+                        elemName = "any single type"
+                }
+        }
+        return "map of " + elemName
 }
 
 func (t typeMap) ElementType() Type {
diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/doc.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/doc.go
new file mode 100644
index 0000000..1eb99f2
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/doc.go
@@ -0,0 +1,14 @@
+// Package msgpack provides functions for serializing cty values in the
+// msgpack encoding, and decoding them again.
+//
+// If the same type information is provided both at encoding and decoding time
+// then values can be round-tripped without loss, except for capsule types
+// which are not currently supported.
+//
+// If any unknown values are passed to Marshal then they will be represented
+// using a msgpack extension with type code zero, which is understood by
+// the Unmarshal function within this package but will not be understood by
+// a generic (non-cty-aware) msgpack decoder. Ensure that no unknown values
+// are used if interoperability with other msgpack implementations is
+// required.
+package msgpack
diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/dynamic.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/dynamic.go
new file mode 100644
index 0000000..1b631d0
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/dynamic.go
@@ -0,0 +1,31 @@
+package msgpack
+
+import (
+        "bytes"
+
+        "github.com/vmihailenco/msgpack"
+        "github.com/zclconf/go-cty/cty"
+)
+
+type dynamicVal struct {
+        Value cty.Value
+        Path  cty.Path
+}
+
+func (dv *dynamicVal) MarshalMsgpack() ([]byte, error) {
+        // Rather than defining a msgpack-specific serialization of types,
+        // instead we use the existing JSON serialization.
+        typeJSON, err := dv.Value.Type().MarshalJSON()
+        if err != nil {
+                return nil, dv.Path.NewErrorf("failed to serialize type: %s", err)
+        }
+        var buf bytes.Buffer
+        enc := msgpack.NewEncoder(&buf)
+        enc.EncodeArrayLen(2)
+        enc.EncodeBytes(typeJSON)
+        err = marshal(dv.Value, dv.Value.Type(), dv.Path, enc)
+        if err != nil {
+                return nil, err
+        }
+        return buf.Bytes(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/infinity.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/infinity.go
new file mode 100644
index 0000000..6db0815
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/infinity.go
@@ -0,0 +1,8 @@
+package msgpack
+
+import (
+        "math"
+)
+
+var negativeInfinity = math.Inf(-1)
+var positiveInfinity = math.Inf(1)
diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/marshal.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/marshal.go
new file mode 100644
index 0000000..87b096c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/marshal.go
@@ -0,0 +1,207 @@
+package msgpack
+
+import (
+        "bytes"
+        "math/big"
+        "sort"
+
+        "github.com/vmihailenco/msgpack"
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+// Marshal produces a msgpack serialization of the given value that
+// can be decoded into the given type later using Unmarshal.
+//
+// The given value must conform to the given type, or an error will
+// be returned.
+func Marshal(val cty.Value, ty cty.Type) ([]byte, error) {
+        errs := val.Type().TestConformance(ty)
+        if errs != nil {
+                // Attempt a conversion
+                var err error
+                val, err = convert.Convert(val, ty)
+                if err != nil {
+                        return nil, err
+                }
+        }
+
+        // From this point onward, val can be assumed to be conforming to t.
+
+        var path cty.Path
+        var buf bytes.Buffer
+        enc := msgpack.NewEncoder(&buf)
+
+        err := marshal(val, ty, path, enc)
+        if err != nil {
+                return nil, err
+        }
+
+        return buf.Bytes(), nil
+}
+
+func marshal(val cty.Value, ty cty.Type, path cty.Path, enc *msgpack.Encoder) error {
+        // If we're going to decode as DynamicPseudoType then we need to save
+        // dynamic type information to recover the real type.
+        if ty == cty.DynamicPseudoType && val.Type() != cty.DynamicPseudoType {
+                return marshalDynamic(val, path, enc)
+        }
+
+        if !val.IsKnown() {
+                err := enc.Encode(unknownVal)
+                if err != nil {
+                        return path.NewError(err)
+                }
+                return nil
+        }
+        if val.IsNull() {
+                err := enc.EncodeNil()
+                if err != nil {
+                        return path.NewError(err)
+                }
+                return nil
+        }
+
+        // The caller should've guaranteed that the given val is conformant with
+        // the given type ty, so we'll proceed under that assumption here.
+        switch {
+        case ty.IsPrimitiveType():
+                switch ty {
+                case cty.String:
+                        err := enc.EncodeString(val.AsString())
+                        if err != nil {
+                                return path.NewError(err)
+                        }
+                        return nil
+                case cty.Number:
+                        var err error
+                        switch {
+                        case val.RawEquals(cty.PositiveInfinity):
+                                err = enc.EncodeFloat64(positiveInfinity)
+                        case val.RawEquals(cty.NegativeInfinity):
+                                err = enc.EncodeFloat64(negativeInfinity)
+                        default:
+                                bf := val.AsBigFloat()
+                                if iv, acc := bf.Int64(); acc == big.Exact {
+                                        err = enc.EncodeInt(iv)
+                                } else if fv, acc := bf.Float64(); acc == big.Exact {
+                                        err = enc.EncodeFloat64(fv)
+                                } else {
+                                        err = enc.EncodeString(bf.Text('f', -1))
+                                }
+                        }
+                        if err != nil {
+                                return path.NewError(err)
+                        }
+                        return nil
+                case cty.Bool:
+                        err := enc.EncodeBool(val.True())
+                        if err != nil {
+                                return path.NewError(err)
+                        }
+                        return nil
+                default:
+                        panic("unsupported primitive type")
+                }
+        case ty.IsListType(), ty.IsSetType():
+                enc.EncodeArrayLen(val.LengthInt())
+                ety := ty.ElementType()
+                it := val.ElementIterator()
+                path := append(path, nil) // local override of 'path' with extra element
+                for it.Next() {
+                        ek, ev := it.Element()
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: ek,
+                        }
+                        err := marshal(ev, ety, path, enc)
+                        if err != nil {
+                                return err
+                        }
+                }
+                return nil
+        case ty.IsMapType():
+                enc.EncodeMapLen(val.LengthInt())
+                ety := ty.ElementType()
+                it := val.ElementIterator()
+                path := append(path, nil) // local override of 'path' with extra element
+                for it.Next() {
+                        ek, ev := it.Element()
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: ek,
+                        }
+                        var err error
+                        err = marshal(ek, ek.Type(), path, enc)
+                        if err != nil {
+                                return err
+                        }
+                        err = marshal(ev, ety, path, enc)
+                        if err != nil {
+                                return err
+                        }
+                }
+                return nil
+        case ty.IsTupleType():
+                etys := ty.TupleElementTypes()
+                it := val.ElementIterator()
+                path := append(path, nil) // local override of 'path' with extra element
+                i := 0
+                enc.EncodeArrayLen(len(etys))
+                for it.Next() {
+                        ety := etys[i]
+                        ek, ev := it.Element()
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: ek,
+                        }
+                        err := marshal(ev, ety, path, enc)
+                        if err != nil {
+                                return err
+                        }
+                        i++
+                }
+                return nil
+        case ty.IsObjectType():
+                atys := ty.AttributeTypes()
+                path := append(path, nil) // local override of 'path' with extra element
+
+                names := make([]string, 0, len(atys))
+                for k := range atys {
+                        names = append(names, k)
+                }
+                sort.Strings(names)
+
+                enc.EncodeMapLen(len(names))
+
+                for _, k := range names {
+                        aty := atys[k]
+                        av := val.GetAttr(k)
+                        path[len(path)-1] = cty.GetAttrStep{
+                                Name: k,
+                        }
+                        var err error
+                        err = marshal(cty.StringVal(k), cty.String, path, enc)
+                        if err != nil {
+                                return err
+                        }
+                        err = marshal(av, aty, path, enc)
+                        if err != nil {
+                                return err
+                        }
+                }
+                return nil
+        case ty.IsCapsuleType():
+                return path.NewErrorf("capsule types not supported for msgpack encoding")
+        default:
+                // should never happen
+                return path.NewErrorf("cannot msgpack-serialize %s", ty.FriendlyName())
+        }
+}
+
+// marshalDynamic adds an extra wrapping object containing dynamic type
+// information for the given value.
+func marshalDynamic(val cty.Value, path cty.Path, enc *msgpack.Encoder) error {
+        dv := dynamicVal{
+                Value: val,
+                Path:  path,
+        }
+        return enc.Encode(&dv)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/type_implied.go
new file mode 100644
index 0000000..6f6022e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/type_implied.go
@@ -0,0 +1,167 @@
+package msgpack
+
+import (
+        "bytes"
+        "fmt"
+        "io"
+
+        "github.com/vmihailenco/msgpack"
+        msgpackcodes "github.com/vmihailenco/msgpack/codes"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType returns the cty Type implied by the structure of the given
+// msgpack-compliant buffer. This function implements the default type mapping
+// behavior used when decoding arbitrary msgpack without explicit cty Type
+// information.
+//
+// The rules are as follows:
+//
+// msgpack strings, numbers and bools map to their equivalent primitive type in
+// cty.
+//
+// msgpack maps become cty object types, with the attributes defined by the
+// map keys and the types of their values.
+//
+// msgpack arrays become cty tuple types, with the elements defined by the
+// types of the array members.
+//
+// Any nulls are typed as DynamicPseudoType, so callers of this function
+// must be prepared to deal with this. Callers that do not wish to deal with
+// dynamic typing should not use this function and should instead describe
+// their required types explicitly with a cty.Type instance when decoding.
+//
+// Any unknown values are similarly typed as DynamicPseudoType, because these
+// do not carry type information on the wire.
+//
+// Any parse errors will be returned as an error, and the type will be the
+// invalid value cty.NilType.
+func ImpliedType(buf []byte) (cty.Type, error) {
+        r := bytes.NewReader(buf)
+        dec := msgpack.NewDecoder(r)
+
+        ty, err := impliedType(dec)
+        if err != nil {
+                return cty.NilType, err
+        }
+
+        // We must now be at the end of the buffer
+        err = dec.Skip()
+        if err != io.EOF {
+                return ty, fmt.Errorf("extra bytes after msgpack value")
+        }
+
+        return ty, nil
+}
+
+func impliedType(dec *msgpack.Decoder) (cty.Type, error) {
+        // If this function returns with a nil error then it must have already
+        // consumed the next value from the decoder, since when called recursively
+        // the caller will be expecting to find a following value here.
+
+        code, err := dec.PeekCode()
+        if err != nil {
+                return cty.NilType, err
+        }
+
+        switch {
+
+        case code == msgpackcodes.Nil || msgpackcodes.IsExt(code):
+                err := dec.Skip()
+                return cty.DynamicPseudoType, err
+
+        case code == msgpackcodes.True || code == msgpackcodes.False:
+                _, err := dec.DecodeBool()
+                return cty.Bool, err
+
+        case msgpackcodes.IsFixedNum(code):
+                _, err := dec.DecodeInt64()
+                return cty.Number, err
+
+        case code == msgpackcodes.Int8 || code == msgpackcodes.Int16 || code == msgpackcodes.Int32 || code == msgpackcodes.Int64:
+                _, err := dec.DecodeInt64()
+                return cty.Number, err
+
+        case code == msgpackcodes.Uint8 || code == msgpackcodes.Uint16 || code == msgpackcodes.Uint32 || code == msgpackcodes.Uint64:
+                _, err := dec.DecodeUint64()
+                return cty.Number, err
+
+        case code == msgpackcodes.Float || code == msgpackcodes.Double:
+                _, err := dec.DecodeFloat64()
+                return cty.Number, err
+
+        case msgpackcodes.IsString(code):
+                _, err := dec.DecodeString()
+                return cty.String, err
+
+        case msgpackcodes.IsFixedMap(code) || code == msgpackcodes.Map16 || code == msgpackcodes.Map32:
+                return impliedObjectType(dec)
+
+        case msgpackcodes.IsFixedArray(code) || code == msgpackcodes.Array16 || code == msgpackcodes.Array32:
+                return impliedTupleType(dec)
+
+        default:
+                return cty.NilType, fmt.Errorf("unsupported msgpack code %#v", code)
+        }
+}
+
+func impliedObjectType(dec *msgpack.Decoder) (cty.Type, error) {
+        // If we get in here then we've already peeked the next code and know
+        // it's some sort of map.
+        l, err := dec.DecodeMapLen()
+        if err != nil {
+                return cty.DynamicPseudoType, nil
+        }
+
+        var atys map[string]cty.Type
+
+        for i := 0; i < l; i++ {
+                // Read the map key first. We require maps to be strings, but msgpack
+                // doesn't so we're prepared to error here if not.
+                k, err := dec.DecodeString()
+                if err != nil {
+                        return cty.DynamicPseudoType, err
+                }
+
+                aty, err := impliedType(dec)
+                if err != nil {
+                        return cty.DynamicPseudoType, err
+                }
+
+                if atys == nil {
+                        atys = make(map[string]cty.Type)
+                }
+                atys[k] = aty
+        }
+
+        if len(atys) == 0 {
+                return cty.EmptyObject, nil
+        }
+
+        return cty.Object(atys), nil
+}
+
+func impliedTupleType(dec *msgpack.Decoder) (cty.Type, error) {
+        // If we get in here then we've already peeked the next code and know
+        // it's some sort of array.
+        l, err := dec.DecodeArrayLen()
+        if err != nil {
+                return cty.DynamicPseudoType, nil
+        }
+
+        if l == 0 {
+                return cty.EmptyTuple, nil
+        }
+
+        etys := make([]cty.Type, l)
+
+        for i := 0; i < l; i++ {
+                ety, err := impliedType(dec)
+                if err != nil {
+                        return cty.DynamicPseudoType, err
+                }
+                etys[i] = ety
+        }
+
+        return cty.Tuple(etys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/unknown.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/unknown.go
new file mode 100644
index 0000000..6507bc4
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/unknown.go
@@ -0,0 +1,16 @@
+package msgpack
+
+type unknownType struct{}
+
+var unknownVal = unknownType{}
+
+// unknownValBytes is the raw bytes of the msgpack fixext1 value we
+// write to represent an unknown value. It's an extension value of
+// type zero whose value is irrelevant. Since it's irrelevant, we
+// set it to a single byte whose value is also zero, since that's
+// the most compact possible representation.
+var unknownValBytes = []byte{0xd4, 0, 0}
+
+func (uv unknownType) MarshalMsgpack() ([]byte, error) {
+        return unknownValBytes, nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/msgpack/unmarshal.go b/vendor/github.com/zclconf/go-cty/cty/msgpack/unmarshal.go
new file mode 100644
index 0000000..51bb76a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/msgpack/unmarshal.go
@@ -0,0 +1,334 @@
+package msgpack
+
+import (
+        "bytes"
+
+        "github.com/vmihailenco/msgpack"
+        msgpackCodes "github.com/vmihailenco/msgpack/codes"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Unmarshal interprets the given bytes as a msgpack-encoded cty Value of
+// the given type, returning the result.
+//
+// If an error is returned, the error is written with a hypothetical
+// end-user that wrote the msgpack file as its audience, using cty type
+// system concepts rather than Go type system concepts.
+func Unmarshal(b []byte, ty cty.Type) (cty.Value, error) {
+        r := bytes.NewReader(b)
+        dec := msgpack.NewDecoder(r)
+
+        var path cty.Path
+        return unmarshal(dec, ty, path)
+}
+
+func unmarshal(dec *msgpack.Decoder, ty cty.Type, path cty.Path) (cty.Value, error) {
+        peek, err := dec.PeekCode()
+        if err != nil {
+                return cty.DynamicVal, path.NewError(err)
+        }
+        if msgpackCodes.IsExt(peek) {
+                // We just assume _all_ extensions are unknown values,
+                // since we don't have any other extensions.
+                dec.Skip() // skip what we've peeked
+                return cty.UnknownVal(ty), nil
+        }
+        if ty == cty.DynamicPseudoType {
+                return unmarshalDynamic(dec, path)
+        }
+        if peek == msgpackCodes.Nil {
+                dec.Skip() // skip what we've peeked
+                return cty.NullVal(ty), nil
+        }
+
+        switch {
+        case ty.IsPrimitiveType():
+                val, err := unmarshalPrimitive(dec, ty, path)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+                return val, nil
+        case ty.IsListType():
+                return unmarshalList(dec, ty.ElementType(), path)
+        case ty.IsSetType():
+                return unmarshalSet(dec, ty.ElementType(), path)
+        case ty.IsMapType():
+                return unmarshalMap(dec, ty.ElementType(), path)
+        case ty.IsTupleType():
+                return unmarshalTuple(dec, ty.TupleElementTypes(), path)
+        case ty.IsObjectType():
+                return unmarshalObject(dec, ty.AttributeTypes(), path)
+        default:
+                return cty.NilVal, path.NewErrorf("unsupported type %s", ty.FriendlyName())
+        }
+}
+
+func unmarshalPrimitive(dec *msgpack.Decoder, ty cty.Type, path cty.Path) (cty.Value, error) {
+        switch ty {
+        case cty.Bool:
+                rv, err := dec.DecodeBool()
+                if err != nil {
+                        return cty.DynamicVal, path.NewErrorf("bool is required")
+                }
+                return cty.BoolVal(rv), nil
+        case cty.Number:
+                // Marshal will try int and float first, if the value can be
+                // losslessly represented in these encodings, and then fall
+                // back on a string if the number is too large or too precise.
+                peek, err := dec.PeekCode()
+                if err != nil {
+                        return cty.DynamicVal, path.NewErrorf("number is required")
+                }
+
+                if msgpackCodes.IsFixedNum(peek) {
+                        rv, err := dec.DecodeInt64()
+                        if err != nil {
+                                return cty.DynamicVal, path.NewErrorf("number is required")
+                        }
+                        return cty.NumberIntVal(rv), nil
+                }
+
+                switch peek {
+                case msgpackCodes.Int8, msgpackCodes.Int16, msgpackCodes.Int32, msgpackCodes.Int64:
+                        rv, err := dec.DecodeInt64()
+                        if err != nil {
+                                return cty.DynamicVal, path.NewErrorf("number is required")
+                        }
+                        return cty.NumberIntVal(rv), nil
+                case msgpackCodes.Uint8, msgpackCodes.Uint16, msgpackCodes.Uint32, msgpackCodes.Uint64:
+                        rv, err := dec.DecodeUint64()
+                        if err != nil {
+                                return cty.DynamicVal, path.NewErrorf("number is required")
+                        }
+                        return cty.NumberUIntVal(rv), nil
+                case msgpackCodes.Float, msgpackCodes.Double:
+                        rv, err := dec.DecodeFloat64()
+                        if err != nil {
+                                return cty.DynamicVal, path.NewErrorf("number is required")
+                        }
+                        return cty.NumberFloatVal(rv), nil
+                default:
+                        rv, err := dec.DecodeString()
+                        if err != nil {
+                                return cty.DynamicVal, path.NewErrorf("number is required")
+                        }
+                        v, err := cty.ParseNumberVal(rv)
+                        if err != nil {
+                                return cty.DynamicVal, path.NewErrorf("number is required")
+                        }
+                        return v, nil
+                }
+        case cty.String:
+                rv, err := dec.DecodeString()
+                if err != nil {
+                        return cty.DynamicVal, path.NewErrorf("string is required")
+                }
+                return cty.StringVal(rv), nil
+        default:
+                // should never happen
+                panic("unsupported primitive type")
+        }
+}
+
+func unmarshalList(dec *msgpack.Decoder, ety cty.Type, path cty.Path) (cty.Value, error) {
+        length, err := dec.DecodeArrayLen()
+        if err != nil {
+                return cty.DynamicVal, path.NewErrorf("a list is required")
+        }
+
+        switch {
+        case length < 0:
+                return cty.NullVal(cty.List(ety)), nil
+        case length == 0:
+                return cty.ListValEmpty(ety), nil
+        }
+
+        vals := make([]cty.Value, 0, length)
+        path = append(path, nil)
+        for i := 0; i < length; i++ {
+                path[len(path)-1] = cty.IndexStep{
+                        Key: cty.NumberIntVal(int64(i)),
+                }
+
+                val, err := unmarshal(dec, ety, path)
+                if err != nil {
+                        return cty.DynamicVal, err
+                }
+
+                vals = append(vals, val)
+        }
+
+        return cty.ListVal(vals), nil
+}
+
+func unmarshalSet(dec *msgpack.Decoder, ety cty.Type, path cty.Path) (cty.Value, error) {
+        length, err := dec.DecodeArrayLen()
+        if err != nil {
+                return cty.DynamicVal, path.NewErrorf("a set is required")
+        }
+
+        switch {
+        case length < 0:
+                return cty.NullVal(cty.Set(ety)), nil
+        case length == 0:
+                return cty.SetValEmpty(ety), nil
+        }
+
+        vals := make([]cty.Value, 0, length)
+        path = append(path, nil)
+        for i := 0; i < length; i++ {
+                path[len(path)-1] = cty.IndexStep{
+                        Key: cty.NumberIntVal(int64(i)),
+                }
+
+                val, err := unmarshal(dec, ety, path)
+                if err != nil {
+                        return cty.DynamicVal, err
+                }
+
+                vals = append(vals, val)
+        }
+
+        return cty.SetVal(vals), nil
+}
+
+func unmarshalMap(dec *msgpack.Decoder, ety cty.Type, path cty.Path) (cty.Value, error) {
+        length, err := dec.DecodeMapLen()
+        if err != nil {
+                return cty.DynamicVal, path.NewErrorf("a map is required")
+        }
+
+        switch {
+        case length < 0:
+                return cty.NullVal(cty.Map(ety)), nil
+        case length == 0:
+                return cty.MapValEmpty(ety), nil
+        }
+
+        vals := make(map[string]cty.Value, length)
+        path = append(path, nil)
+        for i := 0; i < length; i++ {
+                key, err := dec.DecodeString()
+                if err != nil {
+                        path[:len(path)-1].NewErrorf("non-string key in map")
+                }
+
+                path[len(path)-1] = cty.IndexStep{
+                        Key: cty.StringVal(key),
+                }
+
+                val, err := unmarshal(dec, ety, path)
+                if err != nil {
+                        return cty.DynamicVal, err
+                }
+
+                vals[key] = val
+        }
+
+        return cty.MapVal(vals), nil
+}
+
+func unmarshalTuple(dec *msgpack.Decoder, etys []cty.Type, path cty.Path) (cty.Value, error) {
+        length, err := dec.DecodeArrayLen()
+        if err != nil {
+                return cty.DynamicVal, path.NewErrorf("a tuple is required")
+        }
+
+        switch {
+        case length < 0:
+                return cty.NullVal(cty.Tuple(etys)), nil
+        case length == 0:
+                return cty.TupleVal(nil), nil
+        case length != len(etys):
+                return cty.DynamicVal, path.NewErrorf("a tuple of length %d is required", len(etys))
+        }
+
+        vals := make([]cty.Value, 0, length)
+        path = append(path, nil)
+        for i := 0; i < length; i++ {
+                path[len(path)-1] = cty.IndexStep{
+                        Key: cty.NumberIntVal(int64(i)),
+                }
+                ety := etys[i]
+
+                val, err := unmarshal(dec, ety, path)
+                if err != nil {
+                        return cty.DynamicVal, err
+                }
+
+                vals = append(vals, val)
+        }
+
+        return cty.TupleVal(vals), nil
+}
+
+func unmarshalObject(dec *msgpack.Decoder, atys map[string]cty.Type, path cty.Path) (cty.Value, error) {
+        length, err := dec.DecodeMapLen()
+        if err != nil {
+                return cty.DynamicVal, path.NewErrorf("an object is required")
+        }
+
+        switch {
+        case length < 0:
+                return cty.NullVal(cty.Object(atys)), nil
+        case length == 0:
+                return cty.ObjectVal(nil), nil
+        case length != len(atys):
+                return cty.DynamicVal, path.NewErrorf("an object with %d attributes is required (%d given)",
+                        len(atys), length)
+        }
+
+        vals := make(map[string]cty.Value, length)
+        path = append(path, nil)
+        for i := 0; i < length; i++ {
+                key, err := dec.DecodeString()
+                if err != nil {
+                        return cty.DynamicVal, path[:len(path)-1].NewErrorf("all keys must be strings")
+                }
+
+                path[len(path)-1] = cty.IndexStep{
+                        Key: cty.StringVal(key),
+                }
+                aty, exists := atys[key]
+                if !exists {
+                        return cty.DynamicVal, path.NewErrorf("unsupported attribute")
+                }
+
+                val, err := unmarshal(dec, aty, path)
+                if err != nil {
+                        return cty.DynamicVal, err
+                }
+
+                vals[key] = val
+        }
+
+        return cty.ObjectVal(vals), nil
+}
+
+func unmarshalDynamic(dec *msgpack.Decoder, path cty.Path) (cty.Value, error) {
+        length, err := dec.DecodeArrayLen()
+        if err != nil {
+                return cty.DynamicVal, path.NewError(err)
+        }
+
+        switch {
+        case length == -1:
+                return cty.NullVal(cty.DynamicPseudoType), nil
+        case length != 2:
+                return cty.DynamicVal, path.NewErrorf(
+                        "dynamic value array must have exactly two elements",
+                )
+        }
+
+        typeJSON, err := dec.DecodeBytes()
+        if err != nil {
+                return cty.DynamicVal, path.NewError(err)
+        }
+        var ty cty.Type
+        err = (&ty).UnmarshalJSON(typeJSON)
+        if err != nil {
+                return cty.DynamicVal, path.NewError(err)
+        }
+
+        return unmarshal(dec, ty, path)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/object_type.go b/vendor/github.com/zclconf/go-cty/cty/object_type.go
index 2540883..187d387 100644
--- a/vendor/github.com/zclconf/go-cty/cty/object_type.go
+++ b/vendor/github.com/zclconf/go-cty/cty/object_type.go
@@ -51,7 +51,7 @@ func (t typeObject) Equals(other Type) bool {
         return false
 }
 
-func (t typeObject) FriendlyName() string {
+func (t typeObject) FriendlyName(mode friendlyTypeNameMode) string {
         // There isn't really a friendly way to write an object type due to its
         // complexity, so we'll just do something English-ish. Callers will
         // probably want to make some extra effort to avoid ever printing out
diff --git a/vendor/github.com/zclconf/go-cty/cty/path.go b/vendor/github.com/zclconf/go-cty/cty/path.go
index 84a9de0..bf1a7c1 100644
--- a/vendor/github.com/zclconf/go-cty/cty/path.go
+++ b/vendor/github.com/zclconf/go-cty/cty/path.go
@@ -15,6 +15,10 @@ import (
 // but callers can also feel free to just produce a slice of PathStep manually
 // and convert to this type, which may be more appropriate in environments
 // where memory pressure is a concern.
+//
+// Although a Path is technically mutable, by convention callers should not
+// mutate a path once it has been built and passed to some other subsystem.
+// Instead, use Copy and then mutate the copy before using it.
 type Path []PathStep
 
 // PathStep represents a single step down into a data structure, as part
@@ -47,6 +51,11 @@ func (p Path) Index(v Value) Path {
         return ret
 }
 
+// IndexPath is a convenience method to start a new Path with an IndexStep.
+func IndexPath(v Value) Path {
+        return Path{}.Index(v)
+}
+
 // GetAttr returns a new Path that is the reciever with a GetAttrStep appended
 // to the end.
 //
@@ -62,6 +71,11 @@ func (p Path) GetAttr(name string) Path {
         return ret
 }
 
+// GetAttrPath is a convenience method to start a new Path with a GetAttrStep.
+func GetAttrPath(name string) Path {
+        return Path{}.GetAttr(name)
+}
+
 // Apply applies each of the steps in turn to successive values starting with
 // the given value, and returns the result. If any step returns an error,
 // the whole operation returns an error.
@@ -132,9 +146,13 @@ type IndexStep struct {
 // Apply returns the value resulting from indexing the given value with
 // our key value.
 func (s IndexStep) Apply(val Value) (Value, error) {
+        if val == NilVal || val.IsNull() {
+                return NilVal, errors.New("cannot index a null value")
+        }
+
         switch s.Key.Type() {
         case Number:
-                if !val.Type().IsListType() {
+                if !(val.Type().IsListType() || val.Type().IsTupleType()) {
                         return NilVal, errors.New("not a list type")
                 }
         case String:
@@ -170,6 +188,10 @@ type GetAttrStep struct {
 // Apply returns the value of our named attribute from the given value, which
 // must be of an object type that has a value of that name.
 func (s GetAttrStep) Apply(val Value) (Value, error) {
+        if val == NilVal || val.IsNull() {
+                return NilVal, errors.New("cannot access attributes on a null value")
+        }
+
         if !val.Type().IsObjectType() {
                 return NilVal, errors.New("not an object type")
         }
diff --git a/vendor/github.com/zclconf/go-cty/cty/path_set.go b/vendor/github.com/zclconf/go-cty/cty/path_set.go
new file mode 100644
index 0000000..f1c892b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/path_set.go
@@ -0,0 +1,198 @@
+package cty
+
+import (
+        "fmt"
+        "hash/crc64"
+
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+// PathSet represents a set of Path objects. This can be used, for example,
+// to talk about a subset of paths within a value that meet some criteria,
+// without directly modifying the values at those paths.
+type PathSet struct {
+        set set.Set
+}
+
+// NewPathSet creates and returns a PathSet, with initial contents optionally
+// set by the given arguments.
+func NewPathSet(paths ...Path) PathSet {
+        ret := PathSet{
+                set: set.NewSet(pathSetRules{}),
+        }
+
+        for _, path := range paths {
+                ret.Add(path)
+        }
+
+        return ret
+}
+
+// Add inserts a single given path into the set.
+//
+// Paths are immutable after construction by convention. It is particularly
+// important not to mutate a path after it has been placed into a PathSet.
+// If a Path is mutated while in a set, behavior is undefined.
+func (s PathSet) Add(path Path) {
+        s.set.Add(path)
+}
+
+// AddAllSteps is like Add but it also adds all of the steps leading to
+// the given path.
+//
+// For example, if given a path representing "foo.bar", it will add both
+// "foo" and "bar".
+func (s PathSet) AddAllSteps(path Path) {
+        for i := 1; i <= len(path); i++ {
+                s.Add(path[:i])
+        }
+}
+
+// Has returns true if the given path is in the receiving set.
+func (s PathSet) Has(path Path) bool {
+        return s.set.Has(path)
+}
+
+// List makes and returns a slice of all of the paths in the receiving set,
+// in an undefined but consistent order.
+func (s PathSet) List() []Path {
+        if s.Empty() {
+                return nil
+        }
+        ret := make([]Path, 0, s.set.Length())
+        for it := s.set.Iterator(); it.Next(); {
+                ret = append(ret, it.Value().(Path))
+        }
+        return ret
+}
+
+// Remove modifies the receving set to no longer include the given path.
+// If the given path was already absent, this is a no-op.
+func (s PathSet) Remove(path Path) {
+        s.set.Remove(path)
+}
+
+// Empty returns true if the length of the receiving set is zero.
+func (s PathSet) Empty() bool {
+        return s.set.Length() == 0
+}
+
+// Union returns a new set whose contents are the union of the receiver and
+// the given other set.
+func (s PathSet) Union(other PathSet) PathSet {
+        return PathSet{
+                set: s.set.Union(other.set),
+        }
+}
+
+// Intersection returns a new set whose contents are the intersection of the
+// receiver and the given other set.
+func (s PathSet) Intersection(other PathSet) PathSet {
+        return PathSet{
+                set: s.set.Intersection(other.set),
+        }
+}
+
+// Subtract returns a new set whose contents are those from the receiver with
+// any elements of the other given set subtracted.
+func (s PathSet) Subtract(other PathSet) PathSet {
+        return PathSet{
+                set: s.set.Subtract(other.set),
+        }
+}
+
+// SymmetricDifference returns a new set whose contents are the symmetric
+// difference of the receiver and the given other set.
+func (s PathSet) SymmetricDifference(other PathSet) PathSet {
+        return PathSet{
+                set: s.set.SymmetricDifference(other.set),
+        }
+}
+
+// Equal returns true if and only if both the receiver and the given other
+// set contain exactly the same paths.
+func (s PathSet) Equal(other PathSet) bool {
+        if s.set.Length() != other.set.Length() {
+                return false
+        }
+        // Now we know the lengths are the same we only need to test in one
+        // direction whether everything in one is in the other.
+        for it := s.set.Iterator(); it.Next(); {
+                if !other.set.Has(it.Value()) {
+                        return false
+                }
+        }
+        return true
+}
+
+var crc64Table = crc64.MakeTable(crc64.ISO)
+
+var indexStepPlaceholder = []byte("#")
+
+// pathSetRules is an implementation of set.Rules from the set package,
+// used internally within PathSet.
+type pathSetRules struct {
+}
+
+func (r pathSetRules) Hash(v interface{}) int {
+        path := v.(Path)
+        hash := crc64.New(crc64Table)
+
+        for _, rawStep := range path {
+                switch step := rawStep.(type) {
+                case GetAttrStep:
+                        // (this creates some garbage converting the string name to a
+                        // []byte, but that's okay since cty is not designed to be
+                        // used in tight loops under memory pressure.)
+                        hash.Write([]byte(step.Name))
+                default:
+                        // For any other step type we just append a predefined value,
+                        // which means that e.g. all indexes into a given collection will
+                        // hash to the same value but we assume that collections are
+                        // small and thus this won't hurt too much.
+                        hash.Write(indexStepPlaceholder)
+                }
+        }
+
+        // We discard half of the hash on 32-bit platforms; collisions just make
+        // our lookups take marginally longer, so not a big deal.
+        return int(hash.Sum64())
+}
+
+func (r pathSetRules) Equivalent(a, b interface{}) bool {
+        aPath := a.(Path)
+        bPath := b.(Path)
+
+        if len(aPath) != len(bPath) {
+                return false
+        }
+
+        for i := range aPath {
+                switch aStep := aPath[i].(type) {
+                case GetAttrStep:
+                        bStep, ok := bPath[i].(GetAttrStep)
+                        if !ok {
+                                return false
+                        }
+
+                        if aStep.Name != bStep.Name {
+                                return false
+                        }
+                case IndexStep:
+                        bStep, ok := bPath[i].(IndexStep)
+                        if !ok {
+                                return false
+                        }
+
+                        eq := aStep.Key.Equals(bStep.Key)
+                        if !eq.IsKnown() || eq.False() {
+                                return false
+                        }
+                default:
+                        // Should never happen, since we document PathStep as a closed type.
+                        panic(fmt.Errorf("unsupported step type %T", aStep))
+                }
+        }
+
+        return true
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/primitive_type.go b/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
index b8682dd..7b3d119 100644
--- a/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
+++ b/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
@@ -24,7 +24,7 @@ func (t primitiveType) Equals(other Type) bool {
         return false
 }
 
-func (t primitiveType) FriendlyName() string {
+func (t primitiveType) FriendlyName(mode friendlyTypeNameMode) string {
         switch t.Kind {
         case primitiveTypeBool:
                 return "bool"
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/iterator.go b/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
index f15498e..4a60494 100644
--- a/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
+++ b/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
@@ -1,36 +1,15 @@
 package set
 
 type Iterator struct {
-        bucketIds []int
-        vals      map[int][]interface{}
-        bucketIdx int
-        valIdx    int
+        vals []interface{}
+        idx  int
 }
 
 func (it *Iterator) Value() interface{} {
-        return it.currentBucket()[it.valIdx]
+        return it.vals[it.idx]
 }
 
 func (it *Iterator) Next() bool {
-        if it.bucketIdx == -1 {
-                // init
-                if len(it.bucketIds) == 0 {
-                        return false
-                }
-
-                it.valIdx = 0
-                it.bucketIdx = 0
-                return true
-        }
-
-        it.valIdx++
-        if it.valIdx >= len(it.currentBucket()) {
-                it.valIdx = 0
-                it.bucketIdx++
-        }
-        return it.bucketIdx < len(it.bucketIds)
-}
-
-func (it *Iterator) currentBucket() []interface{} {
-        return it.vals[it.bucketIds[it.bucketIdx]]
+        it.idx++
+        return it.idx < len(it.vals)
 }
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/ops.go b/vendor/github.com/zclconf/go-cty/cty/set/ops.go
index 726e707..fd1555f 100644
--- a/vendor/github.com/zclconf/go-cty/cty/set/ops.go
+++ b/vendor/github.com/zclconf/go-cty/cty/set/ops.go
@@ -75,8 +75,12 @@ func (s Set) Copy() Set {
         return ret
 }
 
-// Iterator returns an iterator over values in the set, in an undefined order
-// that callers should not depend on.
+// Iterator returns an iterator over values in the set. If the set's rules
+// implement OrderedRules then the result is ordered per those rules. If
+// no order is provided, or if it is not a total order, then the iteration
+// order is undefined but consistent for a particular version of cty. Do not
+// rely on specific ordering between cty releases unless the rules order is a
+// total order.
 //
 // The pattern for using the returned iterator is:
 //
@@ -89,18 +93,11 @@ func (s Set) Copy() Set {
 // Once an iterator has been created for a set, the set *must not* be mutated
 // until the iterator is no longer in use.
 func (s Set) Iterator() *Iterator {
-        // Sort the bucketIds to ensure that we always traverse in a
-        // consistent order.
-        bucketIds := make([]int, 0, len(s.vals))
-        for id := range s.vals {
-                bucketIds = append(bucketIds, id)
-        }
-        sort.Ints(bucketIds)
+        vals := s.Values()
 
         return &Iterator{
-                bucketIds: bucketIds,
-                vals:      s.vals,
-                bucketIdx: -1,
+                vals: vals,
+                idx:  -1,
         }
 }
 
@@ -113,16 +110,30 @@ func (s Set) EachValue(cb func(interface{})) {
         }
 }
 
-// Values returns a slice of all of the values in the set in no particular
-// order. This is just a wrapper around EachValue that accumulates the results
-// in a slice for caller convenience.
-//
-// The returned slice will be nil if there are no values in the set.
+// Values returns a slice of all the values in the set. If the set rules have
+// an order then the result is in that order. If no order is provided or if
+// it is not a total order then the result order is undefined, but consistent
+// for a particular set value within a specific release of cty.
 func (s Set) Values() []interface{} {
         var ret []interface{}
-        s.EachValue(func(v interface{}) {
-                ret = append(ret, v)
-        })
+        // Sort the bucketIds to ensure that we always traverse in a
+        // consistent order.
+        bucketIDs := make([]int, 0, len(s.vals))
+        for id := range s.vals {
+                bucketIDs = append(bucketIDs, id)
+        }
+        sort.Ints(bucketIDs)
+
+        for _, bucketID := range bucketIDs {
+                ret = append(ret, s.vals[bucketID]...)
+        }
+
+        if orderRules, ok := s.rules.(OrderedRules); ok {
+                sort.SliceStable(ret, func(i, j int) bool {
+                        return orderRules.Less(ret[i], ret[j])
+                })
+        }
+
         return ret
 }
 
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/rules.go b/vendor/github.com/zclconf/go-cty/cty/set/rules.go
index 7200184..51f744b 100644
--- a/vendor/github.com/zclconf/go-cty/cty/set/rules.go
+++ b/vendor/github.com/zclconf/go-cty/cty/set/rules.go
@@ -23,3 +23,21 @@ type Rules interface {
         // be equivalent.
         Equivalent(interface{}, interface{}) bool
 }
+
+// OrderedRules is an extension of Rules that can apply a partial order to
+// element values. When a set's Rules implements OrderedRules an iterator
+// over the set will return items in the order described by the rules.
+//
+// If the given order is not a total order (that is, some pairs of non-equivalent
+// elements do not have a defined order) then the resulting iteration order
+// is undefined but consistent for a particular version of cty. The exact
+// order in that case is not part of the contract and is subject to change
+// between versions.
+type OrderedRules interface {
+        Rules
+
+        // Less returns true if and only if the first argument should sort before
+        // the second argument. If the second argument should sort before the first
+        // or if there is no defined order for the values, return false.
+        Less(interface{}, interface{}) bool
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_internals.go b/vendor/github.com/zclconf/go-cty/cty/set_internals.go
index ce738db..3fd4fb2 100644
--- a/vendor/github.com/zclconf/go-cty/cty/set_internals.go
+++ b/vendor/github.com/zclconf/go-cty/cty/set_internals.go
@@ -6,6 +6,8 @@ import (
         "hash/crc32"
         "math/big"
         "sort"
+
+        "github.com/zclconf/go-cty/cty/set"
 )
 
 // setRules provides a Rules implementation for the ./set package that
@@ -19,12 +21,26 @@ type setRules struct {
         Type Type
 }
 
+var _ set.OrderedRules = setRules{}
+
+// Hash returns a hash value for the receiver that can be used for equality
+// checks where some inaccuracy is tolerable.
+//
+// The hash function is value-type-specific, so it is not meaningful to compare
+// hash results for values of different types.
+//
+// This function is not safe to use for security-related applications, since
+// the hash used is not strong enough.
+func (val Value) Hash() int {
+        hashBytes := makeSetHashBytes(val)
+        return int(crc32.ChecksumIEEE(hashBytes))
+}
+
 func (r setRules) Hash(v interface{}) int {
-        hashBytes := makeSetHashBytes(Value{
+        return Value{
                 ty: r.Type,
                 v:  v,
-        })
-        return int(crc32.ChecksumIEEE(hashBytes))
+        }.Hash()
 }
 
 func (r setRules) Equivalent(v1 interface{}, v2 interface{}) bool {
@@ -46,6 +62,60 @@ func (r setRules) Equivalent(v1 interface{}, v2 interface{}) bool {
         return eqv.v == true
 }
 
+// Less is an implementation of set.OrderedRules so that we can iterate over
+// set elements in a consistent order, where such an order is possible.
+func (r setRules) Less(v1, v2 interface{}) bool {
+        v1v := Value{
+                ty: r.Type,
+                v:  v1,
+        }
+        v2v := Value{
+                ty: r.Type,
+                v:  v2,
+        }
+
+        if v1v.RawEquals(v2v) { // Easy case: if they are equal then v1 can't be less
+                return false
+        }
+
+        // Null values always sort after non-null values
+        if v2v.IsNull() && !v1v.IsNull() {
+                return true
+        } else if v1v.IsNull() {
+                return false
+        }
+        // Unknown values always sort after known values
+        if v1v.IsKnown() && !v2v.IsKnown() {
+                return true
+        } else if !v1v.IsKnown() {
+                return false
+        }
+
+        switch r.Type {
+        case String:
+                // String values sort lexicographically
+                return v1v.AsString() < v2v.AsString()
+        case Bool:
+                // Weird to have a set of bools, but if we do then false sorts before true.
+                if v2v.True() || !v1v.True() {
+                        return true
+                }
+                return false
+        case Number:
+                v1f := v1v.AsBigFloat()
+                v2f := v2v.AsBigFloat()
+                return v1f.Cmp(v2f) < 0
+        default:
+                // No other types have a well-defined ordering, so we just produce a
+                // default consistent-but-undefined ordering then. This situation is
+                // not considered a compatibility constraint; callers should rely only
+                // on the ordering rules for primitive values.
+                v1h := makeSetHashBytes(v1v)
+                v2h := makeSetHashBytes(v2v)
+                return bytes.Compare(v1h, v2h) < 0
+        }
+}
+
 func makeSetHashBytes(val Value) []byte {
         var buf bytes.Buffer
         appendSetHashBytes(val, &buf)
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_type.go b/vendor/github.com/zclconf/go-cty/cty/set_type.go
index 952a2d2..cbc3706 100644
--- a/vendor/github.com/zclconf/go-cty/cty/set_type.go
+++ b/vendor/github.com/zclconf/go-cty/cty/set_type.go
@@ -31,8 +31,14 @@ func (t typeSet) Equals(other Type) bool {
         return t.ElementTypeT.Equals(ot.ElementTypeT)
 }
 
-func (t typeSet) FriendlyName() string {
-        return "set of " + t.ElementTypeT.FriendlyName()
+func (t typeSet) FriendlyName(mode friendlyTypeNameMode) string {
+        elemName := t.ElementTypeT.friendlyNameMode(mode)
+        if mode == friendlyTypeConstraintName {
+                if t.ElementTypeT == DynamicPseudoType {
+                        elemName = "any single type"
+                }
+        }
+        return "set of " + elemName
 }
 
 func (t typeSet) ElementType() Type {
diff --git a/vendor/github.com/zclconf/go-cty/cty/tuple_type.go b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
index b98349e..798cacd 100644
--- a/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
+++ b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
@@ -44,7 +44,7 @@ func (t typeTuple) Equals(other Type) bool {
         return false
 }
 
-func (t typeTuple) FriendlyName() string {
+func (t typeTuple) FriendlyName(mode friendlyTypeNameMode) string {
         // There isn't really a friendly way to write a tuple type due to its
         // complexity, so we'll just do something English-ish. Callers will
         // probably want to make some extra effort to avoid ever printing out
diff --git a/vendor/github.com/zclconf/go-cty/cty/type.go b/vendor/github.com/zclconf/go-cty/cty/type.go
index ae5f1c8..730cb98 100644
--- a/vendor/github.com/zclconf/go-cty/cty/type.go
+++ b/vendor/github.com/zclconf/go-cty/cty/type.go
@@ -19,7 +19,7 @@ type typeImpl interface {
 
         // FriendlyName returns a human-friendly *English* name for the given
         // type.
-        FriendlyName() string
+        FriendlyName(mode friendlyTypeNameMode) string
 
         // GoString implements the GoStringer interface from package fmt.
         GoString() string
@@ -41,7 +41,25 @@ func (t Type) Equals(other Type) bool {
 
 // FriendlyName returns a human-friendly *English* name for the given type.
 func (t Type) FriendlyName() string {
-        return t.typeImpl.FriendlyName()
+        return t.typeImpl.FriendlyName(friendlyTypeName)
+}
+
+// FriendlyNameForConstraint is similar to FriendlyName except that the
+// result is specialized for describing type _constraints_ rather than types
+// themselves. This is more appropriate when reporting that a particular value
+// does not conform to an expected type constraint.
+//
+// In particular, this function uses the term "any type" to refer to
+// cty.DynamicPseudoType, rather than "dynamic" as returned by FriendlyName.
+func (t Type) FriendlyNameForConstraint() string {
+        return t.typeImpl.FriendlyName(friendlyTypeConstraintName)
+}
+
+// friendlyNameMode is an internal combination of the various FriendlyName*
+// variants that just directly takes a mode, for easy passthrough for
+// recursive name construction.
+func (t Type) friendlyNameMode(mode friendlyTypeNameMode) string {
+        return t.typeImpl.FriendlyName(mode)
 }
 
 // GoString returns a string approximating how the receiver type would be
@@ -93,3 +111,10 @@ func (t Type) HasDynamicTypes() bool {
                 panic("HasDynamicTypes does not support the given type")
         }
 }
+
+type friendlyTypeNameMode rune
+
+const (
+        friendlyTypeName           friendlyTypeNameMode = 'N'
+        friendlyTypeConstraintName friendlyTypeNameMode = 'C'
+)
diff --git a/vendor/github.com/zclconf/go-cty/cty/type_conform.go b/vendor/github.com/zclconf/go-cty/cty/type_conform.go
index b417dc7..476eeea 100644
--- a/vendor/github.com/zclconf/go-cty/cty/type_conform.go
+++ b/vendor/github.com/zclconf/go-cty/cty/type_conform.go
@@ -50,23 +50,20 @@ func testConformance(given Type, want Type, path Path, errs *[]error) {
                 givenAttrs := given.AttributeTypes()
                 wantAttrs := want.AttributeTypes()
 
-                if len(givenAttrs) != len(wantAttrs) {
-                        // Something is missing from one of them.
-                        for k := range givenAttrs {
-                                if _, exists := wantAttrs[k]; !exists {
-                                        *errs = append(
-                                                *errs,
-                                                errorf(path, "unsupported attribute %q", k),
-                                        )
-                                }
+                for k := range givenAttrs {
+                        if _, exists := wantAttrs[k]; !exists {
+                                *errs = append(
+                                        *errs,
+                                        errorf(path, "unsupported attribute %q", k),
+                                )
                         }
-                        for k := range wantAttrs {
-                                if _, exists := givenAttrs[k]; !exists {
-                                        *errs = append(
-                                                *errs,
-                                                errorf(path, "missing required attribute %q", k),
-                                        )
-                                }
+                }
+                for k := range wantAttrs {
+                        if _, exists := givenAttrs[k]; !exists {
+                                *errs = append(
+                                        *errs,
+                                        errorf(path, "missing required attribute %q", k),
+                                )
                         }
                 }
 
diff --git a/vendor/github.com/zclconf/go-cty/cty/unknown.go b/vendor/github.com/zclconf/go-cty/cty/unknown.go
index 9f6fce9..e54179e 100644
--- a/vendor/github.com/zclconf/go-cty/cty/unknown.go
+++ b/vendor/github.com/zclconf/go-cty/cty/unknown.go
@@ -54,8 +54,13 @@ func (t pseudoTypeDynamic) Equals(other Type) bool {
         return ok
 }
 
-func (t pseudoTypeDynamic) FriendlyName() string {
-        return "dynamic"
+func (t pseudoTypeDynamic) FriendlyName(mode friendlyTypeNameMode) string {
+        switch mode {
+        case friendlyTypeConstraintName:
+                return "any type"
+        default:
+                return "dynamic"
+        }
 }
 
 func (t pseudoTypeDynamic) GoString() string {
diff --git a/vendor/github.com/zclconf/go-cty/cty/unknown_as_null.go b/vendor/github.com/zclconf/go-cty/cty/unknown_as_null.go
new file mode 100644
index 0000000..ba92647
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/unknown_as_null.go
@@ -0,0 +1,64 @@
+package cty
+
+// UnknownAsNull returns a value of the same type as the given value but
+// with any unknown values (including nested values) replaced with null
+// values of the same type.
+//
+// This can be useful if a result is to be serialized in a format that can't
+// represent unknowns, such as JSON, as long as the caller does not need to
+// retain the unknown value information.
+func UnknownAsNull(val Value) Value {
+        ty := val.Type()
+        switch {
+        case val.IsNull():
+                return val
+        case !val.IsKnown():
+                return NullVal(ty)
+        case ty.IsListType() || ty.IsTupleType() || ty.IsSetType():
+                length := val.LengthInt()
+                if length == 0 {
+                        // If there are no elements then we can't have unknowns
+                        return val
+                }
+                vals := make([]Value, 0, length)
+                it := val.ElementIterator()
+                for it.Next() {
+                        _, v := it.Element()
+                        vals = append(vals, UnknownAsNull(v))
+                }
+                switch {
+                case ty.IsListType():
+                        return ListVal(vals)
+                case ty.IsTupleType():
+                        return TupleVal(vals)
+                default:
+                        return SetVal(vals)
+                }
+        case ty.IsMapType() || ty.IsObjectType():
+                var length int
+                switch {
+                case ty.IsMapType():
+                        length = val.LengthInt()
+                default:
+                        length = len(val.Type().AttributeTypes())
+                }
+                if length == 0 {
+                        // If there are no elements then we can't have unknowns
+                        return val
+                }
+                vals := make(map[string]Value, length)
+                it := val.ElementIterator()
+                for it.Next() {
+                        k, v := it.Element()
+                        vals[k.AsString()] = UnknownAsNull(v)
+                }
+                switch {
+                case ty.IsMapType():
+                        return MapVal(vals)
+                default:
+                        return ObjectVal(vals)
+                }
+        }
+
+        return val
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value_init.go b/vendor/github.com/zclconf/go-cty/cty/value_init.go
index 495a83e..3deeba3 100644
--- a/vendor/github.com/zclconf/go-cty/cty/value_init.go
+++ b/vendor/github.com/zclconf/go-cty/cty/value_init.go
@@ -30,6 +30,44 @@ func NumberVal(v *big.Float) Value {
         }
 }
 
+// ParseNumberVal returns a Value of type number produced by parsing the given
+// string as a decimal real number. To ensure that two identical strings will
+// always produce an equal number, always use this function to derive a number
+// from a string; it will ensure that the precision and rounding mode for the
+// internal big decimal is configured in a consistent way.
+//
+// If the given string cannot be parsed as a number, the returned error has
+// the message "a number is required", making it suitable to return to an
+// end-user to signal a type conversion error.
+//
+// If the given string contains a number that becomes a recurring fraction
+// when expressed in binary then it will be truncated to have a 512-bit
+// mantissa. Note that this is a higher precision than that of a float64,
+// so coverting the same decimal number first to float64 and then calling
+// NumberFloatVal will not produce an equal result; the conversion first
+// to float64 will round the mantissa to fewer than 512 bits.
+func ParseNumberVal(s string) (Value, error) {
+        // Base 10, precision 512, and rounding to nearest even is the standard
+        // way to handle numbers arriving as strings.
+        f, _, err := big.ParseFloat(s, 10, 512, big.ToNearestEven)
+        if err != nil {
+                return NilVal, fmt.Errorf("a number is required")
+        }
+        return NumberVal(f), nil
+}
+
+// MustParseNumberVal is like ParseNumberVal but it will panic in case of any
+// error. It can be used during initialization or any other situation where
+// the given string is a constant or otherwise known to be correct by the
+// caller.
+func MustParseNumberVal(s string) Value {
+        ret, err := ParseNumberVal(s)
+        if err != nil {
+                panic(err)
+        }
+        return ret
+}
+
 // NumberIntVal returns a Value of type Number whose internal value is equal
 // to the given integer.
 func NumberIntVal(v int64) Value {
diff --git a/vendor/github.com/zclconf/go-cty/cty/value_ops.go b/vendor/github.com/zclconf/go-cty/cty/value_ops.go
index 967aa76..afd621c 100644
--- a/vendor/github.com/zclconf/go-cty/cty/value_ops.go
+++ b/vendor/github.com/zclconf/go-cty/cty/value_ops.go
@@ -3,27 +3,27 @@ package cty
 import (
         "fmt"
         "math/big"
-
         "reflect"
 
         "github.com/zclconf/go-cty/cty/set"
 )
 
+// GoString is an implementation of fmt.GoStringer that produces concise
+// source-like representations of values suitable for use in debug messages.
 func (val Value) GoString() string {
         if val == NilVal {
                 return "cty.NilVal"
         }
 
-        if val.ty == DynamicPseudoType {
+        if val.IsNull() {
+                return fmt.Sprintf("cty.NullVal(%#v)", val.ty)
+        }
+        if val == DynamicVal { // is unknown, so must be before the IsKnown check below
                 return "cty.DynamicVal"
         }
-
         if !val.IsKnown() {
                 return fmt.Sprintf("cty.UnknownVal(%#v)", val.ty)
         }
-        if val.IsNull() {
-                return fmt.Sprintf("cty.NullVal(%#v)", val.ty)
-        }
 
         // By the time we reach here we've dealt with all of the exceptions around
         // unknowns and nulls, so we're guaranteed that the values are the
@@ -33,9 +33,8 @@ func (val Value) GoString() string {
         case Bool:
                 if val.v.(bool) {
                         return "cty.True"
-                } else {
-                        return "cty.False"
                 }
+                return "cty.False"
         case Number:
                 fv := val.v.(*big.Float)
                 // We'll try to use NumberIntVal or NumberFloatVal if we can, since
@@ -46,19 +45,42 @@ func (val Value) GoString() string {
                 if rfv, accuracy := fv.Float64(); accuracy == big.Exact {
                         return fmt.Sprintf("cty.NumberFloatVal(%#v)", rfv)
                 }
-                return fmt.Sprintf("cty.NumberVal(new(big.Float).Parse(\"%#v\", 10))", fv)
+                return fmt.Sprintf("cty.MustParseNumberVal(%q)", fv.Text('f', -1))
         case String:
                 return fmt.Sprintf("cty.StringVal(%#v)", val.v)
         }
 
         switch {
         case val.ty.IsSetType():
-                vals := val.v.(set.Set).Values()
-                if vals == nil || len(vals) == 0 {
-                        return fmt.Sprintf("cty.SetValEmpty()")
-                } else {
-                        return fmt.Sprintf("cty.SetVal(%#v)", vals)
+                vals := val.AsValueSlice()
+                if len(vals) == 0 {
+                        return fmt.Sprintf("cty.SetValEmpty(%#v)", val.ty.ElementType())
                 }
+                return fmt.Sprintf("cty.SetVal(%#v)", vals)
+        case val.ty.IsListType():
+                vals := val.AsValueSlice()
+                if len(vals) == 0 {
+                        return fmt.Sprintf("cty.ListValEmpty(%#v)", val.ty.ElementType())
+                }
+                return fmt.Sprintf("cty.ListVal(%#v)", vals)
+        case val.ty.IsMapType():
+                vals := val.AsValueMap()
+                if len(vals) == 0 {
+                        return fmt.Sprintf("cty.MapValEmpty(%#v)", val.ty.ElementType())
+                }
+                return fmt.Sprintf("cty.MapVal(%#v)", vals)
+        case val.ty.IsTupleType():
+                if val.ty.Equals(EmptyTuple) {
+                        return "cty.EmptyTupleVal"
+                }
+                vals := val.AsValueSlice()
+                return fmt.Sprintf("cty.TupleVal(%#v)", vals)
+        case val.ty.IsObjectType():
+                if val.ty.Equals(EmptyObject) {
+                        return "cty.EmptyObjectVal"
+                }
+                vals := val.AsValueMap()
+                return fmt.Sprintf("cty.ObjectVal(%#v)", vals)
         case val.ty.IsCapsuleType():
                 return fmt.Sprintf("cty.CapsuleVal(%#v, %#v)", val.ty, val.v)
         }
@@ -71,26 +93,67 @@ func (val Value) GoString() string {
 // Equals returns True if the receiver and the given other value have the
 // same type and are exactly equal in value.
 //
-// The usual short-circuit rules apply, so the result can be unknown or typed
-// as dynamic if either of the given values are. Use RawEquals to compare
-// if two values are equal *ignoring* the short-circuit rules.
+// As a special case, two null values are always equal regardless of type.
+//
+// The usual short-circuit rules apply, so the result will be unknown if
+// either of the given values are.
+//
+// Use RawEquals to compare if two values are equal *ignoring* the
+// short-circuit rules and the exception for null values.
 func (val Value) Equals(other Value) Value {
-        if val.ty.HasDynamicTypes() || other.ty.HasDynamicTypes() {
+        // Start by handling Unknown values before considering types.
+        // This needs to be done since Null values are always equal regardless of
+        // type.
+        switch {
+        case !val.IsKnown() && !other.IsKnown():
+                // both unknown
                 return UnknownVal(Bool)
+        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
+                        // nulls of any type are equal.
+                        // An unkown 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):
+                        // There is no null comparison or dynamic types, so unequal types
+                        // will never be equal.
+                        return False
+                default:
+                        return UnknownVal(Bool)
+                }
+        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
+                        // nulls of any type are equal.
+                        // An unkown 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):
+                        // There's no null comparison or dynamic types, so unequal types
+                        // will never be equal.
+                        return False
+                default:
+                        return UnknownVal(Bool)
+                }
         }
 
-        if !val.ty.Equals(other.ty) {
+        switch {
+        case val.IsNull() && other.IsNull():
+                // Nulls are always equal, regardless of type
+                return BoolVal(true)
+        case val.IsNull() || other.IsNull():
+                // If only one is null then the result must be false
                 return BoolVal(false)
         }
 
-        if !(val.IsKnown() && other.IsKnown()) {
+        if val.ty.HasDynamicTypes() || other.ty.HasDynamicTypes() {
                 return UnknownVal(Bool)
         }
 
-        if val.IsNull() || other.IsNull() {
-                if val.IsNull() && other.IsNull() {
-                        return BoolVal(true)
-                }
+        if !val.ty.Equals(other.ty) {
                 return BoolVal(false)
         }
 
@@ -758,7 +821,7 @@ func (val Value) HasElement(elem Value) Value {
         if val.IsNull() {
                 panic("can't call HasElement on a nil value")
         }
-        if ty.ElementType() != elem.Type() {
+        if !ty.ElementType().Equals(elem.Type()) {
                 return False
         }
 
@@ -800,6 +863,10 @@ func (val Value) LengthInt() int {
                 // For tuples, we can return the length even if the value is not known.
                 return val.Type().Length()
         }
+        if val.Type().IsObjectType() {
+                // For objects, the length is the number of attributes associated with the type.
+                return len(val.Type().AttributeTypes())
+        }
         if !val.IsKnown() {
                 panic("value is not known")
         }