DefaultAstNode StartOffset

Hello,

It's a bit complex but let me explain.  When you do a "Ast" tree constructor call, it makes the constructed DefaultAstNode have the StartOffset be the first match's start offset in the production and the EndOffset be the last match's end offset in the production, up to that point. 

When the "Expression" node is created, at that point the current production has matched "if" through ")" and that's why the offsets are set that way there.  The same concept applies to the others.  

If offsets are meaningful to you, you really only want to call the "Ast" tree constructor once per production.  So with the "Expression" example above, you could split it out into another separate production like:

var rootExpression = new NonTerminal("Expression");
rootExpression.Production = expression["expression"] > Ast("Expression", AstFrom("expression"));

...

// See "Updated" lines below
Root.Production = @if
	+ @openParen + rootExpression["expression"] + @closeParen  // Updated
	+ statement["true_stm"]
	+ (@else + statement["false_stm"]).Optional()
	> Ast("TestIfStatement",
		AstFrom("expression")),  // Updated
		Ast("TrueStatement", AstFrom("true_stm")),
		Ast("FalseStatement", AstFrom("false_stm")));

Those kinds of changes applied to the others too will fix the issue since in that scenario, only one Ast tree constructor is called per production.

Thank you very much for your help.

I modified my code to call "Ast" once per production and I got correct offsets for "Expression".

I have 2 more questions.

Question 1:

According to what you told me, do I need to define "TrueStatement" and "FalseStatement" separately like below?

var statement = new NonTerminal("statement");
statement.Production = @identifier + @assignInput + @integer + @semicolon;

var trueStatement = new NonTerminal("TrueStatement");
trueStatement.Production = statement["stm"] > Ast("TrueStatement", AstFrom("stm"));

var falseStatement = new NonTerminal("FalseStatement");
falseStatement.Production = statement["stm"] > Ast("FalseStatement", AstFrom("stm"));

Root.Production = @if
	+ @openParen + rootExpression["expression"] + @closeParen
	+ trueStatement["true_stm"]
	+ (@else + falseStatement["false_stm"]).Optional()
	> Ast("TestIfStatement",
		AstFrom("expression"),
		AstFrom("true_stm"),
		AstFrom("false_stm"));

In fact, in my actual grammar, "statement" non-terminal appears in many places, not only twice.

Question 2:

Please tell me how to handle "AdditiveExpression" production.

I implemented it referencing "Walkthrough: Tree Constructors" of your documentation.

To create the abstract syntax tree, it uses "AstValueOfConditional" instead of "Ast" constructor call.

I wrote this grammar but got wrong offsets for "+" operator.

Root = new NonTerminal("DocumentRoot");

var variable = new NonTerminal("Variable");
variable.Production = @identifier["identifier"] > Ast("Variable", AstFrom("identifier"));

var additiveExpression = new NonTerminal("AdditiveExpression");
additiveExpression.Production = variable["leftexp"] + ((@plus | @minus).SetLabel("op") + additiveExpression["rightexp"]).Optional()
	> AstValueOfConditional(AstChildFrom("op"), AstFrom("leftexp"), AstFrom("rightexp"));

var statement = new NonTerminal("Statement");
statement.Production = variable["var"] + @assignInput + additiveExpression["exp"] + @semicolon
	> Ast("TestStatement", AstFrom("var"), AstFrom("exp"));
 
Root.Production = statement["stm"] > Ast("Root", AstFrom("stm"));

Input text:

x:=a+b;

Output from LL Parser Debugger:

Root[
　　TestStatement[
　　　　Variable[
　　　　　　"x"
　　　　]
　　　　+[
　　　　　　Variable[
　　　　　　　　"a"
　　　　　　]
　　　　　　Variable[
　　　　　　　　"b"
　　　　　　]
　　　　]
　　]
]

Ast node offsets(from debugging with Visual Studio):

TestStatement StartOffset: 0 EndOffset: 7
Variable StartOffset: 0 EndOffset: 1
x StartOffset: 0 EndOffset: 1
+ StartOffset: 3 EndOffset: 6
Variable StartOffset: 3 EndOffset: 4
a StartOffset: 3 EndOffset: 4
Variable StartOffset: 5 EndOffset: 6
b StartOffset: 5 EndOffset: 6

StartOffset and EndOffset of "+" Operator are 3 and 6, respectively, and they are wrong.

Hello,

1) If you wish to wrap with "TrueStatement" then yes you would need to separate those too.  The extra "statement" node comes from the "statement" production since it has to make a node to contain all the other child nodes from there.  If you wish to eliminate that, you might be able to do something like this:

trueStatement.Production = statement["stm"] > Ast("TrueStatement", AstChildrenFrom("stm"));

2) In that case, it's by design and is the offset range of everything matched within the additive expression, so it's including the offset ranges of the "a" and "b".  An AST wouldn't work correctly if the parent node had a smaller offset range than its children.  Since in that case, recursive logic that looks for what node contains an offset (say for "a") would skip over the entire "+" node and its descendants.

Thank you for your explanation. I understood.