Fix baseof block regression

From Hugo 0.74.0.

Fixes #7478

1 files changed, 48 insertions, 63 deletions

diff --git a/tpl/tplimpl/template.go b/tpl/tplimpl/template.go
index 6171d167b..e3a4ce090 100644
--- a/tpl/tplimpl/template.go
+++ b/tpl/tplimpl/template.go
@@ -138,7 +138,7 @@ func newTemplateExec(d *deps.Deps) (*templateExec, error) {
 		baseof:       make(map[string]templateInfo),
 		needsBaseof:  make(map[string]templateInfo),
 
-		main: newTemplateNamespace(funcMap, false),
+		main: newTemplateNamespace(funcMap),
 
 		Deps:                d,
 		layoutHandler:       output.NewLayoutHandler(),
@@ -174,17 +174,11 @@ func newTemplateExec(d *deps.Deps) (*templateExec, error) {
 	return e, nil
 }
 
-func newTemplateNamespace(funcs map[string]interface{}, lock bool) *templateNamespace {
-	var mu *sync.RWMutex
-	if lock {
-		mu = &sync.RWMutex{}
-	}
-
+func newTemplateNamespace(funcs map[string]interface{}) *templateNamespace {
 	return &templateNamespace{
 		prototypeHTML: htmltemplate.New("").Funcs(funcs),
 		prototypeText: texttemplate.New("").Funcs(funcs),
 		templateStateMap: &templateStateMap{
-			mu:        mu,
 			templates: make(map[string]*templateState),
 		},
 	}
@@ -426,6 +420,10 @@ func (t *templateHandler) findLayout(d output.LayoutDescriptor, f output.Format)
 
 		t.applyTemplateTransformers(t.main, ts)
 
+		if err := t.extractPartials(ts.Template); err != nil {
+			return nil, false, err
+		}
+
 		return ts, true, nil
 
 	}
@@ -570,24 +568,12 @@ func (t *templateHandler) addTemplateFile(name, path string) error {
 	if isBaseTemplatePath(name) {
 		// Store it for later.
 		t.baseof[name] = tinfo
-		// Also parse and add it on its own to make sure we reach the inline partials.
-		tinfo.name = name + ".___b"
-		_, err := t.addTemplateTo(tinfo, t.main)
-		if err != nil {
-			return tinfo.errWithFileContext("parse failed", err)
-		}
 		return nil
 	}
 
 	needsBaseof := !t.noBaseNeeded(name) && needsBaseTemplate(tinfo.template)
 	if needsBaseof {
 		t.needsBaseof[name] = tinfo
-		// Also parse and add it on its own to make sure we reach the inline partials.
-		tinfo.name = name + ".___b"
-		_, err := t.addTemplateTo(tinfo, t.main)
-		if err != nil {
-			return tinfo.errWithFileContext("parse failed", err)
-		}
 		return nil
 	}
 
@@ -748,6 +734,38 @@ func (t *templateHandler) noBaseNeeded(name string) bool {
 	return strings.Contains(name, "_markup/")
 }
 
+func (t *templateHandler) extractPartials(templ tpl.Template) error {
+	templs := templates(templ)
+	for _, templ := range templs {
+		if templ.Name() == "" || !strings.HasPrefix(templ.Name(), "partials/") {
+			continue
+		}
+
+		ts := newTemplateState(templ, templateInfo{name: templ.Name()})
+		ts.typ = templatePartial
+
+		t.main.mu.RLock()
+		_, found := t.main.templates[templ.Name()]
+		t.main.mu.RUnlock()
+
+		if !found {
+			t.main.mu.Lock()
+			// This is a template defined inline.
+			_, err := applyTemplateTransformers(ts, t.main.newTemplateLookup(ts))
+			if err != nil {
+				t.main.mu.Unlock()
+				return err
+			}
+			t.main.templates[templ.Name()] = ts
+			t.main.mu.Unlock()
+
+		}
+	}
+
+	return nil
+
+}
+
 func (t *templateHandler) postTransform() error {
 	defineCheckedHTML := false
 	defineCheckedText := false
@@ -774,25 +792,8 @@ func (t *templateHandler) postTransform() error {
 			defineCheckedHTML = true
 		}
 
-		templs := templates(v.Template)
-		for _, templ := range templs {
-			if templ.Name() == "" || !strings.HasPrefix(templ.Name(), "partials/") {
-				continue
-			}
-
-			ts := newTemplateState(templ, templateInfo{name: templ.Name()})
-			ts.typ = templatePartial
-
-			if _, found := t.main.templates[templ.Name()]; !found {
-				// This is a template defined inline.
-
-				_, err := applyTemplateTransformers(ts, t.main.newTemplateLookup(ts))
-				if err != nil {
-					return err
-				}
-				t.main.templates[templ.Name()] = ts
-
-			}
+		if err := t.extractPartials(v.Template); err != nil {
+			return err
 		}
 	}
 
@@ -828,20 +829,12 @@ type templateNamespace struct {
 	*templateStateMap
 }
 
-func (t templateNamespace) Clone(lock bool) *templateNamespace {
-	if t.mu != nil {
-		t.mu.Lock()
-		defer t.mu.Unlock()
-	}
-
-	var mu *sync.RWMutex
-	if lock {
-		mu = &sync.RWMutex{}
-	}
+func (t templateNamespace) Clone() *templateNamespace {
+	t.mu.Lock()
+	defer t.mu.Unlock()
 
 	t.templateStateMap = &templateStateMap{
 		templates: make(map[string]*templateState),
-		mu:        mu,
 	}
 
 	t.prototypeText = texttemplate.Must(t.prototypeText.Clone())
@@ -851,20 +844,14 @@ func (t templateNamespace) Clone(lock bool) *templateNamespace {
 }
 
 func (t *templateNamespace) Lookup(name string) (tpl.Template, bool) {
-	if t.mu != nil {
-		t.mu.RLock()
-		defer t.mu.RUnlock()
-	}
+	t.mu.RLock()
+	defer t.mu.RUnlock()
 
 	templ, found := t.templates[name]
 	if !found {
 		return nil, false
 	}
 
-	if t.mu != nil {
-		return &templateWrapperWithLock{RWMutex: t.mu, Template: templ}, true
-	}
-
 	return templ, found
 }
 
@@ -892,10 +879,8 @@ func (t *templateNamespace) newTemplateLookup(in *templateState) func(name strin
 }
 
 func (t *templateNamespace) parse(info templateInfo) (*templateState, error) {
-	if t.mu != nil {
-		t.mu.Lock()
-		defer t.mu.Unlock()
-	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
 
 	if info.isText {
 		prototype := t.prototypeText
@@ -952,7 +937,7 @@ func isText(templ tpl.Template) bool {
 }
 
 type templateStateMap struct {
-	mu        *sync.RWMutex // May be nil
+	mu        sync.RWMutex
 	templates map[string]*templateState
 }