# Layout Sensitivity¶

SDF3 supports definition of layout sensitive syntax by means of low-level layout constraints and high-level layout declarations.

Note

If you want to use layout constraints or layout declarations, you should specify the jsglr-version: layout-sensitive parameter for SDF3, see configuration.

## Layout Constraints¶

While we haven't covered layout constraints in this documentation, the paper of Erdweg et al.1 describes the concepts.

## Layout Declarations¶

In the paper of Erdweg et al.1, the authors describe layout constraints in terms of restrictions involving the position of the subtree involved in the constraint (0, 1, ...), token selectors (first, left, last and right), and position selectors as lines and columns (line and col).

This mechanism allows writing layout constraints to express alignment, offside and indentation rules, but writing such constraints is rather cumbersome and error prone. Alternatively, one may write layout constraints using layout declarations, which are more declarative specifications and abstract over lines, columns and token selectors as the original layout constraints from the Erdweg et al. paper1.

### Tree selectors¶

To specify which trees should be subject to a layout constraint, one may use: tree positions, SDF3 labeled non-terminals, or unique literals that occurs in the production. For example:

context-free syntax

Stmt.IfElse = "if" Exp "then" Stmts "else" else:Stmts  {layout(
indent "if" 3, else &&
align 3 else &&
align "if" "else"
)}


In the layout constraint for the production above, else refers to the tree for the labeled non-terminal else:Stmts, "if" refers to the tree corresponding to the "if" literal and the number 3 correspond to the tree at position 3 in the parse tree (starting at 0, ignoring trees for LAYOUT?).

### align¶

The layout constraint layout(align x y1, ..., yn) specifies that the trees indicated by the tree selectors yi should be aligned with the tree indicated by the tree selector x, i.e., all these trees should start in the same column. For example, if we consider the production above, the following program is correct according to the align constraints:

if x < 0 then
··x = 0
else
··y = 1


Whereas, the following program is incorrect because neither the if and else keyword align (align "if" "else"), nor the statements in the branches (align 3 else):

if x < 0 then
··x = 0
·else
···y = 1


### align-list¶

The constraint align-list can be used to indicate that all subtrees within a list should be aligned. That is, a constraint layout(align-list x), where x is a tree selector for a list subtree, can be used to enforce such constraint. For example, consider the following production and its layout constraint:

context-free syntax

Stmt.If = "if" Exp "then" then:Stmt*  {layout(
align-list then
)}


This constraint indicates that statements inside the list should be aligned. Therefore, the following program is correct according to this constraint:

if x < 0 then
··x = 0
··y = 4
··z = 2


And the following program is invalid, as the second statement is misaligned:

if x < 0 then
··x = 0
···y = 4
··z = 2


### offside¶

The offside rule is very common in layout-sensitive languages. It states that all lines after the first one should be further to the right compared to the first line. For a description of how the offside rule can be modelled with layout constraints, refer to Erdweg et al.1. An example of a declarative specification of the offside rule can be seen in the production below:

context-free syntax

Stmt.Assign = <<ID> = <Exp>> {layout(offside 3)}


The layout constraint specifies that when the expression in the statement spams multiple lines, all following lines should be indented with respect to the column where the expression started. For example, the following program is valid according to this constraint:

x = 4 * 10
·····+ 2


However, the following program is not valid, as the second line of the expression starts at the same column as the first line:

x = 4 * 10
····+ 2


Note that if the expression is written on a single line, the constraint is also verified. That is, the following program successfully parses:

    x = 4 * 10 + 2


It is also possible to use the offside relation on different trees. For example, consider the constraint in the following production:

context-free syntax

Stmt.If = "if" Exp "then" then:Stmt*  {layout(
offside "if" then
)}


This constraint states that all lines (except the first) of the statements in the then branch should be indented with respect to the if literal. Thus, the following program is invalid according to this layout constraint, because the statement x = 2 should be indented with relation to the topmost if.

    if x < 0 then
··if y < 0 then
x = 2


In general, an offside constraint involving more than a single tree is combined with indent constraint to enforce that the column of the first and all subsequent lines should be indented.

### indent¶

An indent constraint indicates that the column of the first line of a certain tree should be further to the right with respect to another tree. For example, consider the following production:

context-free syntax

Stmt.If = "if" Exp "then" then:Stmt*  {layout(
indent "if" then
)}


This constraint indicates that the first line of the list of statements should be indented with respect to the if literal. Thus, according to this constraint the following program is valid:

if x < 0 then
··x = 2


Note that if the list of statements in the then branch spams multiple lines, the constraint does not apply to its subsequent lines. For example, consider the following program:

if x < 0 then
··x = 2 + 10
* 4
y = 3


This program is still valid, since the column of the first line of the first assignment is indented with respect to the if literal. To indicate that the first and all subsequent lines should be indented, an offside constraint should also be included.

context-free syntax

Stmt.If = "if" Exp "then" then:Stmt*  {layout(
indent "if" then &&
offside "if" then
)}


With this constraint, the remainder of the expression * 4 should also be further to the right compared to the "if" literal. The following program is correct according to these two constraints, since the second line of the first assignment and the second assignment are also indented with respect to the if literal:

if x < 0 then
··x = 2 + 10
·* 4
·y = 3


### newline-indent¶

The newline-indent constraint indicates that a certain tree should both be located on a new line, as well as further to the right with respect to another tree.

For example, consider the following production:

context-free syntax

Exp.If = "if" Exp "then" then:Exp "else" Exp  {layout(
newline-indent "if" then
)}


This constraint indicates that the "then" branch of the if-then-else expression needs to be on a new line and indented with respect to the "if" keyword. Thus, according to this constraint the following program is valid:

if x < 0 then
··x + 2 else x * 2


The newline-indent constraint does not require that the expression is located on the immediate next line, but rather that it is located below the reference tree. Consequently, the following is also allowed:

if x < 0 then

··x + 2
else x * 2


Note that the newline-indent constraint is relative to the first character in the reference tree. That means that, given the following syntax:

context-free syntax
Example.Example = a:FooBar b:Baz {layout(newline-indent a b)}
FooBar.FooBar = <foo bar>
Baz.Baz = <baz>


The following syntax is valid, despite bar being indented further than baz:

foo
····bar
··baz


### single-line¶

The single-line constraints indicates that the entirety of the given subtrees must be located on the same line. For example, consider the following production:

context-free syntax
Exp.If = "if" Exp ":" then:Exp "else" Exp {layout(
single-line "if" ":"
)}


This enforces that both the if and : tokens need to be on the same line. As a result, the condition expression also needs to be contained on the same line. Thus, the following program is valid for the given constraints:

if x < 3:
x + 2 else x * 2


Note that the entirety of the referenced tree needs to be on the same line. Consider the following syntax:

context-free syntax
Example.Example = a:Baz b:FooBar {layout(single-line a b)}
FooBar.FooBar = <foo bar>
Baz.Baz = <baz>


With this definition, the following program is invalid, despite baz and the start of foo bar being on the same line:

baz foo
bar


Using the single-line constraint without any parameters will add a constraint that the entire production needs to be on a single line. This can be useful as a shorthand when your grammar requires that the entirety of a production is on the same line:

context-free syntax
Exp.Add = <<Exp> + <Exp>> {layout(single-line)}
// is equivalent to
Exp.Add = <<a:Exp> + <b:Exp>> {layout(single-line a b)}


Finally, all these layout declarations can be ignored by the parser and used only when generating the pretty-printer. To do that, prefix the constraint with pp- writing, for example, pp-offside or pp-align.

1. Sebastian Erdweg, Tillmann Rendel, Christian Kästner, and Klaus Ostermann. Layout-sensitive generalized parsing. In Krzysztof Czarnecki and Görel Hedin, editors, Software Language Engineering, 5th International Conference, SLE 2012, Dresden, Germany, September 26-28, 2012, Revised Selected Papers, volume 7745 of Lecture Notes in Computer Science, 244–263. Springer, 2012. URL: http://dx.doi.org/10.1007/978-3-642-36089-3_14, doi:10.1007/978-3-642-36089-3_14

Last update: 2021-11-15