Compare and cache a read by its one spelling, so two spellings of one reference are one level; reject a slash after a sigil naming the spelling

hold.go

@@ -179,60 +179,20 @@ func renders(n node, want, seen map[node]bool) bool {
 	return false
 }
 
-// arm is one alternative of a {a|b} token or one operand, split into the key
-// naming the node in a template's fields (a sibling field, or the head a
-// reference is bound under) and the tail of a dotted path into it. A non-empty
-// tail is what makes the arm a bound draw: its head is drawn once per expansion
-// (see compileOps).
-type arm struct {
-	name  string // as written, and the key a bound draw's value is held under
-	key   string
-	tail  []string
-	steps []string // key per level passed through; the head and leaf hold their own
-}
-
-// splitArm splits one name into key and tail. refs maps a reference to what
-// linkRefs bound it to; before linking, a reference is whole.
-func splitArm(name string, refs map[string]refBinding) arm {
-	if isRef(name) {
-		b, bound := refs[name]
-		if !bound || len(b.tail) == 0 {
-			key := name
-			if bound {
-				key = b.key
-			}
-			return arm{name: name, key: key}
-		}
-		return pathArm(name, b.key, b.tail)
-	}
-	head, tail, dotted := strings.Cut(name, ".")
-	if !dotted {
-		return arm{name: name, key: name}
-	}
-	return pathArm(name, head, strings.Split(tail, "."))
-}
-
-func pathArm(name, key string, segs []string) arm {
-	var steps []string
-	for i := 0; i < len(segs)-1; i++ { // every level except the leaf's own
-		steps = append(steps, key+"."+strings.Join(segs[:i+1], "."))
-	}
-	return arm{name: name, key: key, tail: segs, steps: steps}
-}
-
 // checkNoOverlap rejects a format that both renders a level and reads a path into
-// it — {p} beside {p.first}, or {p.addr} beside {p.addr.city}. The path reads the
-// level's held draw while rendering the level expands it afresh, so their values
-// would disagree. Names are compared in sorted order, so which pair is reported
-// does not depend on where the tokens sit.
+// it — {p} beside {p.first}, {p.addr} beside {p.addr.city}, {.p} beside
+// {/sv_SE.p.first}. The path reads the level's held draw while rendering the level
+// expands it afresh, so their values would disagree. Reads are compared by their
+// one spelling, in sorted order, so which pair is reported depends neither on how
+// a reference was written nor on where the tokens sit.
 func checkNoOverlap(format string, bound map[string]string, refs map[string]refBinding) error {
 	names := boundReaders(format, bound, refs)
 	// Stable over one format-order scan, so two readers of one name (a token and a
 	// calc operand both naming "p") are reported as the format writes them.
-	sort.SliceStable(names, func(i, j int) bool { return names[i].name < names[j].name })
+	sort.SliceStable(names, func(i, j int) bool { return names[i].path < names[j].path })
 	for i, level := range names {
 		for _, path := range names[i+1:] {
-			if strings.HasPrefix(path.name, level.name+".") {
+			if strings.HasPrefix(path.path, level.path+".") {
 				return fmt.Errorf("%s renders a level that {%s} reads a path into; name the fields you want instead", level.label, path.name)
 			}
 		}
@@ -240,8 +200,9 @@ func checkNoOverlap(format string, bound map[string]string, refs map[string]refB
 	return nil
 }
 
-// reader is one way a format reaches a bound field, and how to name that spelling.
-type reader struct{ name, label string }
+// reader is one way a format reaches a bound field: as written, by its one
+// spelling, and how to name it.
+type reader struct{ name, path, label string }
 
 // boundReaders lists every way a format reaches a bound field, in the order the
 // format writes them. An operand renders its field, so it names a level exactly
@@ -256,14 +217,14 @@ func boundReaders(format string, bound map[string]string, refs map[string]refBin
 			for _, operand := range tokenOperands(t.body) {
 				a := splitArm(operand, refs)
 				if _, isBound := bound[a.key]; isBound {
-					names = append(names, reader{a.name, fmt.Sprintf("%s operand %q", fn, operand)})
+					names = append(names, reader{a.name, a.path, fmt.Sprintf("%s operand %q", fn, operand)})
 				}
 			}
 			return nil
 		}
 		for _, a := range splitArms(t.body, refs) {
 			if _, isBound := bound[a.key]; isBound {
-				names = append(names, reader{a.name, "token {" + a.name + "}"})
+				names = append(names, reader{a.name, a.path, "token {" + a.name + "}"})
 			}
 		}
 		return nil
@@ -271,16 +232,6 @@ func boundReaders(format string, bound map[string]string, refs map[string]refBin
 	return names
 }
 
-// splitArms splits a token body's '|' alternatives.
-func splitArms(body string, refs map[string]refBinding) []arm {
-	parts := strings.Split(body, "|")
-	arms := make([]arm, len(parts))
-	for i, p := range parts {
-		arms[i] = splitArm(p, refs)
-	}
-	return arms
-}
-
 // checkNoRepeatedRead rejects a bare token repeated on a held name: {w} {w} beside
 // {uppercase(w)} would read one draw twice, where {w} {w} alone draws twice. The
 // error names the single-token spelling.
@@ -306,8 +257,8 @@ func checkNoRepeatedRead(format string, c formatOps, refs map[string]refBinding)
 }
 
 // draws is what an expansion has already drawn for its held names: the variant each
-// was drawn as, so every path under it reads one row, and the value each read, so
-// the same name read twice reads one value.
+// was drawn as, so every path under it reads one row, and the value each read, by
+// its one spelling, so the same read written twice reads one value.
 type draws struct {
 	variant map[string]node
 	value   map[string]string
@@ -324,7 +275,7 @@ func readField(s *session, t *template, held *draws, a arm) string {
 	if !t.held[a.key] {
 		return render(s, t.fields[a.key])
 	}
-	if v, read := held.value[a.name]; read {
+	if v, read := held.value[a.path]; read {
 		return v
 	}
 	var v string
@@ -345,7 +296,7 @@ func readField(s *session, t *template, held *draws, a arm) string {
 		},
 		leaf: func(n node) error { v = render(s, n); return nil },
 	})
-	held.value[a.name] = v
+	held.value[a.path] = v
 	return v
 }