8 files changed, 759 insertions, 9 deletions

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
+}