Add parse test

Author: paulsmith

src/text/template/exampleparent_test.go

@@ -29,7 +29,6 @@ func ExampleTemplate_parent() {
 
 	const index_html = `{{define "content"}}<h1>Welcome!</h1>{{end}}`
 	index := template.Must(template.Must(base.Clone()).New("index.html").Parse(index_html))
-
 	{
 		err := index.ExecuteTemplate(os.Stdout, "base.html", nil)
 		if err != nil {
@@ -40,7 +39,6 @@ func ExampleTemplate_parent() {
 	const about_html = `{{define "title"}}{{template parent .}} - About{{end}}
 {{define "content"}}<h1>About us</h1>{{end}}`
 	about := template.Must(template.Must(base.Clone()).New("about.html").Parse(about_html))
-
 	{
 		err := about.ExecuteTemplate(os.Stdout, "base.html", nil)
 		if err != nil {

src/text/template/parse/node.go

@@ -956,7 +956,11 @@ func (t *TemplateNode) String() string {
 
 func (t *TemplateNode) writeTo(sb *strings.Builder) {
 	sb.WriteString("{{template ")
-	sb.WriteString(strconv.Quote(t.Name))
+	if t.Parent {
+		sb.WriteString("parent")
+	} else {
+		sb.WriteString(strconv.Quote(t.Name))
+	}
 	if t.Pipe != nil {
 		sb.WriteByte(' ')
 		t.Pipe.writeTo(sb)

src/text/template/parse/parse.go

@@ -160,7 +160,7 @@ func (t *Tree) ErrorContext(n Node) (location, context string) {
 // errorf formats the error and terminates processing.
 func (t *Tree) errorf(format string, args ...interface{}) {
 	t.Root = nil
-	format = fmt.Sprintf("\x1b[1;33mPAULDEV\x1b[0m template: %s:%d: %s", t.ParseName, t.token[0].line, format)
+	format = fmt.Sprintf("template: %s:%d: %s", t.ParseName, t.token[0].line, format)
 	panic(fmt.Errorf(format, args...))
 }
 
@@ -580,7 +580,7 @@ func (t *Tree) blockControl() Node {
 	block.add()
 	block.stopParse()
 
-	return t.newTemplate(token.pos, token.line, name, false, pipe) // TODO: support parent?
+	return t.newTemplate(token.pos, token.line, name, false, pipe)
 }
 
 // Template:
@@ -595,16 +595,15 @@ func (t *Tree) templateControl() Node {
 		parent bool
 	)
 	if token.typ == itemParent {
-		// If we encounter the `parent` keyword, then we assume the current
-		// definition we're in the midst of is an overriding of a previously
-		// defined template, and the author's intent is to execute that
-		// "parent" template as part of the "child".
+		// If we encounter the `parent` keyword, then we assume the template we're
+		// in the midst currently defining is overriding a previously defined
+		// template, and that the template author's intent is to execute that
+		// "parent" template as part of this "child" template.
 		//
-		// We know the name of the template currently being defined
-		// (overridden), so we augment the name with a flag to indicate to the
-		// execution step that it should lookup the "parent" template with that
-		// name.
-		//fmt.Printf("\x1b[1;31mTEMPLATE NAME: %q\x1b[0m\n", t.Name)
+		// We know the name of the template currently being defined (i.e., the one
+		// overriding a previous definition), so we set a flag to indicate to
+		// template execution that it should lookup the "parent" template with the
+		// same name.
 		name = t.Name
 		parent = true
 	} else {

src/text/template/parse/parse_test.go

@@ -236,6 +236,8 @@ var parseTests = []parseTest{
 		`{{template "x"}}`},
 	{"template with arg", "{{template `x` .Y}}", noError,
 		`{{template "x" .Y}}`},
+	{"template with parent", "{{template parent .}}", noError,
+		`{{template parent .}}`},
 	{"with", "{{with .X}}hello{{end}}", noError,
 		`{{with .X}}"hello"{{end}}`},
 	{"with with else", "{{with .X}}hello{{else}}goodbye{{end}}", noError,

src/text/template/template.go

@@ -209,7 +209,6 @@ func (t *Template) lookup(name string, scope int) *Template {
 	if scope >= len(t.tmpl[name]) {
 		return nil
 	}
-	//fmt.Printf("\x1b[1;35mname: %q\tscope: %d\tlen: %d\x1b[0m\n", name, scope, len(t.tmpl[name]))
 	return t.tmpl[name][scope] // TODO: invariant check: at least one
 }