Support infix rules by msujew · Pull Request #134 · TypeFox/fastbelt

msujew · 2026-07-27T13:56:03Z

Closes #115 (as a side effect).

Adds infix rule support, similar to how Langium did it (but a bit simpler, since we don't need CST support).

Implements the support by rewriting infix rules into parser rules of the shape Expr (op Expr)*.

github-actions

⚠️ Performance Alert ⚠️

Possible performance regression was detected for benchmark.
Benchmark result of this commit is worse than the previous benchmark result exceeding threshold 1.50.

Benchmark suite	Current: `6c2d06c`	Previous: `d803417`	Ratio
`BenchmarkWorkspaceCycle (typefox.dev/fastbelt/examples/statemachine) - MB/s`	`22` MB/s	`5.21` MB/s	`4.22`
`BenchmarkParser (typefox.dev/fastbelt/examples/statemachine) - MB/s`	`90.81` MB/s	`37.68` MB/s	`2.41`
`BenchmarkLexer (typefox.dev/fastbelt/examples/statemachine) - MB/s`	`119.62` MB/s	`64.67` MB/s	`1.85`
`BenchmarkLexerAndParser (typefox.dev/fastbelt/examples/statemachine) - MB/s`	`50.43` MB/s	`23.82` MB/s	`2.12`
`BenchmarkLocalLinking (typefox.dev/fastbelt/examples/statemachine) - MB/s`	`25.57` MB/s	`16.69` MB/s	`1.53`

This comment was automatically generated by workflow using github-action-benchmark.

ssmifi

Looks well-designed and -tested. There are one design and some minor questions left.

ssmifi · 2026-08-10T10:42:03Z

+				iin.AppendLine("operators = append(operators, token)")
+			})
+			in.AppendLine("}")
+			emitOperand(in, secondCall)


Question: Is it safe to emit the operand, even if the operator wasn't appended before?

Emitting the operand is definitely safe. The question should be: Is it safe to append the operand if the operator didn't exist ;)

In that case, it's still safe, since we cannot enter the for loop that is emitted before that. The lookahead done there asserts that the next token is the expected operator token. And even then, error recovery should ensure that this works as expected.

Lotes · 2026-08-04T12:57:47Z

+
+	// Mixed with tighter ("%") and looser ("*") levels.
+	expr = parseExpression(t, "1 * 2 ^ 3 % 4 ^ 5")
+	assert.Equal(t, "(1 * (2 ^ ((3 % 4) ^ 5)))", printExpression(expr))


This line reads weird, until you mind the comment and the special grammar with % as strongest operator.

Lotes · 2026-08-04T13:00:34Z

+// and "+" | "-" bind loosest, so "1 + 2 * 3" parses as "1 + (2 * 3)".
+//
+// Groups are left-associative by default; prefix a group with "right assoc"
+// (or explicitly "left assoc") to control associativity:


We could also think of a "non assoc" for operators like less and greater. But I would prefer a extra validation I think

How would an AST for a non-associative operation look like? It wouldn't be binary (i.e. just left vs right) anymore.

Lotes · 2026-08-14T07:38:29Z

 // becomes the current object. The operator += is also valid for tree-rewriting
 // actions on slice properties.
 //
+// # Infix Rules


We could also explain

what the difference between associativity and precedence is

how it is done without infix notation, and that infix is faster than manual

that this is useful to reduce ambiguities in expressions

and that reducing ambiguities, is increasing parsing performance

Thanks, I've adjusted the documentation a bit.

what the difference between associativity and precedence is

They are unrelated. I think this is clearer with the adjusted documentation.

that this is useful to reduce ambiguities in expressions, and that reducing ambiguities, is increasing parsing performance.

This is not true? It's increasing performance by flattening the parse tree into one single loop, instead of a list of recursive parsing calls. Ambiguity isn't relevant here.

Lotes · 2026-08-14T07:41:45Z

+			return fmt.Errorf("could not resolve the operand rule of infix rule '%s'", rule.Name())
+		}
+
+		tokenGroup, err := synthesizeOperatorGroup(g, rule, groupName, ctx)


What if an operator is not a terminal? Looking at the grammar, this should be an option.

We have a validation that prevents this.

Lotes · 2026-08-14T07:47:36Z

+
+// synthesizeInfixBody attaches the flat "operand (operator operand)*" body to
+// the infix rule.
+func synthesizeInfixBody(rule InfixRule, operand ParserRule, operatorGroup TokenGroup) {


I feel a bit lost here.

operand (operator operand)* only handles left association. What about right association? Or what do I read wrong?

Is this about creating a AST for the infix operators?

Both associativity directions aren't handled in the parsing phase. They are only relevant for the AST. I.e. whether an expression like A + B + C is (A + B) + C or A + (B + C) is a pure AST mutation. We can apply this as a post-processing on the parsing. Therefore, we first parse all operators and operands into an array, and then apply a transformation that produces the final AST, based on the predetermined precedence.

Lotes · 2026-08-14T07:53:48Z

+	// Mirrors the arithmetics grammar: "%" > "^" > "*" | "/" > "+" | "-",
+	// plus a loosest right-associative "=" level.
+	precedence := map[int]InfixPrecedence{
+		typeIds["%"]: {Level: 0},


Just because it reads weird:
Instead of the modulo operator can we instead use the tetration operator?
Either "!!" or "↑↑" (decimal: 8593, hex: 2191, entity: &uarr).

What is problematic about the modulo operator? We use the same in the arithmetics language in Langium.

Lotes · 2026-08-14T08:03:01Z

+func TestInfixRuleOperatorGroupNameTaken(t *testing.T) {
+	f := test.New(t, CreateServices())
+	doc := f.Parse(`
+		grammar Test;
+	` + infixInterfaces + `
+		token BinaryExpressionOperator: /@+/;
+		infix <|1:BinaryExpression|> on PrimaryExpression: "+"
+	` + commonTokens)
+	doc.ExpectDiagnostic("1").WithSeverity(core.SeverityError).WithCode(ValidateInfixOperatorGroupName)
+}


What is the problem here? Is BinaryExpressionOperator a reserved name when using infix?

Yes, the <infix-rule-name>Operator is a token group that is automatically generated as an optimization (so lookahead just needs to do a BinaryExpressionOperator.Matches(p.LA(1)) to figure out whether to continue parsing the binary expression).

github-actions Bot reviewed Jul 27, 2026

View reviewed changes

ssmifi reviewed Aug 10, 2026

View reviewed changes

msujew force-pushed the msujew/infix-operator branch from fe3f042 to b6735dc Compare August 10, 2026 16:31

msujew added 5 commits August 12, 2026 10:42

Support infix rules

0d6b775

Update API

14b2a0b

Review comments

1bcb85e

Optimize binary expression building in O(n)

38ef83a

Rebase

efe4301

msujew force-pushed the msujew/infix-operator branch from 6c2d06c to efe4301 Compare August 12, 2026 08:46

Lotes reviewed Aug 14, 2026

View reviewed changes

Update docs

9d34ba2

Uh oh!

Uh oh!

Conversation

msujew commented Jul 27, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions Bot left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

⚠️ Performance Alert ⚠️

Uh oh!

ssmifi left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Lotes Aug 14, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

msujew commented Jul 27, 2026 •

edited

Loading

github-actions Bot left a comment •

edited

Loading

Lotes Aug 14, 2026 •

edited

Loading