How to get a map or list of template 'actions' from a parsed template?

So I would like to somehow get all of my {{ .blahblah }} actions defined in a template as slice of strings.

For example if I have this template:

<h1>{{ .name }} {{ .age }}</h1>

I would like to be able to get []string{"name", "age"}. Pretend that a template has the method func (t *Template) Fields() []string:

t := template.New("cooltemplate").Parse(`<h1>{{ .name }} {{ .age }}</h1>`)
if t.Fields() == []string{"name", "age"} {
    fmt.Println("Yay, now I know what fields I can pass in!")
    // Now lets pass in the name field that we just discovered.
    _ = t.Execute(os.Stdout, map[string]string{"name": "Jack", "age":"120"})
}

Is there a way to inspect a parsed template like this?
Thanks!

Foreword: As Voker suggests, the Template.Tree field is "exported only for use by html/template and should be treated as unexported by all other clients."

You should not rely on such thing to be able to provide input for a template execution. You must know the template you want to execute along with the data it expects. You shouldn't "explore" it at runtime to provide arguments for it.

The value you get out of parsing a template is template.Template (either text/template or html/template, they have the same API). This template represents the templates as a tree of type parse.Tree. Everything that a text template contains is stored in this tree in nodes, including static texts, actions etc.

Having said that, you can walk this tree and look for nodes that identify such actions that access fields or call functions. The nodes are of type parse.Node which has a Node.Type() method returning its type. The possible types are defined as constants in the parse package, next to the parse.NodeType type, e.g.

const (
        NodeText    NodeType = iota // Plain text.
        NodeAction                  // A non-control action such as a field evaluation.
        NodeBool                    // A boolean constant.
        NodeChain                   // A sequence of field accesses.
        NodeCommand                 // An element of a pipeline.
        NodeDot                     // The cursor, dot.

        NodeField      // A field or method name.
        NodeIdentifier // An identifier; always a function name.
        NodeIf         // An if action.
        NodeList       // A list of Nodes.
        NodeNil        // An untyped nil constant.
        NodeNumber     // A numerical constant.
        NodePipe       // A pipeline of commands.
        NodeRange      // A range action.
        NodeString     // A string constant.
        NodeTemplate   // A template invocation action.
        NodeVariable   // A $ variable.
        NodeWith       // A with action.
)

So here is an example program that recursively walks a template tree, and looks for nodes with NodeAction type, which is "A non-control action such as a field evaluation."

This solution is just a demonstration, a proof of concept, it does not handle all cases.

func ListTemplFields(t *template.Template) []string {
	return listNodeFields(t.Tree.Root, nil)
}

func listNodeFields(node parse.Node, res []string) []string {
	if node.Type() == parse.NodeAction {
		res = append(res, node.String())
	}

	if ln, ok := node.(*parse.ListNode); ok {
		for _, n := range ln.Nodes {
			res = listNodeFields(n, res)
		}
	}
	return res
}

Example using it:

t := template.Must(template.New("cooltemplate").
    Parse(`<h1>{{ .name }} {{ .age }}</h1>`))
fmt.Println(ListTemplFields(t))

Output (try it on the Go Playground):

[{{.name}} {{.age}}]

A small optimization to @icza 's answer, maybe it helps a little

func listNodeFieldsV2(node parse.Node) []string {
	var res []string
	if node.Type() == parse.NodeAction {
		res = append(res, node.String())
	}
	if ln, ok := node.(*parse.ListNode); ok {
		for _, n := range ln.Nodes {
			res = append(res, listNodeFieldsV2(n)...)
		}
	}
	return res
}

I have happened to need roughly the same code.
In my use case, we allow users to create templates on one side, and to enter a map[string]string of variables to be used for rendering in a different form.

This is the code that I came up with so far (inspired by icza's answer):

// Extract the template vars required from *simple* templates.
// Only works for top level, plain variables. Returns all problematic parse.Node as errors.
func RequiredTemplateVars(t *template.Template) ([]string, []error) {
	var res []string
	var errors []error
	var ln *parse.ListNode
	ln = t.Tree.Root
Node:
	for _, n := range ln.Nodes {
		if nn, ok := n.(*parse.ActionNode); ok {
			p := nn.Pipe
			if len(p.Decl) > 0 {
				errors = append(errors, fmt.Errorf("Node %v not supported", n))
				continue Node
			}
			for _, c := range p.Cmds {
				if len(c.Args) != 1 {
					errors = append(errors, fmt.Errorf("Node %v not supported", n))
					continue Node
				}
				if a, ok := c.Args[0].(*parse.FieldNode); ok {
					if len(a.Ident) != 1 {
						errors = append(errors, fmt.Errorf("Node %v not supported", n))
						continue Node
					}
					res = append(res, a.Ident[0])
				} else {
					errors = append(errors, fmt.Errorf("Node %v not supported", n))
					continue Node
				}

			}
		} else {
			if _, ok := n.(*parse.TextNode); !ok {
				errors = append(errors, fmt.Errorf("Node %v not supported", n))
				continue Node
			}
		}
	}
	return res, errors
}

https://play.golang.org/p/nH95B45jUmI

solution for search variables in template, with reflect + template

func parseTemplateVariables(template string) {
parsedTemplate, err := text_template.New("test").Option("missingkey=error").Parse(template)
if err != nil {
panic(err)
}
visited := make(map[interface{}]bool)
queue := []reflect.Value{reflect.ValueOf(parsedTemplate.Root)}
for len(queue) != 0 {
node := queue[0]
queue = queue[1:]
for node.Kind() != reflect.Struct && node.Kind() != reflect.Array && node.Kind() != reflect.Slice {
node = node.Elem()
}
if node.CanInterface() {
vInterface := node.Interface()
if listNode, ok := vInterface.([]parse.Node); ok {
for _, itemNode := range listNode {
if itemNode.Type() == parse.NodeField {
log.Printf("using variable: %v", itemNode)
}
}
}
}
var n int
if node.Kind() == reflect.Array || node.Kind() == reflect.Slice {
n = node.Len()
} else {
n = node.NumField()
}
for i := 0; i != n; i++ {
var itemNode reflect.Value
if node.Kind() == reflect.Array || node.Kind() == reflect.Slice {
itemNode = node.Index(i)
} else {
itemNode = node.Field(i)
}
if !itemNode.IsValid() || itemNode.IsZero() {
continue
}
if itemNode.Kind() == reflect.Bool ||
itemNode.Kind() == reflect.String ||
itemNode.Kind() == reflect.Int || itemNode.Kind() == reflect.Int8 || itemNode.Kind() == reflect.Int16 || itemNode.Kind() == reflect.Int32 || itemNode.Kind() == reflect.Int64 ||
itemNode.Kind() == reflect.Uint || itemNode.Kind() == reflect.Uint8 || itemNode.Kind() == reflect.Uint16 || itemNode.Kind() == reflect.Uint32 || itemNode.Kind() == reflect.Uint64 || itemNode.Kind() == reflect.Uintptr ||
itemNode.Kind() == reflect.Float32 || itemNode.Kind() == reflect.Float64 ||
itemNode.Kind() == reflect.Complex64 || itemNode.Kind() == reflect.Complex128 {
continue
}
k := itemNode.Kind()
_ = k
if itemNode.Kind() == reflect.Array || itemNode.Kind() == reflect.Slice {
itemNodePtr := itemNode.Addr()
if _, ok := visited[itemNodePtr]; ok {
continue
}
visited[itemNodePtr] = true
//log.Printf("%v", itemNodePtr)
} else {
itemNodePtr := itemNode.Addr()
if _, ok := visited[itemNodePtr]; ok {
continue
}
visited[itemNodePtr] = true
//log.Printf("%v", itemNodePtr)
}
queue = append(queue, itemNode)
}
}
}

solution for find variables, with reflect + template

func parseTemplateVariables(template string) {
parsedTemplate, err := text_template.New("test").Option("missingkey=error").Parse(template)
if err != nil {
panic(err)
}
visited := make(map[interface{}]bool)
queue := []reflect.Value{reflect.ValueOf(parsedTemplate.Root)}
for len(queue) != 0 {
node := queue[0]
queue = queue[1:]
for node.Kind() != reflect.Struct && node.Kind() != reflect.Array && node.Kind() != reflect.Slice {
node = node.Elem()
}
if node.CanInterface() {
vInterface := node.Interface()
if listNode, ok := vInterface.([]parse.Node); ok {
for _, itemNode := range listNode {
if itemNode.Type() == parse.NodeField {
log.Printf("using variable: %v", itemNode)
}
}
}
}
var n int
if node.Kind() == reflect.Array || node.Kind() == reflect.Slice {
n = node.Len()
} else {
n = node.NumField()
}
for i := 0; i != n; i++ {
var itemNode reflect.Value
if node.Kind() == reflect.Array || node.Kind() == reflect.Slice {
itemNode = node.Index(i)
} else {
itemNode = node.Field(i)
}
if !itemNode.IsValid() || itemNode.IsZero() {
continue
}
if itemNode.Kind() == reflect.Bool ||
itemNode.Kind() == reflect.String ||
itemNode.Kind() == reflect.Int || itemNode.Kind() == reflect.Int8 || itemNode.Kind() == reflect.Int16 || itemNode.Kind() == reflect.Int32 || itemNode.Kind() == reflect.Int64 ||
itemNode.Kind() == reflect.Uint || itemNode.Kind() == reflect.Uint8 || itemNode.Kind() == reflect.Uint16 || itemNode.Kind() == reflect.Uint32 || itemNode.Kind() == reflect.Uint64 || itemNode.Kind() == reflect.Uintptr ||
itemNode.Kind() == reflect.Float32 || itemNode.Kind() == reflect.Float64 ||
itemNode.Kind() == reflect.Complex64 || itemNode.Kind() == reflect.Complex128 {
continue
}
k := itemNode.Kind()
_ = k
if itemNode.Kind() == reflect.Array || itemNode.Kind() == reflect.Slice {
itemNodePtr := itemNode.Addr()
if _, ok := visited[itemNodePtr]; ok {
continue
}
visited[itemNodePtr] = true
//log.Printf("%v", itemNodePtr)
} else {
itemNodePtr := itemNode.Addr()
if _, ok := visited[itemNodePtr]; ok {
continue
}
visited[itemNodePtr] = true
//log.Printf("%v", itemNodePtr)
}
queue = append(queue, itemNode)
}
}
}