tpl: Add templates.Current

This commit also

* Unexport all internal state in TemplateInfo.
* Make the dispatcher keys used for passing context.Context into uint8 from string to save memory allocations.

Co-authored-by: Joe Mooring <joe@mooring.com>

Updates #13571

Author: bep

common/hugo/hugo.go

@@ -139,9 +139,13 @@ func (i HugoInfo) IsMultilingual() bool {
 	return i.conf.IsMultilingual()
 }
 
-type contextKey string
+type contextKey uint8
 
-var markupScope = hcontext.NewContextDispatcher[string](contextKey("markupScope"))
+const (
+	contextKeyMarkupScope contextKey = iota
+)
+
+var markupScope = hcontext.NewContextDispatcher[string](contextKeyMarkupScope)
 
 type Context struct{}
 

hugolib/page__content.go

@@ -667,7 +667,13 @@ func (c *cachedContentScope) mustContentToC(ctx context.Context) contentTableOfC
 	return ct
 }
 
-var setGetContentCallbackInContext = hcontext.NewContextDispatcher[func(*pageContentOutput, contentTableOfContents)]("contentCallback")
+type contextKey uint8
+
+const (
+	contextKeyContentCallback contextKey = iota
+)
+
+var setGetContentCallbackInContext = hcontext.NewContextDispatcher[func(*pageContentOutput, contentTableOfContents)](contextKeyContentCallback)
 
 func (c *cachedContentScope) contentToC(ctx context.Context) (contentTableOfContents, error) {
 	cp := c.pco

hugolib/page__per_output.go

@@ -120,7 +120,7 @@ func (pco *pageContentOutput) Render(ctx context.Context, layout ...string) (tem
 	// Make sure to send the *pageState and not the *pageContentOutput to the template.
 	res, err := executeToString(ctx, pco.po.p.s.GetTemplateStore(), templ, pco.po.p)
 	if err != nil {
-		return "", pco.po.p.wrapError(fmt.Errorf("failed to execute template %s: %w", templ.Template.Name(), err))
+		return "", pco.po.p.wrapError(fmt.Errorf("failed to execute template %s: %w", templ.Name(), err))
 	}
 	return template.HTML(res), nil
 }
@@ -323,7 +323,7 @@ func (pco *pageContentOutput) initRenderHooks() error {
 					return false
 				}
 
-				if ignoreInternal && candidate.SubCategory == tplimpl.SubCategoryEmbedded {
+				if ignoreInternal && candidate.SubCategory() == tplimpl.SubCategoryEmbedded {
 					// Don't consider the internal hook templates.
 					return false
 				}

hugolib/site_render.go

@@ -168,7 +168,7 @@ func pageRenderer(
 
 		s.Log.Trace(
 			func() string {
-				return fmt.Sprintf("rendering outputFormat %q kind %q using layout %q to %q", p.pageOutput.f.Name, p.Kind(), templ.Template.Name(), targetPath)
+				return fmt.Sprintf("rendering outputFormat %q kind %q using layout %q to %q", p.pageOutput.f.Name, p.Kind(), templ.Name(), targetPath)
 			},
 		)
 

resources/resource_factories/create/create.go

@@ -55,12 +55,16 @@ type Client struct {
 	remoteResourceLogger  logg.LevelLogger
 }
 
-type contextKey string
+type contextKey uint8
+
+const (
+	contextKeyResourceID contextKey = iota
+)
 
 // New creates a new Client with the given specification.
 func New(rs *resources.Spec) *Client {
 	fileCache := rs.FileCaches.GetResourceCache()
-	resourceIDDispatcher := hcontext.NewContextDispatcher[string](contextKey("resourceID"))
+	resourceIDDispatcher := hcontext.NewContextDispatcher[string](contextKeyResourceID)
 	httpCacheConfig := rs.Cfg.GetConfigSection("httpCacheCompiled").(hhttpcache.ConfigCompiled)
 	var remoteResourceChecker *tasks.RunEvery
 	if rs.Cfg.Watching() && !httpCacheConfig.IsPollingDisabled() {

tpl/partials/partials.go

@@ -157,8 +157,7 @@ func (ns *Namespace) include(ctx context.Context, name string, dataList ...any)
 	if len(dataList) > 0 {
 		data = dataList[0]
 	}
-	name, desc := ns.deps.TemplateStore.TemplateDescriptorFromPath(name)
-	v := ns.deps.TemplateStore.LookupPartial(name, desc)
+	v := ns.deps.TemplateStore.LookupPartial(name)
 	if v == nil {
 		return includeResult{err: fmt.Errorf("partial %q not found", name)}
 	}
@@ -199,7 +198,7 @@ func (ns *Namespace) include(ctx context.Context, name string, dataList ...any)
 	}
 
 	return includeResult{
-		name:   templ.Template.Name(),
+		name:   templ.Name(),
 		result: result,
 	}
 }

tpl/template.go

@@ -16,6 +16,7 @@ package tpl
 
 import (
 	"context"
+	"slices"
 	"strings"
 	"sync"
 	"unicode"
@@ -41,7 +42,17 @@ type RenderingContext struct {
 	SiteOutIdx int
 }
 
-type contextKey string
+type (
+	contextKey uint8
+)
+
+const (
+	contextKeyDependencyManagerScopedProvider contextKey = iota
+	contextKeyDependencyScope
+	contextKeyPage
+	contextKeyIsInGoldmark
+	cntextKeyCurrentTemplateInfo
+)
 
 // Context manages values passed in the context to templates.
 var Context = struct {
@@ -50,11 +61,13 @@ var Context = struct {
 	DependencyScope                    hcontext.ContextDispatcher[int]
 	Page                               hcontext.ContextDispatcher[page]
 	IsInGoldmark                       hcontext.ContextDispatcher[bool]
+	CurrentTemplate                    hcontext.ContextDispatcher[*CurrentTemplateInfo]
 }{
-	DependencyManagerScopedProvider: hcontext.NewContextDispatcher[identity.DependencyManagerScopedProvider](contextKey("DependencyManagerScopedProvider")),
-	DependencyScope:                 hcontext.NewContextDispatcher[int](contextKey("DependencyScope")),
-	Page:                            hcontext.NewContextDispatcher[page](contextKey("Page")),
-	IsInGoldmark:                    hcontext.NewContextDispatcher[bool](contextKey("IsInGoldmark")),
+	DependencyManagerScopedProvider: hcontext.NewContextDispatcher[identity.DependencyManagerScopedProvider](contextKeyDependencyManagerScopedProvider),
+	DependencyScope:                 hcontext.NewContextDispatcher[int](contextKeyDependencyScope),
+	Page:                            hcontext.NewContextDispatcher[page](contextKeyPage),
+	IsInGoldmark:                    hcontext.NewContextDispatcher[bool](contextKeyIsInGoldmark),
+	CurrentTemplate:                 hcontext.NewContextDispatcher[*CurrentTemplateInfo](cntextKeyCurrentTemplateInfo),
 }
 
 func init() {
@@ -130,3 +143,46 @@ type DeferredExecution struct {
 	Executed bool
 	Result   string
 }
+
+type CurrentTemplateInfoOps interface {
+	CurrentTemplateInfoCommonOps
+	Base() CurrentTemplateInfoCommonOps
+}
+
+type CurrentTemplateInfoCommonOps interface {
+	// Template name.
+	Name() string
+	// Template source filename.
+	// Will be empty for internal templates.
+	Filename() string
+}
+
+// CurrentTemplateInfo as returned in templates.Current.
+type CurrentTemplateInfo struct {
+	Parent *CurrentTemplateInfo
+	CurrentTemplateInfoOps
+}
+
+// CurrentTemplateInfos is a slice of CurrentTemplateInfo.
+type CurrentTemplateInfos []*CurrentTemplateInfo
+
+// Reverse creates a copy of the slice and reverses it.
+func (c CurrentTemplateInfos) Reverse() CurrentTemplateInfos {
+	if len(c) == 0 {
+		return c
+	}
+	r := make(CurrentTemplateInfos, len(c))
+	copy(r, c)
+	slices.Reverse(r)
+	return r
+}
+
+// Ancestors returns the ancestors of the current template.
+func (ti *CurrentTemplateInfo) Ancestors() CurrentTemplateInfos {
+	var ancestors []*CurrentTemplateInfo
+	for ti.Parent != nil {
+		ti = ti.Parent
+		ancestors = append(ancestors, ti)
+	}
+	return ancestors
+}

tpl/templates/templates.go

@@ -102,3 +102,8 @@ func (ns *Namespace) DoDefer(ctx context.Context, id string, optsv any) string {
 
 	return id
 }
+
+// Get information about the currently executing template.
+func (ns *Namespace) Current(ctx context.Context) *tpl.CurrentTemplateInfo {
+	return tpl.Context.CurrentTemplate.Get(ctx)
+}

tpl/templates/templates_integration_test.go

@@ -14,6 +14,7 @@
 package templates_test
 
 import (
+	"path/filepath"
 	"testing"
 
 	"github.com/gohugoio/hugo/hugolib"
@@ -127,3 +128,41 @@ Try printf: {{ (try (printf "hello %s" "world")).Value }}
 		"Try printf: hello world",
 	)
 }
+
+func TestTemplatesCurrent(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+-- layouts/baseof.html --
+baseof: {{ block "main" . }}{{ end }}
+-- layouts/all.html --
+{{ define "main" }}
+all.current: {{ templates.Current.Name }}
+all.current.filename: {{ templates.Current.Filename }}
+all.base: {{ with templates.Current.Base }}{{ .Name }}{{ end }}|
+all.parent: {{ with .Parent }}Name: {{ .Name }}{{ end }}|
+{{ partial "p1.html" . }}
+{{ end }}
+-- layouts/_partials/p1.html --
+p1.current: {{ with templates.Current }}Name: {{ .Name }}|{{ with .Parent }}Parent.Name: {{ .Name }}{{ end }}{{ end }}|
+p1.current.Ancestors: {{ with templates.Current }}{{ range .Ancestors }}{{ .Name }}|{{ end }}{{ end }}
+{{ partial "p2.html" . }}
+-- layouts/_partials/p2.html --
+p2.current: {{ with templates.Current }}Name: {{ .Name }}|{{ with .Parent }}Parent.Name: {{ .Name }}{{ end }}{{ end }}|
+p2.current.Ancestors: {{ with templates.Current }}{{ range .Ancestors }}{{ .Name }}|{{ end }}{{ end }}
+p3.current.Ancestors.Reverse: {{ with templates.Current }}{{ range .Ancestors.Reverse }}{{ .Name }}|{{ end }}{{ end }}
+
+`
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/index.html",
+		"all.current: all.html",
+		filepath.FromSlash("all.current.filename: /layouts/all.html"),
+		"all.base: baseof.html",
+		"all.parent: |",
+		"p1.current: Name: _partials/p1.html|Parent.Name: all.html|",
+		"p1.current.Ancestors: all.html|",
+		"p2.current.Ancestors: _partials/p1.html|all.html",
+	)
+}

tpl/tplimpl/templates.go

@@ -25,9 +25,9 @@ func (t *templateNamespace) readTemplateInto(templ *TemplInfo) error {
 		if err != nil {
 			return err
 		}
-		templ.Content = removeLeadingBOM(string(b))
-		if !templ.NoBaseOf {
-			templ.NoBaseOf = !needsBaseTemplate(templ.Content)
+		templ.content = removeLeadingBOM(string(b))
+		if !templ.noBaseOf {
+			templ.noBaseOf = !needsBaseTemplate(templ.content)
 		}
 		return nil
 	}(); err != nil {
@@ -43,7 +43,7 @@ var embeddedTemplatesAliases = map[string][]string{
 }
 
 func (t *templateNamespace) parseTemplate(ti *TemplInfo) error {
-	if !ti.NoBaseOf || ti.Category == CategoryBaseof {
+	if !ti.noBaseOf || ti.category == CategoryBaseof {
 		// Delay parsing until we have the base template.
 		return nil
 	}
@@ -62,18 +62,18 @@ func (t *templateNamespace) parseTemplate(ti *TemplInfo) error {
 
 	if ti.D.IsPlainText {
 		prototype := t.parseText
-		templ, err = prototype.New(name).Parse(ti.Content)
+		templ, err = prototype.New(name).Parse(ti.content)
 		if err != nil {
 			return err
 		}
 	} else {
 		prototype := t.parseHTML
-		templ, err = prototype.New(name).Parse(ti.Content)
+		templ, err = prototype.New(name).Parse(ti.content)
 		if err != nil {
 			return err
 		}
 
-		if ti.SubCategory == SubCategoryEmbedded {
+		if ti.subCategory == SubCategoryEmbedded {
 			// In Hugo 0.146.0 we moved the internal templates around.
 			// For the "_internal/twitter_cards.html" style templates, they
 			// were moved to the _partials directory.
@@ -111,17 +111,17 @@ func (t *templateNamespace) applyBaseTemplate(overlay *TemplInfo, base keyTempla
 		Base:    base.Info,
 	}
 
-	base.Info.Overlays = append(base.Info.Overlays, overlay)
+	base.Info.overlays = append(base.Info.overlays, overlay)
 
 	var templ tpl.Template
 	if overlay.D.IsPlainText {
 		tt := texttemplate.Must(t.parseText.Clone()).New(overlay.PathInfo.PathNoLeadingSlash())
 		var err error
-		tt, err = tt.Parse(base.Info.Content)
+		tt, err = tt.Parse(base.Info.content)
 		if err != nil {
 			return err
 		}
-		tt, err = tt.Parse(overlay.Content)
+		tt, err = tt.Parse(overlay.content)
 		if err != nil {
 			return err
 		}
@@ -130,11 +130,11 @@ func (t *templateNamespace) applyBaseTemplate(overlay *TemplInfo, base keyTempla
 	} else {
 		tt := htmltemplate.Must(t.parseHTML.CloneShallow()).New(overlay.PathInfo.PathNoLeadingSlash())
 		var err error
-		tt, err = tt.Parse(base.Info.Content)
+		tt, err = tt.Parse(base.Info.content)
 		if err != nil {
 			return err
 		}
-		tt, err = tt.Parse(overlay.Content)
+		tt, err = tt.Parse(overlay.content)
 		if err != nil {
 			return err
 		}
@@ -146,17 +146,17 @@ func (t *templateNamespace) applyBaseTemplate(overlay *TemplInfo, base keyTempla
 
 	tb.Template = &TemplInfo{
 		Template: templ,
-		Base:     base.Info,
+		base:     base.Info,
 		PathInfo: overlay.PathInfo,
 		Fi:       overlay.Fi,
 		D:        overlay.D,
-		NoBaseOf: true,
+		noBaseOf: true,
 	}
 
-	variants := overlay.BaseVariants.Get(base.Key)
+	variants := overlay.baseVariants.Get(base.Key)
 	if variants == nil {
 		variants = make(map[TemplateDescriptor]*TemplWithBaseApplied)
-		overlay.BaseVariants.Insert(base.Key, variants)
+		overlay.baseVariants.Insert(base.Key, variants)
 	}
 	variants[base.Info.D] = tb
 	return nil