Reimplement and simplify Hugo's template system

See #13541 for details.

Fixes #13545
Fixes #13515
Closes #7964
Closes #13365
Closes #12988
Closes #4891

hugolib/doctree/simpletree.go

@@ -14,35 +14,46 @@
 package doctree
 
 import (
+	"iter"
 	"sync"
 
 	radix "github.com/armon/go-radix"
 )
 
-// Tree is a radix tree that holds T.
+// Tree is a non thread safe radix tree that holds T.
 type Tree[T any] interface {
+	TreeCommon[T]
+	WalkPrefix(s string, f func(s string, v T) (bool, error)) error
+	WalkPath(s string, f func(s string, v T) (bool, error)) error
+	All() iter.Seq2[string, T]
+}
+
+// TreeThreadSafe is a thread safe radix tree that holds T.
+type TreeThreadSafe[T any] interface {
+	TreeCommon[T]
+	WalkPrefix(lockType LockType, s string, f func(s string, v T) (bool, error)) error
+	WalkPath(lockType LockType, s string, f func(s string, v T) (bool, error)) error
+	All(lockType LockType) iter.Seq2[string, T]
+}
+
+type TreeCommon[T any] interface {
 	Get(s string) T
 	LongestPrefix(s string) (string, T)
 	Insert(s string, v T) T
-	WalkPrefix(lockType LockType, s string, f func(s string, v T) (bool, error)) error
 }
 
-// NewSimpleTree creates a new SimpleTree.
-func NewSimpleTree[T comparable]() *SimpleTree[T] {
+func NewSimpleTree[T any]() *SimpleTree[T] {
 	return &SimpleTree[T]{tree: radix.New()}
 }
 
-// SimpleTree is a thread safe radix tree that holds T.
-type SimpleTree[T comparable] struct {
-	mu   sync.RWMutex
+// SimpleTree is a radix tree that holds T.
+// This tree is not thread safe.
+type SimpleTree[T any] struct {
 	tree *radix.Tree
 	zero T
 }
 
 func (tree *SimpleTree[T]) Get(s string) T {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-
 	if v, ok := tree.tree.Get(s); ok {
 		return v.(T)
 	}
@@ -50,9 +61,6 @@ func (tree *SimpleTree[T]) Get(s string) T {
 }
 
 func (tree *SimpleTree[T]) LongestPrefix(s string) (string, T) {
-	tree.mu.RLock()
-	defer tree.mu.RUnlock()
-
 	if s, v, ok := tree.tree.LongestPrefix(s); ok {
 		return s, v.(T)
 	}
@@ -60,17 +68,121 @@ func (tree *SimpleTree[T]) LongestPrefix(s string) (string, T) {
 }
 
 func (tree *SimpleTree[T]) Insert(s string, v T) T {
+	tree.tree.Insert(s, v)
+	return v
+}
+
+func (tree *SimpleTree[T]) Walk(f func(s string, v T) (bool, error)) error {
+	var err error
+	tree.tree.Walk(func(s string, v any) bool {
+		var b bool
+		b, err = f(s, v.(T))
+		if err != nil {
+			return true
+		}
+		return b
+	})
+	return err
+}
+
+func (tree *SimpleTree[T]) WalkPrefix(s string, f func(s string, v T) (bool, error)) error {
+	var err error
+	tree.tree.WalkPrefix(s, func(s string, v any) bool {
+		var b bool
+		b, err = f(s, v.(T))
+		if err != nil {
+			return true
+		}
+		return b
+	})
+
+	return err
+}
+
+func (tree *SimpleTree[T]) WalkPath(s string, f func(s string, v T) (bool, error)) error {
+	var err error
+	tree.tree.WalkPath(s, func(s string, v any) bool {
+		var b bool
+		b, err = f(s, v.(T))
+		if err != nil {
+			return true
+		}
+		return b
+	})
+	return err
+}
+
+func (tree *SimpleTree[T]) All() iter.Seq2[string, T] {
+	return func(yield func(s string, v T) bool) {
+		tree.tree.Walk(func(s string, v any) bool {
+			return !yield(s, v.(T))
+		})
+	}
+}
+
+// NewSimpleThreadSafeTree creates a new SimpleTree.
+func NewSimpleThreadSafeTree[T any]() *SimpleThreadSafeTree[T] {
+	return &SimpleThreadSafeTree[T]{tree: radix.New(), mu: new(sync.RWMutex)}
+}
+
+// SimpleThreadSafeTree is a thread safe radix tree that holds T.
+type SimpleThreadSafeTree[T any] struct {
+	mu     *sync.RWMutex
+	noLock bool
+	tree   *radix.Tree
+	zero   T
+}
+
+var noopFunc = func() {}
+
+func (tree *SimpleThreadSafeTree[T]) readLock() func() {
+	if tree.noLock {
+		return noopFunc
+	}
+	tree.mu.RLock()
+	return tree.mu.RUnlock
+}
+
+func (tree *SimpleThreadSafeTree[T]) writeLock() func() {
+	if tree.noLock {
+		return noopFunc
+	}
 	tree.mu.Lock()
-	defer tree.mu.Unlock()
+	return tree.mu.Unlock
+}
+
+func (tree *SimpleThreadSafeTree[T]) Get(s string) T {
+	unlock := tree.readLock()
+	defer unlock()
+
+	if v, ok := tree.tree.Get(s); ok {
+		return v.(T)
+	}
+	return tree.zero
+}
+
+func (tree *SimpleThreadSafeTree[T]) LongestPrefix(s string) (string, T) {
+	unlock := tree.readLock()
+	defer unlock()
+
+	if s, v, ok := tree.tree.LongestPrefix(s); ok {
+		return s, v.(T)
+	}
+	return "", tree.zero
+}
+
+func (tree *SimpleThreadSafeTree[T]) Insert(s string, v T) T {
+	unlock := tree.writeLock()
+	defer unlock()
 
 	tree.tree.Insert(s, v)
 	return v
 }
 
-func (tree *SimpleTree[T]) Lock(lockType LockType) func() {
+func (tree *SimpleThreadSafeTree[T]) Lock(lockType LockType) func() {
 	switch lockType {
 	case LockTypeNone:
-		return func() {}
+		return noopFunc
 	case LockTypeRead:
 		tree.mu.RLock()
 		return tree.mu.RUnlock
@@ -78,10 +190,16 @@ func (tree *SimpleTree[T]) Lock(lockType LockType) func() {
 		tree.mu.Lock()
 		return tree.mu.Unlock
 	}
-	return func() {}
+	return noopFunc
 }
 
-func (tree *SimpleTree[T]) WalkPrefix(lockType LockType, s string, f func(s string, v T) (bool, error)) error {
+func (tree SimpleThreadSafeTree[T]) LockTree(lockType LockType) (TreeThreadSafe[T], func()) {
+	unlock := tree.Lock(lockType)
+	tree.noLock = true
+	return &tree, unlock // create a copy of tree with the noLock flag set to true.
+}
+
+func (tree *SimpleThreadSafeTree[T]) WalkPrefix(lockType LockType, s string, f func(s string, v T) (bool, error)) error {
 	commit := tree.Lock(lockType)
 	defer commit()
 	var err error
@@ -96,3 +214,31 @@ func (tree *SimpleTree[T]) WalkPrefix(lockType LockType, s string, f func(s stri
 
 	return err
 }
+
+func (tree *SimpleThreadSafeTree[T]) WalkPath(lockType LockType, s string, f func(s string, v T) (bool, error)) error {
+	commit := tree.Lock(lockType)
+	defer commit()
+	var err error
+	tree.tree.WalkPath(s, func(s string, v any) bool {
+		var b bool
+		b, err = f(s, v.(T))
+		if err != nil {
+			return true
+		}
+		return b
+	})
+
+	return err
+}
+
+func (tree *SimpleThreadSafeTree[T]) All(lockType LockType) iter.Seq2[string, T] {
+	commit := tree.Lock(lockType)
+	defer commit()
+	return func(yield func(s string, v T) bool) {
+		tree.tree.Walk(func(s string, v any) bool {
+			return !yield(s, v.(T))
+		})
+	}
+}
+
+// iter.Seq[*TemplWithBaseApplied]

hugolib/doctree/support.go

@@ -17,8 +17,6 @@ import (
 	"fmt"
 	"strings"
 	"sync"
-
-	radix "github.com/armon/go-radix"
 )
 
 var _ MutableTrees = MutableTrees{}
@@ -60,11 +58,9 @@ func (ctx *WalkContext[T]) AddPostHook(handler func() error) {
 	ctx.HooksPost = append(ctx.HooksPost, handler)
 }
 
-func (ctx *WalkContext[T]) Data() *SimpleTree[any] {
+func (ctx *WalkContext[T]) Data() *SimpleThreadSafeTree[any] {
 	ctx.dataInit.Do(func() {
-		ctx.data = &SimpleTree[any]{
-			tree: radix.New(),
-		}
+		ctx.data = NewSimpleThreadSafeTree[any]()
 	})
 	return ctx.data
 }
@@ -191,7 +187,7 @@ func (t MutableTrees) CanLock() bool {
 
 // WalkContext is passed to the Walk callback.
 type WalkContext[T any] struct {
-	data          *SimpleTree[any]
+	data          *SimpleThreadSafeTree[any]
 	dataInit      sync.Once
 	eventHandlers eventHandlers[T]
 	events        []*Event[T]

hugolib/doctree/treeshifttree.go

@@ -13,7 +13,9 @@
 
 package doctree
 
-var _ Tree[string] = (*TreeShiftTree[string])(nil)
+import "iter"
+
+var _ TreeThreadSafe[string] = (*TreeShiftTree[string])(nil)
 
 type TreeShiftTree[T comparable] struct {
 	// This tree is shiftable in one dimension.
@@ -26,16 +28,16 @@ type TreeShiftTree[T comparable] struct {
 	zero T
 
 	// Will be of length equal to the length of the dimension.
-	trees []*SimpleTree[T]
+	trees []*SimpleThreadSafeTree[T]
 }
 
 func NewTreeShiftTree[T comparable](d, length int) *TreeShiftTree[T] {
 	if length <= 0 {
 		panic("length must be > 0")
 	}
-	trees := make([]*SimpleTree[T], length)
+	trees := make([]*SimpleThreadSafeTree[T], length)
 	for i := range length {
-		trees[i] = NewSimpleTree[T]()
+		trees[i] = NewSimpleThreadSafeTree[T]()
 	}
 	return &TreeShiftTree[T]{d: d, trees: trees}
 }
@@ -91,6 +93,14 @@ func (t *TreeShiftTree[T]) WalkPrefixRaw(lockType LockType, s string, f func(s s
 	return nil
 }
 
+func (t *TreeShiftTree[T]) WalkPath(lockType LockType, s string, f func(s string, v T) (bool, error)) error {
+	return t.trees[t.v].WalkPath(lockType, s, f)
+}
+
+func (t *TreeShiftTree[T]) All(lockType LockType) iter.Seq2[string, T] {
+	return t.trees[t.v].All(lockType)
+}
+
 func (t *TreeShiftTree[T]) LenRaw() int {
 	var count int
 	for _, tt := range t.trees {