vendor: Update vendor logic

vendor/sigs.k8s.io/structured-merge-diff/fieldpath/element.go

@@ -35,7 +35,7 @@ type PathElement struct {
 	// Key selects the list element which has fields matching those given.
 	// The containing object must be an associative list with map typed
 	// elements.
-	Key []value.Field
+	Key *value.FieldList
 
 	// Value selects the list element with the given value. The containing
 	// object must be an associative list with a primitive typed element
@@ -47,19 +47,65 @@ type PathElement struct {
 	Index *int
 }
 
+// Less provides an order for path elements.
+func (e PathElement) Less(rhs PathElement) bool {
+	if e.FieldName != nil {
+		if rhs.FieldName == nil {
+			return true
+		}
+		return *e.FieldName < *rhs.FieldName
+	} else if rhs.FieldName != nil {
+		return false
+	}
+
+	if e.Key != nil {
+		if rhs.Key == nil {
+			return true
+		}
+		return e.Key.Less(*rhs.Key)
+	} else if rhs.Key != nil {
+		return false
+	}
+
+	if e.Value != nil {
+		if rhs.Value == nil {
+			return true
+		}
+		return e.Value.Less(*rhs.Value)
+	} else if rhs.Value != nil {
+		return false
+	}
+
+	if e.Index != nil {
+		if rhs.Index == nil {
+			return true
+		}
+		return *e.Index < *rhs.Index
+	} else if rhs.Index != nil {
+		// Yes, I know the next statement is the same.  But this way
+		// the obvious way of extending the function wil be bug-free.
+		return false
+	}
+
+	return false
+}
+
+// Equals returns true if both path elements are equal.
+func (e PathElement) Equals(rhs PathElement) bool {
+	return !e.Less(rhs) && !rhs.Less(e)
+}
+
 // String presents the path element as a human-readable string.
 func (e PathElement) String() string {
 	switch {
 	case e.FieldName != nil:
 		return "." + *e.FieldName
-	case len(e.Key) > 0:
-		strs := make([]string, len(e.Key))
-		for i, k := range e.Key {
+	case e.Key != nil:
+		strs := make([]string, len(*e.Key))
+		for i, k := range *e.Key {
 			strs[i] = fmt.Sprintf("%v=%v", k.Name, k.Value)
 		}
-		// The order must be canonical, since we use the string value
-		// in a set structure.
-		sort.Strings(strs)
+		// Keys are supposed to be sorted.
 		return "[" + strings.Join(strs, ",") + "]"
 	case e.Value != nil:
 		return fmt.Sprintf("[=%v]", e.Value)
@@ -75,79 +121,124 @@ func (e PathElement) String() string {
 // names (type must be string) with values (type must be value.Value). If these
 // conditions are not met, KeyByFields will panic--it's intended for static
 // construction and shouldn't have user-produced values passed to it.
-func KeyByFields(nameValues ...interface{}) []value.Field {
+func KeyByFields(nameValues ...interface{}) *value.FieldList {
 	if len(nameValues)%2 != 0 {
 		panic("must have a value for every name")
 	}
-	out := []value.Field{}
+	out := value.FieldList{}
 	for i := 0; i < len(nameValues)-1; i += 2 {
 		out = append(out, value.Field{
 			Name:  nameValues[i].(string),
 			Value: nameValues[i+1].(value.Value),
 		})
 	}
-	return out
+	out.Sort()
+	return &out
 }
 
 // PathElementSet is a set of path elements.
 // TODO: serialize as a list.
 type PathElementSet struct {
-	// The strange construction is because there's no way to test
-	// PathElements for equality (it can't be used as a key for a map).
-	members map[string]PathElement
+	members sortedPathElements
 }
 
+func MakePathElementSet(size int) PathElementSet {
+	return PathElementSet{
+		members: make(sortedPathElements, 0, size),
+	}
+}
+
+type sortedPathElements []PathElement
+
+// Implement the sort interface; this would permit bulk creation, which would
+// be faster than doing it one at a time via Insert.
+func (spe sortedPathElements) Len() int           { return len(spe) }
+func (spe sortedPathElements) Less(i, j int) bool { return spe[i].Less(spe[j]) }
+func (spe sortedPathElements) Swap(i, j int)      { spe[i], spe[j] = spe[j], spe[i] }
+
 // Insert adds pe to the set.
 func (s *PathElementSet) Insert(pe PathElement) {
-	serialized := pe.String()
-	if s.members == nil {
-		s.members = map[string]PathElement{
-			serialized: pe,
-		}
+	loc := sort.Search(len(s.members), func(i int) bool {
+		return !s.members[i].Less(pe)
+	})
+	if loc == len(s.members) {
+		s.members = append(s.members, pe)
 		return
 	}
-	if _, ok := s.members[serialized]; !ok {
-		s.members[serialized] = pe
+	if s.members[loc].Equals(pe) {
+		return
 	}
+	s.members = append(s.members, PathElement{})
+	copy(s.members[loc+1:], s.members[loc:])
+	s.members[loc] = pe
 }
 
 // Union returns a set containing elements that appear in either s or s2.
 func (s *PathElementSet) Union(s2 *PathElementSet) *PathElementSet {
-	out := &PathElementSet{
-		members: map[string]PathElement{},
+	out := &PathElementSet{}
+
+	i, j := 0, 0
+	for i < len(s.members) && j < len(s2.members) {
+		if s.members[i].Less(s2.members[j]) {
+			out.members = append(out.members, s.members[i])
+			i++
+		} else {
+			out.members = append(out.members, s2.members[j])
+			if !s2.members[j].Less(s.members[i]) {
+				i++
+			}
+			j++
+		}
 	}
-	for k, v := range s.members {
-		out.members[k] = v
+
+	if i < len(s.members) {
+		out.members = append(out.members, s.members[i:]...)
 	}
-	for k, v := range s2.members {
-		out.members[k] = v
+	if j < len(s2.members) {
+		out.members = append(out.members, s2.members[j:]...)
 	}
 	return out
 }
 
 // Intersection returns a set containing elements which appear in both s and s2.
 func (s *PathElementSet) Intersection(s2 *PathElementSet) *PathElementSet {
-	out := &PathElementSet{
-		members: map[string]PathElement{},
-	}
-	for k, v := range s.members {
-		if _, ok := s2.members[k]; ok {
-			out.members[k] = v
+	out := &PathElementSet{}
+
+	i, j := 0, 0
+	for i < len(s.members) && j < len(s2.members) {
+		if s.members[i].Less(s2.members[j]) {
+			i++
+		} else {
+			if !s2.members[j].Less(s.members[i]) {
+				out.members = append(out.members, s.members[i])
+				i++
+			}
+			j++
 		}
 	}
+
 	return out
 }
 
 // Difference returns a set containing elements which appear in s but not in s2.
 func (s *PathElementSet) Difference(s2 *PathElementSet) *PathElementSet {
-	out := &PathElementSet{
-		members: map[string]PathElement{},
-	}
-	for k, v := range s.members {
-		if _, ok := s2.members[k]; !ok {
-			out.members[k] = v
+	out := &PathElementSet{}
+
+	i, j := 0, 0
+	for i < len(s.members) && j < len(s2.members) {
+		if s.members[i].Less(s2.members[j]) {
+			out.members = append(out.members, s.members[i])
+			i++
+		} else {
+			if !s2.members[j].Less(s.members[i]) {
+				i++
+			}
+			j++
 		}
 	}
+	if i < len(s.members) {
+		out.members = append(out.members, s.members[i:]...)
+	}
 	return out
 }
 
@@ -156,11 +247,16 @@ func (s *PathElementSet) Size() int { return len(s.members) }
 
 // Has returns true if pe is a member of the set.
 func (s *PathElementSet) Has(pe PathElement) bool {
-	if s.members == nil {
+	loc := sort.Search(len(s.members), func(i int) bool {
+		return !s.members[i].Less(pe)
+	})
+	if loc == len(s.members) {
 		return false
 	}
-	_, ok := s.members[pe.String()]
-	return ok
+	if s.members[loc].Equals(pe) {
+		return true
+	}
+	return false
 }
 
 // Equals returns true if s and s2 have exactly the same members.
@@ -169,14 +265,14 @@ func (s *PathElementSet) Equals(s2 *PathElementSet) bool {
 		return false
 	}
 	for k := range s.members {
-		if _, ok := s2.members[k]; !ok {
+		if !s.members[k].Equals(s2.members[k]) {
 			return false
 		}
 	}
 	return true
 }
 
-// Iterate calls f for each PathElement in the set.
+// Iterate calls f for each PathElement in the set. The order is deterministic.
 func (s *PathElementSet) Iterate(f func(PathElement)) {
 	for _, pe := range s.members {
 		f(pe)

vendor/sigs.k8s.io/structured-merge-diff/fieldpath/fromvalue.go

@@ -104,7 +104,7 @@ func GuessBestListPathElement(index int, item value.Value) PathElement {
 		return PathElement{Index: &index}
 	}
 
-	var keys []value.Field
+	var keys value.FieldList
 	for _, name := range AssociativeListCandidateFieldNames {
 		f, ok := item.MapValue.Get(name)
 		if !ok {
@@ -117,7 +117,8 @@ func GuessBestListPathElement(index int, item value.Value) PathElement {
 		keys = append(keys, *f)
 	}
 	if len(keys) > 0 {
-		return PathElement{Key: keys}
+		keys.Sort()
+		return PathElement{Key: &keys}
 	}
 	return PathElement{Index: &index}
 }

vendor/sigs.k8s.io/structured-merge-diff/fieldpath/managers.go

@@ -16,16 +16,42 @@ package fieldpath
 // APIVersion describes the version of an object or of a fieldset.
 type APIVersion string
 
+type VersionedSet interface {
+	Set() *Set
+	APIVersion() APIVersion
+	Applied() bool
+}
+
 // VersionedSet associates a version to a set.
-type VersionedSet struct {
-	*Set
-	APIVersion APIVersion
-	Applied    bool
+type versionedSet struct {
+	set        *Set
+	apiVersion APIVersion
+	applied    bool
+}
+
+func NewVersionedSet(set *Set, apiVersion APIVersion, applied bool) VersionedSet {
+	return versionedSet{
+		set:        set,
+		apiVersion: apiVersion,
+		applied:    applied,
+	}
+}
+
+func (v versionedSet) Set() *Set {
+	return v.set
+}
+
+func (v versionedSet) APIVersion() APIVersion {
+	return v.apiVersion
+}
+
+func (v versionedSet) Applied() bool {
+	return v.applied
 }
 
 // ManagedFields is a map from manager to VersionedSet (what they own in
 // what version).
-type ManagedFields map[string]*VersionedSet
+type ManagedFields map[string]VersionedSet
 
 // Difference returns a symmetric difference between two Managers. If a
 // given user's entry has version X in lhs and version Y in rhs, then
@@ -37,7 +63,7 @@ func (lhs ManagedFields) Difference(rhs ManagedFields) ManagedFields {
 	for manager, left := range lhs {
 		right, ok := rhs[manager]
 		if !ok {
-			if !left.Empty() {
+			if !left.Set().Empty() {
 				diff[manager] = left
 			}
 			continue
@@ -46,17 +72,14 @@ func (lhs ManagedFields) Difference(rhs ManagedFields) ManagedFields {
 		// If we have sets in both but their version
 		// differs, we don't even diff and keep the
 		// entire thing.
-		if left.APIVersion != right.APIVersion {
+		if left.APIVersion() != right.APIVersion() {
 			diff[manager] = right
 			continue
 		}
 
-		newSet := left.Difference(right.Set).Union(right.Difference(left.Set))
+		newSet := left.Set().Difference(right.Set()).Union(right.Set().Difference(left.Set()))
 		if !newSet.Empty() {
-			diff[manager] = &VersionedSet{
-				Set:        newSet,
-				APIVersion: right.APIVersion,
-			}
+			diff[manager] = NewVersionedSet(newSet, right.APIVersion(), false)
 		}
 	}
 
@@ -65,7 +88,7 @@ func (lhs ManagedFields) Difference(rhs ManagedFields) ManagedFields {
 			// Already done
 			continue
 		}
-		if !set.Empty() {
+		if !set.Set().Empty() {
 			diff[manager] = set
 		}
 	}

vendor/sigs.k8s.io/structured-merge-diff/fieldpath/path.go

@@ -35,6 +35,40 @@ func (fp Path) String() string {
 	return strings.Join(strs, "")
 }
 
+// Equals returns true if the two paths are equivalent.
+func (fp Path) Equals(fp2 Path) bool {
+	return !fp.Less(fp2) && !fp2.Less(fp)
+}
+
+// Less provides a lexical order for Paths.
+func (fp Path) Less(rhs Path) bool {
+	i := 0
+	for {
+		if i >= len(fp) && i >= len(rhs) {
+			// Paths are the same length and all items are equal.
+			return false
+		}
+		if i >= len(fp) {
+			// LHS is shorter.
+			return true
+		}
+		if i >= len(rhs) {
+			// RHS is shorter.
+			return false
+		}
+		if fp[i].Less(rhs[i]) {
+			// LHS is less; return
+			return true
+		}
+		if rhs[i].Less(fp[i]) {
+			// RHS is less; return
+			return false
+		}
+		// The items are equal; continue.
+		i++
+	}
+}
+
 func (fp Path) Copy() Path {
 	new := make(Path, len(fp))
 	copy(new, fp)
@@ -54,8 +88,8 @@ func MakePath(parts ...interface{}) (Path, error) {
 			fp = append(fp, PathElement{Index: &t})
 		case string:
 			fp = append(fp, PathElement{FieldName: &t})
-		case []value.Field:
-			if len(t) == 0 {
+		case *value.FieldList:
+			if len(*t) == 0 {
 				return nil, fmt.Errorf("associative list key type path elements must have at least one key (got zero)")
 			}
 			fp = append(fp, PathElement{Key: t})

vendor/sigs.k8s.io/structured-merge-diff/fieldpath/pathelementmap.go

@@ -0,0 +1,85 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fieldpath
+
+import (
+	"sort"
+
+	"sigs.k8s.io/structured-merge-diff/value"
+)
+
+// PathElementValueMap is a map from PathElement to value.Value.
+//
+// TODO(apelisse): We have multiple very similar implementation of this
+// for PathElementSet and SetNodeMap, so we could probably share the
+// code.
+type PathElementValueMap struct {
+	members sortedPathElementValues
+}
+
+func MakePathElementValueMap(size int) PathElementValueMap {
+	return PathElementValueMap{
+		members: make(sortedPathElementValues, 0, size),
+	}
+}
+
+type pathElementValue struct {
+	PathElement PathElement
+	Value       value.Value
+}
+
+type sortedPathElementValues []pathElementValue
+
+// Implement the sort interface; this would permit bulk creation, which would
+// be faster than doing it one at a time via Insert.
+func (spev sortedPathElementValues) Len() int { return len(spev) }
+func (spev sortedPathElementValues) Less(i, j int) bool {
+	return spev[i].PathElement.Less(spev[j].PathElement)
+}
+func (spev sortedPathElementValues) Swap(i, j int) { spev[i], spev[j] = spev[j], spev[i] }
+
+// Insert adds the pathelement and associated value in the map.
+func (s *PathElementValueMap) Insert(pe PathElement, v value.Value) {
+	loc := sort.Search(len(s.members), func(i int) bool {
+		return !s.members[i].PathElement.Less(pe)
+	})
+	if loc == len(s.members) {
+		s.members = append(s.members, pathElementValue{pe, v})
+		return
+	}
+	if s.members[loc].PathElement.Equals(pe) {
+		return
+	}
+	s.members = append(s.members, pathElementValue{})
+	copy(s.members[loc+1:], s.members[loc:])
+	s.members[loc] = pathElementValue{pe, v}
+}
+
+// Get retrieves the value associated with the given PathElement from the map.
+// (nil, false) is returned if there is no such PathElement.
+func (s *PathElementValueMap) Get(pe PathElement) (value.Value, bool) {
+	loc := sort.Search(len(s.members), func(i int) bool {
+		return !s.members[i].PathElement.Less(pe)
+	})
+	if loc == len(s.members) {
+		return value.Value{}, false
+	}
+	if s.members[loc].PathElement.Equals(pe) {
+		return s.members[loc].Value, true
+	}
+	return value.Value{}, false
+}

vendor/sigs.k8s.io/structured-merge-diff/fieldpath/serialize-pe.go

@@ -0,0 +1,166 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fieldpath
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+
+	jsoniter "github.com/json-iterator/go"
+	"sigs.k8s.io/structured-merge-diff/value"
+)
+
+var ErrUnknownPathElementType = errors.New("unknown path element type")
+
+const (
+	// Field indicates that the content of this path element is a field's name
+	peField = "f"
+
+	// Value indicates that the content of this path element is a field's value
+	peValue = "v"
+
+	// Index indicates that the content of this path element is an index in an array
+	peIndex = "i"
+
+	// Key indicates that the content of this path element is a key value map
+	peKey = "k"
+
+	// Separator separates the type of a path element from the contents
+	peSeparator = ":"
+)
+
+var (
+	peFieldSepBytes = []byte(peField + peSeparator)
+	peValueSepBytes = []byte(peValue + peSeparator)
+	peIndexSepBytes = []byte(peIndex + peSeparator)
+	peKeySepBytes   = []byte(peKey + peSeparator)
+	peSepBytes      = []byte(peSeparator)
+)
+
+// DeserializePathElement parses a serialized path element
+func DeserializePathElement(s string) (PathElement, error) {
+	b := []byte(s)
+	if len(b) < 2 {
+		return PathElement{}, errors.New("key must be 2 characters long:")
+	}
+	typeSep, b := b[:2], b[2:]
+	if typeSep[1] != peSepBytes[0] {
+		return PathElement{}, fmt.Errorf("missing colon: %v", s)
+	}
+	switch typeSep[0] {
+	case peFieldSepBytes[0]:
+		// Slice s rather than convert b, to save on
+		// allocations.
+		str := s[2:]
+		return PathElement{
+			FieldName: &str,
+		}, nil
+	case peValueSepBytes[0]:
+		iter := readPool.BorrowIterator(b)
+		defer readPool.ReturnIterator(iter)
+		v, err := value.ReadJSONIter(iter)
+		if err != nil {
+			return PathElement{}, err
+		}
+		return PathElement{Value: &v}, nil
+	case peKeySepBytes[0]:
+		iter := readPool.BorrowIterator(b)
+		defer readPool.ReturnIterator(iter)
+		fields := value.FieldList{}
+		iter.ReadObjectCB(func(iter *jsoniter.Iterator, key string) bool {
+			v, err := value.ReadJSONIter(iter)
+			if err != nil {
+				iter.Error = err
+				return false
+			}
+			fields = append(fields, value.Field{Name: key, Value: v})
+			return true
+		})
+		fields.Sort()
+		return PathElement{Key: &fields}, iter.Error
+	case peIndexSepBytes[0]:
+		i, err := strconv.Atoi(s[2:])
+		if err != nil {
+			return PathElement{}, err
+		}
+		return PathElement{
+			Index: &i,
+		}, nil
+	default:
+		return PathElement{}, ErrUnknownPathElementType
+	}
+}
+
+var (
+	readPool  = jsoniter.NewIterator(jsoniter.ConfigCompatibleWithStandardLibrary).Pool()
+	writePool = jsoniter.NewStream(jsoniter.ConfigCompatibleWithStandardLibrary, nil, 1024).Pool()
+)
+
+// SerializePathElement serializes a path element
+func SerializePathElement(pe PathElement) (string, error) {
+	buf := strings.Builder{}
+	err := serializePathElementToWriter(&buf, pe)
+	return buf.String(), err
+}
+
+func serializePathElementToWriter(w io.Writer, pe PathElement) error {
+	stream := writePool.BorrowStream(w)
+	defer writePool.ReturnStream(stream)
+	switch {
+	case pe.FieldName != nil:
+		if _, err := stream.Write(peFieldSepBytes); err != nil {
+			return err
+		}
+		stream.WriteRaw(*pe.FieldName)
+	case pe.Key != nil:
+		if _, err := stream.Write(peKeySepBytes); err != nil {
+			return err
+		}
+		stream.WriteObjectStart()
+		for i, field := range *pe.Key {
+			if i > 0 {
+				stream.WriteMore()
+			}
+			stream.WriteObjectField(field.Name)
+			field.Value.WriteJSONStream(stream)
+		}
+		stream.WriteObjectEnd()
+	case pe.Value != nil:
+		if _, err := stream.Write(peValueSepBytes); err != nil {
+			return err
+		}
+		pe.Value.WriteJSONStream(stream)
+	case pe.Index != nil:
+		if _, err := stream.Write(peIndexSepBytes); err != nil {
+			return err
+		}
+		stream.WriteInt(*pe.Index)
+	default:
+		return errors.New("invalid PathElement")
+	}
+	b := stream.Buffer()
+	err := stream.Flush()
+	// Help jsoniter manage its buffers--without this, the next
+	// use of the stream is likely to require an allocation. Look
+	// at the jsoniter stream code to understand why. They were probably
+	// optimizing for folks using the buffer directly.
+	stream.SetBuffer(b[:0])
+	return err
+}

vendor/sigs.k8s.io/structured-merge-diff/fieldpath/serialize.go

@@ -0,0 +1,237 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fieldpath
+
+import (
+	"bytes"
+	"io"
+	"unsafe"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+func (s *Set) ToJSON() ([]byte, error) {
+	buf := bytes.Buffer{}
+	err := s.ToJSONStream(&buf)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (s *Set) ToJSONStream(w io.Writer) error {
+	stream := writePool.BorrowStream(w)
+	defer writePool.ReturnStream(stream)
+
+	var r reusableBuilder
+
+	stream.WriteObjectStart()
+	err := s.emitContents_v1(false, stream, &r)
+	if err != nil {
+		return err
+	}
+	stream.WriteObjectEnd()
+	return stream.Flush()
+}
+
+func manageMemory(stream *jsoniter.Stream) error {
+	// Help jsoniter manage its buffers--without this, it does a bunch of
+	// alloctaions that are not necessary. They were probably optimizing
+	// for folks using the buffer directly.
+	b := stream.Buffer()
+	if len(b) > 4096 || cap(b)-len(b) < 2048 {
+		if err := stream.Flush(); err != nil {
+			return err
+		}
+		stream.SetBuffer(b[:0])
+	}
+	return nil
+}
+
+type reusableBuilder struct {
+	bytes.Buffer
+}
+
+func (r *reusableBuilder) unsafeString() string {
+	b := r.Bytes()
+	return *(*string)(unsafe.Pointer(&b))
+}
+
+func (r *reusableBuilder) reset() *bytes.Buffer {
+	r.Reset()
+	return &r.Buffer
+}
+
+func (s *Set) emitContents_v1(includeSelf bool, stream *jsoniter.Stream, r *reusableBuilder) error {
+	mi, ci := 0, 0
+	first := true
+	preWrite := func() {
+		if first {
+			first = false
+			return
+		}
+		stream.WriteMore()
+	}
+
+	for mi < len(s.Members.members) && ci < len(s.Children.members) {
+		mpe := s.Members.members[mi]
+		cpe := s.Children.members[ci].pathElement
+
+		if mpe.Less(cpe) {
+			preWrite()
+			if err := serializePathElementToWriter(r.reset(), mpe); err != nil {
+				return err
+			}
+			stream.WriteObjectField(r.unsafeString())
+			stream.WriteEmptyObject()
+			mi++
+		} else if cpe.Less(mpe) {
+			preWrite()
+			if err := serializePathElementToWriter(r.reset(), cpe); err != nil {
+				return err
+			}
+			stream.WriteObjectField(r.unsafeString())
+			stream.WriteObjectStart()
+			if err := s.Children.members[ci].set.emitContents_v1(false, stream, r); err != nil {
+				return err
+			}
+			stream.WriteObjectEnd()
+			ci++
+		} else {
+			preWrite()
+			if err := serializePathElementToWriter(r.reset(), cpe); err != nil {
+				return err
+			}
+			stream.WriteObjectField(r.unsafeString())
+			stream.WriteObjectStart()
+			if err := s.Children.members[ci].set.emitContents_v1(true, stream, r); err != nil {
+				return err
+			}
+			stream.WriteObjectEnd()
+			mi++
+			ci++
+		}
+	}
+
+	for mi < len(s.Members.members) {
+		mpe := s.Members.members[mi]
+
+		preWrite()
+		if err := serializePathElementToWriter(r.reset(), mpe); err != nil {
+			return err
+		}
+		stream.WriteObjectField(r.unsafeString())
+		stream.WriteEmptyObject()
+		mi++
+	}
+
+	for ci < len(s.Children.members) {
+		cpe := s.Children.members[ci].pathElement
+
+		preWrite()
+		if err := serializePathElementToWriter(r.reset(), cpe); err != nil {
+			return err
+		}
+		stream.WriteObjectField(r.unsafeString())
+		stream.WriteObjectStart()
+		if err := s.Children.members[ci].set.emitContents_v1(false, stream, r); err != nil {
+			return err
+		}
+		stream.WriteObjectEnd()
+		ci++
+	}
+
+	if includeSelf && !first {
+		preWrite()
+		stream.WriteObjectField(".")
+		stream.WriteEmptyObject()
+	}
+	return manageMemory(stream)
+}
+
+// FromJSON clears s and reads a JSON formatted set structure.
+func (s *Set) FromJSON(r io.Reader) error {
+	// The iterator pool is completely useless for memory management, grrr.
+	iter := jsoniter.Parse(jsoniter.ConfigCompatibleWithStandardLibrary, r, 4096)
+
+	found, _ := readIter_v1(iter)
+	if found == nil {
+		*s = Set{}
+	} else {
+		*s = *found
+	}
+	return iter.Error
+}
+
+// returns true if this subtree is also (or only) a member of parent; s is nil
+// if there are no further children.
+func readIter_v1(iter *jsoniter.Iterator) (children *Set, isMember bool) {
+	iter.ReadMapCB(func(iter *jsoniter.Iterator, key string) bool {
+		if key == "." {
+			isMember = true
+			iter.Skip()
+			return true
+		}
+		pe, err := DeserializePathElement(key)
+		if err == ErrUnknownPathElementType {
+			// Ignore these-- a future version maybe knows what
+			// they are. We drop these completely rather than try
+			// to preserve things we don't understand.
+			iter.Skip()
+			return true
+		} else if err != nil {
+			iter.ReportError("parsing key as path element", err.Error())
+			iter.Skip()
+			return true
+		}
+		grandchildren, childIsMember := readIter_v1(iter)
+		if childIsMember {
+			if children == nil {
+				children = &Set{}
+			}
+			m := &children.Members.members
+			// Since we expect that most of the time these will have been
+			// serialized in the right order, we just verify that and append.
+			appendOK := len(*m) == 0 || (*m)[len(*m)-1].Less(pe)
+			if appendOK {
+				*m = append(*m, pe)
+			} else {
+				children.Members.Insert(pe)
+			}
+		}
+		if grandchildren != nil {
+			if children == nil {
+				children = &Set{}
+			}
+			// Since we expect that most of the time these will have been
+			// serialized in the right order, we just verify that and append.
+			m := &children.Children.members
+			appendOK := len(*m) == 0 || (*m)[len(*m)-1].pathElement.Less(pe)
+			if appendOK {
+				*m = append(*m, setNode{pe, grandchildren})
+			} else {
+				*children.Children.Descend(pe) = *grandchildren
+			}
+		}
+		return true
+	})
+	if children == nil {
+		isMember = true
+	}
+
+	return children, isMember
+}

vendor/sigs.k8s.io/structured-merge-diff/fieldpath/set.go

@@ -17,6 +17,7 @@ limitations under the License.
 package fieldpath
 
 import (
+	"sort"
 	"strings"
 )
 
@@ -172,24 +173,33 @@ type setNode struct {
 
 // SetNodeMap is a map of PathElement to subset.
 type SetNodeMap struct {
-	members map[string]setNode
+	members sortedSetNode
 }
 
+type sortedSetNode []setNode
+
+// Implement the sort interface; this would permit bulk creation, which would
+// be faster than doing it one at a time via Insert.
+func (s sortedSetNode) Len() int           { return len(s) }
+func (s sortedSetNode) Less(i, j int) bool { return s[i].pathElement.Less(s[j].pathElement) }
+func (s sortedSetNode) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
 // Descend adds pe to the set if necessary, returning the associated subset.
 func (s *SetNodeMap) Descend(pe PathElement) *Set {
-	serialized := pe.String()
-	if s.members == nil {
-		s.members = map[string]setNode{}
+	loc := sort.Search(len(s.members), func(i int) bool {
+		return !s.members[i].pathElement.Less(pe)
+	})
+	if loc == len(s.members) {
+		s.members = append(s.members, setNode{pathElement: pe, set: &Set{}})
+		return s.members[loc].set
 	}
-	if n, ok := s.members[serialized]; ok {
-		return n.set
+	if s.members[loc].pathElement.Equals(pe) {
+		return s.members[loc].set
 	}
-	ss := &Set{}
-	s.members[serialized] = setNode{
-		pathElement: pe,
-		set:         ss,
-	}
-	return ss
+	s.members = append(s.members, setNode{})
+	copy(s.members[loc+1:], s.members[loc:])
+	s.members[loc] = setNode{pathElement: pe, set: &Set{}}
+	return s.members[loc].set
 }
 
 // Size returns the sum of the number of members of all subsets.
@@ -213,12 +223,14 @@ func (s *SetNodeMap) Empty() bool {
 
 // Get returns (the associated set, true) or (nil, false) if there is none.
 func (s *SetNodeMap) Get(pe PathElement) (*Set, bool) {
-	if s.members == nil {
+	loc := sort.Search(len(s.members), func(i int) bool {
+		return !s.members[i].pathElement.Less(pe)
+	})
+	if loc == len(s.members) {
 		return nil, false
 	}
-	serialized := pe.String()
-	if n, ok := s.members[serialized]; ok {
-		return n.set, true
+	if s.members[loc].pathElement.Equals(pe) {
+		return s.members[loc].set, true
 	}
 	return nil, false
 }
@@ -229,12 +241,11 @@ func (s *SetNodeMap) Equals(s2 *SetNodeMap) bool {
 	if len(s.members) != len(s2.members) {
 		return false
 	}
-	for k, v := range s.members {
-		v2, ok := s2.members[k]
-		if !ok {
+	for i := range s.members {
+		if !s.members[i].pathElement.Equals(s2.members[i].pathElement) {
 			return false
 		}
-		if !v.set.Equals(v2.set) {
+		if !s.members[i].set.Equals(s2.members[i].set) {
 			return false
 		}
 	}
@@ -244,21 +255,28 @@ func (s *SetNodeMap) Equals(s2 *SetNodeMap) bool {
 // Union returns a SetNodeMap with members that appear in either s or s2.
 func (s *SetNodeMap) Union(s2 *SetNodeMap) *SetNodeMap {
 	out := &SetNodeMap{}
-	for k, sn := range s.members {
-		pe := sn.pathElement
-		if sn2, ok := s2.members[k]; ok {
-			*out.Descend(pe) = *sn.set.Union(sn2.set)
+
+	i, j := 0, 0
+	for i < len(s.members) && j < len(s2.members) {
+		if s.members[i].pathElement.Less(s2.members[j].pathElement) {
+			out.members = append(out.members, s.members[i])
+			i++
 		} else {
-			*out.Descend(pe) = *sn.set
+			if !s2.members[j].pathElement.Less(s.members[i].pathElement) {
+				out.members = append(out.members, setNode{pathElement: s.members[i].pathElement, set: s.members[i].set.Union(s2.members[j].set)})
+				i++
+			} else {
+				out.members = append(out.members, s2.members[j])
+			}
+			j++
 		}
 	}
-	for k, sn2 := range s2.members {
-		pe := sn2.pathElement
-		if _, ok := s.members[k]; ok {
-			// already handled
-			continue
-		}
-		*out.Descend(pe) = *sn2.set
+
+	if i < len(s.members) {
+		out.members = append(out.members, s.members[i:]...)
+	}
+	if j < len(s2.members) {
+		out.members = append(out.members, s2.members[j:]...)
 	}
 	return out
 }
@@ -266,13 +284,20 @@ func (s *SetNodeMap) Union(s2 *SetNodeMap) *SetNodeMap {
 // Intersection returns a SetNodeMap with members that appear in both s and s2.
 func (s *SetNodeMap) Intersection(s2 *SetNodeMap) *SetNodeMap {
 	out := &SetNodeMap{}
-	for k, sn := range s.members {
-		pe := sn.pathElement
-		if sn2, ok := s2.members[k]; ok {
-			i := *sn.set.Intersection(sn2.set)
-			if !i.Empty() {
-				*out.Descend(pe) = i
+
+	i, j := 0, 0
+	for i < len(s.members) && j < len(s2.members) {
+		if s.members[i].pathElement.Less(s2.members[j].pathElement) {
+			i++
+		} else {
+			if !s2.members[j].pathElement.Less(s.members[i].pathElement) {
+				res := s.members[i].set.Intersection(s2.members[j].set)
+				if !res.Empty() {
+					out.members = append(out.members, setNode{pathElement: s.members[i].pathElement, set: res})
+				}
+				i++
 			}
+			j++
 		}
 	}
 	return out
@@ -281,18 +306,30 @@ func (s *SetNodeMap) Intersection(s2 *SetNodeMap) *SetNodeMap {
 // Difference returns a SetNodeMap with members that appear in s but not in s2.
 func (s *SetNodeMap) Difference(s2 *Set) *SetNodeMap {
 	out := &SetNodeMap{}
-	for k, sn := range s.members {
-		pe := sn.pathElement
-		if sn2, ok := s2.Children.members[k]; ok {
-			diff := *sn.set.Difference(sn2.set)
-			// We aren't permitted to add nodes with no elements.
-			if !diff.Empty() {
-				*out.Descend(pe) = diff
-			}
+
+	i, j := 0, 0
+	for i < len(s.members) && j < len(s2.Children.members) {
+		if s.members[i].pathElement.Less(s2.Children.members[j].pathElement) {
+			out.members = append(out.members, setNode{pathElement: s.members[i].pathElement, set: s.members[i].set})
+			i++
 		} else {
-			*out.Descend(pe) = *sn.set
+			if !s2.Children.members[j].pathElement.Less(s.members[i].pathElement) {
+
+				diff := s.members[i].set.Difference(s2.Children.members[j].set)
+				// We aren't permitted to add nodes with no elements.
+				if !diff.Empty() {
+					out.members = append(out.members, setNode{pathElement: s.members[i].pathElement, set: diff})
+				}
+
+				i++
+			}
+			j++
 		}
 	}
+
+	if i < len(s.members) {
+		out.members = append(out.members, s.members[i:]...)
+	}
 	return out
 }
 

vendor/sigs.k8s.io/structured-merge-diff/merge/conflict.go

@@ -40,6 +40,14 @@ func (c Conflict) Error() string {
 	return fmt.Sprintf("conflict with %q: %v", c.Manager, c.Path)
 }
 
+// Equals returns true if c == c2
+func (c Conflict) Equals(c2 Conflict) bool {
+	if c.Manager != c2.Manager {
+		return false
+	}
+	return c.Path.Equals(c2.Path)
+}
+
 // Conflicts accumulates multiple conflicts and aggregates them by managers.
 type Conflicts []Conflict
 
@@ -74,12 +82,25 @@ func (conflicts Conflicts) Error() string {
 	return strings.Join(messages, "\n")
 }
 
+// Equals returns true if the lists of conflicts are the same.
+func (c Conflicts) Equals(c2 Conflicts) bool {
+	if len(c) != len(c2) {
+		return false
+	}
+	for i := range c {
+		if !c[i].Equals(c2[i]) {
+			return false
+		}
+	}
+	return true
+}
+
 // ConflictsFromManagers creates a list of conflicts given Managers sets.
 func ConflictsFromManagers(sets fieldpath.ManagedFields) Conflicts {
 	conflicts := []Conflict{}
 
 	for manager, set := range sets {
-		set.Iterate(func(p fieldpath.Path) {
+		set.Set().Iterate(func(p fieldpath.Path) {
 			conflicts = append(conflicts, Conflict{
 				Manager: manager,
 				Path:    p,

vendor/sigs.k8s.io/structured-merge-diff/merge/update.go

@@ -23,7 +23,7 @@ import (
 // Converter is an interface to the conversion logic. The converter
 // needs to be able to convert objects from one version to another.
 type Converter interface {
-	Convert(object typed.TypedValue, version fieldpath.APIVersion) (typed.TypedValue, error)
+	Convert(object *typed.TypedValue, version fieldpath.APIVersion) (*typed.TypedValue, error)
 	IsMissingVersionError(error) bool
 }
 
@@ -31,87 +31,87 @@ type Converter interface {
 // merge the object on Apply.
 type Updater struct {
 	Converter Converter
+
+	enableUnions bool
 }
 
-func (s *Updater) update(oldObject, newObject typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, workflow string, force bool) (fieldpath.ManagedFields, error) {
+// EnableUnionFeature turns on union handling. It is disabled by default until the
+// feature is complete.
+func (s *Updater) EnableUnionFeature() {
+	s.enableUnions = true
+}
+
+func (s *Updater) update(oldObject, newObject *typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, workflow string, force bool) (fieldpath.ManagedFields, *typed.Comparison, error) {
 	conflicts := fieldpath.ManagedFields{}
 	removed := fieldpath.ManagedFields{}
-	type Versioned struct {
-		oldObject typed.TypedValue
-		newObject typed.TypedValue
+	compare, err := oldObject.Compare(newObject)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to compare objects: %v", err)
 	}
-	versions := map[fieldpath.APIVersion]Versioned{
-		version: Versioned{
-			oldObject: oldObject,
-			newObject: newObject,
-		},
+
+	versions := map[fieldpath.APIVersion]*typed.Comparison{
+		version: compare,
 	}
 
 	for manager, managerSet := range managers {
 		if manager == workflow {
 			continue
 		}
-		versioned, ok := versions[managerSet.APIVersion]
+		compare, ok := versions[managerSet.APIVersion()]
 		if !ok {
 			var err error
-			versioned.oldObject, err = s.Converter.Convert(oldObject, managerSet.APIVersion)
+			versionedOldObject, err := s.Converter.Convert(oldObject, managerSet.APIVersion())
 			if err != nil {
 				if s.Converter.IsMissingVersionError(err) {
 					delete(managers, manager)
 					continue
 				}
-				return nil, fmt.Errorf("failed to convert old object: %v", err)
+				return nil, nil, fmt.Errorf("failed to convert old object: %v", err)
 			}
-			versioned.newObject, err = s.Converter.Convert(newObject, managerSet.APIVersion)
+			versionedNewObject, err := s.Converter.Convert(newObject, managerSet.APIVersion())
 			if err != nil {
 				if s.Converter.IsMissingVersionError(err) {
 					delete(managers, manager)
 					continue
 				}
-				return nil, fmt.Errorf("failed to convert new object: %v", err)
+				return nil, nil, fmt.Errorf("failed to convert new object: %v", err)
 			}
-			versions[managerSet.APIVersion] = versioned
-		}
-		compare, err := versioned.oldObject.Compare(versioned.newObject)
-		if err != nil {
-			return nil, fmt.Errorf("failed to compare objects: %v", err)
+			compare, err = versionedOldObject.Compare(versionedNewObject)
+			if err != nil {
+				return nil, nil, fmt.Errorf("failed to compare objects: %v", err)
+			}
+			versions[managerSet.APIVersion()] = compare
 		}
 
-		conflictSet := managerSet.Intersection(compare.Modified.Union(compare.Added))
+		conflictSet := managerSet.Set().Intersection(compare.Modified.Union(compare.Added))
 		if !conflictSet.Empty() {
-			conflicts[manager] = &fieldpath.VersionedSet{
-				Set:        conflictSet,
-				APIVersion: managerSet.APIVersion,
-			}
+			conflicts[manager] = fieldpath.NewVersionedSet(conflictSet, managerSet.APIVersion(), false)
 		}
 
 		if !compare.Removed.Empty() {
-			removed[manager] = &fieldpath.VersionedSet{
-				Set:        compare.Removed,
-				APIVersion: managerSet.APIVersion,
-			}
+			removed[manager] = fieldpath.NewVersionedSet(compare.Removed, managerSet.APIVersion(), false)
 		}
 	}
 
 	if !force && len(conflicts) != 0 {
-		return nil, ConflictsFromManagers(conflicts)
+		return nil, nil, ConflictsFromManagers(conflicts)
 	}
 
 	for manager, conflictSet := range conflicts {
-		managers[manager].Set = managers[manager].Set.Difference(conflictSet.Set)
+		managers[manager] = fieldpath.NewVersionedSet(managers[manager].Set().Difference(conflictSet.Set()), managers[manager].APIVersion(), managers[manager].Applied())
 	}
 
 	for manager, removedSet := range removed {
-		managers[manager].Set = managers[manager].Set.Difference(removedSet.Set)
+		managers[manager] = fieldpath.NewVersionedSet(managers[manager].Set().Difference(removedSet.Set()), managers[manager].APIVersion(), managers[manager].Applied())
 	}
 
 	for manager := range managers {
-		if managers[manager].Set.Empty() {
+		if managers[manager].Set().Empty() {
 			delete(managers, manager)
 		}
 	}
 
-	return managers, nil
+	return managers, compare, nil
 }
 
 // Update is the method you should call once you've merged your final
@@ -119,54 +119,66 @@ func (s *Updater) update(oldObject, newObject typed.TypedValue, version fieldpat
 // that you intend to persist (after applying the patch if this is for a
 // PATCH call), and liveObject must be the original object (empty if
 // this is a CREATE call).
-func (s *Updater) Update(liveObject, newObject typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, manager string) (fieldpath.ManagedFields, error) {
+func (s *Updater) Update(liveObject, newObject *typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, manager string) (*typed.TypedValue, fieldpath.ManagedFields, error) {
 	var err error
-	managers = shallowCopyManagers(managers)
-	managers, err = s.update(liveObject, newObject, version, managers, manager, true)
-	if err != nil {
-		return fieldpath.ManagedFields{}, err
-	}
-	compare, err := liveObject.Compare(newObject)
-	if err != nil {
-		return fieldpath.ManagedFields{}, fmt.Errorf("failed to compare live and new objects: %v", err)
-	}
-	if _, ok := managers[manager]; !ok {
-		managers[manager] = &fieldpath.VersionedSet{
-			Set: fieldpath.NewSet(),
+	if s.enableUnions {
+		newObject, err = liveObject.NormalizeUnions(newObject)
+		if err != nil {
+			return nil, fieldpath.ManagedFields{}, err
 		}
 	}
-	managers[manager].Set = managers[manager].Set.Union(compare.Modified).Union(compare.Added).Difference(compare.Removed)
-	managers[manager].APIVersion = version
-	if managers[manager].Set.Empty() {
+	managers = shallowCopyManagers(managers)
+	managers, compare, err := s.update(liveObject, newObject, version, managers, manager, true)
+	if err != nil {
+		return nil, fieldpath.ManagedFields{}, err
+	}
+	if _, ok := managers[manager]; !ok {
+		managers[manager] = fieldpath.NewVersionedSet(fieldpath.NewSet(), version, false)
+	}
+	managers[manager] = fieldpath.NewVersionedSet(
+		managers[manager].Set().Union(compare.Modified).Union(compare.Added).Difference(compare.Removed),
+		version,
+		false,
+	)
+	if managers[manager].Set().Empty() {
 		delete(managers, manager)
 	}
-	return managers, nil
+	return newObject, managers, nil
 }
 
 // Apply should be called when Apply is run, given the current object as
 // well as the configuration that is applied. This will merge the object
 // and return it.
-func (s *Updater) Apply(liveObject, configObject typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, manager string, force bool) (typed.TypedValue, fieldpath.ManagedFields, error) {
+func (s *Updater) Apply(liveObject, configObject *typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, manager string, force bool) (*typed.TypedValue, fieldpath.ManagedFields, error) {
 	managers = shallowCopyManagers(managers)
+	var err error
+	if s.enableUnions {
+		configObject, err = configObject.NormalizeUnionsApply(configObject)
+		if err != nil {
+			return nil, fieldpath.ManagedFields{}, err
+		}
+	}
 	newObject, err := liveObject.Merge(configObject)
 	if err != nil {
 		return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to merge config: %v", err)
 	}
+	if s.enableUnions {
+		newObject, err = configObject.NormalizeUnionsApply(newObject)
+		if err != nil {
+			return nil, fieldpath.ManagedFields{}, err
+		}
+	}
 	lastSet := managers[manager]
 	set, err := configObject.ToFieldSet()
 	if err != nil {
 		return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to get field set: %v", err)
 	}
-	managers[manager] = &fieldpath.VersionedSet{
-		Set:        set,
-		APIVersion: version,
-		Applied:    true,
-	}
+	managers[manager] = fieldpath.NewVersionedSet(set, version, true)
 	newObject, err = s.prune(newObject, managers, manager, lastSet)
 	if err != nil {
 		return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to prune fields: %v", err)
 	}
-	managers, err = s.update(liveObject, newObject, version, managers, manager, force)
+	managers, _, err = s.update(liveObject, newObject, version, managers, manager, force)
 	if err != nil {
 		return nil, fieldpath.ManagedFields{}, err
 	}
@@ -185,18 +197,18 @@ func shallowCopyManagers(managers fieldpath.ManagedFields) fieldpath.ManagedFiel
 // * applyingManager applied it last time
 // * applyingManager didn't apply it this time
 // * no other applier claims to manage it
-func (s *Updater) prune(merged typed.TypedValue, managers fieldpath.ManagedFields, applyingManager string, lastSet *fieldpath.VersionedSet) (typed.TypedValue, error) {
-	if lastSet == nil || lastSet.Set.Empty() {
+func (s *Updater) prune(merged *typed.TypedValue, managers fieldpath.ManagedFields, applyingManager string, lastSet fieldpath.VersionedSet) (*typed.TypedValue, error) {
+	if lastSet == nil || lastSet.Set().Empty() {
 		return merged, nil
 	}
-	convertedMerged, err := s.Converter.Convert(merged, lastSet.APIVersion)
+	convertedMerged, err := s.Converter.Convert(merged, lastSet.APIVersion())
 	if err != nil {
 		if s.Converter.IsMissingVersionError(err) {
 			return merged, nil
 		}
 		return nil, fmt.Errorf("failed to convert merged object to last applied version: %v", err)
 	}
-	pruned := convertedMerged.RemoveItems(lastSet.Set)
+	pruned := convertedMerged.RemoveItems(lastSet.Set())
 	pruned, err = s.addBackOwnedItems(convertedMerged, pruned, managers, applyingManager)
 	if err != nil {
 		return nil, fmt.Errorf("failed add back owned items: %v", err)
@@ -205,20 +217,20 @@ func (s *Updater) prune(merged typed.TypedValue, managers fieldpath.ManagedField
 	if err != nil {
 		return nil, fmt.Errorf("failed add back dangling items: %v", err)
 	}
-	return s.Converter.Convert(pruned, managers[applyingManager].APIVersion)
+	return s.Converter.Convert(pruned, managers[applyingManager].APIVersion())
 }
 
 // addBackOwnedItems adds back any list and map items that were removed by prune,
 // but other appliers (or the current applier's new config) claim to own.
-func (s *Updater) addBackOwnedItems(merged, pruned typed.TypedValue, managedFields fieldpath.ManagedFields, applyingManager string) (typed.TypedValue, error) {
+func (s *Updater) addBackOwnedItems(merged, pruned *typed.TypedValue, managedFields fieldpath.ManagedFields, applyingManager string) (*typed.TypedValue, error) {
 	var err error
 	managedAtVersion := map[fieldpath.APIVersion]*fieldpath.Set{}
 	for _, managerSet := range managedFields {
-		if managerSet.Applied {
-			if _, ok := managedAtVersion[managerSet.APIVersion]; !ok {
-				managedAtVersion[managerSet.APIVersion] = fieldpath.NewSet()
+		if managerSet.Applied() {
+			if _, ok := managedAtVersion[managerSet.APIVersion()]; !ok {
+				managedAtVersion[managerSet.APIVersion()] = fieldpath.NewSet()
 			}
-			managedAtVersion[managerSet.APIVersion] = managedAtVersion[managerSet.APIVersion].Union(managerSet.Set)
+			managedAtVersion[managerSet.APIVersion()] = managedAtVersion[managerSet.APIVersion()].Union(managerSet.Set())
 		}
 	}
 	for version, managed := range managedAtVersion {
@@ -249,12 +261,11 @@ func (s *Updater) addBackOwnedItems(merged, pruned typed.TypedValue, managedFiel
 	return pruned, nil
 }
 
-
 // addBackDanglingItems makes sure that the only items removed by prune are items that were
 // previously owned by the currently applying manager. This will add back unowned items and items
 // which are owned by Updaters that shouldn't be removed.
-func (s *Updater) addBackDanglingItems(merged, pruned typed.TypedValue, lastSet *fieldpath.VersionedSet) (typed.TypedValue, error) {
-	convertedPruned, err := s.Converter.Convert(pruned, lastSet.APIVersion)
+func (s *Updater) addBackDanglingItems(merged, pruned *typed.TypedValue, lastSet fieldpath.VersionedSet) (*typed.TypedValue, error) {
+	convertedPruned, err := s.Converter.Convert(pruned, lastSet.APIVersion())
 	if err != nil {
 		if s.Converter.IsMissingVersionError(err) {
 			return merged, nil
@@ -269,5 +280,5 @@ func (s *Updater) addBackDanglingItems(merged, pruned typed.TypedValue, lastSet
 	if err != nil {
 		return nil, fmt.Errorf("failed to create field set from merged object in last applied version: %v", err)
 	}
-	return merged.RemoveItems(mergedSet.Difference(prunedSet).Intersection(lastSet.Set)), nil
+	return merged.RemoveItems(mergedSet.Difference(prunedSet).Intersection(lastSet.Set())), nil
 }

vendor/sigs.k8s.io/structured-merge-diff/schema/elements.go

@@ -16,9 +16,17 @@ limitations under the License.
 
 package schema
 
+import "sync"
+
 // Schema is a list of named types.
+//
+// Schema types are indexed in a map before the first search so this type
+// should be considered immutable.
 type Schema struct {
 	Types []TypeDef `yaml:"types,omitempty"`
+
+	once sync.Once
+	m    map[string]TypeDef
 }
 
 // A TypeSpecifier references a particular type in a schema.
@@ -43,13 +51,12 @@ type TypeRef struct {
 }
 
 // Atom represents the smallest possible pieces of the type system.
+// Each set field in the Atom represents a possible type for the object.
+// If none of the fields are set, any object will fail validation against the atom.
 type Atom struct {
-	// Exactly one of the below must be set.
-	*Scalar  `yaml:"scalar,omitempty"`
-	*Struct  `yaml:"struct,omitempty"`
-	*List    `yaml:"list,omitempty"`
-	*Map     `yaml:"map,omitempty"`
-	*Untyped `yaml:"untyped,omitempty"`
+	*Scalar `yaml:"scalar,omitempty"`
+	*List   `yaml:"list,omitempty"`
+	*Map    `yaml:"map,omitempty"`
 }
 
 // Scalar (AKA "primitive") represents a type which has a single value which is
@@ -65,45 +72,122 @@ const (
 )
 
 // ElementRelationship is an enum of the different possible relationships
-// between the elements of container types (maps, lists, structs, untyped).
+// between the elements of container types (maps, lists).
 type ElementRelationship string
 
 const (
 	// Associative only applies to lists (see the documentation there).
 	Associative = ElementRelationship("associative")
-	// Atomic makes container types (lists, maps, structs, untyped) behave
-	// as scalars / leaf fields (which is the default for untyped data).
+	// Atomic makes container types (lists, maps) behave
+	// as scalars / leaf fields
 	Atomic = ElementRelationship("atomic")
 	// Separable means the items of the container type have no particular
-	// relationship (default behavior for maps and structs).
+	// relationship (default behavior for maps).
 	Separable = ElementRelationship("separable")
 )
 
-// Struct represents a type which is composed of a number of different fields.
+// Map is a key-value pair. Its default semantics are the same as an
+// associative list, but:
+// * It is serialized differently:
+//     map:  {"k": {"value": "v"}}
+//     list: [{"key": "k", "value": "v"}]
+// * Keys must be string typed.
+// * Keys can't have multiple components.
+//
+// Optionally, maps may be atomic (for example, imagine representing an RGB
+// color value--it doesn't make sense to have different actors own the R and G
+// values).
+//
+// Maps may also represent a type which is composed of a number of different fields.
 // Each field has a name and a type.
 //
-// TODO: in the future, we will add one-of groups (sometimes called unions).
-type Struct struct {
+// Fields are indexed in a map before the first search so this type
+// should be considered immutable.
+type Map struct {
 	// Each struct field appears exactly once in this list. The order in
 	// this list defines the canonical field ordering.
 	Fields []StructField `yaml:"fields,omitempty"`
 
-	// TODO: Implement unions, either this way or by inlining.
-	// Unions are groupings of fields with special rules. They may refer to
+	// A Union is a grouping of fields with special rules. It may refer to
 	// one or more fields in the above list. A given field from the above
 	// list may be referenced in exactly 0 or 1 places in the below list.
-	// Unions []Union `yaml:"unions,omitempty"`
+	// One can have multiple unions in the same struct, but the fields can't
+	// overlap between unions.
+	Unions []Union `yaml:"unions,omitempty"`
 
-	// ElementRelationship states the relationship between the struct's items.
+	// ElementType is the type of the structs's unknown fields.
+	ElementType TypeRef `yaml:"elementType,omitempty"`
+
+	// ElementRelationship states the relationship between the map's items.
 	// * `separable` (or unset) implies that each element is 100% independent.
 	// * `atomic` implies that all elements depend on each other, and this
 	//   is effectively a scalar / leaf field; it doesn't make sense for
 	//   separate actors to set the elements. Example: an RGB color struct;
 	//   it would never make sense to "own" only one component of the
 	//   color.
-	// The default behavior for structs is `separable`; it's permitted to
+	// The default behavior for maps is `separable`; it's permitted to
 	// leave this unset to get the default behavior.
 	ElementRelationship ElementRelationship `yaml:"elementRelationship,omitempty"`
+
+	once sync.Once
+	m    map[string]StructField
+}
+
+// FindField is a convenience function that returns the referenced StructField,
+// if it exists, or (nil, false) if it doesn't.
+func (m *Map) FindField(name string) (StructField, bool) {
+	m.once.Do(func() {
+		m.m = make(map[string]StructField, len(m.Fields))
+		for _, field := range m.Fields {
+			m.m[field.Name] = field
+		}
+	})
+	sf, ok := m.m[name]
+	return sf, ok
+}
+
+// UnionFields are mapping between the fields that are part of the union and
+// their discriminated value. The discriminated value has to be set, and
+// should not conflict with other discriminated value in the list.
+type UnionField struct {
+	// FieldName is the name of the field that is part of the union. This
+	// is the serialized form of the field.
+	FieldName string `yaml:"fieldName"`
+	// Discriminatorvalue is the value of the discriminator to
+	// select that field. If the union doesn't have a discriminator,
+	// this field is ignored.
+	DiscriminatorValue string `yaml:"discriminatorValue"`
+}
+
+// Union, or oneof, means that only one of multiple fields of a structure can be
+// set at a time. Setting the discriminator helps clearing oher fields:
+// - If discriminator changed to non-nil, and a new field has been added
+// that doesn't match, an error is returned,
+// - If discriminator hasn't changed and two fields or more are set, an
+// error is returned,
+// - If discriminator changed to non-nil, all other fields but the
+// discriminated one will be cleared,
+// - Otherwise, If only one field is left, update discriminator to that value.
+type Union struct {
+	// Discriminator, if present, is the name of the field that
+	// discriminates fields in the union. The mapping between the value of
+	// the discriminator and the field is done by using the Fields list
+	// below.
+	Discriminator *string `yaml:"discriminator,omitempty"`
+
+	// DeduceInvalidDiscriminator indicates if the discriminator
+	// should be updated automatically based on the fields set. This
+	// typically defaults to false since we don't want to deduce by
+	// default (the behavior exists to maintain compatibility on
+	// existing types and shouldn't be used for new types).
+	DeduceInvalidDiscriminator bool `yaml:"deduceInvalidDiscriminator,omitempty"`
+
+	// This is the list of fields that belong to this union. All the
+	// fields present in here have to be part of the parent
+	// structure. Discriminator (if oneOf has one), is NOT included in
+	// this list. The value for field is how we map the name of the field
+	// to actual value for discriminator.
+	Fields []UnionField `yaml:"fields,omitempty"`
 }
 
 // StructField pairs a field name with a field type.
@@ -129,15 +213,14 @@ type List struct {
 	// * `atomic`: the list is treated as a single entity, like a scalar.
 	// * `associative`:
 	//   - If the list element is a scalar, the list is treated as a set.
-	//   - If the list element is a struct, the list is treated as a map.
-	//   - The list element must not be a map or a list itself.
+	//   - If the list element is a map, the list is treated as a map.
 	// There is no default for this value for lists; all schemas must
 	// explicitly state the element relationship for all lists.
 	ElementRelationship ElementRelationship `yaml:"elementRelationship,omitempty"`
 
 	// Iff ElementRelationship is `associative`, and the element type is
-	// struct, then Keys must have non-zero length, and it lists the fields
-	// of the element's struct type which are to be used as the keys of the
+	// map, then Keys must have non-zero length, and it lists the fields
+	// of the element's map type which are to be used as the keys of the
 	// list.
 	//
 	// TODO: change this to "non-atomic struct" above and make the code reflect this.
@@ -146,60 +229,17 @@ type List struct {
 	Keys []string `yaml:"keys,omitempty"`
 }
 
-// Map is a key-value pair. Its default semantics are the same as an
-// associative list, but:
-// * It is serialized differently:
-//     map:  {"k": {"value": "v"}}
-//     list: [{"key": "k", "value": "v"}]
-// * Keys must be string typed.
-// * Keys can't have multiple components.
-//
-// Although serialized the same, maps are different from structs in that each
-// map item must have the same type.
-//
-// Optionally, maps may be atomic (for example, imagine representing an RGB
-// color value--it doesn't make sense to have different actors own the R and G
-// values).
-type Map struct {
-	// ElementType is the type of the list's elements.
-	ElementType TypeRef `yaml:"elementType,omitempty"`
-
-	// ElementRelationship states the relationship between the map's items.
-	// * `separable` implies that each element is 100% independent.
-	// * `atomic` implies that all elements depend on each other, and this
-	//   is effectively a scalar / leaf field; it doesn't make sense for
-	//   separate actors to set the elements.
-	//   TODO: find a simple example.
-	// The default behavior for maps is `separable`; it's permitted to
-	// leave this unset to get the default behavior.
-	ElementRelationship ElementRelationship `yaml:"elementRelationship,omitempty"`
-}
-
-// Untyped represents types that allow arbitrary content. (Think: plugin
-// objects.)
-type Untyped struct {
-	// ElementRelationship states the relationship between the items, if
-	// container-typed data happens to be present here.
-	// * `atomic` implies that all elements depend on each other, and this
-	//   is effectively a scalar / leaf field; it doesn't make sense for
-	//   separate actors to set the elements.
-	// TODO: support "guess" (guesses at associative list keys)
-	// TODO: support "lookup" (calls a lookup function to figure out the
-	//       schema based on the data)
-	// The default behavior for untyped data is `atomic`; it's permitted to
-	// leave this unset to get the default behavior.
-	ElementRelationship ElementRelationship `yaml:"elementRelationship,omitempty"`
-}
-
 // FindNamedType is a convenience function that returns the referenced TypeDef,
 // if it exists, or (nil, false) if it doesn't.
-func (s Schema) FindNamedType(name string) (TypeDef, bool) {
-	for _, t := range s.Types {
-		if t.Name == name {
-			return t, true
+func (s *Schema) FindNamedType(name string) (TypeDef, bool) {
+	s.once.Do(func() {
+		s.m = make(map[string]TypeDef, len(s.Types))
+		for _, t := range s.Types {
+			s.m[t.Name] = t
 		}
-	}
-	return TypeDef{}, false
+	})
+	t, ok := s.m[name]
+	return t, ok
 }
 
 // Resolve is a convenience function which returns the atom referenced, whether

vendor/sigs.k8s.io/structured-merge-diff/schema/equals.go

@@ -0,0 +1,166 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package schema
+
+// Equals returns true iff the two Schemas are equal.
+func (a Schema) Equals(b Schema) bool {
+	if len(a.Types) != len(b.Types) {
+		return false
+	}
+	for i := range a.Types {
+		if !a.Types[i].Equals(b.Types[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// Equals returns true iff the two TypeRefs are equal.
+//
+// Note that two typerefs that have an equivalent type but where one is
+// inlined and the other is named, are not considered equal.
+func (a TypeRef) Equals(b TypeRef) bool {
+	if (a.NamedType == nil) != (b.NamedType == nil) {
+		return false
+	}
+	if a.NamedType != nil {
+		if *a.NamedType != *b.NamedType {
+			return false
+		}
+		//return true
+	}
+	return a.Inlined.Equals(b.Inlined)
+}
+
+// Equals returns true iff the two TypeDefs are equal.
+func (a TypeDef) Equals(b TypeDef) bool {
+	if a.Name != b.Name {
+		return false
+	}
+	return a.Atom.Equals(b.Atom)
+}
+
+// Equals returns true iff the two Atoms are equal.
+func (a Atom) Equals(b Atom) bool {
+	if (a.Scalar == nil) != (b.Scalar == nil) {
+		return false
+	}
+	if (a.List == nil) != (b.List == nil) {
+		return false
+	}
+	if (a.Map == nil) != (b.Map == nil) {
+		return false
+	}
+	switch {
+	case a.Scalar != nil:
+		return *a.Scalar == *b.Scalar
+	case a.List != nil:
+		return a.List.Equals(*b.List)
+	case a.Map != nil:
+		return a.Map.Equals(*b.Map)
+	}
+	return true
+}
+
+// Equals returns true iff the two Maps are equal.
+func (a Map) Equals(b Map) bool {
+	if !a.ElementType.Equals(b.ElementType) {
+		return false
+	}
+	if a.ElementRelationship != b.ElementRelationship {
+		return false
+	}
+	if len(a.Fields) != len(b.Fields) {
+		return false
+	}
+	for i := range a.Fields {
+		if !a.Fields[i].Equals(b.Fields[i]) {
+			return false
+		}
+	}
+	if len(a.Unions) != len(b.Unions) {
+		return false
+	}
+	for i := range a.Unions {
+		if !a.Unions[i].Equals(b.Unions[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// Equals returns true iff the two Unions are equal.
+func (a Union) Equals(b Union) bool {
+	if (a.Discriminator == nil) != (b.Discriminator == nil) {
+		return false
+	}
+	if a.Discriminator != nil {
+		if *a.Discriminator != *b.Discriminator {
+			return false
+		}
+	}
+	if a.DeduceInvalidDiscriminator != b.DeduceInvalidDiscriminator {
+		return false
+	}
+	if len(a.Fields) != len(b.Fields) {
+		return false
+	}
+	for i := range a.Fields {
+		if !a.Fields[i].Equals(b.Fields[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// Equals returns true iff the two UnionFields are equal.
+func (a UnionField) Equals(b UnionField) bool {
+	if a.FieldName != b.FieldName {
+		return false
+	}
+	if a.DiscriminatorValue != b.DiscriminatorValue {
+		return false
+	}
+	return true
+}
+
+// Equals returns true iff the two StructFields are equal.
+func (a StructField) Equals(b StructField) bool {
+	if a.Name != b.Name {
+		return false
+	}
+	return a.Type.Equals(b.Type)
+}
+
+// Equals returns true iff the two Lists are equal.
+func (a List) Equals(b List) bool {
+	if !a.ElementType.Equals(b.ElementType) {
+		return false
+	}
+	if a.ElementRelationship != b.ElementRelationship {
+		return false
+	}
+	if len(a.Keys) != len(b.Keys) {
+		return false
+	}
+	for i := range a.Keys {
+		if a.Keys[i] != b.Keys[i] {
+			return false
+		}
+	}
+	return true
+}

vendor/sigs.k8s.io/structured-merge-diff/schema/fromvalue.go

@@ -1,57 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package schema
-
-import (
-	"sigs.k8s.io/structured-merge-diff/value"
-)
-
-// TypeRefFromValue creates an inlined type from a value v
-func TypeRefFromValue(v value.Value) TypeRef {
-	atom := atomFor(v)
-	return TypeRef{
-		Inlined: atom,
-	}
-}
-
-func atomFor(v value.Value) Atom {
-	switch {
-	// Untyped cases (handled at the bottom of this function)
-	case v.Null:
-	case v.ListValue != nil:
-	case v.FloatValue != nil:
-	case v.IntValue != nil:
-	case v.StringValue != nil:
-	case v.BooleanValue != nil:
-	// Recursive case
-	case v.MapValue != nil:
-		s := Struct{}
-		for i := range v.MapValue.Items {
-			child := v.MapValue.Items[i]
-			field := StructField{
-				Name: child.Name,
-				Type: TypeRef{
-					Inlined: atomFor(child.Value),
-				},
-			}
-			s.Fields = append(s.Fields, field)
-		}
-		return Atom{Struct: &s}
-	}
-
-	return Atom{Untyped: &Untyped{}}
-}

vendor/sigs.k8s.io/structured-merge-diff/schema/schemaschema.go

@@ -20,7 +20,7 @@ package schema
 // It will validate itself. It can be unmarshalled into a Schema type.
 var SchemaSchemaYAML = `types:
 - name: schema
-  struct:
+  map:
     fields:
       - name: types
         type:
@@ -31,7 +31,7 @@ var SchemaSchemaYAML = `types:
             keys:
             - name
 - name: typeDef
-  struct:
+  map:
     fields:
     - name: name
       type:
@@ -39,20 +39,17 @@ var SchemaSchemaYAML = `types:
     - name: scalar
       type:
         scalar: string
-    - name: struct
-      type:
-        namedType: struct
-    - name: list
-      type:
-        namedType: list
     - name: map
       type:
         namedType: map
+    - name: list
+      type:
+        namedType: list
     - name: untyped
       type:
         namedType: untyped
 - name: typeRef
-  struct:
+  map:
     fields:
     - name: namedType
       type:
@@ -60,22 +57,19 @@ var SchemaSchemaYAML = `types:
     - name: scalar
       type:
         scalar: string
-    - name: struct
-      type:
-        namedType: struct
-    - name: list
-      type:
-        namedType: list
     - name: map
       type:
         namedType: map
+    - name: list
+      type:
+        namedType: list
     - name: untyped
       type:
         namedType: untyped
 - name: scalar
   scalar: string
-- name: struct
-  struct:
+- name: map
+  map:
     fields:
     - name: fields
       type:
@@ -84,11 +78,46 @@ var SchemaSchemaYAML = `types:
             namedType: structField
           elementRelationship: associative
           keys: [ "name" ]
+    - name: unions
+      type:
+        list:
+          elementType:
+            namedType: union
+          elementRelationship: atomic
+    - name: elementType
+      type:
+        namedType: typeRef
     - name: elementRelationship
       type:
         scalar: string
+- name: unionField
+  map:
+    fields:
+    - name: fieldName
+      type:
+        scalar: string
+    - name: discriminatorValue
+      type:
+        scalar: string
+- name: union
+  map:
+    fields:
+    - name: discriminator
+      type:
+        scalar: string
+    - name: deduceInvalidDiscriminator
+      type:
+        scalar: bool
+    - name: fields
+      type:
+        list:
+          elementRelationship: associative
+          elementType:
+            namedType: unionField
+          keys:
+          - fieldName
 - name: structField
-  struct:
+  map:
     fields:
     - name: name
       type:
@@ -97,7 +126,7 @@ var SchemaSchemaYAML = `types:
       type:
         namedType: typeRef
 - name: list
-  struct:
+  map:
     fields:
     - name: elementType
       type:
@@ -110,17 +139,8 @@ var SchemaSchemaYAML = `types:
         list:
           elementType:
             scalar: string
-- name: map
-  struct:
-    fields:
-    - name: elementType
-      type:
-        namedType: typeRef
-    - name: elementRelationship
-      type:
-        scalar: string
 - name: untyped
-  struct:
+  map:
     fields:
     - name: elementRelationship
       type:

vendor/sigs.k8s.io/structured-merge-diff/typed/deduced.go

@@ -1,178 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package typed
-
-import (
-	"reflect"
-
-	"sigs.k8s.io/structured-merge-diff/fieldpath"
-	"sigs.k8s.io/structured-merge-diff/value"
-)
-
-// deducedTypedValue holds a value and guesses what it is and what to
-// do with it.
-type deducedTypedValue struct {
-	value value.Value
-}
-
-// AsTypedDeduced is going to generate it's own type definition based on
-// the content of the object. This is useful for CRDs that don't have a
-// validation field.
-func AsTypedDeduced(v value.Value) TypedValue {
-	return deducedTypedValue{value: v}
-}
-
-func (dv deducedTypedValue) AsValue() *value.Value {
-	return &dv.value
-}
-
-func (deducedTypedValue) Validate() error {
-	return nil
-}
-
-func (dv deducedTypedValue) ToFieldSet() (*fieldpath.Set, error) {
-	set := fieldpath.NewSet()
-	fieldsetDeduced(dv.value, fieldpath.Path{}, set)
-	return set, nil
-}
-
-func fieldsetDeduced(v value.Value, path fieldpath.Path, set *fieldpath.Set) {
-	if v.MapValue == nil {
-		set.Insert(path)
-		return
-	}
-
-	// We have a map.
-	// copy the existing path, append each item, and recursively call.
-	for i := range v.MapValue.Items {
-		child := v.MapValue.Items[i]
-		np := path.Copy()
-		np = append(np, fieldpath.PathElement{FieldName: &child.Name})
-		fieldsetDeduced(child.Value, np, set)
-	}
-}
-
-func (dv deducedTypedValue) Merge(pso TypedValue) (TypedValue, error) {
-	tpso, ok := pso.(deducedTypedValue)
-	if !ok {
-		return nil, errorFormatter{}.
-			errorf("can't merge deducedTypedValue with %T", tpso)
-	}
-	return AsTypedDeduced(mergeDeduced(dv.value, tpso.value)), nil
-}
-
-func mergeDeduced(lhs, rhs value.Value) value.Value {
-	// If both sides are maps, merge them, otherwise return right
-	// side.
-	if rhs.MapValue == nil || lhs.MapValue == nil {
-		return rhs
-	}
-
-	v := value.Value{MapValue: &value.Map{}}
-	for i := range lhs.MapValue.Items {
-		child := lhs.MapValue.Items[i]
-		v.MapValue.Set(child.Name, child.Value)
-	}
-	for i := range rhs.MapValue.Items {
-		child := rhs.MapValue.Items[i]
-		if sub, ok := v.MapValue.Get(child.Name); ok {
-			new := mergeDeduced(sub.Value, child.Value)
-			v.MapValue.Set(child.Name, new)
-		} else {
-			v.MapValue.Set(child.Name, child.Value)
-		}
-	}
-	return v
-}
-
-func (dv deducedTypedValue) Compare(rhs TypedValue) (c *Comparison, err error) {
-	trhs, ok := rhs.(deducedTypedValue)
-	if !ok {
-		return nil, errorFormatter{}.
-			errorf("can't merge deducedTypedValue with %T", rhs)
-	}
-
-	c = &Comparison{
-		Removed:  fieldpath.NewSet(),
-		Modified: fieldpath.NewSet(),
-		Added:    fieldpath.NewSet(),
-	}
-
-	added(dv.value, trhs.value, fieldpath.Path{}, c.Added)
-	added(trhs.value, dv.value, fieldpath.Path{}, c.Removed)
-	modified(dv.value, trhs.value, fieldpath.Path{}, c.Modified)
-
-	merge, err := dv.Merge(rhs)
-	if err != nil {
-		return nil, err
-	}
-	c.Merged = merge
-	return c, nil
-}
-
-func added(lhs, rhs value.Value, path fieldpath.Path, set *fieldpath.Set) {
-	if lhs.MapValue == nil && rhs.MapValue == nil {
-		// Both non-maps, nothing added, do nothing.
-	} else if lhs.MapValue == nil && rhs.MapValue != nil {
-		// From leaf to map, add leaf fields of map.
-		fieldsetDeduced(rhs, path, set)
-	} else if lhs.MapValue != nil && rhs.MapValue == nil {
-		// Went from map to field, add field.
-		set.Insert(path)
-	} else {
-		// Both are maps.
-		for i := range rhs.MapValue.Items {
-			child := rhs.MapValue.Items[i]
-			np := path.Copy()
-			np = append(np, fieldpath.PathElement{FieldName: &child.Name})
-
-			if v, ok := lhs.MapValue.Get(child.Name); ok {
-				added(v.Value, child.Value, np, set)
-			} else {
-				fieldsetDeduced(child.Value, np, set)
-			}
-		}
-	}
-}
-
-func modified(lhs, rhs value.Value, path fieldpath.Path, set *fieldpath.Set) {
-	if lhs.MapValue == nil && rhs.MapValue == nil {
-		if !reflect.DeepEqual(lhs, rhs) {
-			set.Insert(path)
-		}
-	} else if lhs.MapValue != nil && rhs.MapValue != nil {
-		// Both are maps.
-		for i := range rhs.MapValue.Items {
-			child := rhs.MapValue.Items[i]
-
-			v, ok := lhs.MapValue.Get(child.Name)
-			if !ok {
-				continue
-			}
-
-			np := path.Copy()
-			np = append(np, fieldpath.PathElement{FieldName: &child.Name})
-			modified(v.Value, child.Value, np, set)
-		}
-	}
-}
-
-// RemoveItems does nothing because all lists in a deducedTypedValue are considered atomic,
-// and there are no maps because it is indistinguishable from a struct.
-func (dv deducedTypedValue) RemoveItems(_ *fieldpath.Set) TypedValue {
-	return dv
-}

vendor/sigs.k8s.io/structured-merge-diff/typed/helpers.go

@@ -67,6 +67,14 @@ func (ef *errorFormatter) descend(pe fieldpath.PathElement) {
 	ef.path = append(ef.path, pe)
 }
 
+// parent returns the parent, for the purpose of buffer reuse. It's an error to
+// call this if there is no parent.
+func (ef *errorFormatter) parent() errorFormatter {
+	return errorFormatter{
+		path: ef.path[:len(ef.path)-1],
+	}
+}
+
 func (ef errorFormatter) errorf(format string, args ...interface{}) ValidationErrors {
 	return ValidationErrors{{
 		Path:         append(fieldpath.Path{}, ef.path...),
@@ -89,32 +97,44 @@ func (ef errorFormatter) prefixError(prefix string, err error) ValidationErrors
 }
 
 type atomHandler interface {
-	doScalar(schema.Scalar) ValidationErrors
-	doStruct(schema.Struct) ValidationErrors
-	doList(schema.List) ValidationErrors
-	doMap(schema.Map) ValidationErrors
-	doUntyped(schema.Untyped) ValidationErrors
+	doScalar(*schema.Scalar) ValidationErrors
+	doList(*schema.List) ValidationErrors
+	doMap(*schema.Map) ValidationErrors
 
 	errorf(msg string, args ...interface{}) ValidationErrors
 }
 
-func resolveSchema(s *schema.Schema, tr schema.TypeRef, ah atomHandler) ValidationErrors {
+func resolveSchema(s *schema.Schema, tr schema.TypeRef, v *value.Value, ah atomHandler) ValidationErrors {
 	a, ok := s.Resolve(tr)
 	if !ok {
 		return ah.errorf("schema error: no type found matching: %v", *tr.NamedType)
 	}
 
+	a = deduceAtom(a, v)
+	return handleAtom(a, tr, ah)
+}
+
+func deduceAtom(a schema.Atom, v *value.Value) schema.Atom {
+	switch {
+	case v == nil:
+	case v.FloatValue != nil, v.IntValue != nil, v.StringValue != nil, v.BooleanValue != nil:
+		return schema.Atom{Scalar: a.Scalar}
+	case v.ListValue != nil:
+		return schema.Atom{List: a.List}
+	case v.MapValue != nil:
+		return schema.Atom{Map: a.Map}
+	}
+	return a
+}
+
+func handleAtom(a schema.Atom, tr schema.TypeRef, ah atomHandler) ValidationErrors {
 	switch {
-	case a.Scalar != nil:
-		return ah.doScalar(*a.Scalar)
-	case a.Struct != nil:
-		return ah.doStruct(*a.Struct)
-	case a.List != nil:
-		return ah.doList(*a.List)
 	case a.Map != nil:
-		return ah.doMap(*a.Map)
-	case a.Untyped != nil:
-		return ah.doUntyped(*a.Untyped)
+		return ah.doMap(a.Map)
+	case a.Scalar != nil:
+		return ah.doScalar(a.Scalar)
+	case a.List != nil:
+		return ah.doList(a.List)
 	}
 
 	name := "inlined"
@@ -125,14 +145,14 @@ func resolveSchema(s *schema.Schema, tr schema.TypeRef, ah atomHandler) Validati
 	return ah.errorf("schema error: invalid atom: %v", name)
 }
 
-func (ef errorFormatter) validateScalar(t schema.Scalar, v *value.Value, prefix string) (errs ValidationErrors) {
+func (ef errorFormatter) validateScalar(t *schema.Scalar, v *value.Value, prefix string) (errs ValidationErrors) {
 	if v == nil {
 		return nil
 	}
 	if v.Null {
 		return nil
 	}
-	switch t {
+	switch *t {
 	case schema.Numeric:
 		if v.FloatValue == nil && v.IntValue == nil {
 			// TODO: should the schema separate int and float?
@@ -164,30 +184,18 @@ func listValue(val value.Value) (*value.List, error) {
 }
 
 // Returns the map, or an error. Reminder: nil is a valid map and might be returned.
-func mapOrStructValue(val value.Value, typeName string) (*value.Map, error) {
+func mapValue(val value.Value) (*value.Map, error) {
 	switch {
 	case val.Null:
 		return nil, nil
 	case val.MapValue != nil:
 		return val.MapValue, nil
 	default:
-		return nil, fmt.Errorf("expected %v, got %v", typeName, val)
+		return nil, fmt.Errorf("expected map, got %v", val)
 	}
 }
 
-func (ef errorFormatter) rejectExtraStructFields(m *value.Map, allowedNames map[string]struct{}, prefix string) (errs ValidationErrors) {
-	if m == nil {
-		return nil
-	}
-	for _, f := range m.Items {
-		if _, allowed := allowedNames[f.Name]; !allowed {
-			errs = append(errs, ef.errorf("%vfield %v is not mentioned in the schema", prefix, f.Name)...)
-		}
-	}
-	return errs
-}
-
-func keyedAssociativeListItemToPathElement(list schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
+func keyedAssociativeListItemToPathElement(list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
 	pe := fieldpath.PathElement{}
 	if child.Null {
 		// For now, the keys are required which means that null entries
@@ -197,6 +205,7 @@ func keyedAssociativeListItemToPathElement(list schema.List, index int, child va
 	if child.MapValue == nil {
 		return pe, errors.New("associative list with keys may not have non-map elements")
 	}
+	keyMap := value.FieldList{}
 	for _, fieldName := range list.Keys {
 		var fieldValue value.Value
 		field, ok := child.MapValue.Get(fieldName)
@@ -206,15 +215,14 @@ func keyedAssociativeListItemToPathElement(list schema.List, index int, child va
 			// Treat keys as required.
 			return pe, fmt.Errorf("associative list with keys has an element that omits key field %q", fieldName)
 		}
-		pe.Key = append(pe.Key, value.Field{
-			Name:  fieldName,
-			Value: fieldValue,
-		})
+		keyMap = append(keyMap, value.Field{Name: fieldName, Value: fieldValue})
 	}
+	keyMap.Sort()
+	pe.Key = &keyMap
 	return pe, nil
 }
 
-func setItemToPathElement(list schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
+func setItemToPathElement(list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
 	pe := fieldpath.PathElement{}
 	switch {
 	case child.MapValue != nil:
@@ -234,7 +242,7 @@ func setItemToPathElement(list schema.List, index int, child value.Value) (field
 	}
 }
 
-func listItemToPathElement(list schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
+func listItemToPathElement(list *schema.List, index int, child value.Value) (fieldpath.PathElement, error) {
 	if list.ElementRelationship == schema.Associative {
 		if len(list.Keys) > 0 {
 			return keyedAssociativeListItemToPathElement(list, index, child)

vendor/sigs.k8s.io/structured-merge-diff/typed/merge.go

@@ -41,6 +41,9 @@ type mergingWalker struct {
 
 	// internal housekeeping--don't set when constructing.
 	inLeaf bool // Set to true if we're in a "big leaf"--atomic map/list
+
+	// Allocate only as many walkers as needed for the depth by storing them here.
+	spareWalkers *[]*mergingWalker
 }
 
 // merge rules examine w.lhs and w.rhs (up to one of which may be nil) and
@@ -61,12 +64,26 @@ var (
 )
 
 // merge sets w.out.
-func (w *mergingWalker) merge() ValidationErrors {
+func (w *mergingWalker) merge() (errs ValidationErrors) {
 	if w.lhs == nil && w.rhs == nil {
 		// check this condidition here instead of everywhere below.
 		return w.errorf("at least one of lhs and rhs must be provided")
 	}
-	errs := resolveSchema(w.schema, w.typeRef, w)
+	a, ok := w.schema.Resolve(w.typeRef)
+	if !ok {
+		return w.errorf("schema error: no type found matching: %v", *w.typeRef.NamedType)
+	}
+
+	alhs := deduceAtom(a, w.lhs)
+	arhs := deduceAtom(a, w.rhs)
+	if alhs.Equals(arhs) {
+		errs = append(errs, handleAtom(arhs, w.typeRef, w)...)
+	} else {
+		w2 := *w
+		errs = append(errs, handleAtom(alhs, w.typeRef, &w2)...)
+		errs = append(errs, handleAtom(arhs, w.typeRef, w)...)
+	}
+
 	if !w.inLeaf && w.postItemHook != nil {
 		w.postItemHook(w)
 	}
@@ -87,7 +104,7 @@ func (w *mergingWalker) doLeaf() {
 	w.rule(w)
 }
 
-func (w *mergingWalker) doScalar(t schema.Scalar) (errs ValidationErrors) {
+func (w *mergingWalker) doScalar(t *schema.Scalar) (errs ValidationErrors) {
 	errs = append(errs, w.validateScalar(t, w.lhs, "lhs: ")...)
 	errs = append(errs, w.validateScalar(t, w.rhs, "rhs: ")...)
 	if len(errs) > 0 {
@@ -101,70 +118,39 @@ func (w *mergingWalker) doScalar(t schema.Scalar) (errs ValidationErrors) {
 }
 
 func (w *mergingWalker) prepareDescent(pe fieldpath.PathElement, tr schema.TypeRef) *mergingWalker {
-	w2 := *w
+	if w.spareWalkers == nil {
+		// first descent.
+		w.spareWalkers = &[]*mergingWalker{}
+	}
+	var w2 *mergingWalker
+	if n := len(*w.spareWalkers); n > 0 {
+		w2, *w.spareWalkers = (*w.spareWalkers)[n-1], (*w.spareWalkers)[:n-1]
+	} else {
+		w2 = &mergingWalker{}
+	}
+	*w2 = *w
 	w2.typeRef = tr
 	w2.errorFormatter.descend(pe)
 	w2.lhs = nil
 	w2.rhs = nil
 	w2.out = nil
-	return &w2
+	return w2
 }
 
-func (w *mergingWalker) visitStructFields(t schema.Struct, lhs, rhs *value.Map) (errs ValidationErrors) {
-	out := &value.Map{}
-
-	valOrNil := func(m *value.Map, name string) *value.Value {
-		if m == nil {
-			return nil
-		}
-		val, ok := m.Get(name)
-		if ok {
-			return &val.Value
-		}
-		return nil
-	}
-
-	allowedNames := map[string]struct{}{}
-	for i := range t.Fields {
-		// I don't want to use the loop variable since a reference
-		// might outlive the loop iteration (in an error message).
-		f := t.Fields[i]
-		allowedNames[f.Name] = struct{}{}
-		w2 := w.prepareDescent(fieldpath.PathElement{FieldName: &f.Name}, f.Type)
-		w2.lhs = valOrNil(lhs, f.Name)
-		w2.rhs = valOrNil(rhs, f.Name)
-		if w2.lhs == nil && w2.rhs == nil {
-			// All fields are optional
-			continue
-		}
-		if newErrs := w2.merge(); len(newErrs) > 0 {
-			errs = append(errs, newErrs...)
-		} else if w2.out != nil {
-			out.Set(f.Name, *w2.out)
-		}
-	}
-
-	// All fields may be optional, but unknown fields are not allowed.
-	errs = append(errs, w.rejectExtraStructFields(lhs, allowedNames, "lhs: ")...)
-	errs = append(errs, w.rejectExtraStructFields(rhs, allowedNames, "rhs: ")...)
-	if len(errs) > 0 {
-		return errs
-	}
-
-	if len(out.Items) > 0 {
-		w.out = &value.Value{MapValue: out}
-	}
-
-	return errs
+func (w *mergingWalker) finishDescent(w2 *mergingWalker) {
+	// if the descent caused a realloc, ensure that we reuse the buffer
+	// for the next sibling.
+	w.errorFormatter = w2.errorFormatter.parent()
+	*w.spareWalkers = append(*w.spareWalkers, w2)
 }
 
-func (w *mergingWalker) derefMapOrStruct(prefix, typeName string, v *value.Value, dest **value.Map) (errs ValidationErrors) {
+func (w *mergingWalker) derefMap(prefix string, v *value.Value, dest **value.Map) (errs ValidationErrors) {
 	// taking dest as input so that it can be called as a one-liner with
 	// append.
 	if v == nil {
 		return nil
 	}
-	m, err := mapOrStructValue(*v, typeName)
+	m, err := mapValue(*v)
 	if err != nil {
 		return w.prefixError(prefix, err)
 	}
@@ -172,38 +158,7 @@ func (w *mergingWalker) derefMapOrStruct(prefix, typeName string, v *value.Value
 	return nil
 }
 
-func (w *mergingWalker) doStruct(t schema.Struct) (errs ValidationErrors) {
-	var lhs, rhs *value.Map
-	errs = append(errs, w.derefMapOrStruct("lhs: ", "struct", w.lhs, &lhs)...)
-	errs = append(errs, w.derefMapOrStruct("rhs: ", "struct", w.rhs, &rhs)...)
-	if len(errs) > 0 {
-		return errs
-	}
-
-	// If both lhs and rhs are empty/null, treat it as a
-	// leaf: this helps preserve the empty/null
-	// distinction.
-	emptyPromoteToLeaf := (lhs == nil || len(lhs.Items) == 0) &&
-		(rhs == nil || len(rhs.Items) == 0)
-
-	if t.ElementRelationship == schema.Atomic || emptyPromoteToLeaf {
-		w.doLeaf()
-		return nil
-	}
-
-	if lhs == nil && rhs == nil {
-		// nil is a valid map!
-		return nil
-	}
-
-	errs = w.visitStructFields(t, lhs, rhs)
-
-	// TODO: Check unions.
-
-	return errs
-}
-
-func (w *mergingWalker) visitListItems(t schema.List, lhs, rhs *value.List) (errs ValidationErrors) {
+func (w *mergingWalker) visitListItems(t *schema.List, lhs, rhs *value.List) (errs ValidationErrors) {
 	out := &value.List{}
 
 	// TODO: ordering is totally wrong.
@@ -213,8 +168,9 @@ func (w *mergingWalker) visitListItems(t schema.List, lhs, rhs *value.List) (err
 	rhsOrder := []fieldpath.PathElement{}
 
 	// First, collect all RHS children.
-	observedRHS := map[string]value.Value{}
+	var observedRHS fieldpath.PathElementValueMap
 	if rhs != nil {
+		observedRHS = fieldpath.MakePathElementValueMap(len(rhs.Items))
 		for i, child := range rhs.Items {
 			pe, err := listItemToPathElement(t, i, child)
 			if err != nil {
@@ -224,18 +180,18 @@ func (w *mergingWalker) visitListItems(t schema.List, lhs, rhs *value.List) (err
 				// this element.
 				continue
 			}
-			keyStr := pe.String()
-			if _, found := observedRHS[keyStr]; found {
-				errs = append(errs, w.errorf("rhs: duplicate entries for key %v", keyStr)...)
+			if _, ok := observedRHS.Get(pe); ok {
+				errs = append(errs, w.errorf("rhs: duplicate entries for key %v", pe.String())...)
 			}
-			observedRHS[keyStr] = child
+			observedRHS.Insert(pe, child)
 			rhsOrder = append(rhsOrder, pe)
 		}
 	}
 
 	// Then merge with LHS children.
-	observedLHS := map[string]struct{}{}
+	var observedLHS fieldpath.PathElementSet
 	if lhs != nil {
+		observedLHS = fieldpath.MakePathElementSet(len(lhs.Items))
 		for i, child := range lhs.Items {
 			pe, err := listItemToPathElement(t, i, child)
 			if err != nil {
@@ -245,15 +201,14 @@ func (w *mergingWalker) visitListItems(t schema.List, lhs, rhs *value.List) (err
 				// this element.
 				continue
 			}
-			keyStr := pe.String()
-			if _, found := observedLHS[keyStr]; found {
-				errs = append(errs, w.errorf("lhs: duplicate entries for key %v", keyStr)...)
+			if observedLHS.Has(pe) {
+				errs = append(errs, w.errorf("lhs: duplicate entries for key %v", pe.String())...)
 				continue
 			}
-			observedLHS[keyStr] = struct{}{}
+			observedLHS.Insert(pe)
 			w2 := w.prepareDescent(pe, t.ElementType)
 			w2.lhs = &child
-			if rchild, ok := observedRHS[keyStr]; ok {
+			if rchild, ok := observedRHS.Get(pe); ok {
 				w2.rhs = &rchild
 			}
 			if newErrs := w2.merge(); len(newErrs) > 0 {
@@ -261,21 +216,23 @@ func (w *mergingWalker) visitListItems(t schema.List, lhs, rhs *value.List) (err
 			} else if w2.out != nil {
 				out.Items = append(out.Items, *w2.out)
 			}
-			// Keep track of children that have been handled
-			delete(observedRHS, keyStr)
+			w.finishDescent(w2)
 		}
 	}
 
-	for _, rhsToCheck := range rhsOrder {
-		if unmergedChild, ok := observedRHS[rhsToCheck.String()]; ok {
-			w2 := w.prepareDescent(rhsToCheck, t.ElementType)
-			w2.rhs = &unmergedChild
-			if newErrs := w2.merge(); len(newErrs) > 0 {
-				errs = append(errs, newErrs...)
-			} else if w2.out != nil {
-				out.Items = append(out.Items, *w2.out)
-			}
+	for _, pe := range rhsOrder {
+		if observedLHS.Has(pe) {
+			continue
 		}
+		value, _ := observedRHS.Get(pe)
+		w2 := w.prepareDescent(pe, t.ElementType)
+		w2.rhs = &value
+		if newErrs := w2.merge(); len(newErrs) > 0 {
+			errs = append(errs, newErrs...)
+		} else if w2.out != nil {
+			out.Items = append(out.Items, *w2.out)
+		}
+		w.finishDescent(w2)
 	}
 
 	if len(out.Items) > 0 {
@@ -298,13 +255,10 @@ func (w *mergingWalker) derefList(prefix string, v *value.Value, dest **value.Li
 	return nil
 }
 
-func (w *mergingWalker) doList(t schema.List) (errs ValidationErrors) {
+func (w *mergingWalker) doList(t *schema.List) (errs ValidationErrors) {
 	var lhs, rhs *value.List
-	errs = append(errs, w.derefList("lhs: ", w.lhs, &lhs)...)
-	errs = append(errs, w.derefList("rhs: ", w.rhs, &rhs)...)
-	if len(errs) > 0 {
-		return errs
-	}
+	w.derefList("lhs: ", w.lhs, &lhs)
+	w.derefList("rhs: ", w.rhs, &rhs)
 
 	// If both lhs and rhs are empty/null, treat it as a
 	// leaf: this helps preserve the empty/null
@@ -326,13 +280,17 @@ func (w *mergingWalker) doList(t schema.List) (errs ValidationErrors) {
 	return errs
 }
 
-func (w *mergingWalker) visitMapItems(t schema.Map, lhs, rhs *value.Map) (errs ValidationErrors) {
+func (w *mergingWalker) visitMapItems(t *schema.Map, lhs, rhs *value.Map) (errs ValidationErrors) {
 	out := &value.Map{}
 
 	if lhs != nil {
-		for _, litem := range lhs.Items {
-			name := litem.Name
-			w2 := w.prepareDescent(fieldpath.PathElement{FieldName: &name}, t.ElementType)
+		for i := range lhs.Items {
+			litem := &lhs.Items[i]
+			fieldType := t.ElementType
+			if sf, ok := t.FindField(litem.Name); ok {
+				fieldType = sf.Type
+			}
+			w2 := w.prepareDescent(fieldpath.PathElement{FieldName: &litem.Name}, fieldType)
 			w2.lhs = &litem.Value
 			if rhs != nil {
 				if ritem, ok := rhs.Get(litem.Name); ok {
@@ -342,27 +300,33 @@ func (w *mergingWalker) visitMapItems(t schema.Map, lhs, rhs *value.Map) (errs V
 			if newErrs := w2.merge(); len(newErrs) > 0 {
 				errs = append(errs, newErrs...)
 			} else if w2.out != nil {
-				out.Set(name, *w2.out)
+				out.Items = append(out.Items, value.Field{litem.Name, *w2.out})
 			}
+			w.finishDescent(w2)
 		}
 	}
 
 	if rhs != nil {
-		for _, ritem := range rhs.Items {
+		for j := range rhs.Items {
+			ritem := &rhs.Items[j]
 			if lhs != nil {
 				if _, ok := lhs.Get(ritem.Name); ok {
 					continue
 				}
 			}
 
-			name := ritem.Name
-			w2 := w.prepareDescent(fieldpath.PathElement{FieldName: &name}, t.ElementType)
+			fieldType := t.ElementType
+			if sf, ok := t.FindField(ritem.Name); ok {
+				fieldType = sf.Type
+			}
+			w2 := w.prepareDescent(fieldpath.PathElement{FieldName: &ritem.Name}, fieldType)
 			w2.rhs = &ritem.Value
 			if newErrs := w2.merge(); len(newErrs) > 0 {
 				errs = append(errs, newErrs...)
 			} else if w2.out != nil {
-				out.Set(name, *w2.out)
+				out.Items = append(out.Items, value.Field{ritem.Name, *w2.out})
 			}
+			w.finishDescent(w2)
 		}
 	}
 
@@ -372,13 +336,10 @@ func (w *mergingWalker) visitMapItems(t schema.Map, lhs, rhs *value.Map) (errs V
 	return errs
 }
 
-func (w *mergingWalker) doMap(t schema.Map) (errs ValidationErrors) {
+func (w *mergingWalker) doMap(t *schema.Map) (errs ValidationErrors) {
 	var lhs, rhs *value.Map
-	errs = append(errs, w.derefMapOrStruct("lhs: ", "map", w.lhs, &lhs)...)
-	errs = append(errs, w.derefMapOrStruct("rhs: ", "map", w.rhs, &rhs)...)
-	if len(errs) > 0 {
-		return errs
-	}
+	w.derefMap("lhs: ", w.lhs, &lhs)
+	w.derefMap("rhs: ", w.rhs, &rhs)
 
 	// If both lhs and rhs are empty/null, treat it as a
 	// leaf: this helps preserve the empty/null
@@ -395,16 +356,7 @@ func (w *mergingWalker) doMap(t schema.Map) (errs ValidationErrors) {
 		return nil
 	}
 
-	errs = w.visitMapItems(t, lhs, rhs)
+	errs = append(errs, w.visitMapItems(t, lhs, rhs)...)
 
 	return errs
 }
-
-func (w *mergingWalker) doUntyped(t schema.Untyped) (errs ValidationErrors) {
-	if t.ElementRelationship == "" || t.ElementRelationship == schema.Atomic {
-		// Untyped sections allow anything, and are considered leaf
-		// fields.
-		w.doLeaf()
-	}
-	return nil
-}

vendor/sigs.k8s.io/structured-merge-diff/typed/parser.go

@@ -33,9 +33,9 @@ type Parser struct {
 }
 
 // create builds an unvalidated parser.
-func create(schema YAMLObject) (*Parser, error) {
+func create(s YAMLObject) (*Parser, error) {
 	p := Parser{}
-	err := yaml.Unmarshal([]byte(schema), &p.Schema)
+	err := yaml.Unmarshal([]byte(s), &p.Schema)
 	return &p, err
 }
 
@@ -55,7 +55,11 @@ func NewParser(schema YAMLObject) (*Parser, error) {
 	if err != nil {
 		return nil, fmt.Errorf("unable to validate schema: %v", err)
 	}
-	return create(schema)
+	p, err := create(schema)
+	if err != nil {
+		return nil, err
+	}
+	return p, nil
 }
 
 // TypeNames returns a list of types this parser understands.
@@ -69,79 +73,65 @@ func (p *Parser) TypeNames() (names []string) {
 // Type returns a helper which can produce objects of the given type. Any
 // errors are deferred until a further function is called.
 func (p *Parser) Type(name string) ParseableType {
-	return &parseableType{
-		parser:   p,
-		typename: name,
+	return ParseableType{
+		Schema:  &p.Schema,
+		TypeRef: schema.TypeRef{NamedType: &name},
 	}
 }
 
 // ParseableType allows for easy production of typed objects.
-type ParseableType interface {
-	IsValid() bool
-	FromYAML(YAMLObject) (TypedValue, error)
-	FromUnstructured(interface{}) (TypedValue, error)
+type ParseableType struct {
+	TypeRef schema.TypeRef
+	Schema  *schema.Schema
 }
 
-type parseableType struct {
-	parser   *Parser
-	typename string
-}
-
-var _ ParseableType = &parseableType{}
-
 // IsValid return true if p's schema and typename are valid.
-func (p *parseableType) IsValid() bool {
-	_, ok := p.parser.Schema.Resolve(schema.TypeRef{NamedType: &p.typename})
+func (p ParseableType) IsValid() bool {
+	_, ok := p.Schema.Resolve(p.TypeRef)
 	return ok
 }
 
 // FromYAML parses a yaml string into an object with the current schema
 // and the type "typename" or an error if validation fails.
-func (p *parseableType) FromYAML(object YAMLObject) (TypedValue, error) {
+func (p ParseableType) FromYAML(object YAMLObject) (*TypedValue, error) {
 	v, err := value.FromYAML([]byte(object))
 	if err != nil {
 		return nil, err
 	}
-	return AsTyped(v, &p.parser.Schema, p.typename)
+	return AsTyped(v, p.Schema, p.TypeRef)
 }
 
 // FromUnstructured converts a go interface to a TypedValue. It will return an
 // error if the resulting object fails schema validation.
-func (p *parseableType) FromUnstructured(in interface{}) (TypedValue, error) {
+func (p ParseableType) FromUnstructured(in interface{}) (*TypedValue, error) {
 	v, err := value.FromUnstructured(in)
 	if err != nil {
 		return nil, err
 	}
-	return AsTyped(v, &p.parser.Schema, p.typename)
+	return AsTyped(v, p.Schema, p.TypeRef)
 }
 
 // DeducedParseableType is a ParseableType that deduces the type from
 // the content of the object.
-type DeducedParseableType struct{}
-
-var _ ParseableType = DeducedParseableType{}
-
-// IsValid always returns true for a DeducedParseableType.
-func (p DeducedParseableType) IsValid() bool {
-	return true
-}
-
-// FromYAML parses a yaml string into an object and deduces the type for
-// that object.
-func (p DeducedParseableType) FromYAML(object YAMLObject) (TypedValue, error) {
-	v, err := value.FromYAML([]byte(object))
-	if err != nil {
-		return nil, err
-	}
-	return AsTypedDeduced(v), nil
-}
-
-// FromUnstructured converts a go interface to a TypedValue. It will return an
-// error if the input object uses un-handled types.
-func (p DeducedParseableType) FromUnstructured(in interface{}) (TypedValue, error) {
-	v, err := value.FromUnstructured(in)
-	if err != nil {
-		return nil, err
-	}
-	return AsTypedDeduced(v), nil
-}
+var DeducedParseableType ParseableType = createOrDie(YAMLObject(`types:
+- name: __untyped_atomic_
+  scalar: untyped
+  list:
+    elementType:
+      namedType: __untyped_atomic_
+    elementRelationship: atomic
+  map:
+    elementType:
+      namedType: __untyped_atomic_
+    elementRelationship: atomic
+- name: __untyped_deduced_
+  scalar: untyped
+  list:
+    elementType:
+      namedType: __untyped_atomic_
+    elementRelationship: atomic
+  map:
+    elementType:
+      namedType: __untyped_deduced_
+    elementRelationship: separable
+`)).Type("__untyped_deduced_")

vendor/sigs.k8s.io/structured-merge-diff/typed/remove.go

@@ -31,39 +31,16 @@ func removeItemsWithSchema(value *value.Value, toRemove *fieldpath.Set, schema *
 		schema:   schema,
 		toRemove: toRemove,
 	}
-	resolveSchema(schema, typeRef, w)
+	resolveSchema(schema, typeRef, value, w)
 }
 
 // doLeaf should be called on leaves before descending into children, if there
 // will be a descent. It modifies w.inLeaf.
 func (w *removingWalker) doLeaf() ValidationErrors { return nil }
 
-func (w *removingWalker) doScalar(t schema.Scalar) ValidationErrors { return nil }
+func (w *removingWalker) doScalar(t *schema.Scalar) ValidationErrors { return nil }
 
-func (w *removingWalker) doStruct(t schema.Struct) ValidationErrors {
-	s := w.value.MapValue
-
-	// If struct is null, empty, or atomic just return
-	if s == nil || len(s.Items) == 0 || t.ElementRelationship == schema.Atomic {
-		return nil
-	}
-
-	fieldTypes := map[string]schema.TypeRef{}
-	for _, structField := range t.Fields {
-		fieldTypes[structField.Name] = structField.Type
-	}
-
-	for i, _ := range s.Items {
-		item := s.Items[i]
-		pe := fieldpath.PathElement{FieldName: &item.Name}
-		if subset := w.toRemove.WithPrefix(pe); !subset.Empty() {
-			removeItemsWithSchema(&s.Items[i].Value, subset, w.schema, fieldTypes[item.Name])
-		}
-	}
-	return nil
-}
-
-func (w *removingWalker) doList(t schema.List) (errs ValidationErrors) {
+func (w *removingWalker) doList(t *schema.List) (errs ValidationErrors) {
 	l := w.value.ListValue
 
 	// If list is null, empty, or atomic just return
@@ -72,7 +49,7 @@ func (w *removingWalker) doList(t schema.List) (errs ValidationErrors) {
 	}
 
 	newItems := []value.Value{}
-	for i, _ := range l.Items {
+	for i := range l.Items {
 		item := l.Items[i]
 		// Ignore error because we have already validated this list
 		pe, _ := listItemToPathElement(t, i, item)
@@ -93,7 +70,7 @@ func (w *removingWalker) doList(t schema.List) (errs ValidationErrors) {
 	return nil
 }
 
-func (w *removingWalker) doMap(t schema.Map) ValidationErrors {
+func (w *removingWalker) doMap(t *schema.Map) ValidationErrors {
 	m := w.value.MapValue
 
 	// If map is null, empty, or atomic just return
@@ -101,16 +78,26 @@ func (w *removingWalker) doMap(t schema.Map) ValidationErrors {
 		return nil
 	}
 
+	fieldTypes := map[string]schema.TypeRef{}
+	for _, structField := range t.Fields {
+		fieldTypes[structField.Name] = structField.Type
+	}
+
 	newMap := &value.Map{}
-	for i, _ := range m.Items {
+	for i := range m.Items {
 		item := m.Items[i]
 		pe := fieldpath.PathElement{FieldName: &item.Name}
 		path, _ := fieldpath.MakePath(pe)
-		if w.toRemove.Has(path) {
-			continue
+		fieldType := t.ElementType
+		if ft, ok := fieldTypes[item.Name]; ok {
+			fieldType = ft
+		} else {
+			if w.toRemove.Has(path) {
+				continue
+			}
 		}
 		if subset := w.toRemove.WithPrefix(pe); !subset.Empty() {
-			removeItemsWithSchema(&m.Items[i].Value, subset, w.schema, t.ElementType)
+			removeItemsWithSchema(&m.Items[i].Value, subset, w.schema, fieldType)
 		}
 		newMap.Set(item.Name, m.Items[i].Value)
 	}
@@ -122,6 +109,4 @@ func (w *removingWalker) doMap(t schema.Map) ValidationErrors {
 	return nil
 }
 
-func (*removingWalker) doUntyped(_ schema.Untyped) ValidationErrors { return nil }
-
 func (*removingWalker) errorf(_ string, _ ...interface{}) ValidationErrors { return nil }

vendor/sigs.k8s.io/structured-merge-diff/typed/typed.go

@@ -18,52 +18,21 @@ package typed
 
 import (
 	"fmt"
-	"reflect"
+	"strings"
+	"sync"
 
 	"sigs.k8s.io/structured-merge-diff/fieldpath"
 	"sigs.k8s.io/structured-merge-diff/schema"
 	"sigs.k8s.io/structured-merge-diff/value"
 )
 
-// TypedValue is a value with an associated type.
-type TypedValue interface {
-	// AsValue removes the type from the TypedValue and only keeps the value.
-	AsValue() *value.Value
-	// Validate returns an error with a list of every spec violation.
-	Validate() error
-	// ToFieldSet creates a set containing every leaf field and item mentioned, or
-	// validation errors, if any were encountered.
-	ToFieldSet() (*fieldpath.Set, error)
-	// Merge returns the result of merging tv and pso ("partially specified
-	// object") together. Of note:
-	//  * No fields can be removed by this operation.
-	//  * If both tv and pso specify a given leaf field, the result will keep pso's
-	//    value.
-	//  * Container typed elements will have their items ordered:
-	//    * like tv, if pso doesn't change anything in the container
-	//    * like pso, if pso does change something in the container.
-	// tv and pso must both be of the same type (their Schema and TypeRef must
-	// match), or an error will be returned. Validation errors will be returned if
-	// the objects don't conform to the schema.
-	Merge(pso TypedValue) (TypedValue, error)
-	// Compare compares the two objects. See the comments on the `Comparison`
-	// struct for details on the return value.
-	//
-	// tv and rhs must both be of the same type (their Schema and TypeRef must
-	// match), or an error will be returned. Validation errors will be returned if
-	// the objects don't conform to the schema.
-	Compare(rhs TypedValue) (c *Comparison, err error)
-	// RemoveItems removes each provided list or map item from the value.
-	RemoveItems(items *fieldpath.Set) TypedValue
-}
-
 // AsTyped accepts a value and a type and returns a TypedValue. 'v' must have
 // type 'typeName' in the schema. An error is returned if the v doesn't conform
 // to the schema.
-func AsTyped(v value.Value, s *schema.Schema, typeName string) (TypedValue, error) {
-	tv := typedValue{
+func AsTyped(v value.Value, s *schema.Schema, typeRef schema.TypeRef) (*TypedValue, error) {
+	tv := &TypedValue{
 		value:   v,
-		typeRef: schema.TypeRef{NamedType: &typeName},
+		typeRef: typeRef,
 		schema:  s,
 	}
 	if err := tv.Validate(); err != nil {
@@ -76,38 +45,43 @@ func AsTyped(v value.Value, s *schema.Schema, typeName string) (TypedValue, erro
 // conforms to the schema, for cases where that has already been checked or
 // where you're going to call a method that validates as a side-effect (like
 // ToFieldSet).
-func AsTypedUnvalidated(v value.Value, s *schema.Schema, typeName string) TypedValue {
-	tv := typedValue{
+func AsTypedUnvalidated(v value.Value, s *schema.Schema, typeRef schema.TypeRef) *TypedValue {
+	tv := &TypedValue{
 		value:   v,
-		typeRef: schema.TypeRef{NamedType: &typeName},
+		typeRef: typeRef,
 		schema:  s,
 	}
 	return tv
 }
 
-// typedValue is a value of some specific type.
-type typedValue struct {
+// TypedValue is a value of some specific type.
+type TypedValue struct {
 	value   value.Value
 	typeRef schema.TypeRef
 	schema  *schema.Schema
 }
 
-var _ TypedValue = typedValue{}
-
-func (tv typedValue) AsValue() *value.Value {
+// AsValue removes the type from the TypedValue and only keeps the value.
+func (tv TypedValue) AsValue() *value.Value {
 	return &tv.value
 }
 
-func (tv typedValue) Validate() error {
-	if errs := tv.walker().validate(); len(errs) != 0 {
+// Validate returns an error with a list of every spec violation.
+func (tv TypedValue) Validate() error {
+	w := tv.walker()
+	defer w.finished()
+	if errs := w.validate(); len(errs) != 0 {
 		return errs
 	}
 	return nil
 }
 
-func (tv typedValue) ToFieldSet() (*fieldpath.Set, error) {
+// ToFieldSet creates a set containing every leaf field and item mentioned, or
+// validation errors, if any were encountered.
+func (tv TypedValue) ToFieldSet() (*fieldpath.Set, error) {
 	s := fieldpath.NewSet()
 	w := tv.walker()
+	defer w.finished()
 	w.leafFieldCallback = func(p fieldpath.Path) { s.Insert(p) }
 	w.nodeFieldCallback = func(p fieldpath.Path) { s.Insert(p) }
 	if errs := w.validate(); len(errs) != 0 {
@@ -116,38 +90,43 @@ func (tv typedValue) ToFieldSet() (*fieldpath.Set, error) {
 	return s, nil
 }
 
-func (tv typedValue) Merge(pso TypedValue) (TypedValue, error) {
-	tpso, ok := pso.(typedValue)
-	if !ok {
-		return nil, errorFormatter{}.
-			errorf("can't merge typedValue with %T", pso)
-	}
-	return merge(tv, tpso, ruleKeepRHS, nil)
+// Merge returns the result of merging tv and pso ("partially specified
+// object") together. Of note:
+//  * No fields can be removed by this operation.
+//  * If both tv and pso specify a given leaf field, the result will keep pso's
+//    value.
+//  * Container typed elements will have their items ordered:
+//    * like tv, if pso doesn't change anything in the container
+//    * like pso, if pso does change something in the container.
+// tv and pso must both be of the same type (their Schema and TypeRef must
+// match), or an error will be returned. Validation errors will be returned if
+// the objects don't conform to the schema.
+func (tv TypedValue) Merge(pso *TypedValue) (*TypedValue, error) {
+	return merge(&tv, pso, ruleKeepRHS, nil)
 }
 
-func (tv typedValue) Compare(rhs TypedValue) (c *Comparison, err error) {
-	trhs, ok := rhs.(typedValue)
-	if !ok {
-		return nil, errorFormatter{}.
-			errorf("can't compare typedValue with %T", rhs)
-	}
+// Compare compares the two objects. See the comments on the `Comparison`
+// struct for details on the return value.
+//
+// tv and rhs must both be of the same type (their Schema and TypeRef must
+// match), or an error will be returned. Validation errors will be returned if
+// the objects don't conform to the schema.
+func (tv TypedValue) Compare(rhs *TypedValue) (c *Comparison, err error) {
 	c = &Comparison{
 		Removed:  fieldpath.NewSet(),
 		Modified: fieldpath.NewSet(),
 		Added:    fieldpath.NewSet(),
 	}
-	c.Merged, err = merge(tv, trhs, func(w *mergingWalker) {
+	_, err = merge(&tv, rhs, func(w *mergingWalker) {
 		if w.lhs == nil {
 			c.Added.Insert(w.path)
 		} else if w.rhs == nil {
 			c.Removed.Insert(w.path)
-		} else if !reflect.DeepEqual(w.rhs, w.lhs) {
-			// TODO: reflect.DeepEqual is not sufficient for this.
+		} else if !w.rhs.Equals(*w.lhs) {
+			// TODO: Equality is not sufficient for this.
 			// Need to implement equality check on the value type.
 			c.Modified.Insert(w.path)
 		}
-
-		ruleKeepRHS(w)
 	}, func(w *mergingWalker) {
 		if w.lhs == nil {
 			c.Added.Insert(w.path)
@@ -163,37 +142,115 @@ func (tv typedValue) Compare(rhs TypedValue) (c *Comparison, err error) {
 }
 
 // RemoveItems removes each provided list or map item from the value.
-func (tv typedValue) RemoveItems(items *fieldpath.Set) TypedValue {
-	copied := tv
-	copied.value, _ = value.FromUnstructured(tv.value.ToUnstructured(true))
-	removeItemsWithSchema(&copied.value, items, copied.schema, copied.typeRef)
-	return copied
+func (tv TypedValue) RemoveItems(items *fieldpath.Set) *TypedValue {
+	tv.value, _ = value.FromUnstructured(tv.value.ToUnstructured(true))
+	removeItemsWithSchema(&tv.value, items, tv.schema, tv.typeRef)
+	return &tv
 }
 
-func merge(lhs, rhs typedValue, rule, postRule mergeRule) (TypedValue, error) {
+// NormalizeUnions takes the new object and normalizes the union:
+// - If discriminator changed to non-nil, and a new field has been added
+// that doesn't match, an error is returned,
+// - If discriminator hasn't changed and two fields or more are set, an
+// error is returned,
+// - If discriminator changed to non-nil, all other fields but the
+// discriminated one will be cleared,
+// - Otherwise, If only one field is left, update discriminator to that value.
+//
+// Please note: union behavior isn't finalized yet and this is still experimental.
+func (tv TypedValue) NormalizeUnions(new *TypedValue) (*TypedValue, error) {
+	var errs ValidationErrors
+	var normalizeFn = func(w *mergingWalker) {
+		if w.rhs != nil {
+			v := *w.rhs
+			w.out = &v
+		}
+		if err := normalizeUnions(w); err != nil {
+			errs = append(errs, w.error(err)...)
+		}
+	}
+	out, mergeErrs := merge(&tv, new, func(w *mergingWalker) {}, normalizeFn)
+	if mergeErrs != nil {
+		errs = append(errs, mergeErrs.(ValidationErrors)...)
+	}
+	if len(errs) > 0 {
+		return nil, errs
+	}
+	return out, nil
+}
+
+// NormalizeUnionsApply specifically normalize unions on apply. It
+// validates that the applied union is correct (there should be no
+// ambiguity there), and clear the fields according to the sent intent.
+//
+// Please note: union behavior isn't finalized yet and this is still experimental.
+func (tv TypedValue) NormalizeUnionsApply(new *TypedValue) (*TypedValue, error) {
+	var errs ValidationErrors
+	var normalizeFn = func(w *mergingWalker) {
+		if w.rhs != nil {
+			v := *w.rhs
+			w.out = &v
+		}
+		if err := normalizeUnionsApply(w); err != nil {
+			errs = append(errs, w.error(err)...)
+		}
+	}
+	out, mergeErrs := merge(&tv, new, func(w *mergingWalker) {}, normalizeFn)
+	if mergeErrs != nil {
+		errs = append(errs, mergeErrs.(ValidationErrors)...)
+	}
+	if len(errs) > 0 {
+		return nil, errs
+	}
+	return out, nil
+}
+
+func (tv TypedValue) Empty() *TypedValue {
+	tv.value = value.Value{Null: true}
+	return &tv
+}
+
+var mwPool = sync.Pool{
+	New: func() interface{} { return &mergingWalker{} },
+}
+
+func merge(lhs, rhs *TypedValue, rule, postRule mergeRule) (*TypedValue, error) {
 	if lhs.schema != rhs.schema {
 		return nil, errorFormatter{}.
 			errorf("expected objects with types from the same schema")
 	}
-	if !reflect.DeepEqual(lhs.typeRef, rhs.typeRef) {
+	if !lhs.typeRef.Equals(rhs.typeRef) {
 		return nil, errorFormatter{}.
 			errorf("expected objects of the same type, but got %v and %v", lhs.typeRef, rhs.typeRef)
 	}
 
-	mw := mergingWalker{
-		lhs:          &lhs.value,
-		rhs:          &rhs.value,
-		schema:       lhs.schema,
-		typeRef:      lhs.typeRef,
-		rule:         rule,
-		postItemHook: postRule,
-	}
+	mw := mwPool.Get().(*mergingWalker)
+	defer func() {
+		mw.lhs = nil
+		mw.rhs = nil
+		mw.schema = nil
+		mw.typeRef = schema.TypeRef{}
+		mw.rule = nil
+		mw.postItemHook = nil
+		mw.out = nil
+		mw.inLeaf = false
+
+		mwPool.Put(mw)
+	}()
+
+	mw.lhs = &lhs.value
+	mw.rhs = &rhs.value
+	mw.schema = lhs.schema
+	mw.typeRef = lhs.typeRef
+	mw.rule = rule
+	mw.postItemHook = postRule
+
 	errs := mw.merge()
 	if len(errs) > 0 {
 		return nil, errs
 	}
 
-	out := typedValue{
+	out := &TypedValue{
 		schema:  lhs.schema,
 		typeRef: lhs.typeRef,
 	}
@@ -210,10 +267,6 @@ func merge(lhs, rhs typedValue, rule, postRule mergeRule) (TypedValue, error) {
 // No field will appear in more than one of the three fieldsets. If all of the
 // fieldsets are empty, then the objects must have been equal.
 type Comparison struct {
-	// Merged is the result of merging the two objects, as explained in the
-	// comments on TypedValue.Merge().
-	Merged TypedValue
-
 	// Removed contains any fields removed by rhs (the right-hand-side
 	// object in the comparison).
 	Removed *fieldpath.Set
@@ -231,15 +284,15 @@ func (c *Comparison) IsSame() bool {
 
 // String returns a human readable version of the comparison.
 func (c *Comparison) String() string {
-	str := fmt.Sprintf("- Merged Object:\n%v\n", c.Merged.AsValue())
+	bld := strings.Builder{}
 	if !c.Modified.Empty() {
-		str += fmt.Sprintf("- Modified Fields:\n%v\n", c.Modified)
+		bld.WriteString(fmt.Sprintf("- Modified Fields:\n%v\n", c.Modified))
 	}
 	if !c.Added.Empty() {
-		str += fmt.Sprintf("- Added Fields:\n%v\n", c.Added)
+		bld.WriteString(fmt.Sprintf("- Added Fields:\n%v\n", c.Added))
 	}
 	if !c.Removed.Empty() {
-		str += fmt.Sprintf("- Removed Fields:\n%v\n", c.Removed)
+		bld.WriteString(fmt.Sprintf("- Removed Fields:\n%v\n", c.Removed))
 	}
-	return str
+	return bld.String()
 }

vendor/sigs.k8s.io/structured-merge-diff/typed/union.go

@@ -0,0 +1,273 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package typed
+
+import (
+	"fmt"
+	"strings"
+
+	"sigs.k8s.io/structured-merge-diff/schema"
+	"sigs.k8s.io/structured-merge-diff/value"
+)
+
+func normalizeUnions(w *mergingWalker) error {
+	atom, found := w.schema.Resolve(w.typeRef)
+	if !found {
+		panic(fmt.Sprintf("Unable to resolve schema in normalize union: %v/%v", w.schema, w.typeRef))
+	}
+	// Unions can only be in structures, and the struct must not have been removed
+	if atom.Map == nil || w.out == nil {
+		return nil
+	}
+
+	old := &value.Map{}
+	if w.lhs != nil {
+		old = w.lhs.MapValue
+	}
+	for _, union := range atom.Map.Unions {
+		if err := newUnion(&union).Normalize(old, w.rhs.MapValue, w.out.MapValue); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func normalizeUnionsApply(w *mergingWalker) error {
+	atom, found := w.schema.Resolve(w.typeRef)
+	if !found {
+		panic(fmt.Sprintf("Unable to resolve schema in normalize union: %v/%v", w.schema, w.typeRef))
+	}
+	// Unions can only be in structures, and the struct must not have been removed
+	if atom.Map == nil || w.out == nil {
+		return nil
+	}
+
+	old := &value.Map{}
+	if w.lhs != nil {
+		old = w.lhs.MapValue
+	}
+	for _, union := range atom.Map.Unions {
+		if err := newUnion(&union).NormalizeApply(old, w.rhs.MapValue, w.out.MapValue); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type discriminated string
+type field string
+
+type discriminatedNames struct {
+	f2d map[field]discriminated
+	d2f map[discriminated]field
+}
+
+func newDiscriminatedName(f2d map[field]discriminated) discriminatedNames {
+	d2f := map[discriminated]field{}
+	for key, value := range f2d {
+		d2f[value] = key
+	}
+	return discriminatedNames{
+		f2d: f2d,
+		d2f: d2f,
+	}
+}
+
+func (dn discriminatedNames) toField(d discriminated) field {
+	if f, ok := dn.d2f[d]; ok {
+		return f
+	}
+	return field(d)
+}
+
+func (dn discriminatedNames) toDiscriminated(f field) discriminated {
+	if d, ok := dn.f2d[f]; ok {
+		return d
+	}
+	return discriminated(f)
+}
+
+type discriminator struct {
+	name string
+}
+
+func (d *discriminator) Set(m *value.Map, v discriminated) {
+	if d == nil {
+		return
+	}
+	m.Set(d.name, value.StringValue(string(v)))
+}
+
+func (d *discriminator) Get(m *value.Map) discriminated {
+	if d == nil || m == nil {
+		return ""
+	}
+	f, ok := m.Get(d.name)
+	if !ok {
+		return ""
+	}
+	if f.Value.StringValue == nil {
+		return ""
+	}
+	return discriminated(*f.Value.StringValue)
+}
+
+type fieldsSet map[field]struct{}
+
+// newFieldsSet returns a map of the fields that are part of the union and are set
+// in the given map.
+func newFieldsSet(m *value.Map, fields []field) fieldsSet {
+	if m == nil {
+		return nil
+	}
+	set := fieldsSet{}
+	for _, f := range fields {
+		if subField, ok := m.Get(string(f)); ok && !subField.Value.Null {
+			set.Add(f)
+		}
+	}
+	return set
+}
+
+func (fs fieldsSet) Add(f field) {
+	if fs == nil {
+		fs = map[field]struct{}{}
+	}
+	fs[f] = struct{}{}
+}
+
+func (fs fieldsSet) One() *field {
+	for f := range fs {
+		return &f
+	}
+	return nil
+}
+
+func (fs fieldsSet) Has(f field) bool {
+	_, ok := fs[f]
+	return ok
+}
+
+func (fs fieldsSet) List() []field {
+	fields := []field{}
+	for f := range fs {
+		fields = append(fields, f)
+	}
+	return fields
+}
+
+func (fs fieldsSet) Difference(o fieldsSet) fieldsSet {
+	n := fieldsSet{}
+	for f := range fs {
+		if !o.Has(f) {
+			n.Add(f)
+		}
+	}
+	return n
+}
+
+func (fs fieldsSet) String() string {
+	s := []string{}
+	for k := range fs {
+		s = append(s, string(k))
+	}
+	return strings.Join(s, ", ")
+}
+
+type union struct {
+	deduceInvalidDiscriminator bool
+	d                          *discriminator
+	dn                         discriminatedNames
+	f                          []field
+}
+
+func newUnion(su *schema.Union) *union {
+	u := &union{}
+	if su.Discriminator != nil {
+		u.d = &discriminator{name: *su.Discriminator}
+	}
+	f2d := map[field]discriminated{}
+	for _, f := range su.Fields {
+		u.f = append(u.f, field(f.FieldName))
+		f2d[field(f.FieldName)] = discriminated(f.DiscriminatorValue)
+	}
+	u.dn = newDiscriminatedName(f2d)
+	u.deduceInvalidDiscriminator = su.DeduceInvalidDiscriminator
+	return u
+}
+
+// clear removes all the fields in map that are part of the union, but
+// the one we decided to keep.
+func (u *union) clear(m *value.Map, f field) {
+	for _, fieldName := range u.f {
+		if field(fieldName) != f {
+			m.Delete(string(fieldName))
+		}
+	}
+}
+
+func (u *union) Normalize(old, new, out *value.Map) error {
+	os := newFieldsSet(old, u.f)
+	ns := newFieldsSet(new, u.f)
+	diff := ns.Difference(os)
+
+	if u.d.Get(old) != u.d.Get(new) && u.d.Get(new) != "" {
+		if len(diff) == 1 && u.d.Get(new) != u.dn.toDiscriminated(*diff.One()) {
+			return fmt.Errorf("discriminator (%v) and field changed (%v) don't match", u.d.Get(new), diff.One())
+		}
+		if len(diff) > 1 {
+			return fmt.Errorf("multiple new fields added: %v", diff)
+		}
+		u.clear(out, u.dn.toField(u.d.Get(new)))
+		return nil
+	}
+
+	if len(ns) > 1 {
+		return fmt.Errorf("multiple fields set without discriminator change: %v", ns)
+	}
+
+	// Update discriminiator if it needs to be deduced.
+	if u.deduceInvalidDiscriminator && len(ns) == 1 {
+		u.d.Set(out, u.dn.toDiscriminated(*ns.One()))
+	}
+
+	return nil
+}
+
+func (u *union) NormalizeApply(applied, merged, out *value.Map) error {
+	as := newFieldsSet(applied, u.f)
+	if len(as) > 1 {
+		return fmt.Errorf("more than one field of union applied: %v", as)
+	}
+	if len(as) == 0 {
+		// None is set, just leave.
+		return nil
+	}
+	// We have exactly one, discriminiator must match if set
+	if u.d.Get(applied) != "" && u.d.Get(applied) != u.dn.toDiscriminated(*as.One()) {
+		return fmt.Errorf("applied discriminator (%v) doesn't match applied field (%v)", u.d.Get(applied), *as.One())
+	}
+
+	// Update discriminiator if needed
+	if u.deduceInvalidDiscriminator {
+		u.d.Set(out, u.dn.toDiscriminated(*as.One()))
+	}
+	// Clear others fields.
+	u.clear(out, *as.One())
+
+	return nil
+}

vendor/sigs.k8s.io/structured-merge-diff/typed/validate.go

@@ -17,17 +17,33 @@ limitations under the License.
 package typed
 
 import (
+	"sync"
+
 	"sigs.k8s.io/structured-merge-diff/fieldpath"
 	"sigs.k8s.io/structured-merge-diff/schema"
 	"sigs.k8s.io/structured-merge-diff/value"
 )
 
-func (tv typedValue) walker() *validatingObjectWalker {
-	return &validatingObjectWalker{
-		value:   tv.value,
-		schema:  tv.schema,
-		typeRef: tv.typeRef,
-	}
+var vPool = sync.Pool{
+	New: func() interface{} { return &validatingObjectWalker{} },
+}
+
+func (tv TypedValue) walker() *validatingObjectWalker {
+	v := vPool.Get().(*validatingObjectWalker)
+	v.value = tv.value
+	v.schema = tv.schema
+	v.typeRef = tv.typeRef
+	return v
+}
+
+func (v *validatingObjectWalker) finished() {
+	v.value = value.Value{}
+	v.schema = nil
+	v.typeRef = schema.TypeRef{}
+	v.leafFieldCallback = nil
+	v.nodeFieldCallback = nil
+	v.inLeaf = false
+	vPool.Put(v)
 }
 
 type validatingObjectWalker struct {
@@ -49,10 +65,37 @@ type validatingObjectWalker struct {
 
 	// internal housekeeping--don't set when constructing.
 	inLeaf bool // Set to true if we're in a "big leaf"--atomic map/list
+
+	// Allocate only as many walkers as needed for the depth by storing them here.
+	spareWalkers *[]*validatingObjectWalker
 }
 
-func (v validatingObjectWalker) validate() ValidationErrors {
-	return resolveSchema(v.schema, v.typeRef, v)
+func (v *validatingObjectWalker) prepareDescent(pe fieldpath.PathElement, tr schema.TypeRef) *validatingObjectWalker {
+	if v.spareWalkers == nil {
+		// first descent.
+		v.spareWalkers = &[]*validatingObjectWalker{}
+	}
+	var v2 *validatingObjectWalker
+	if n := len(*v.spareWalkers); n > 0 {
+		v2, *v.spareWalkers = (*v.spareWalkers)[n-1], (*v.spareWalkers)[:n-1]
+	} else {
+		v2 = &validatingObjectWalker{}
+	}
+	*v2 = *v
+	v2.typeRef = tr
+	v2.errorFormatter.descend(pe)
+	return v2
+}
+
+func (v *validatingObjectWalker) finishDescent(v2 *validatingObjectWalker) {
+	// if the descent caused a realloc, ensure that we reuse the buffer
+	// for the next sibling.
+	v.errorFormatter = v2.errorFormatter.parent()
+	*v.spareWalkers = append(*v.spareWalkers, v2)
+}
+
+func (v *validatingObjectWalker) validate() ValidationErrors {
+	return resolveSchema(v.schema, v.typeRef, &v.value, v)
 }
 
 // doLeaf should be called on leaves before descending into children, if there
@@ -87,7 +130,7 @@ func (v *validatingObjectWalker) doNode() {
 	}
 }
 
-func (v validatingObjectWalker) doScalar(t schema.Scalar) ValidationErrors {
+func (v *validatingObjectWalker) doScalar(t *schema.Scalar) ValidationErrors {
 	if errs := v.validateScalar(t, &v.value, ""); len(errs) > 0 {
 		return errs
 	}
@@ -98,53 +141,8 @@ func (v validatingObjectWalker) doScalar(t schema.Scalar) ValidationErrors {
 	return nil
 }
 
-func (v validatingObjectWalker) visitStructFields(t schema.Struct, m *value.Map) (errs ValidationErrors) {
-	allowedNames := map[string]struct{}{}
-	for i := range t.Fields {
-		// I don't want to use the loop variable since a reference
-		// might outlive the loop iteration (in an error message).
-		f := t.Fields[i]
-		allowedNames[f.Name] = struct{}{}
-		child, ok := m.Get(f.Name)
-		if !ok {
-			// All fields are optional
-			continue
-		}
-		v2 := v
-		v2.errorFormatter.descend(fieldpath.PathElement{FieldName: &f.Name})
-		v2.value = child.Value
-		v2.typeRef = f.Type
-		errs = append(errs, v2.validate()...)
-	}
-
-	// All fields may be optional, but unknown fields are not allowed.
-	return append(errs, v.rejectExtraStructFields(m, allowedNames, "")...)
-}
-
-func (v validatingObjectWalker) doStruct(t schema.Struct) (errs ValidationErrors) {
-	m, err := mapOrStructValue(v.value, "struct")
-	if err != nil {
-		return v.error(err)
-	}
-
-	if t.ElementRelationship == schema.Atomic {
-		v.doLeaf()
-	}
-
-	if m == nil {
-		// nil is a valid map!
-		return nil
-	}
-
-	errs = v.visitStructFields(t, m)
-
-	// TODO: Check unions.
-
-	return errs
-}
-
-func (v validatingObjectWalker) visitListItems(t schema.List, list *value.List) (errs ValidationErrors) {
-	observedKeys := map[string]struct{}{}
+func (v *validatingObjectWalker) visitListItems(t *schema.List, list *value.List) (errs ValidationErrors) {
+	observedKeys := fieldpath.MakePathElementSet(len(list.Items))
 	for i, child := range list.Items {
 		pe, err := listItemToPathElement(t, i, child)
 		if err != nil {
@@ -154,23 +152,21 @@ func (v validatingObjectWalker) visitListItems(t schema.List, list *value.List)
 			// this element.
 			continue
 		}
-		keyStr := pe.String()
-		if _, found := observedKeys[keyStr]; found {
-			errs = append(errs, v.errorf("duplicate entries for key %v", keyStr)...)
+		if observedKeys.Has(pe) {
+			errs = append(errs, v.errorf("duplicate entries for key %v", pe.String())...)
 		}
-		observedKeys[keyStr] = struct{}{}
-		v2 := v
-		v2.errorFormatter.descend(pe)
+		observedKeys.Insert(pe)
+		v2 := v.prepareDescent(pe, t.ElementType)
 		v2.value = child
-		v2.typeRef = t.ElementType
 		errs = append(errs, v2.validate()...)
 
 		v2.doNode()
+		v.finishDescent(v2)
 	}
 	return errs
 }
 
-func (v validatingObjectWalker) doList(t schema.List) (errs ValidationErrors) {
+func (v *validatingObjectWalker) doList(t *schema.List) (errs ValidationErrors) {
 	list, err := listValue(v.value)
 	if err != nil {
 		return v.error(err)
@@ -189,22 +185,29 @@ func (v validatingObjectWalker) doList(t schema.List) (errs ValidationErrors) {
 	return errs
 }
 
-func (v validatingObjectWalker) visitMapItems(t schema.Map, m *value.Map) (errs ValidationErrors) {
-	for _, item := range m.Items {
-		v2 := v
-		name := item.Name
-		v2.errorFormatter.descend(fieldpath.PathElement{FieldName: &name})
-		v2.value = item.Value
-		v2.typeRef = t.ElementType
-		errs = append(errs, v2.validate()...)
+func (v *validatingObjectWalker) visitMapItems(t *schema.Map, m *value.Map) (errs ValidationErrors) {
+	for i := range m.Items {
+		item := &m.Items[i]
+		pe := fieldpath.PathElement{FieldName: &item.Name}
 
-		v2.doNode()
+		if sf, ok := t.FindField(item.Name); ok {
+			v2 := v.prepareDescent(pe, sf.Type)
+			v2.value = item.Value
+			errs = append(errs, v2.validate()...)
+			v.finishDescent(v2)
+		} else {
+			v2 := v.prepareDescent(pe, t.ElementType)
+			v2.value = item.Value
+			errs = append(errs, v2.validate()...)
+			v2.doNode()
+			v.finishDescent(v2)
+		}
 	}
 	return errs
 }
 
-func (v validatingObjectWalker) doMap(t schema.Map) (errs ValidationErrors) {
-	m, err := mapOrStructValue(v.value, "map")
+func (v *validatingObjectWalker) doMap(t *schema.Map) (errs ValidationErrors) {
+	m, err := mapValue(v.value)
 	if err != nil {
 		return v.error(err)
 	}
@@ -221,12 +224,3 @@ func (v validatingObjectWalker) doMap(t schema.Map) (errs ValidationErrors) {
 
 	return errs
 }
-
-func (v validatingObjectWalker) doUntyped(t schema.Untyped) (errs ValidationErrors) {
-	if t.ElementRelationship == "" || t.ElementRelationship == schema.Atomic {
-		// Untyped sections allow anything, and are considered leaf
-		// fields.
-		v.doLeaf()
-	}
-	return nil
-}

vendor/sigs.k8s.io/structured-merge-diff/value/fastjson.go

@@ -0,0 +1,149 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package value
+
+import (
+	"bytes"
+	"fmt"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+var (
+	readPool  = jsoniter.NewIterator(jsoniter.ConfigCompatibleWithStandardLibrary).Pool()
+	writePool = jsoniter.NewStream(jsoniter.ConfigCompatibleWithStandardLibrary, nil, 1024).Pool()
+)
+
+// FromJSONFast is a helper function for reading a JSON document
+func FromJSONFast(input []byte) (Value, error) {
+	iter := readPool.BorrowIterator(input)
+	defer readPool.ReturnIterator(iter)
+	return ReadJSONIter(iter)
+}
+
+func ReadJSONIter(iter *jsoniter.Iterator) (Value, error) {
+	next := iter.WhatIsNext()
+	switch next {
+	case jsoniter.InvalidValue:
+		iter.ReportError("reading an object", "got invalid token")
+		return Value{}, iter.Error
+	case jsoniter.StringValue:
+		str := String(iter.ReadString())
+		return Value{StringValue: &str}, nil
+	case jsoniter.NumberValue:
+		number := iter.ReadNumber()
+		isFloat := false
+		for _, c := range number {
+			if c == 'e' || c == 'E' || c == '.' {
+				isFloat = true
+				break
+			}
+		}
+		if isFloat {
+			f, err := number.Float64()
+			if err != nil {
+				iter.ReportError("parsing as float", err.Error())
+				return Value{}, err
+			}
+			return Value{FloatValue: (*Float)(&f)}, nil
+		}
+		i, err := number.Int64()
+		if err != nil {
+			iter.ReportError("parsing as float", err.Error())
+			return Value{}, err
+		}
+		return Value{IntValue: (*Int)(&i)}, nil
+	case jsoniter.NilValue:
+		iter.ReadNil()
+		return Value{Null: true}, nil
+	case jsoniter.BoolValue:
+		b := Boolean(iter.ReadBool())
+		return Value{BooleanValue: &b}, nil
+	case jsoniter.ArrayValue:
+		list := &List{}
+		iter.ReadArrayCB(func(iter *jsoniter.Iterator) bool {
+			v, err := ReadJSONIter(iter)
+			if err != nil {
+				iter.Error = err
+				return false
+			}
+			list.Items = append(list.Items, v)
+			return true
+		})
+		return Value{ListValue: list}, iter.Error
+	case jsoniter.ObjectValue:
+		m := &Map{}
+		iter.ReadObjectCB(func(iter *jsoniter.Iterator, key string) bool {
+			v, err := ReadJSONIter(iter)
+			if err != nil {
+				iter.Error = err
+				return false
+			}
+			m.Items = append(m.Items, Field{Name: key, Value: v})
+			return true
+		})
+		return Value{MapValue: m}, iter.Error
+	default:
+		return Value{}, fmt.Errorf("unexpected object type %v", next)
+	}
+}
+
+// ToJSONFast is a helper function for producing a JSon document.
+func (v *Value) ToJSONFast() ([]byte, error) {
+	buf := bytes.Buffer{}
+	stream := writePool.BorrowStream(&buf)
+	defer writePool.ReturnStream(stream)
+	v.WriteJSONStream(stream)
+	err := stream.Flush()
+	return buf.Bytes(), err
+}
+
+func (v *Value) WriteJSONStream(stream *jsoniter.Stream) {
+	switch {
+	case v.Null:
+		stream.WriteNil()
+	case v.FloatValue != nil:
+		stream.WriteFloat64(float64(*v.FloatValue))
+	case v.IntValue != nil:
+		stream.WriteInt64(int64(*v.IntValue))
+	case v.BooleanValue != nil:
+		stream.WriteBool(bool(*v.BooleanValue))
+	case v.StringValue != nil:
+		stream.WriteString(string(*v.StringValue))
+	case v.ListValue != nil:
+		stream.WriteArrayStart()
+		for i := range v.ListValue.Items {
+			if i > 0 {
+				stream.WriteMore()
+			}
+			v.ListValue.Items[i].WriteJSONStream(stream)
+		}
+		stream.WriteArrayEnd()
+	case v.MapValue != nil:
+		stream.WriteObjectStart()
+		for i := range v.MapValue.Items {
+			if i > 0 {
+				stream.WriteMore()
+			}
+			stream.WriteObjectField(v.MapValue.Items[i].Name)
+			v.MapValue.Items[i].Value.WriteJSONStream(stream)
+		}
+		stream.WriteObjectEnd()
+	default:
+		stream.Write([]byte("invalid_value"))
+	}
+}

vendor/sigs.k8s.io/structured-merge-diff/value/value.go

@@ -18,6 +18,7 @@ package value
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 )
 
@@ -33,22 +34,296 @@ type Value struct {
 	Null         bool // represents an explicit `"foo" = null`
 }
 
+// Equals returns true iff the two values are equal.
+func (v Value) Equals(rhs Value) bool {
+	if v.FloatValue != nil || rhs.FloatValue != nil {
+		var lf float64
+		if v.FloatValue != nil {
+			lf = float64(*v.FloatValue)
+		} else if v.IntValue != nil {
+			lf = float64(*v.IntValue)
+		} else {
+			return false
+		}
+		var rf float64
+		if rhs.FloatValue != nil {
+			rf = float64(*rhs.FloatValue)
+		} else if rhs.IntValue != nil {
+			rf = float64(*rhs.IntValue)
+		} else {
+			return false
+		}
+		return lf == rf
+	}
+	if v.IntValue != nil {
+		if rhs.IntValue != nil {
+			return *v.IntValue == *rhs.IntValue
+		}
+		return false
+	}
+	if v.StringValue != nil {
+		if rhs.StringValue != nil {
+			return *v.StringValue == *rhs.StringValue
+		}
+		return false
+	}
+	if v.BooleanValue != nil {
+		if rhs.BooleanValue != nil {
+			return *v.BooleanValue == *rhs.BooleanValue
+		}
+		return false
+	}
+	if v.ListValue != nil {
+		if rhs.ListValue != nil {
+			return v.ListValue.Equals(rhs.ListValue)
+		}
+		return false
+	}
+	if v.MapValue != nil {
+		if rhs.MapValue != nil {
+			return v.MapValue.Equals(rhs.MapValue)
+		}
+		return false
+	}
+	if v.Null {
+		if rhs.Null {
+			return true
+		}
+		return false
+	}
+	// No field is set, on either objects.
+	return true
+}
+
+// Less provides a total ordering for Value (so that they can be sorted, even
+// if they are of different types).
+func (v Value) Less(rhs Value) bool {
+	return v.Compare(rhs) == -1
+}
+
+// Compare provides a total ordering for Value (so that they can be
+// sorted, even if they are of different types). The result will be 0 if
+// v==rhs, -1 if v < rhs, and +1 if v > rhs.
+func (v Value) Compare(rhs Value) int {
+	if v.FloatValue != nil {
+		if rhs.FloatValue == nil {
+			// Extra: compare floats and ints numerically.
+			if rhs.IntValue != nil {
+				return v.FloatValue.Compare(Float(*rhs.IntValue))
+			}
+			return -1
+		}
+		return v.FloatValue.Compare(*rhs.FloatValue)
+	} else if rhs.FloatValue != nil {
+		// Extra: compare floats and ints numerically.
+		if v.IntValue != nil {
+			return Float(*v.IntValue).Compare(*rhs.FloatValue)
+		}
+		return 1
+	}
+
+	if v.IntValue != nil {
+		if rhs.IntValue == nil {
+			return -1
+		}
+		return v.IntValue.Compare(*rhs.IntValue)
+	} else if rhs.IntValue != nil {
+		return 1
+	}
+
+	if v.StringValue != nil {
+		if rhs.StringValue == nil {
+			return -1
+		}
+		return strings.Compare(string(*v.StringValue), string(*rhs.StringValue))
+	} else if rhs.StringValue != nil {
+		return 1
+	}
+
+	if v.BooleanValue != nil {
+		if rhs.BooleanValue == nil {
+			return -1
+		}
+		return v.BooleanValue.Compare(*rhs.BooleanValue)
+	} else if rhs.BooleanValue != nil {
+		return 1
+	}
+
+	if v.ListValue != nil {
+		if rhs.ListValue == nil {
+			return -1
+		}
+		return v.ListValue.Compare(rhs.ListValue)
+	} else if rhs.ListValue != nil {
+		return 1
+	}
+	if v.MapValue != nil {
+		if rhs.MapValue == nil {
+			return -1
+		}
+		return v.MapValue.Compare(rhs.MapValue)
+	} else if rhs.MapValue != nil {
+		return 1
+	}
+	if v.Null {
+		if !rhs.Null {
+			return -1
+		}
+		return 0
+	} else if rhs.Null {
+		return 1
+	}
+
+	// Invalid Value-- nothing is set.
+	return 0
+}
+
 type Int int64
 type Float float64
 type String string
 type Boolean bool
 
+// Compare compares integers. The result will be 0 if i==rhs, -1 if i <
+// rhs, and +1 if i > rhs.
+func (i Int) Compare(rhs Int) int {
+	if i > rhs {
+		return 1
+	} else if i < rhs {
+		return -1
+	}
+	return 0
+}
+
+// Compare compares floats. The result will be 0 if f==rhs, -1 if f <
+// rhs, and +1 if f > rhs.
+func (f Float) Compare(rhs Float) int {
+	if f > rhs {
+		return 1
+	} else if f < rhs {
+		return -1
+	}
+	return 0
+}
+
+// Compare compares booleans. The result will be 0 if b==rhs, -1 if b <
+// rhs, and +1 if b > rhs.
+func (b Boolean) Compare(rhs Boolean) int {
+	if b == rhs {
+		return 0
+	} else if b == false {
+		return -1
+	}
+	return 1
+}
+
 // Field is an individual key-value pair.
 type Field struct {
 	Name  string
 	Value Value
 }
 
+// FieldList is a list of key-value pairs. Each field is expected to
+// have a different name.
+type FieldList []Field
+
+// Sort sorts the field list by Name.
+func (f FieldList) Sort() {
+	if len(f) < 2 {
+		return
+	}
+	if len(f) == 2 {
+		if f[1].Name < f[0].Name {
+			f[0], f[1] = f[1], f[0]
+		}
+		return
+	}
+	sort.SliceStable(f, func(i, j int) bool {
+		return f[i].Name < f[j].Name
+	})
+}
+
+// Less compares two lists lexically.
+func (f FieldList) Less(rhs FieldList) bool {
+	return f.Compare(rhs) == -1
+}
+
+// Less compares two lists lexically. The result will be 0 if f==rhs, -1
+// if f < rhs, and +1 if f > rhs.
+func (f FieldList) Compare(rhs FieldList) int {
+	i := 0
+	for {
+		if i >= len(f) && i >= len(rhs) {
+			// Maps are the same length and all items are equal.
+			return 0
+		}
+		if i >= len(f) {
+			// F is shorter.
+			return -1
+		}
+		if i >= len(rhs) {
+			// RHS is shorter.
+			return 1
+		}
+		if c := strings.Compare(f[i].Name, rhs[i].Name); c != 0 {
+			return c
+		}
+		if c := f[i].Value.Compare(rhs[i].Value); c != 0 {
+			return c
+		}
+		// The items are equal; continue.
+		i++
+	}
+}
+
 // List is a list of items.
 type List struct {
 	Items []Value
 }
 
+// Equals compares two lists lexically.
+func (l *List) Equals(rhs *List) bool {
+	if len(l.Items) != len(rhs.Items) {
+		return false
+	}
+
+	for i, lv := range l.Items {
+		if !lv.Equals(rhs.Items[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// Less compares two lists lexically.
+func (l *List) Less(rhs *List) bool {
+	return l.Compare(rhs) == -1
+}
+
+// Compare compares two lists lexically. The result will be 0 if l==rhs, -1
+// if l < rhs, and +1 if l > rhs.
+func (l *List) Compare(rhs *List) int {
+	i := 0
+	for {
+		if i >= len(l.Items) && i >= len(rhs.Items) {
+			// Lists are the same length and all items are equal.
+			return 0
+		}
+		if i >= len(l.Items) {
+			// LHS is shorter.
+			return -1
+		}
+		if i >= len(rhs.Items) {
+			// RHS is shorter.
+			return 1
+		}
+		if c := l.Items[i].Compare(rhs.Items[i]); c != 0 {
+			return c
+		}
+		// The items are equal; continue.
+		i++
+	}
+}
+
 // Map is a map of key-value pairs. It represents both structs and maps. We use
 // a list and a go-language map to preserve order.
 //
@@ -58,20 +333,129 @@ type Map struct {
 
 	// may be nil; lazily constructed.
 	// TODO: Direct modifications to Items above will cause serious problems.
-	index map[string]*Field
+	index map[string]int
+	// may be empty; lazily constructed.
+	// TODO: Direct modifications to Items above will cause serious problems.
+	order []int
+}
+
+func (m *Map) computeOrder() []int {
+	if len(m.order) != len(m.Items) {
+		m.order = make([]int, len(m.Items))
+		for i := range m.order {
+			m.order[i] = i
+		}
+		sort.SliceStable(m.order, func(i, j int) bool {
+			return m.Items[m.order[i]].Name < m.Items[m.order[j]].Name
+		})
+	}
+	return m.order
+}
+
+// Equals compares two maps lexically.
+func (m *Map) Equals(rhs *Map) bool {
+	if len(m.Items) != len(rhs.Items) {
+		return false
+	}
+	for _, lfield := range m.Items {
+		rfield, ok := rhs.Get(lfield.Name)
+		if !ok {
+			return false
+		}
+		if !lfield.Value.Equals(rfield.Value) {
+			return false
+		}
+	}
+	return true
+}
+
+// Less compares two maps lexically.
+func (m *Map) Less(rhs *Map) bool {
+	return m.Compare(rhs) == -1
+}
+
+// Compare compares two maps lexically.
+func (m *Map) Compare(rhs *Map) int {
+	var noAllocL, noAllocR [2]int
+	var morder, rorder []int
+
+	// For very short maps (<2 elements) this permits us to avoid
+	// allocating the order array. We could make this accomodate larger
+	// maps, but 2 items should be enough to cover most path element
+	// comparisons, and at some point there will be diminishing returns.
+	// This has a large effect on the path element deserialization test,
+	// because everything is sorted / compared, but only once.
+	switch len(m.Items) {
+	case 0:
+		morder = noAllocL[0:0]
+	case 1:
+		morder = noAllocL[0:1]
+	case 2:
+		morder = noAllocL[0:2]
+		if m.Items[0].Name > m.Items[1].Name {
+			morder[0] = 1
+		} else {
+			morder[1] = 1
+		}
+	default:
+		morder = m.computeOrder()
+	}
+
+	switch len(rhs.Items) {
+	case 0:
+		rorder = noAllocR[0:0]
+	case 1:
+		rorder = noAllocR[0:1]
+	case 2:
+		rorder = noAllocR[0:2]
+		if rhs.Items[0].Name > rhs.Items[1].Name {
+			rorder[0] = 1
+		} else {
+			rorder[1] = 1
+		}
+	default:
+		rorder = rhs.computeOrder()
+	}
+
+	i := 0
+	for {
+		if i >= len(morder) && i >= len(rorder) {
+			// Maps are the same length and all items are equal.
+			return 0
+		}
+		if i >= len(morder) {
+			// LHS is shorter.
+			return -1
+		}
+		if i >= len(rorder) {
+			// RHS is shorter.
+			return 1
+		}
+		fa, fb := &m.Items[morder[i]], &rhs.Items[rorder[i]]
+		if c := strings.Compare(fa.Name, fb.Name); c != 0 {
+			return c
+		}
+		if c := fa.Value.Compare(fb.Value); c != 0 {
+			return c
+		}
+		// The items are equal; continue.
+		i++
+	}
 }
 
 // Get returns the (Field, true) or (nil, false) if it is not present
 func (m *Map) Get(key string) (*Field, bool) {
 	if m.index == nil {
-		m.index = map[string]*Field{}
+		m.index = map[string]int{}
 		for i := range m.Items {
-			f := &m.Items[i]
-			m.index[f.Name] = f
+			m.index[m.Items[i].Name] = i
 		}
 	}
 	f, ok := m.index[key]
-	return f, ok
+	if !ok {
+		return nil, false
+	}
+	return &m.Items[f], true
 }
 
 // Set inserts or updates the given item.
@@ -81,7 +465,22 @@ func (m *Map) Set(key string, value Value) {
 		return
 	}
 	m.Items = append(m.Items, Field{Name: key, Value: value})
-	m.index = nil // Since the append might have reallocated
+	i := len(m.Items) - 1
+	m.index[key] = i
+	m.order = nil
+}
+
+// Delete removes the key from the set.
+func (m *Map) Delete(key string) {
+	items := []Field{}
+	for i := range m.Items {
+		if m.Items[i].Name != key {
+			items = append(items, m.Items[i])
+		}
+	}
+	m.Items = items
+	m.index = nil // Since the list has changed
+	m.order = nil
 }
 
 // StringValue returns s as a scalar string Value.