Move the render's read path into render.go and merge holdset.go into hold.go

hold.go

@@ -23,92 +23,66 @@ type readValue struct {
 	null bool
 }
 
-// readField renders one arm of a token. A name the expansion holds — a level some
-// token addresses by a dotted path that is not a reference, or a field an operand
-// reads — is drawn once and kept in held, so {place.postal-code} and {place.locality}
-// read one row, either read twice gives one value, and a shown operand is the operand
-// computed. Every other name is drawn afresh, so {word} {word} still draws twice.
-func readField(s *session, t *template, held *hold, sc renderScope, a arm) readValue {
-	if isRef(a.key) && len(a.tail) > 0 {
-		return readReference(s, t, sc, a)
-	}
-	if sc.set.trace != nil {
-		traceRead(sc.set.trace, t, sc, a)
-	}
-	if !t.compiled.held[a.key] {
-		if len(a.tail) > 0 {
-			panic(internalError("%q reads a path into %q, which the expansion does not hold", a.spelling, a.key))
-		}
-		return readValue{text: render(s, t.head(a.key), sc)}
-	}
-	if held == nil {
-		panic(internalError("%q reads a name the expansion holds, with no hold to keep it in", a.spelling))
-	}
-	return readHeld(s, t, held, nil, sc, a)
-}
-
-// readReference reads a reference path, kept in the render's hold for its group, so its draw
-// spans the render.
-func readReference(s *session, t *template, sc renderScope, a arm) readValue {
-	if sc.set.trace != nil {
-		traceRead(sc.set.trace, t, sc, a)
-	}
-	group := sc.groupHold()
-	return readHeld(s, t, &group.hold, &group.pins, sc, a)
-}
-
-func readHeld(s *session, t *template, held *hold, pins *pinSet, sc renderScope, a arm) readValue {
-	if r, done := held.value[a.path]; done {
-		return r
-	}
-	leaf := drawPath(t.head(a.key), a.tail, a.key, &pathDraw{s: s, held: held, pins: pins, a: &a})
-	if pins != nil {
-		sc = sc.at(leaf, pins)
-	}
-	r := renderLeaf(s, leaf, sc)
-	if held.value == nil {
-		held.value = map[string]readValue{}
-	}
-	held.value[a.path] = r
-	return r
-}
-
 // renderTrace is a test's view of the fields a render reads; nil outside a test.
 type renderTrace func(group, table string, row int, a arm)
 
-func traceRead(trace renderTrace, t *template, sc renderScope, a arm) {
-	var table string
-	row := t.site.row
-	if t.site.table != nil {
-		table = t.site.table.path
-	}
-	if row == formatRow {
-		row = sc.rowOf(t.site.table)
-	}
-	trace(strings.Clone(sc.group), strings.Clone(table), row, a)
+// holdSet is one render's reference draws: the unnamed draw group's, and each named one's; and a
+// test's trace of its reads.
+type holdSet struct {
+	unnamed groupHold
+	named   map[string]*groupHold
+	trace   renderTrace
 }
 
-// renderLeaf draws and renders what a read lands on: null on a null item, or on a column of one
-// reference alone whose read drew null.
-func renderLeaf(s *session, n node, sc renderScope) readValue {
-	n = resolveChoice(s, n)
-	switch leaf := n.(type) {
-	case *nullItem:
-		return readValue{null: true}
-	case *template:
-		if leaf.link.readsColumn != nil {
-			return readReference(s, leaf, sc.in(leaf), leaf.link.readsColumn.a)
+// renderScope is where a render reads its reference paths: a hold set, in the draw group of the
+// template rendering; and row, the row of the table rendering, which its columns read. It passes
+// by value, and what is read from it reaches a map key, an interface or a func value only as a
+// copy; else sc, and with it every render's hold set, moves to the heap.
+type renderScope struct {
+	set   *holdSet
+	group string
+	row   tablePin
+}
+
+// in is the scope t renders in: its draw group where it names one, else its caller's.
+func (sc renderScope) in(t *template) renderScope {
+	if t.link.drawGroupKey != "" {
+		sc.group = t.link.drawGroupKey
+	}
+	return sc
+}
+
+// at is the scope n, the leaf of a path that pinned its rows in pins, renders in: where n is a
+// table's row or column, at the row pins holds for that table.
+func (sc renderScope) at(n node, pins *pinSet) renderScope {
+	switch n := n.(type) {
+	case *tableRow:
+		sc.row = tablePin{n.t, pins.mustRow(n.t)}
+	case *tableColumn:
+		sc.row = tablePin{n.t, pins.mustRow(n.t)}
+	}
+	return sc
+}
+
+// rowOf is the row of t its columns render from.
+func (sc renderScope) rowOf(t *table) int {
+	if sc.row.t != t {
+		panic(internalError("a column of %s renders in a scope holding no row of it", t.segment))
+	}
+	return sc.row.row
+}
+
+func (sc renderScope) groupHold() *groupHold {
+	if sc.group == "" {
+		return &sc.set.unnamed
+	}
+	d, drew := sc.set.named[sc.group]
+	if !drew {
+		if sc.set.named == nil {
+			sc.set.named = map[string]*groupHold{}
 		}
+		d = &groupHold{}
+		sc.set.named[strings.Clone(sc.group)] = d
 	}
-	return readValue{text: render(s, n, sc)}
-}
-
-// resolveChoice resolves a choice to one variant, so a held head is a concrete node the
-// rest of the expansion shares. Nested choices unwrap too: a draw is one value, not
-// another set to pick from.
-func resolveChoice(s *session, n node) node {
-	for c, ok := n.(*choice); ok; c, ok = n.(*choice) {
-		n = pick(s, c)
-	}
-	return n
+	return d
 }