internal/astinternal: add IncludePointers

This has been very useful for me when debugging ASTs
to tally pointers in log messages with nodes in the
final AST.

Signed-off-by: Roger Peppe <[email protected]>
Change-Id: Icdc564619069120aa425a16990c99c2faff2906f
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1205771
TryBot-Result: CUEcueckoo <[email protected]>
Reviewed-by: Daniel Martí <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>

Author: rogpeppe

Diff for: internal/astinternal/debug.go

@@ -56,6 +56,11 @@ type DebugConfig struct {
 	// IncludeNodeRefs causes a Node reference in an identifier
 	// to indicate which (if any) ast.Node it refers to.
 	IncludeNodeRefs bool
+
+	// IncludePointers causes all nodes to be printed with their pointer
+	// values; setting this also implies [DebugConfig.IncludeNodeRefs]
+	// and references will be printed as pointers.
+	IncludePointers bool
 }
 
 type debugPrinter struct {
@@ -82,6 +87,7 @@ func (d *debugPrinter) value0(v reflect.Value, impliedType reflect.Type) {
 	// Skip over interfaces and pointers, stopping early if nil.
 	concreteType := v.Type()
 	refName := ""
+	ptrVal := uintptr(0)
 	for {
 		k := v.Kind()
 		if k != reflect.Interface && k != reflect.Pointer {
@@ -95,6 +101,7 @@ func (d *debugPrinter) value0(v reflect.Value, impliedType reflect.Type) {
 		}
 		if k == reflect.Pointer {
 			if n, ok := v.Interface().(ast.Node); ok {
+				ptrVal = v.Pointer()
 				if id, ok := d.nodeRefs[n]; ok {
 					refName = refIDToName(id)
 				}
@@ -143,7 +150,11 @@ func (d *debugPrinter) value0(v reflect.Value, impliedType reflect.Type) {
 		if concreteType != impliedType {
 			d.printf("%s", concreteType)
 		}
-		if refName != "" {
+		if d.cfg.IncludePointers {
+			if ptrVal != 0 {
+				d.printf("@%#x", ptrVal)
+			}
+		} else if refName != "" {
 			d.printf("@%s", refName)
 		}
 		d.printf("{")
@@ -192,11 +203,18 @@ func (d *debugPrinter) structFields(v reflect.Value) (anyElems bool) {
 		}
 		if f.Name == "Node" {
 			nodeVal := v.Field(i)
-			if !d.cfg.IncludeNodeRefs || nodeVal.IsNil() {
+			if (!d.cfg.IncludeNodeRefs && !d.cfg.IncludePointers) || nodeVal.IsNil() {
 				continue
 			}
 			d.newline()
-			d.printf("Node: @%s (%v)", refIDToName(d.nodeRefs[nodeVal.Interface().(ast.Node)]), nodeVal.Elem().Type())
+			if d.cfg.IncludePointers {
+				if nodeVal.Kind() == reflect.Interface {
+					nodeVal = nodeVal.Elem()
+				}
+				d.printf("Node: @%#v (%v)", nodeVal.Pointer(), nodeVal.Elem().Type())
+			} else {
+				d.printf("Node: @%s (%v)", refIDToName(d.nodeRefs[nodeVal.Interface().(ast.Node)]), nodeVal.Elem().Type())
+			}
 			continue
 		}
 		switch f.Name {

Diff for: internal/astinternal/debug_test.go

@@ -17,6 +17,7 @@ package astinternal_test
 import (
 	"path"
 	"reflect"
+	"regexp"
 	"strings"
 	"testing"
 
@@ -28,17 +29,21 @@ import (
 	"github.com/go-quicktest/qt"
 )
 
+var ptrPat = regexp.MustCompile(`0x[0-9a-z]+`)
+
 func TestDebugPrint(t *testing.T) {
 	test := cuetxtar.TxTarTest{
 		Root: "testdata",
 		Name: "debugprint",
 	}
 
 	test.Run(t, func(t *cuetxtar.Test) {
+		includePointers := t.HasTag("includePointers")
 		for _, file := range t.Archive.Files {
 			if strings.HasPrefix(file.Name, "out/") {
 				continue
 			}
+
 			f, err := parser.ParseFile(file.Name, file.Data, parser.ParseComments)
 			qt.Assert(t, qt.IsNil(err))
 
@@ -49,7 +54,13 @@ func TestDebugPrint(t *testing.T) {
 			// the generated reference names should be deterministic.
 			full := astinternal.AppendDebug(nil, f, astinternal.DebugConfig{
 				IncludeNodeRefs: true,
+				IncludePointers: includePointers,
 			})
+			if includePointers {
+				// Pointer values change between runs. Replace with a constant
+				// string so that we can test stable output.
+				full = ptrPat.ReplaceAll(full, []byte("XXXX"))
+			}
 			t.Writer(file.Name).Write(full)
 
 			// A syntax tree which omits any empty values,

Diff for: internal/astinternal/testdata/debugprint/withpointer.txtar

@@ -0,0 +1,79 @@
+#includePointers
+-- file.cue --
+package p
+
+a: b
+b: 3
+-- out/debugprint/file.cue --
+*ast.File@XXXX{
+	Filename: "file.cue"
+	Decls: []ast.Decl{
+		*ast.Package@XXXX{
+			PackagePos: token.Pos("file.cue:1:1", nospace)
+			Name: *ast.Ident@XXXX{
+				NamePos: token.Pos("file.cue:1:9", blank)
+				Name: "p"
+			}
+		}
+		*ast.Field@XXXX{
+			Label: *ast.Ident@XXXX{
+				NamePos: token.Pos("file.cue:3:1", section)
+				Name: "a"
+			}
+			Optional: token.Pos("-")
+			Constraint: token.Token("ILLEGAL")
+			TokenPos: token.Pos("file.cue:3:2", nospace)
+			Token: token.Token(":")
+			Value: *ast.Ident@XXXX{
+				NamePos: token.Pos("file.cue:3:4", blank)
+				Name: "b"
+				Node: @XXXX (ast.BasicLit)
+			}
+			Attrs: []*ast.Attribute{}
+		}
+		*ast.Field@XXXX{
+			Label: *ast.Ident@XXXX{
+				NamePos: token.Pos("file.cue:4:1", newline)
+				Name: "b"
+			}
+			Optional: token.Pos("-")
+			Constraint: token.Token("ILLEGAL")
+			TokenPos: token.Pos("file.cue:4:2", nospace)
+			Token: token.Token(":")
+			Value: *ast.BasicLit@XXXX{
+				ValuePos: token.Pos("file.cue:4:4", blank)
+				Kind: token.Token("INT")
+				Value: "3"
+			}
+			Attrs: []*ast.Attribute{}
+		}
+	}
+	Imports: []*ast.ImportSpec{}
+}
+-- out/debugprint/file.cue/omitempty-strings --
+*ast.File{
+	Filename: "file.cue"
+	Decls: []ast.Decl{
+		*ast.Package{
+			Name: *ast.Ident{
+				Name: "p"
+			}
+		}
+		*ast.Field{
+			Label: *ast.Ident{
+				Name: "a"
+			}
+			Value: *ast.Ident{
+				Name: "b"
+			}
+		}
+		*ast.Field{
+			Label: *ast.Ident{
+				Name: "b"
+			}
+			Value: *ast.BasicLit{
+				Value: "3"
+			}
+		}
+	}
+}