3 files changed, 54 insertions, 46 deletions

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