Add explanatory comment

Author: jcburley

spew/bypass.go

@@ -49,6 +49,8 @@ var (
 	// value may be taken.
 	flagAddr flag
 
+	// flagPrivate indicates whether the reflect.Value is exported
+	// or private.
 	flagPrivate flag
 )
 

spew/config.go

@@ -98,19 +98,6 @@ type ConfigState struct {
 	// be spewed to strings and sorted by those strings.  This is only
 	// considered if SortKeys is true.
 	SpewKeys bool
-
-	// NoDuplicates specifies that any given pointer should have
-	// its dereference dumped only once. This is similar to
-	// circularity detection, but applies to all pointers across a
-	// given dump action. This can consume much memory.
-	NoDuplicates bool
-
-	// UseOrdinals specifies that pointer values are to be
-	// replaced with monotonically increasing integers. It has no
-	// effect if DisablePointerAddresses is true; else, it
-	// provides some degree of stability across runs versus
-	// printing out raw pointers. This can consume much memory.
-	UseOrdinals bool
 }
 
 // Config is the active configuration of the top-level functions.

spew/dump.go

@@ -52,11 +52,9 @@ type dumpState struct {
 	w                io.Writer
 	depth            int
 	pointers         map[uintptr]int
-	allPointers      map[uintptr]uintptr
 	ignoreNextType   bool
 	ignoreNextIndent bool
 	cs               *ConfigState
-	nextOrdinal      uintptr
 }
 
 // indent performs indentation according to the depth level and cs.Indent
@@ -79,50 +77,6 @@ func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
 	return v
 }
 
-func (d *dumpState) isPointerSeen(addr uintptr) (seen bool, ordinal uintptr) {
-	ordinal = uintptr(addr)
-
-	if d.allPointers == nil {
-		return false, ordinal
-	}
-
-	// d.cs.NoDuplicates || d.cs.UseOrdinals
-	duplicateFound := false
-	if ord, ok := d.allPointers[addr]; ok {
-		if d.cs.UseOrdinals {
-			ordinal = ord
-		}
-		if d.cs.NoDuplicates {
-			duplicateFound = true
-		}
-	} else {
-		if d.cs.UseOrdinals {
-			d.nextOrdinal++
-			ordinal = d.nextOrdinal
-		}
-		d.allPointers[addr] = ordinal
-	}
-
-	return duplicateFound, ordinal
-}
-
-func (d *dumpState) printPtrOrOrdinal(addr uintptr) {
-	if d.cs.UseOrdinals {
-		printOrdinal(d.w, addr)
-	} else {
-		printHexPtr(d.w, addr)
-	}
-}
-
-func (d *dumpState) printPtr(addr uintptr) {
-	if d.cs.UseOrdinals {
-		_, addr := d.isPointerSeen(addr)
-		printOrdinal(d.w, addr)
-	} else {
-		printHexPtr(d.w, addr)
-	}
-}
-
 // dumpPtr handles formatting of pointers by indirecting them as necessary.
 func (d *dumpState) dumpPtr(v reflect.Value) {
 	// Remove pointers at or below the current depth from map used to detect
@@ -141,7 +95,6 @@ func (d *dumpState) dumpPtr(v reflect.Value) {
 	// references.
 	nilFound := false
 	cycleFound := false
-	duplicateFound := false
 	indirects := 0
 	ve := v
 	for ve.Kind() == reflect.Ptr {
@@ -151,21 +104,12 @@ func (d *dumpState) dumpPtr(v reflect.Value) {
 		}
 		indirects++
 		addr := ve.Pointer()
-
+		pointerChain = append(pointerChain, addr)
 		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
 			cycleFound = true
-		}
-
-		dup, ordinal := d.isPointerSeen(addr)
-
-		pointerChain = append(pointerChain, ordinal)
-
-		if cycleFound || dup {
 			indirects--
-			duplicateFound = true
 			break
 		}
-
 		d.pointers[addr] = d.depth
 
 		ve = ve.Elem()
@@ -191,7 +135,7 @@ func (d *dumpState) dumpPtr(v reflect.Value) {
 			if i > 0 {
 				d.w.Write(pointerChainBytes)
 			}
-			d.printPtrOrOrdinal(addr)
+			printHexPtr(d.w, addr)
 		}
 		d.w.Write(closeParenBytes)
 	}
@@ -205,9 +149,6 @@ func (d *dumpState) dumpPtr(v reflect.Value) {
 	case cycleFound:
 		d.w.Write(circularBytes)
 
-	case duplicateFound:
-		d.w.Write(duplicateBytes)
-
 	default:
 		d.ignoreNextType = true
 		d.dump(ve)
@@ -441,7 +382,6 @@ func (d *dumpState) dump(v reflect.Value) {
 			d.indent()
 			d.w.Write(maxNewlineBytes)
 		} else {
-			v = unsafeReflectValue(v)
 			numEntries := v.Len()
 			keys := v.MapKeys()
 			if d.cs.SortKeys {
@@ -491,10 +431,10 @@ func (d *dumpState) dump(v reflect.Value) {
 		d.w.Write(closeBraceBytes)
 
 	case reflect.Uintptr:
-		d.printPtr(uintptr(v.Uint()))
+		printHexPtr(d.w, uintptr(v.Uint()))
 
 	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		d.printPtr(v.Pointer())
+		printHexPtr(d.w, v.Pointer())
 
 	// There were not any other types at the time this code was written, but
 	// fall back to letting the default fmt package handle it in case any new
@@ -522,9 +462,6 @@ func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
 
 		d := dumpState{w: w, cs: cs}
 		d.pointers = make(map[uintptr]int)
-		if cs.NoDuplicates || cs.UseOrdinals {
-			d.allPointers = make(map[uintptr]uintptr)
-		}
 		d.dump(reflect.ValueOf(arg))
 		d.w.Write(newlineBytes)
 	}

spew/dump_test.go

@@ -1040,117 +1040,3 @@ func TestDumpSortedKeys(t *testing.T) {
 	}
 
 }
-
-func TestDumpDuplicatePointers(t *testing.T) {
-	cfg := spew.ConfigState{NoDuplicates: true}
-	type info struct {
-		a int
-		b int
-	}
-	type twice struct {
-		info1 *info
-		info2 *info
-		info3 *info
-	}
-	i1 := &info{a: 1, b: 2}
-	ip1 := fmt.Sprintf("%p", i1)
-	i2 := &info{a: 3, b: 4}
-	ip2 := fmt.Sprintf("%p", i2)
-	v := twice{info1: i1, info2: i2, info3: i1}
-	//	vt := "spew_test.twice"
-	s := cfg.Sdump(v)
-	expected := `(spew_test.twice) {
-info1: (*spew_test.info)(` + ip1 + `)({
-a: (int) 1,
-b: (int) 2
-}),
-info2: (*spew_test.info)(` + ip2 + `)({
-a: (int) 3,
-b: (int) 4
-}),
-info3: (*spew_test.info)(` + ip1 + `)(<already seen>)
-}
-`
-	if s != expected {
-		t.Errorf("Duplicate-pointers mismatch:\n  %v %v", s, expected)
-	}
-}
-
-func TestDumpOrdinals(t *testing.T) {
-	cfg := spew.ConfigState{UseOrdinals: true}
-	type info struct {
-		a int
-		b int
-	}
-	type twice struct {
-		info1 *info
-		info2 *info
-		info3 *info
-	}
-	i := &info{a: 1, b: 2}
-	v := twice{info1: i, info2: &info{a: 3, b: 4}, info3: i}
-	//	vt := "spew_test.twice"
-	s := cfg.Sdump(v)
-	expected := `(spew_test.twice) {
-info1: (*spew_test.info)(#1)({
-a: (int) 1,
-b: (int) 2
-}),
-info2: (*spew_test.info)(#2)({
-a: (int) 3,
-b: (int) 4
-}),
-info3: (*spew_test.info)(#1)({
-a: (int) 1,
-b: (int) 2
-})
-}
-`
-	if s != expected {
-		t.Errorf("Ordinals mismatch:\n  %v %v", s, expected)
-	}
-}
-
-func a() {
-}
-
-func b() {
-}
-
-func TestDumpDuplicateOrdinals(t *testing.T) {
-	cfg := spew.ConfigState{NoDuplicates: true, UseOrdinals: true}
-	type info struct {
-		a int
-		b int
-	}
-	type twice struct {
-		info1 *info
-		info2 *info
-		info3 *info
-		fn1   func()
-		fn2   func()
-		fn3   func()
-	}
-	i := &info{a: 1, b: 2}
-	v := twice{info1: i, info2: &info{a: 3, b: 4}, info3: i, fn1: a, fn2: b, fn3: a}
-	//	vt := "spew_test.twice"
-	s := cfg.Sdump(v)
-	expected := `(spew_test.twice) {
-info1: (*spew_test.info)(#1)({
-a: (int) 1,
-b: (int) 2
-}),
-info2: (*spew_test.info)(#2)({
-a: (int) 3,
-b: (int) 4
-}),
-info3: (*spew_test.info)(#1)(<already seen>),
-fn1: (func()) #3,
-fn2: (func()) #4,
-fn3: (func()) #3
-}
-`
-	if s != expected {
-		t.Errorf("Duplicate-pointers mismatch:\n  %v %v", s, expected)
-	}
-}