text/template: make redefinition of a template in a set more consistent.

Also make it agree with the documentation. You get an error, unless you're
calling Add explicitly, in which case it panics since that's almost certainly
a bug. The discrepancy was caused by a panic that wasn't turned into
an error along one path; deleted the offending function for clarity.

R=r, rsc
CC=golang-dev
https://golang.org/cl/5354045

diff --git a/src/pkg/text/template/parse.go b/src/pkg/text/template/parse.go
index 2fbd37ffa9953dd8a72bcbeb40ea2efe9e38f43c..6ecd2f50b49eeeae9e6598b3fbd24dce56fed4b5 100644 (file)
--- a/src/pkg/text/template/parse.go
+++ b/src/pkg/text/template/parse.go
@@ -71,7 +71,7 @@ func (t *Template) Parse(s string) (tmpl *Template, err error) {
 
 // ParseInSet parses the template definition string to construct an internal
 // representation of the template for execution. It also adds the template
-// to the set.
+// to the set. It is an error if s is already defined in the set.
 // Function bindings are checked against those in the set.
 func (t *Template) ParseInSet(s string, set *Set) (tmpl *Template, err error) {
        var setFuncs FuncMap
@@ -82,15 +82,8 @@ func (t *Template) ParseInSet(s string, set *Set) (tmpl *Template, err error) {
        if err != nil {
                return nil, err
        }
-       t.addToSet(set)
-       return t, nil
-}
-
-// addToSet adds the template to the set, verifying it's not being double-assigned.
-func (t *Template) addToSet(set *Set) {
-       if set == nil || t.set == set {
-               return
+       if set != nil {
+               err = set.add(t)
        }
-       // If double-assigned, Add will panic and we will turn that into an error.
-       set.Add(t)
+       return t, err
 }

diff --git a/src/pkg/text/template/set.go b/src/pkg/text/template/set.go
index bd0dfc6b36333b83fb1316c821401f01a263a7db..ba5dc005446bb0309e5d8a11ac7222065a7c1acf 100644 (file)
--- a/src/pkg/text/template/set.go
+++ b/src/pkg/text/template/set.go
@@ -101,8 +101,7 @@ func (s *Set) Execute(wr io.Writer, name string, data interface{}) error {
 
 // Parse parses a string into a set of named templates.  Parse may be called
 // multiple times for a given set, adding the templates defined in the string
-// to the set.  If a template is redefined, the element in the set is
-// overwritten with the new definition.
+// to the set.  It is an error if a template has a name already defined in the set.
 func (s *Set) Parse(text string) (*Set, error) {
        trees, err := parse.Set(text, s.leftDelim, s.rightDelim, s.parseFuncs, builtins)
        if err != nil {
@@ -112,8 +111,10 @@ func (s *Set) Parse(text string) (*Set, error) {
        for name, tree := range trees {
                tmpl := New(name)
                tmpl.Tree = tree
-               tmpl.addToSet(s)
-               s.tmpl[name] = tmpl
+               err = s.add(tmpl)
+               if err != nil {
+                       return s, err
+               }
        }
        return s, nil
 }