Fix formatting of floating point literals that use `−` (Unicode U+2212)
instead of the typically used `-` (ASCII/Unicode U+002D). The parser
treats them as synonyms but the former triggered an assertion error in
Runic while formatting. After this change Runic will normalize to `-`
when formatting. Fixes#137.
This patch simplifies the verbose output a bit and fixes various cases
where an error message would be printed before the file info line
instead of after.
This patch improves the command line argument parsing to handle more
edge cases related to input files and directories (such as e.g. empty
directories).
This patch implements a new command line argument `--verbose` which
enables verbose ouutput. Runic is now silent by default so `--verbose`
re-enables the verbose file printing from previous releases.
This patch also adds a progress prefix to each file of the form
`[file/nfiles]` to verbose output.
This patch implements the `--lines=a:b` command line argument for
limiting the formatting to the line range `a:b`. Multiple ranges are
supported. Closes#114.
This patch removes an assertion about whitespace after the `function`
keyword in the indent pass. The core issue is the
`is_longform_anon_function` predicate which is wrong for the testcases,
but the assert is not needed since we can just use the next
non-whitespace noce as the signature in all cases. Fixes#109.
Running testsuite *without* asserts takes roughly 150% or the time to
run it *with* asserts, probably because the compiler is helped by some
of the checks. The toggling is unused anyway, so delete it.
This patch changes the parsed syntax tree normalization with the goal of
simplifying the formatting code. JuliaSyntax is not very consistent with
where whitespace ends up which make formatting tricky since you always
have to "peek" into the next node (sometimes multiple levels) to check
if the next leaf is e.g. whitespace. This patch reworks the
normalization to "bubble up" whitespace so that all nodes start and end
with a non-whitespace node.
For example, given `a + b * c`, the output from JuliaSyntax is:
```
[call]
Identifier
Whitespace
+
[call]
Whitespace
Identifier
Whitespace
*
Whitespace
Identifier
```
and now after normalization the leading whitespace of the `*`-call is
bubbled up:
```
[call]
Identifier
Whitespace
+
Whitespace
[call]
Identifier
Whitespace
*
Whitespace
Identifier
```
As seen from the diff, this make it possible to remove a lot of
complicated code that were necessary to handle the random whitespace
placement. In particular, there is no need to peek into the nodes to
check for whitespace.
As a bonus, this fixes two issues:
- `global\n\n x = 1` would previously not indent correctly because we
had to double-peek (first into the `=` node, then into the LHS node).
- `runic: (off|on) toggling within array literals. Previously the
toggle comments would end up inside the `row` nodes so in the tree
they weren't on the same "level" which is required for the toggling.
Behavior of `..` is more tricky than `:`. Sometimes the space is
required like in e.g. `a .. -b` which, formatted as `a..-b`, would give
`ParseError: invalid operator ..-`.
This reverts commit 7d26dcf268.
This patch relaxes the toggle comments `# runic: (off|on)` such that the
comment may contain more than just the toggle comment. This is useful
when combining with other "pragmas" such as e.g. Literate.jl line
filters. For example, the following now also toggles formatting:
```julia
\# runic: off #src
not = formatted #src
\# runic: on #src
```
This doesn't cost much (5 % perf hit for some large files) and can catch
some errors. Note that it isn't possible/trivial to compare the trees
since the formatter make changes to it.
This patch make sure that function and macro definitions, as well as
do-blocks, end with an explicit `return` statement before the last
expression in the body. The following exceptions are made:
- If the last expression is a `for` or `while` loop (which both always
evaluate to `nothing`) `return` is added *after* the loop.
- If the last expression is a `if` or `try` block the `return` is only
added in case there is no `return` inside any of the branches.
- If the last expression is a `let` or `begin` block the `return` is
only added in case there is no `return` inside the block.
- If the last expression is a macro call the `return` is only added in
case there is no `return` inside the macro.
- If the last expression is a function call, and the function name is
`throw`, `rethrow`, or `error`, no `return` is added. This is because
it is pretty obvious that these calls terminate the function without
the explicit `return`.
Since adding `return` changes the expression that a macro will see, this
rule is disabled for function definitions inside of macros with the
exception of some known ones from Base (e.g. `@inline`, `@generated`,
...).
Closes#43.
This patch changes where spaces are inserted before comments so that it
is always added as a sibling to the comment instead of as a "uncle" when
a comment is found as the first leaf of a kid.
This patch fixes the usage of trailing commas in implicit tuples when
used in destructuring assignment, e.g. `x, = z`. In this context the
trailing comma is needed to preserve the tuple node, which is different
from e.g. implicit tuples in `do`-blocks. A trailing comma is allowed
(e.g. preserved from the source) for multi-item implicit tuples so that
e.g. `x, y, = z` can be used to signal that z contains more than two
items. Closes#58.
This patch simplifies the juliac compatible pipe-fork-exec
implementation for running git on the formatted text. Instead of
collecting all bytes and then writing to stderr we instead write
directly from the intermediate buffer to stderr. The drawback is that if
reading bytes fail we might have already written something to stderr,
but this should rarely, if ever, happen under normal circumstances.
