// Copyright 2017, The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE.md file. package cmp import ( "fmt" "reflect" "strings" "unicode" "unicode/utf8" ) type ( // Path is a list of PathSteps describing the sequence of operations to get // from some root type to the current position in the value tree. // The first Path element is always an operation-less PathStep that exists // simply to identify the initial type. // // When traversing structs with embedded structs, the embedded struct will // always be accessed as a field before traversing the fields of the // embedded struct themselves. That is, an exported field from the // embedded struct will never be accessed directly from the parent struct. Path []PathStep // PathStep is a union-type for specific operations to traverse // a value's tree structure. Users of this package never need to implement // these types as values of this type will be returned by this package. PathStep interface { String() string Type() reflect.Type // Resulting type after performing the path step isPathStep() } // SliceIndex is an index operation on a slice or array at some index Key. SliceIndex interface { PathStep Key() int // May return -1 if in a split state // SplitKeys returns the indexes for indexing into slices in the // x and y values, respectively. These indexes may differ due to the // insertion or removal of an element in one of the slices, causing // all of the indexes to be shifted. If an index is -1, then that // indicates that the element does not exist in the associated slice. // // Key is guaranteed to return -1 if and only if the indexes returned // by SplitKeys are not the same. SplitKeys will never return -1 for // both indexes. SplitKeys() (x int, y int) isSliceIndex() } // MapIndex is an index operation on a map at some index Key. MapIndex interface { PathStep Key() reflect.Value isMapIndex() } // TypeAssertion represents a type assertion on an interface. TypeAssertion interface { PathStep isTypeAssertion() } // StructField represents a struct field access on a field called Name. StructField interface { PathStep Name() string Index() int isStructField() } // Indirect represents pointer indirection on the parent type. Indirect interface { PathStep isIndirect() } // Transform is a transformation from the parent type to the current type. Transform interface { PathStep Name() string Func() reflect.Value // Option returns the originally constructed Transformer option. // The == operator can be used to detect the exact option used. Option() Option isTransform() } ) func (pa *Path) push(s PathStep) { *pa = append(*pa, s) } func (pa *Path) pop() { *pa = (*pa)[:len(*pa)-1] } // Last returns the last PathStep in the Path. // If the path is empty, this returns a non-nil PathStep that reports a nil Type. func (pa Path) Last() PathStep { return pa.Index(-1) } // Index returns the ith step in the Path and supports negative indexing. // A negative index starts counting from the tail of the Path such that -1 // refers to the last step, -2 refers to the second-to-last step, and so on. // If index is invalid, this returns a non-nil PathStep that reports a nil Type. func (pa Path) Index(i int) PathStep { if i < 0 { i = len(pa) + i } if i < 0 || i >= len(pa) { return pathStep{} } return pa[i] } // String returns the simplified path to a node. // The simplified path only contains struct field accesses. // // For example: // MyMap.MySlices.MyField func (pa Path) String() string { var ss []string for _, s := range pa { if _, ok := s.(*structField); ok { ss = append(ss, s.String()) } } return strings.TrimPrefix(strings.Join(ss, ""), ".") } // GoString returns the path to a specific node using Go syntax. // // For example: // (*root.MyMap["key"].(*mypkg.MyStruct).MySlices)[2][3].MyField func (pa Path) GoString() string { var ssPre, ssPost []string var numIndirect int for i, s := range pa { var nextStep PathStep if i+1 < len(pa) { nextStep = pa[i+1] } switch s := s.(type) { case *indirect: numIndirect++ pPre, pPost := "(", ")" switch nextStep.(type) { case *indirect: continue // Next step is indirection, so let them batch up case *structField: numIndirect-- // Automatic indirection on struct fields case nil: pPre, pPost = "", "" // Last step; no need for parenthesis } if numIndirect > 0 { ssPre = append(ssPre, pPre+strings.Repeat("*", numIndirect)) ssPost = append(ssPost, pPost) } numIndirect = 0 continue case *transform: ssPre = append(ssPre, s.trans.name+"(") ssPost = append(ssPost, ")") continue case *typeAssertion: // As a special-case, elide type assertions on anonymous types // since they are typically generated dynamically and can be very // verbose. For example, some transforms return interface{} because // of Go's lack of generics, but typically take in and return the // exact same concrete type. if s.Type().PkgPath() == "" { continue } } ssPost = append(ssPost, s.String()) } for i, j := 0, len(ssPre)-1; i < j; i, j = i+1, j-1 { ssPre[i], ssPre[j] = ssPre[j], ssPre[i] } return strings.Join(ssPre, "") + strings.Join(ssPost, "") } type ( pathStep struct { typ reflect.Type } sliceIndex struct { pathStep xkey, ykey int } mapIndex struct { pathStep key reflect.Value } typeAssertion struct { pathStep } structField struct { pathStep name string idx int // These fields are used for forcibly accessing an unexported field. // pvx, pvy, and field are only valid if unexported is true. unexported bool force bool // Forcibly allow visibility pvx, pvy reflect.Value // Parent values field reflect.StructField // Field information } indirect struct { pathStep } transform struct { pathStep trans *transformer } ) func (ps pathStep) Type() reflect.Type { return ps.typ } func (ps pathStep) String() string { if ps.typ == nil { return "" } s := ps.typ.String() if s == "" || strings.ContainsAny(s, "{}\n") { return "root" // Type too simple or complex to print } return fmt.Sprintf("{%s}", s) } func (si sliceIndex) String() string { switch { case si.xkey == si.ykey: return fmt.Sprintf("[%d]", si.xkey) case si.ykey == -1: // [5->?] means "I don't know where X[5] went" return fmt.Sprintf("[%d->?]", si.xkey) case si.xkey == -1: // [?->3] means "I don't know where Y[3] came from" return fmt.Sprintf("[?->%d]", si.ykey) default: // [5->3] means "X[5] moved to Y[3]" return fmt.Sprintf("[%d->%d]", si.xkey, si.ykey) } } func (mi mapIndex) String() string { return fmt.Sprintf("[%#v]", mi.key) } func (ta typeAssertion) String() string { return fmt.Sprintf(".(%v)", ta.typ) } func (sf structField) String() string { return fmt.Sprintf(".%s", sf.name) } func (in indirect) String() string { return "*" } func (tf transform) String() string { return fmt.Sprintf("%s()", tf.trans.name) } func (si sliceIndex) Key() int { if si.xkey != si.ykey { return -1 } return si.xkey } func (si sliceIndex) SplitKeys() (x, y int) { return si.xkey, si.ykey } func (mi mapIndex) Key() reflect.Value { return mi.key } func (sf structField) Name() string { return sf.name } func (sf structField) Index() int { return sf.idx } func (tf transform) Name() string { return tf.trans.name } func (tf transform) Func() reflect.Value { return tf.trans.fnc } func (tf transform) Option() Option { return tf.trans } func (pathStep) isPathStep() {} func (sliceIndex) isSliceIndex() {} func (mapIndex) isMapIndex() {} func (typeAssertion) isTypeAssertion() {} func (structField) isStructField() {} func (indirect) isIndirect() {} func (transform) isTransform() {} var ( _ SliceIndex = sliceIndex{} _ MapIndex = mapIndex{} _ TypeAssertion = typeAssertion{} _ StructField = structField{} _ Indirect = indirect{} _ Transform = transform{} _ PathStep = sliceIndex{} _ PathStep = mapIndex{} _ PathStep = typeAssertion{} _ PathStep = structField{} _ PathStep = indirect{} _ PathStep = transform{} ) // isExported reports whether the identifier is exported. func isExported(id string) bool { r, _ := utf8.DecodeRuneInString(id) return unicode.IsUpper(r) } // isValid reports whether the identifier is valid. // Empty and underscore-only strings are not valid. func isValid(id string) bool { ok := id != "" && id != "_" for j, c := range id { ok = ok && (j > 0 || !unicode.IsDigit(c)) ok = ok && (c == '_' || unicode.IsLetter(c) || unicode.IsDigit(c)) } return ok }