Fully automatic indenting

[jngls]

A few random thoughts that are not fully formed, but need to go somewhere.

Even with the new Indentation and Layout, handling newlines and indenting is still a fairly manual process.

Currently, to set up indenting and newlines for inner types, we use something like:

// nl = beg to begin each item on an indented newline
#[derive(SyntaxFmt)]
#[syntax(nl = beg, suf = ";")]
struct Item {
    name: &'static str,
}

#[derive(SyntaxFmt)]
struct Block {
    // nl = cont to insert an additional unindented newline after the items
    #[syntax(ind, nl = cont, pre = "{", suf = "}", delim = "")]
    items: Vec<Item>,
}

This is a little visually clunky and requires knowledge of the behaviour of the macro to know where to put newlines.

But it results in nicely formatted output (in pretty mode):

{
    itemA;
    itemB;
    itemC;
}

I am wondering if it would be possible to fully automate by always indenting within types by default, then giving additional options to deny newlines or indentation.

Something like this, to result in the same output:

#[derive(SyntaxFmt)]
#[syntax(suf = ";")]
struct Item {
    name: &'static str,
}

#[derive(SyntaxFmt)]
struct Block {
    #[syntax(pre = "{", suf = "}", delim = "")]
    items: Vec<Item>,
}

And then if you don't want newlines and indentation:

#[derive(SyntaxFmt)]
#[syntax(nl = deny, suf = ";")]
struct Item {
    name: &'static str,
}

#[derive(SyntaxFmt)]
struct Block {
    #[syntax(pre = "{", suf = "}", delim = "")]
    items: Vec<Item>,
}

Which would result in:

{itemA;itemB;itemC;}

And of course, we could still support the explicit nl options.

Another possibility would be to conditionally add newlines based on some character length, array length, line length heuristics.

[jngls]

I decided I needed some of these features sooner rather than later.

I've partially implemented this in this branch.

It's not fully automatic, but it may end up being all we need.

Key change is the introduction of the sep option for nl, which enables newlines on separators. And the inner option for nl, which is shorthand forpre, sep, cont.

This already gets us most of the way there:

// No `nl` needed
#[derive(SyntaxFmt)]
struct Item {
    name: &'static str,
}

#[derive(SyntaxFmt)]
struct Block {
    // nl = inner to insert appropriate newlines with the vec content
    #[syntax(ind, nl = inner, pre = "{", suf = "}", sep = "")]
    items: Vec<Item>,
}

The most important change is removing the need for nl on the item type, which was confusing and easy to forget.

The pattern of ind, nl = inner has been coming up a lot in my code, so I may look to further reduce that boilerplate, maybe with another shorthand attribute arg to combine the ind and nl.

[jngls]

Now merged in #14