Make labels scope to their closest containing choice branch instead of the entire rule.

Previously labels were scoped to the rule. This meant that labels down different choice branches could never be initialized at the same time, but nonetheless needed unique names.

In practice, it ended up being common to need to do clumsy things like add number suffixes to label names to distinguish them across choice branches. This is nosiy and error prone:

	A <-
		thing0:Thing /
		"(" thing1:Thing ")" /
		"{" thing2:Thing "}"

With this change, the scope of the name is now bound to the nearest containing choice branch, so the same label name can be reused if they never will never conflict:

	A <-
		thing:Thing /
		"(" thing:Thing ")" /
		"{" thing:Thing "}"

Author: eaburns

README.md

@@ -205,6 +205,26 @@ A label is an identifier followed by : followed by an expression.
 
 Labels are used to create new identifiers used by actions and code predicates.
 
+The scope of a label is its branch in the nearest, containing choice expression,
+or in the entire rule if there is no choice expression.
+
+For example,
+
+	R <- a:A / a:A / a:A / a:A
+
+All `a`s refer to different labels, as they are all scoped to different branches of the choice, `/`.
+
+Similarly, in this expression,
+
+	R <- a:A / (a:A / a:A)
+
+all `a`s are different labels.
+However,
+
+	R <- a:A / a:A a:A
+
+is an error, as `a` is re-defined in the right-hand branch of the choice, `/`.
+
 **Accepts:**
 A label accepts if its subexpression accepts.
 
@@ -349,7 +369,7 @@ The expression must result in a boolean value,
 and must be syntactically valid as the condition of an
 [if statement](https://golang.org/ref/spec#If_statements).
 
-Label expressions of the containing rule define identifiers accessible in the Go code.
+Label expressions in scope of the code predicate define identifiers accessible in the Go code.
 The value of the identifier is a `string` of the input consumed by the labeled expression.
 If the labeled expression has yet to accept at the time the code predicate is evalutade, the string is empty.
 
@@ -431,7 +451,7 @@ and the returned value must be one of:
 * [a rune literal](https://golang.org/ref/spec#Rune_literals)
 * [a string literal](https://golang.org/ref/spec#String_literals)
 
-Label expressions of the containing rule define identifiers accessible in the Go code.
+Label expressions in scope of the action define identifiers accessible in the Go code.
 The value of the identifier is the value of the labeled expression if it accepted.
 If the labeled expression has yet to accept at the time the action is evaluated,
 the value is the zero value of the corresponding type.

check.go

@@ -30,21 +30,8 @@ func Check(grammar *Grammar) error {
 	for _, r := range rules {
 		r.checkLeft(ruleMap, p, &errs)
 	}
-
-	var labels []map[string]*LabelExpr
 	for _, r := range rules {
-		ls := check(r, ruleMap, &errs)
-		labels = append(labels, ls)
-	}
-	for i, ls := range labels {
-		rule := rules[i]
-		for name, expr := range ls {
-			l := Label{Name: name, Type: expr.Type(), N: expr.N}
-			rule.Labels = append(rule.Labels, l)
-		}
-		sort.Slice(rule.Labels, func(i, j int) bool {
-			return rule.Labels[i].N < rule.Labels[j].N
-		})
+		check(r, ruleMap, &errs)
 	}
 	if err := errs.ret(); err != nil {
 		return err
@@ -238,30 +225,44 @@ func (e *CharClass) checkLeft(rules map[string]*Rule, p path, errs *Errors) {}
 
 func (e *Any) checkLeft(rules map[string]*Rule, p path, errs *Errors) {}
 
-func check(rule *Rule, rules map[string]*Rule, errs *Errors) map[string]*LabelExpr {
-	labels := make(map[string]*LabelExpr)
-	rule.Expr.check(rules, labels, true, errs)
-	return labels
+type ctx struct {
+	rules     map[string]*Rule
+	allLabels *[]*LabelExpr
+	curLabels map[string]*LabelExpr
 }
 
-func (e *Choice) check(rules map[string]*Rule, labels map[string]*LabelExpr, valueUsed bool, errs *Errors) {
-	for _, sub := range e.Exprs {
-		sub.check(rules, labels, valueUsed, errs)
+func check(rule *Rule, rules map[string]*Rule, errs *Errors) {
+	ctx := ctx{
+		rules:     rules,
+		allLabels: &rule.Labels,
+		curLabels: make(map[string]*LabelExpr),
 	}
+	rule.Expr.check(ctx, true, errs)
+	sort.Slice(rule.Labels, func(i, j int) bool {
+		return rule.Labels[i].N < rule.Labels[j].N
+	})
+}
 
-	t := e.Type()
+func (e *Choice) check(ctx ctx, valueUsed bool, errs *Errors) {
+	for _, sub := range e.Exprs {
+		subCtx := ctx
+		subCtx.curLabels = make(map[string]*LabelExpr)
+		for n, l := range ctx.curLabels {
+			subCtx.curLabels[n] = l
+		}
+		sub.check(subCtx, valueUsed, errs)
+	}
+	t := e.Exprs[0].Type()
 	for _, sub := range e.Exprs {
-		// Check types, but if either type is "",
-		// it's from a previous error; don't report again.
 		if got := sub.Type(); *genActions && valueUsed && got != t && got != "" && t != "" {
 			errs.add(sub, "type mismatch: got %s, expected %s", got, t)
 		}
 	}
 }
 
-func (e *Action) check(rules map[string]*Rule, labels map[string]*LabelExpr, valueUsed bool, errs *Errors) {
-	e.Expr.check(rules, labels, false, errs)
-	for _, l := range labels {
+func (e *Action) check(ctx ctx, valueUsed bool, errs *Errors) {
+	e.Expr.check(ctx, false, errs)
+	for _, l := range ctx.curLabels {
 		e.Labels = append(e.Labels, l)
 	}
 	sort.Slice(e.Labels, func(i, j int) bool {
@@ -270,9 +271,9 @@ func (e *Action) check(rules map[string]*Rule, labels map[string]*LabelExpr, val
 }
 
 // BUG: figure out what to do about sequence types.
-func (e *Sequence) check(rules map[string]*Rule, labels map[string]*LabelExpr, valueUsed bool, errs *Errors) {
+func (e *Sequence) check(ctx ctx, valueUsed bool, errs *Errors) {
 	for _, sub := range e.Exprs {
-		sub.check(rules, labels, valueUsed, errs)
+		sub.check(ctx, valueUsed, errs)
 	}
 	t := e.Exprs[0].Type()
 	for _, sub := range e.Exprs {
@@ -282,51 +283,52 @@ func (e *Sequence) check(rules map[string]*Rule, labels map[string]*LabelExpr, v
 	}
 }
 
-func (e *LabelExpr) check(rules map[string]*Rule, labels map[string]*LabelExpr, valueUsed bool, errs *Errors) {
-	e.Expr.check(rules, labels, true, errs)
-	if _, ok := labels[e.Label.String()]; ok {
+func (e *LabelExpr) check(ctx ctx, valueUsed bool, errs *Errors) {
+	e.Expr.check(ctx, true, errs)
+	if _, ok := ctx.curLabels[e.Label.String()]; ok {
 		errs.add(e.Label, "label %s redefined", e.Label.String())
 	}
-	e.N = len(labels)
-	labels[e.Label.String()] = e
+	e.N = len(*ctx.allLabels)
+	*ctx.allLabels = append(*ctx.allLabels, e)
+	ctx.curLabels[e.Label.String()] = e
 }
 
-func (e *PredExpr) check(rules map[string]*Rule, labels map[string]*LabelExpr, valueUsed bool, errs *Errors) {
-	e.Expr.check(rules, labels, false, errs)
+func (e *PredExpr) check(ctx ctx, valueUsed bool, errs *Errors) {
+	e.Expr.check(ctx, false, errs)
 }
 
-func (e *RepExpr) check(rules map[string]*Rule, labels map[string]*LabelExpr, valueUsed bool, errs *Errors) {
-	e.Expr.check(rules, labels, valueUsed, errs)
+func (e *RepExpr) check(ctx ctx, valueUsed bool, errs *Errors) {
+	e.Expr.check(ctx, valueUsed, errs)
 }
 
-func (e *OptExpr) check(rules map[string]*Rule, labels map[string]*LabelExpr, valueUsed bool, errs *Errors) {
-	e.Expr.check(rules, labels, valueUsed, errs)
+func (e *OptExpr) check(ctx ctx, valueUsed bool, errs *Errors) {
+	e.Expr.check(ctx, valueUsed, errs)
 }
 
-func (e *SubExpr) check(rules map[string]*Rule, labels map[string]*LabelExpr, valueUsed bool, errs *Errors) {
-	e.Expr.check(rules, labels, valueUsed, errs)
+func (e *SubExpr) check(ctx ctx, valueUsed bool, errs *Errors) {
+	e.Expr.check(ctx, valueUsed, errs)
 }
 
-func (e *Ident) check(rules map[string]*Rule, _ map[string]*LabelExpr, _ bool, errs *Errors) {
-	r, ok := rules[e.Name.String()]
+func (e *Ident) check(ctx ctx, _ bool, errs *Errors) {
+	r, ok := ctx.rules[e.Name.String()]
 	if !ok {
 		errs.add(e, "rule %s undefined", e.Name.String())
 	} else {
 		e.rule = r
 	}
 }
 
-func (e *PredCode) check(_ map[string]*Rule, labels map[string]*LabelExpr, _ bool, _ *Errors) {
-	for _, l := range labels {
+func (e *PredCode) check(ctx ctx, _ bool, _ *Errors) {
+	for _, l := range ctx.curLabels {
 		e.Labels = append(e.Labels, l)
 	}
 	sort.Slice(e.Labels, func(i, j int) bool {
 		return e.Labels[i].Label.String() < e.Labels[j].Label.String()
 	})
 }
 
-func (e *Literal) check(map[string]*Rule, map[string]*LabelExpr, bool, *Errors) {}
+func (e *Literal) check(ctx, bool, *Errors) {}
 
-func (e *CharClass) check(map[string]*Rule, map[string]*LabelExpr, bool, *Errors) {}
+func (e *CharClass) check(ctx, bool, *Errors) {}
 
-func (e *Any) check(map[string]*Rule, map[string]*LabelExpr, bool, *Errors) {}
+func (e *Any) check(ctx, bool, *Errors) {}

check_test.go

@@ -78,6 +78,16 @@ G <- [fgh]*`,
 			in:   "A <- a:[a] a:[a]",
 			err:  "^test.file:1.12,1.13: label a redefined",
 		},
+		{
+			name: "non-redefined label with same name in different branch",
+			in:   "A <- a:[a] / (a:[a] / a:[a]) / a:[a]",
+			err:  "",
+		},
+		{
+			name: "redefined label in same choice branch",
+			in:   "A <- a:[a] / a:[a] a:[a]",
+			err:  "^test.file:1.20,1.21: label a redefined",
+		},
 		{
 			name: "choice first error",
 			in:   "A <- Undefined / A",

example/calc/calc.go

@@ -18,7 +18,11 @@ func main() {
 	scanner := bufio.NewScanner(os.Stdin)
 	for scanner.Scan() {
 		line := scanner.Text()
-		p := _NewParser(line)
+		p, err := _NewParser(line)
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
 		if pos, perr := _ExprAccepts(p, 0); pos < 0 {
 			_, fail := _ExprFail(p, 0, perr)
 			fmt.Println(peg.SimpleError(line, fail))
@@ -84,15 +88,24 @@ type _key struct {
 	rule  int
 }
 
-func _NewParser(text string) *_Parser {
-	return &_Parser{
+type tooBigError struct{}
+
+func (tooBigError) Error() string { return "input is too big" }
+
+func _NewParser(text string) (*_Parser, error) {
+	n := len(text) + 1
+	if n < 0 {
+		return nil, tooBigError{}
+	}
+	p := &_Parser{
 		text:     text,
-		deltaPos: make([][_N]int32, len(text)+1),
-		deltaErr: make([][_N]int32, len(text)+1),
+		deltaPos: make([][_N]int32, n),
+		deltaErr: make([][_N]int32, n),
 		node:     make(map[_key]*peg.Node),
 		fail:     make(map[_key]*peg.Fail),
 		act:      make(map[_key]interface{}),
 	}
+	return p, nil
 }
 
 func _max(a, b int) int {

example/calc/calc.peggy

@@ -19,7 +19,11 @@ func main() {
 	scanner := bufio.NewScanner(os.Stdin)
 	for scanner.Scan() {
 		line := scanner.Text()
-		p := _NewParser(line)
+		p, err := _NewParser(line)
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
 		if pos, perr := _ExprAccepts(p, 0); pos < 0 {
 			_, fail := _ExprFail(p, 0 ,perr)
 			fmt.Println(peg.SimpleError(line, fail))