Based on your example, you want to call the parser directly. You can tell the parser to not complain about functions by, after the call to parse.New adding a line parser.Mode = parse.SkipFuncCheck.

Closing because I don't think there is anything to change in the text/template package. Please comment if you disagree.

Hi @ianlancetaylor, the issue doesn't lie in the parser. The issue is declaring a new template via template.New() does not initialize the internal func map with the built-in functions. The map of built-in functions is also not exported from the text/template package, so its not accessible for use in a call to Funcs().

In scenarios where you're using text/template/parse.Parse over text/template.Template.Parse (like memoize the parse.Tree objects, for example) the built-in functions will never get set, so calling template.Execute will panic with the error mentioned above.

I hope that makes more sense. I don't believe this issue should be closed

In that case, could you show a test case that demonstrates the problem? The test case you showed earlier doesn't use template.New. It uses parse.New. Thanks.

Sure, here's the code from the playground link in the OP:

package main

import (
	"bytes"
	"text/template"
	"text/template/parse"
)

func main() {
	tmpl := `
	  {{ define "base" }}
	    {{ if eq "true" "true" }}
	    {{ end }}
	  {{ end }} 
	`

	parser := parse.New("base")
	treeSet := make(map[string]*parse.Tree)
	_, err := parser.Parse(tmpl, "{{", "}}", treeSet)
	if err != nil {
		panic(err)
	}

	t := template.New("base") 
	for k, v := range treeSet {
		_, err := t.AddParseTree(k, v)
		if err != nil {
			panic(err)
		}
	}

	buf := bytes.Buffer{}
	err = t.ExecuteTemplate(&buf, "base", nil)
	if err != nil {
		panic(err) // panic here: function "eq" not defined
	}
}

See the Parse function implementation of text/template:

builtins are added to the template's FuncMap when Parse is called, since the expectation is that those functions will always be available.

But what if you use text/template/parse.Parse directly? You can't access builtins because its an unexported function, as with all of the functions it references.

Perhaps we could move the addition of builtins to the template's internal init function so that these functions are always available, whether the parsing was handled internally by the template or not.

On line 77:
t.Funcs(builtins())

Without this, theres not much utility to text/template/parse except for internal to the text/template package.

I saw the code in the playground link. When I run it I see a panic after a call to Parse.New and parser.Parse. It panics before the call to template.New. You are saying there is a problem with template.New, and I'm asking to see code that demonstrates that problem. Thanks.