From 71398875657e0777ed81b140eadfae70890d133c Mon Sep 17 00:00:00 2001
From: Martin Atkins <mart@degeneration.co.uk>
Date: Wed, 29 Aug 2018 11:13:35 -0700
Subject: [PATCH] vendor: upgrade go-cty to latest

This includes the new PathSet type, which we'll use to represent the
"requires replacement" set of attribute paths coming back from providers
during planning.
---
 go.mod                                        |   2 +-
 go.sum                                        |   2 +
 vendor/github.com/zclconf/go-cty/cty/path.go  |   4 +
 .../github.com/zclconf/go-cty/cty/path_set.go | 182 ++++++++++++++++++
 vendor/modules.txt                            |   2 +-
 5 files changed, 190 insertions(+), 2 deletions(-)
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/path_set.go

diff --git a/go.mod b/go.mod
index 881a56d00..2ba77ba5d 100644
--- a/go.mod
+++ b/go.mod
@@ -130,7 +130,7 @@ require (
 	github.com/xanzy/ssh-agent v0.1.0
 	github.com/xiang90/probing v0.0.0-20160813154853-07dd2e8dfe18 // indirect
 	github.com/xlab/treeprint v0.0.0-20161029104018-1d6e34225557
-	github.com/zclconf/go-cty v0.0.0-20180827182259-5a135111c744
+	github.com/zclconf/go-cty v0.0.0-20180829180805-c2393a5d54f2
 	golang.org/x/crypto v0.0.0-20180816225734-aabede6cba87
 	golang.org/x/net v0.0.0-20180826012351-8a410e7b638d
 	golang.org/x/oauth2 v0.0.0-20170928010508-bb50c06baba3
diff --git a/go.sum b/go.sum
index 981768748..d899d15f5 100644
--- a/go.sum
+++ b/go.sum
@@ -276,6 +276,8 @@ github.com/xlab/treeprint v0.0.0-20161029104018-1d6e34225557 h1:Jpn2j6wHkC9wJv5i
 github.com/xlab/treeprint v0.0.0-20161029104018-1d6e34225557/go.mod h1:ce1O1j6UtZfjr22oyGxGLbauSBp2YVXpARAosm7dHBg=
 github.com/zclconf/go-cty v0.0.0-20180827182259-5a135111c744 h1:JNsGrc8/oqtTgRC2tqAGqJ14S+u4KdtHY0olF95bGsA=
 github.com/zclconf/go-cty v0.0.0-20180827182259-5a135111c744/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
+github.com/zclconf/go-cty v0.0.0-20180829180805-c2393a5d54f2 h1:6kLV7zzkF4LbOhuztGPIJjd/u7csij6t3GXRz/1hu2Y=
+github.com/zclconf/go-cty v0.0.0-20180829180805-c2393a5d54f2/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
 golang.org/x/crypto v0.0.0-20180816225734-aabede6cba87 h1:gCHhzI+1R9peHIMyiWVxoVaWlk1cYK7VThX5ptLtbXY=
 golang.org/x/crypto v0.0.0-20180816225734-aabede6cba87/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/net v0.0.0-20180811021610-c39426892332 h1:efGso+ep0DjyCBJPjvoz0HI6UldX4Md2F1rZFe1ir0E=
diff --git a/vendor/github.com/zclconf/go-cty/cty/path.go b/vendor/github.com/zclconf/go-cty/cty/path.go
index 84a9de0c4..69bc4819d 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
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 000000000..6eddcb5a2
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/path_set.go
@@ -0,0 +1,182 @@
+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),
+	}
+}
+
+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/modules.txt b/vendor/modules.txt
index d8460c8c3..a9b877cf9 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -447,7 +447,7 @@ github.com/vmihailenco/msgpack/codes
 github.com/xanzy/ssh-agent
 # github.com/xlab/treeprint v0.0.0-20161029104018-1d6e34225557
 github.com/xlab/treeprint
-# github.com/zclconf/go-cty v0.0.0-20180827182259-5a135111c744
+# github.com/zclconf/go-cty v0.0.0-20180829180805-c2393a5d54f2
 github.com/zclconf/go-cty/cty
 github.com/zclconf/go-cty/cty/gocty
 github.com/zclconf/go-cty/cty/convert