Format files using DocumentFormat

Author: davidanthoff

docs/make.jl

@@ -7,16 +7,16 @@ makedocs(;
     repo="https://github.com/julia-vscode/CSTParser.jl/blob/{commit}{path}#L{line}",
     sitename="CSTParser.jl",
     format=Documenter.HTML(;
-        prettyurls=prettyurls = get(ENV, "CI", nothing) == "true",
+        prettyurls=prettyurls = get(ENV, "CI", nothing) == "true"
         # canonical="https://www.julia-vscode.org/CSTParser.jl",
         # assets=String[],
     ),
     pages=[
         "Home" => "index.md",
         "Syntax Reference" => "syntax.md",
-    ],
+    ]
 )
 
 deploydocs(;
-    repo="github.com/julia-vscode/CSTParser.jl",
+    repo="github.com/julia-vscode/CSTParser.jl"
 )

src/CSTParser.jl

@@ -38,7 +38,7 @@ Acceptable starting tokens are:
 + An `@`.
 
 """
-function parse_expression(ps::ParseState, esc_on_error = false; allow_const_field = false)
+function parse_expression(ps::ParseState, esc_on_error=false; allow_const_field=false)
     if kindof(ps.nt) === Tokens.ENDMARKER
         ret = mErrorToken(ps, UnexpectedToken)
     elseif (esc_on_error && ps.nt.kind == Tokens.ERROR)
@@ -48,7 +48,7 @@ function parse_expression(ps::ParseState, esc_on_error = false; allow_const_fiel
     else
         next(ps)
         if iskeyword(kindof(ps.t)) && kindof(ps.t) != Tokens.DO
-            ret = parse_kw(ps; allow_const_field = allow_const_field)
+            ret = parse_kw(ps; allow_const_field=allow_const_field)
         elseif kindof(ps.t) === Tokens.LPAREN
             ret = parse_paren(ps)
         elseif kindof(ps.t) === Tokens.LSQUARE
@@ -143,9 +143,9 @@ function parse_compound(ps::ParseState, ret::EXPR)
         # prime operator followed by an identifier has an implicit multiplication
         nextarg = @precedence ps TimesOp parse_expression(ps)
         ret = EXPR(:call, EXPR[EXPR(:OPERATOR, 0, 0, "*"), ret, nextarg], nothing)
-# ###############################################################################
-# Everything below here is an error
-# ###############################################################################
+        # ###############################################################################
+        # Everything below here is an error
+        # ###############################################################################
     else
         ps.errored = true
         if kindof(ps.nt) in (Tokens.RPAREN, Tokens.RSQUARE, Tokens.RBRACE)
@@ -173,7 +173,7 @@ Parses an expression starting with a `(`.
 function parse_paren(ps::ParseState)
     args = EXPR[]
     trivia = EXPR[EXPR(ps)]
-    @closeparen ps @default ps @nocloser ps :inwhere parse_comma_sep(ps, args, trivia, false, true, true, insert_params_at = 1)
+    @closeparen ps @default ps @nocloser ps :inwhere parse_comma_sep(ps, args, trivia, false, true, true, insert_params_at=1)
     if length(args) == 1 && length(trivia) == 1 && ((kindof(ps.ws) !== SemiColonWS || headof(args[1]) === :block) && headof(args[1]) !== :parameters)
         accept_rparen(ps, trivia)
         ret = EXPR(:brackets, args, trivia)
@@ -292,10 +292,10 @@ end
 
 function _continue_doc_parse(ps::ParseState, x::EXPR)
     kindof(ps.nt) !== Tokens.ENDMARKER &&
-    headof(x) === :macrocall &&
-    valof(x.args[1]) == "@doc" &&
-    length(x.args) < 4 &&
-    ps.t.endpos[1] + 1 == ps.nt.startpos[1]
+        headof(x) === :macrocall &&
+        valof(x.args[1]) == "@doc" &&
+        length(x.args) < 4 &&
+        ps.t.endpos[1] + 1 == ps.nt.startpos[1]
 end
 
 include("precompile.jl")

src/components/internals.jl

@@ -4,7 +4,7 @@ const term_c = (Tokens.RPAREN, Tokens.RSQUARE, Tokens.RBRACE, Tokens.END, Tokens
 Continue parsing statements until an element of `closers` is hit (usually
 `end`). Statements are grouped in a `Block` EXPR.
 """
-function parse_block(ps::ParseState, ret::Vector{EXPR}=EXPR[], closers=(Tokens.END,), docable=false; allow_const_field = false)
+function parse_block(ps::ParseState, ret::Vector{EXPR}=EXPR[], closers=(Tokens.END,), docable=false; allow_const_field=false)
     prevpos = position(ps)
     while kindof(ps.nt) ∉ closers # loop until an expected closer is hit
         if kindof(ps.nt) ∈ term_c # error handling if an unexpected closer is hit
@@ -17,7 +17,7 @@ function parse_block(ps::ParseState, ret::Vector{EXPR}=EXPR[], closers=(Tokens.E
             if docable
                 a = parse_doc(ps)
             else
-                a = parse_expression(ps; allow_const_field = allow_const_field)
+                a = parse_expression(ps; allow_const_field=allow_const_field)
             end
             push!(ret, a)
         end
@@ -31,7 +31,7 @@ Parses an iterator, allowing for the preceding keyword `outer`. Returns an
 error expression if an invalid expression is parsed (anything other than
 `=`, `in`, `∈`).
 """
-function parse_iterator(ps::ParseState, outer = parse_outer(ps))
+function parse_iterator(ps::ParseState, outer=parse_outer(ps))
     arg = @closer ps :range @closer ps :ws @nocloser ps :wsop parse_expression(ps)
     if !is_range(arg)
         arg = mErrorToken(ps, arg, InvalidIterator)
@@ -135,7 +135,7 @@ function parse_call(ps::ParseState, ret::EXPR, ismacro=false)
         end
         # args = ismacro ? EXPR[ret, EXPR(:NOTHING, 0, 0)] : EXPR[ret]
         trivia = EXPR[EXPR(next(ps))]
-        @closeparen ps @default ps parse_comma_sep(ps, args, trivia, !ismacro, insert_params_at = ismacro ? 3 : 2)
+        @closeparen ps @default ps parse_comma_sep(ps, args, trivia, !ismacro, insert_params_at=ismacro ? 3 : 2)
         accept_rparen(ps, trivia)
         ret = EXPR(ismacro ? :macrocall : syntaxcall ? ret : :call, args, trivia)
     end
@@ -146,7 +146,7 @@ end
 Parses a comma separated list, optionally allowing for conversion of
 assignment (`=`) expressions to `Kw`.
 """
-function parse_comma_sep(ps::ParseState, args::Vector{EXPR}, trivia::Vector{EXPR}, kw = true, block = false, istuple = false; insert_params_at = 2)
+function parse_comma_sep(ps::ParseState, args::Vector{EXPR}, trivia::Vector{EXPR}, kw=true, block=false, istuple=false; insert_params_at=2)
     prevpos = position(ps)
     @nocloser ps :inwhere @nocloser ps :newline @closer ps :comma while !closer(ps)
         a = parse_expression(ps)
@@ -205,11 +205,11 @@ end
 
 Parses parameter arguments for a function call (e.g. following a semicolon).
 """
-function parse_parameters(ps::ParseState, args::Vector{EXPR}, args1::Vector{EXPR} = EXPR[], insert_params_at = 2; usekw = true)
+function parse_parameters(ps::ParseState, args::Vector{EXPR}, args1::Vector{EXPR}=EXPR[], insert_params_at=2; usekw=true)
     trivia = EXPR[]
     isfirst = isempty(args1)
     prevpos = position(ps)
-    @nocloser ps :inwhere @nocloser ps :newline  @closer ps :comma while !isfirst || (@nocloser ps :semicolon !closer(ps))
+    @nocloser ps :inwhere @nocloser ps :newline @closer ps :comma while !isfirst || (@nocloser ps :semicolon !closer(ps))
         a = isfirst ? parse_expression(ps) : first(args1)
         if usekw && _do_kw_convert(ps, a)
             a = _kw_convert(a)
@@ -347,7 +347,7 @@ end
 function get_appropriate_child_to_expand(x)
     if headof(x) === :generator && !(headof(x.args[1]) in (:generator, :flatten))
         return x, x.args[1]
-    elseif headof(x) === :flatten &&  headof(x.args[1]) === :generator && headof(x.args[1].args[1]) === :generator
+    elseif headof(x) === :flatten && headof(x.args[1]) === :generator && headof(x.args[1].args[1]) === :generator
         x.args[1], x.args[1].args[1]
     else
         get_appropriate_child_to_expand(x.args[1])
@@ -365,7 +365,7 @@ function parse_nonstd_identifier(ps)
     end
 end
 
-function parse_importexport_item(ps, is_colon = false)
+function parse_importexport_item(ps, is_colon=false)
     if kindof(ps.nt) === Tokens.AT_SIGN
         parse_macroname(next(ps))
     elseif kindof(ps.nt) === Tokens.LPAREN
@@ -377,7 +377,7 @@ function parse_importexport_item(ps, is_colon = false)
         parse_unary(ps, INSTANCE(next(ps)))
     elseif !is_colon && isoperator(ps.nt)
         next(ps)
-        EXPR(:OPERATOR, ps.nt.startbyte - ps.t.startbyte,  1 + ps.t.endbyte - ps.t.startbyte, val(ps.t, ps))
+        EXPR(:OPERATOR, ps.nt.startbyte - ps.t.startbyte, 1 + ps.t.endbyte - ps.t.startbyte, val(ps.t, ps))
     elseif is_nonstd_identifier(ps)
         parse_nonstd_identifier(ps)
     else

src/components/keywords.jl

@@ -3,7 +3,7 @@
 
 Dispatch function for when the parser has reached a keyword.
 """
-function parse_kw(ps::ParseState; allow_const_field = false)
+function parse_kw(ps::ParseState; allow_const_field=false)
     k = kindof(ps.t)
     if ps.closer.precedence == 20 && ps.lt.kind === Tokens.EX_OR && k !== Tokens.END
         return EXPR(:IDENTIFIER, ps)
@@ -52,7 +52,7 @@ function parse_kw(ps::ParseState; allow_const_field = false)
     elseif k === Tokens.BAREMODULE
         return @default ps @closer ps :block parse_blockexpr(ps, :baremodule)
     elseif k === Tokens.CONST
-        return @default ps parse_const(ps; allow_const_field = allow_const_field)
+        return @default ps parse_const(ps; allow_const_field=allow_const_field)
     elseif k === Tokens.GLOBAL
         return @default ps parse_local_global(ps, false)
     elseif k === Tokens.LOCAL
@@ -75,7 +75,7 @@ function parse_kw(ps::ParseState; allow_const_field = false)
     elseif k === Tokens.TYPE
         return EXPR(:IDENTIFIER, ps)
     elseif k === Tokens.STRUCT
-        return @default ps @closer ps :block parse_blockexpr(ps, :struct, allow_const_field = true)
+        return @default ps @closer ps :block parse_blockexpr(ps, :struct, allow_const_field=true)
     elseif k === Tokens.MUTABLE
         return @default ps @closer ps :block parse_mutable(ps)
     elseif k === Tokens.OUTER
@@ -85,7 +85,7 @@ function parse_kw(ps::ParseState; allow_const_field = false)
     end
 end
 
-function parse_const(ps::ParseState; allow_const_field = false)
+function parse_const(ps::ParseState; allow_const_field=false)
     kw = EXPR(ps)
     arg = parse_expression(ps)
     if !allow_const_field && !(isassignment(unwrapbracket(arg)) || (headof(arg) === :global && length(arg.args) > 0 && isassignment(unwrapbracket(arg.args[1]))))
@@ -95,7 +95,7 @@ function parse_const(ps::ParseState; allow_const_field = false)
     return ret
 end
 
-function parse_local_global(ps::ParseState, islocal = true)
+function parse_local_global(ps::ParseState, islocal=true)
     kw = EXPR(ps)
     if ps.nt.kind === Tokens.CONST
         arg1 = parse_const(next(ps))
@@ -154,7 +154,7 @@ function parse_mutable(ps::ParseState)
     if kindof(ps.nt) === Tokens.STRUCT
         kw = EXPR(ps)
         next(ps)
-        ret = parse_blockexpr(ps, :mutable, allow_const_field = true)
+        ret = parse_blockexpr(ps, :mutable, allow_const_field=true)
         pushfirst!(ret.trivia, setparent!(kw, ret))
         update_span!(ret)
     else
@@ -313,10 +313,10 @@ end
 General function for parsing block expressions comprised of a series of statements
 terminated by an `end`.
 """
-function parse_blockexpr(ps::ParseState, head; allow_const_field = false)
+function parse_blockexpr(ps::ParseState, head; allow_const_field=false)
     kw = EXPR(ps)
     sig = parse_blockexpr_sig(ps, head)
-    blockargs = parse_block(ps, EXPR[], (Tokens.END,), docable(head); allow_const_field = allow_const_field)
+    blockargs = parse_block(ps, EXPR[], (Tokens.END,), docable(head); allow_const_field=allow_const_field)
     if head === :begin
         EXPR(:block, blockargs, EXPR[kw, accept_end(ps)])
     elseif sig === nothing
@@ -347,7 +347,7 @@ end
 
 Parse an `if` block.
 """
-function parse_if(ps::ParseState, nested = false)
+function parse_if(ps::ParseState, nested=false)
     args = EXPR[]
     trivia = EXPR[EXPR(ps)]
 
@@ -417,7 +417,7 @@ function parse_try(ps::ParseState)
             args[3] = EXPR(:block, 0, 0, "")
         end
         else_trivia = EXPR(next(ps))
-        else_arg = EXPR(:block, parse_block(ps, EXPR[], (Tokens.FINALLY,Tokens.END)))
+        else_arg = EXPR(:block, parse_block(ps, EXPR[], (Tokens.FINALLY, Tokens.END)))
     end
 
     has_finally = false

src/components/lists.jl

@@ -46,7 +46,7 @@ function parse_tuple(ps::ParseState, ret::EXPR)
 end
 
 # XXX: Avert thine eyes.
-function count_semicolons(ps, check_newline = true)
+function count_semicolons(ps, check_newline=true)
     dims = 0
     has_newline = false
     old_pos = position(ps.l.io)
@@ -75,7 +75,7 @@ Having hit '[' return either:
 + A comprehension
 + An array (vcat of hcats)
 """
-function parse_array(ps::ParseState, isref = false)
+function parse_array(ps::ParseState, isref=false)
     args = EXPR[]
     trivia = EXPR[EXPR(ps)]
     # [] or [;;;]
@@ -100,7 +100,7 @@ function parse_array(ps::ParseState, isref = false)
     end
 end
 
-binding_power(ps, nl = true) =
+binding_power(ps, nl=true) =
     if kindof(ps.ws) == SemiColonWS
         -count_semicolons(ps, nl)
     elseif kindof(ps.ws) == NewLineWS
@@ -150,7 +150,7 @@ function parse_array_outer(ps::ParseState, trivia, isref)
                 args = EXPR[]
                 push!(args, a)
                 push!(trivia, accept_comma(ps))
-                @closesquare ps parse_comma_sep(ps, args, trivia, isref, insert_params_at = 1)
+                @closesquare ps parse_comma_sep(ps, args, trivia, isref, insert_params_at=1)
                 return EXPR(:vect, args, trivia)
             end
         end
@@ -307,7 +307,7 @@ function parse_barray(ps::ParseState)
         accept_rbrace(ps, trivia)
         ret = EXPR(:braces, args, trivia)
     else
-        first_arg = @nocloser ps :newline @closebrace ps  @closer ps :ws @closer ps :wsop @closer ps :comma parse_expression(ps)
+        first_arg = @nocloser ps :newline @closebrace ps @closer ps :ws @closer ps :wsop @closer ps :comma parse_expression(ps)
         if kindof(ps.nt) === Tokens.RBRACE
             push!(args, first_arg)
             if kindof(ps.ws) == SemiColonWS
@@ -318,15 +318,15 @@ function parse_barray(ps::ParseState)
         elseif iscomma(ps.nt)
             push!(args, first_arg)
             accept_comma(ps, trivia)
-            @closebrace ps parse_comma_sep(ps, args, trivia, true, insert_params_at = 1)
+            @closebrace ps parse_comma_sep(ps, args, trivia, true, insert_params_at=1)
             accept_rbrace(ps, trivia)
             return EXPR(:braces, args, trivia)
         elseif kindof(ps.ws) == NewLineWS
             ret = EXPR(:bracescat, args, trivia)
             push!(ret, first_arg)
             prevpos = position(ps)
             while kindof(ps.nt) != Tokens.RBRACE && kindof(ps.nt) !== Tokens.ENDMARKER
-                a = @closebrace ps  parse_expression(ps)
+                a = @closebrace ps parse_expression(ps)
                 push!(ret, a)
                 prevpos = loop_check(ps, prevpos)
             end