Remove boxed closure captures warned about by JET

* Use Ref to avoid triggering boxing of captures via closure variable
  assignment.
* Use let blocks for temporary ParseState transitions to avoid some
  closures.

Author: c42f

src/parser.jl

@@ -53,10 +53,10 @@ function normal_context(ps::ParseState)
                whitespace_newline=false)
 end
 
-function with_space_sensitive(f::Function, ps::ParseState)
-    f(ParseState(ps,
-                 space_sensitive=true,
-                 whitespace_newline=false))
+function with_space_sensitive(ps::ParseState)
+    ParseState(ps,
+               space_sensitive=true,
+               whitespace_newline=false)
 end
 
 # Convenient wrappers for ParseStream
@@ -1176,20 +1176,20 @@ function parse_unary_call(ps::ParseState)
         mark_before_paren = position(ps)
         bump(ps, TRIVIA_FLAG) # (
         initial_semi = peek(ps) == K";"
-        is_call = false
-        is_block = false
+        is_call = Ref(false)
+        is_block = Ref(false)
         parse_brackets(ps, K")") do had_commas, had_splat, num_semis, num_subexprs
-            is_call = had_commas || had_splat || initial_semi
-            is_block = !is_call && num_semis > 0
+            is_call[] = had_commas || had_splat || initial_semi
+            is_block[] = !is_call[] && num_semis > 0
             bump_closing_token(ps, K")")
-            return (needs_parameters=is_call,
-                    eq_is_kw_before_semi=is_call,
-                    eq_is_kw_after_semi=is_call)
+            return (needs_parameters=is_call[],
+                    eq_is_kw_before_semi=is_call[],
+                    eq_is_kw_after_semi=is_call[])
         end
 
         # The precedence between unary + and any following infix ^ depends on
         # whether the parens are a function call or not
-        if is_call
+        if is_call[]
             if preceding_whitespace(t2)
                 # Whitespace not allowed before prefix function call bracket
                 # + (a,b)   ==> (call + (error) a b)
@@ -1211,7 +1211,7 @@ function parse_unary_call(ps::ParseState)
             parse_factor_with_initial_ex(ps, mark)
         else
             # Unary function calls with brackets as grouping, not an arglist
-            if is_block
+            if is_block[]
                 # +(a;b)   ==>  (call + (block a b))
                 emit(ps, mark_before_paren, K"block")
             end
@@ -1400,7 +1400,7 @@ function parse_call_chain(ps::ParseState, mark, is_macrocall=false)
             # a().@x y    ==> (macrocall (error (. (call a) (quote x))) y)
             # [@foo "x"]  ==> (vect (macrocall @foo "x"))
             finish_macroname(ps, mark, valid_macroname, macro_name_position)
-            with_space_sensitive(ps) do ps
+            let ps = with_space_sensitive(ps)
                 # Space separated macro arguments
                 # A.@foo a b    ==> (macrocall (. A (quote @foo)) a b)
                 # @A.foo a b    ==> (macrocall (. A (quote @foo)) a b)
@@ -1779,8 +1779,10 @@ function parse_resword(ps::ParseState)
         bump(ps, TRIVIA_FLAG)
         @check peek(ps) == K"type"
         bump(ps, TRIVIA_FLAG)
-        with_space_sensitive(parse_subtype_spec, ps)
-        with_space_sensitive(parse_cond, ps)
+        let ps = with_space_sensitive(ps)
+            parse_subtype_spec(ps)
+            parse_cond(ps)
+        end
         bump_semicolon_trivia(ps)
         bump_closing_token(ps, K"end")
         emit(ps, mark, K"primitive")
@@ -1975,7 +1977,7 @@ function parse_function(ps::ParseState)
     word = peek(ps)
     @check word in KSet`macro function`
     is_function = word == K"function"
-    is_anon_func::Bool = false
+    is_anon_func = false
     bump(ps, TRIVIA_FLAG)
     bump_trivia(ps)
 
@@ -2005,13 +2007,15 @@ function parse_function(ps::ParseState)
             #
             # The flisp parser disambiguates this case quite differently,
             # producing less consistent syntax for anonymous functions.
+            is_anon_func_ = Ref(is_anon_func)
             parse_brackets(ps, K")") do _, _, _, _
                 bump_closing_token(ps, K")")
-                is_anon_func = peek(ps) != K"("
-                return (needs_parameters     = is_anon_func,
-                        eq_is_kw_before_semi = is_anon_func,
-                        eq_is_kw_after_semi  = is_anon_func)
+                is_anon_func_[] = peek(ps) != K"("
+                return (needs_parameters     = is_anon_func_[],
+                        eq_is_kw_before_semi = is_anon_func_[],
+                        eq_is_kw_after_semi  = is_anon_func_[])
             end
+            is_anon_func = is_anon_func_[]
             if is_anon_func
                 # function (x) body end ==>  (function (tuple x) (block body))
                 # function (x,y) end    ==>  (function (tuple x y) (block))
@@ -2209,8 +2213,8 @@ function parse_macro_name(ps::ParseState)
         # @! x   ==>  (macrocall @! x)
         # @.. x  ==>  (macrocall @.. x)
         # @$ x   ==>  (macrocall @$ x)
-        with_space_sensitive(ps) do ps1
-            parse_atom(ps1, false)
+        let ps = with_space_sensitive(ps)
+            parse_atom(ps, false)
         end
     end
 end
@@ -2263,13 +2267,14 @@ function parse_imports(ps::ParseState)
         # import A, y      ==>  (import (. A) (. y))
         # import A: x, y   ==>  (import (: (. A) (. x) (. y)))
         # import A: +, ==  ==>  (import (: (. A) (. +) (. ==)))
-        parse_comma_separated(ps, ps1->parse_import(ps1, word, has_import_prefix))
+        has_import_prefix_ = has_import_prefix
+        parse_comma_separated(ps, ps1->parse_import(ps1, word, has_import_prefix_))
         if peek(ps) == K":"
             # Error recovery
             # import A: x, B: y ==> (import (: (. A) (. x) (. B) (error-t (. y))))
             emark = position(ps)
             bump(ps, TRIVIA_FLAG)
-            parse_comma_separated(ps, ps1->parse_import(ps1, word, has_import_prefix))
+            parse_comma_separated(ps, ps1->parse_import(ps1, word, has_import_prefix_))
             emit(ps, emark, K"error", TRIVIA_FLAG,
                  error="`:` can only be used when importing a single module. Split imports into multiple lines")
         end
@@ -2436,7 +2441,7 @@ function parse_iteration_spec(ps::ParseState)
     mark = position(ps)
     k = peek(ps)
     # Handle `outer` contextual keyword
-    with_space_sensitive(parse_pipe_lt, ps)
+    parse_pipe_lt(with_space_sensitive(ps))
     if peek_behind(ps).orig_kind == K"outer"
         if peek_skip_newline_in_gen(ps) in KSet`= in ∈`
             # Not outer keyword
@@ -2465,19 +2470,18 @@ end
 
 # flisp: parse-space-separated-exprs
 function parse_space_separated_exprs(ps::ParseState)
-    with_space_sensitive(ps) do ps
-        n_sep = 0
-        while true
-            k = peek(ps)
-            if is_closing_token(ps, k) || k == K"NewlineWs" ||
-                    (ps.for_generator && k == K"for")
-                break
-            end
-            parse_eq(ps)
-            n_sep += 1
+    ps = with_space_sensitive(ps)
+    n_sep = 0
+    while true
+        k = peek(ps)
+        if is_closing_token(ps, k) || k == K"NewlineWs" ||
+                (ps.for_generator && k == K"for")
+            break
         end
-        return n_sep
+        parse_eq(ps)
+        n_sep += 1
     end
+    return n_sep
 end
 
 # like parse-arglist, but with `for` parsed as a generator
@@ -2858,18 +2862,18 @@ function parse_paren(ps::ParseState, check_identifiers=true)
         # Deal with all other cases of tuple or block syntax via the generic
         # parse_brackets
         initial_semi = peek(ps) == K";"
-        is_tuple = false
-        is_block = false
+        is_tuple = Ref(false)
+        is_block = Ref(false)
         parse_brackets(ps, K")") do had_commas, had_splat, num_semis, num_subexprs
-            is_tuple = had_commas || (had_splat && num_semis >= 1) ||
+            is_tuple[] = had_commas || (had_splat && num_semis >= 1) ||
                        (initial_semi && (num_semis == 1 || num_subexprs > 0))
-            is_block = num_semis > 0
+            is_block[] = num_semis > 0
             bump_closing_token(ps, K")")
-            return (needs_parameters=is_tuple,
+            return (needs_parameters=is_tuple[],
                     eq_is_kw_before_semi=false,
-                    eq_is_kw_after_semi=is_tuple)
+                    eq_is_kw_after_semi=is_tuple[])
         end
-        if is_tuple
+        if is_tuple[]
             # Tuple syntax with commas
             # (x,)        ==>  (tuple x)
             # (x,y)       ==>  (tuple x y)
@@ -2886,7 +2890,7 @@ function parse_paren(ps::ParseState, check_identifiers=true)
             # (a; b; c,d)     ==> (tuple a (parameters b (parameters c d)))
             # (a=1, b=2; c=3) ==> (tuple (= a 1) (= b 2) (parameters (kw c 3)))
             emit(ps, mark, K"tuple")
-        elseif is_block
+        elseif is_block[]
             # Blocks
             # (;;)        ==>  (block)
             # (a=1;)      ==>  (block (= a 1))