fix and optimize erroneous code paths (#58)

Co-authored-by: Sebastian Pfitzner <pfitzseb@gmail.com>

Author: aviatesk

README.md

@@ -471,7 +471,7 @@ There's arguably a few downsides:
 Practically the flisp parser is not quite a classic [recursive descent
 parser](https://en.wikipedia.org/wiki/Recursive_descent_parser), because it
 often looks back and modifies the output tree it has already produced. We've
-tried to eliminate this pattern it favor of lookahead where possible because
+tried to eliminate this pattern in favor of lookahead where possible because
 
 * It works poorly when the parser is emitting a stream of node spans with
   strict source ordering constraints.

src/diagnostics.jl

@@ -32,7 +32,7 @@ end
 function Diagnostic(first_byte, last_byte; error=nothing, warning=nothing)
     message = !isnothing(error)   ? error :
               !isnothing(warning) ? warning :
-              error("No message in diagnostic")
+              Base.error("No message in diagnostic")
     level = !isnothing(error) ? :error : :warning
     Diagnostic(first_byte, last_byte, level, message)
 end
@@ -48,11 +48,12 @@ function show_diagnostic(io::IO, diagnostic::Diagnostic, source::SourceFile)
                    (:normal, "Info")
     line, col = source_location(source, first_byte(diagnostic))
     linecol = "$line:$col"
-    if !isnothing(source.filename)
-        locstr = "$(source.filename):$linecol"
+    filename = source.filename
+    if !isnothing(filename)
+        locstr = "$filename:$linecol"
         if get(io, :color, false)
             # Also add hyperlinks in color terminals
-            url = "file://$(abspath(source.filename))#$linecol"
+            url = "file://$(abspath(filename))#$linecol"
             locstr = "\e]8;;$url\e\\$locstr\e]8;;\e\\"
         end
     else

src/expr.jl

@@ -8,19 +8,20 @@ end
 
 function _to_expr(node::SyntaxNode, iteration_spec=false, need_linenodes=true)
     if !haschildren(node)
-        if node.val isa Union{Int128,UInt128,BigInt}
+        val = node.val
+        if val isa Union{Int128,UInt128,BigInt}
             # Ignore the values of large integers and convert them back to
             # symbolic/textural form for compatibility with the Expr
             # representation of these.
             str = replace(sourcetext(node), '_'=>"")
             headsym = :macrocall
             k = kind(node)
-            macname = node.val isa Int128  ? Symbol("@int128_str")  :
-                      node.val isa UInt128 ? Symbol("@uint128_str") :
+            macname = val isa Int128  ? Symbol("@int128_str")  :
+                      val isa UInt128 ? Symbol("@uint128_str") :
                       Symbol("@big_str")
             return Expr(:macrocall, GlobalRef(Core, macname), nothing, str)
         else
-            return node.val
+            return val
         end
     end
     headstr = untokenize(head(node), include_flag_suff=false)
@@ -165,7 +166,8 @@ function _to_expr(node::SyntaxNode, iteration_spec=false, need_linenodes=true)
         args[1] = Expr(:block, loc, args[1])
     elseif headsym == :(->)
         if Meta.isexpr(args[2], :block)
-            if node.parent isa SyntaxNode && kind(node.parent) != K"do"
+            parent = node.parent
+            if parent isa SyntaxNode && kind(parent) != K"do"
                 pushfirst!(args[2].args, loc)
             end
         else
@@ -207,4 +209,3 @@ Base.Expr(node::SyntaxNode) = _to_expr(node)
 function build_tree(::Type{Expr}, stream::ParseStream; kws...)
     Expr(build_tree(SyntaxNode, stream; kws...))
 end
-

src/hooks.jl

@@ -9,7 +9,7 @@ else
         # incremental compilation. (Ideally we'd just arrange for Core._parse to be
         # set to the JuliaSyntax parser. But how do we signal that to the dumping
         # code outside of the initial creation of Core?)
-        i = findfirst(==(:incremental), fieldnames(Base.JLOptions))
+        i = Base.fieldindex(Base.JLOptions, :incremental)
         ptr = convert(Ptr{fieldtype(Base.JLOptions, i)},
                       cglobal(:jl_options, Base.JLOptions) + fieldoffset(Base.JLOptions, i))
         incremental = unsafe_load(ptr)
@@ -173,4 +173,3 @@ function enable_in_core!(enable=true; freeze_world_age = true,
     _set_core_parse_hook(enable ? core_parser_hook : _default_parser)
     nothing
 end
-

src/parse_stream.jl

@@ -61,7 +61,7 @@ function Base.summary(head::SyntaxHead)
 end
 
 function untokenize(head::SyntaxHead; unique=true, include_flag_suff=true)
-    str = is_error(kind(head)) ? "error" : untokenize(kind(head); unique=unique)
+    str = is_error(kind(head)) ? "error" : untokenize(kind(head); unique=unique)::String
     if is_dotted(head)
         str = "."*str
     end
@@ -281,7 +281,7 @@ function release_positions(stream, positions)
 end
 
 #-------------------------------------------------------------------------------
-# Return true when a token was emitted last at stream position `pos` 
+# Return true when a token was emitted last at stream position `pos`
 function token_is_last(stream, pos)
     return pos.range_index == 0 ||
            pos.token_index > stream.ranges[pos.range_index].last_token
@@ -872,8 +872,9 @@ stream's text buffer. Note that this leaves the `ParseStream` in an invalid
 state for further parsing.
 """
 function sourcetext(stream::ParseStream; steal_textbuf=false)
-    if stream.text_root isa AbstractString && codeunit(stream.text_root) == UInt8
-        return stream.text_root
+    root = stream.text_root
+    if root isa AbstractString && codeunit(root) == UInt8
+        return root
     elseif steal_textbuf
         return String(stream.textbuf)
     else

src/syntax_tree.jl

@@ -118,13 +118,13 @@ function interpolate_literal(node::SyntaxNode, val)
     SyntaxNode(node.source, node.raw, node.position, node.parent, true, val)
 end
 
-function _show_syntax_node(io, current_filename, node, indent)
+function _show_syntax_node(io, current_filename, node::SyntaxNode, indent)
     fname = node.source.filename
     line, col = source_location(node.source, node.position)
     posstr = "$(lpad(line, 4)):$(rpad(col,3))│$(lpad(node.position,6)):$(rpad(node.position+span(node)-1,6))│"
-    nodestr = haschildren(node)   ?  "[$(untokenize(head(node)))]" :
-              node.val isa Symbol ? string(node.val) :
-              repr(node.val)
+    val = node.val
+    nodestr = haschildren(node) ? "[$(untokenize(head(node)))]" :
+              isa(val, Symbol) ? string(val) : repr(val)
     treestr = string(indent, nodestr)
     # Add filename if it's changed from the previous node
     if fname != current_filename[]
@@ -141,12 +141,13 @@ function _show_syntax_node(io, current_filename, node, indent)
     end
 end
 
-function _show_syntax_node_sexpr(io, node)
+function _show_syntax_node_sexpr(io, node::SyntaxNode)
     if !haschildren(node)
         if is_error(node)
             print(io, "(", untokenize(head(node)), ")")
         else
-            print(io, node.val isa Symbol ? string(node.val) : repr(node.val))
+            val = node.val
+            print(io, val isa Symbol ? string(val) : repr(val))
         end
     else
         print(io, "(", untokenize(head(node)))
@@ -256,4 +257,3 @@ function highlight(code::String, node, path::Int...; color=(40,40,70))
     _printstyled(stdout, code[p:q-1]; bgcolor=color)
     print(stdout, code[q:end])
 end
-

src/value_parsing.jl

@@ -228,7 +228,7 @@ function utf8proc_decompose(str, options, buffer, nwords)
     ret = ccall(:utf8proc_decompose_custom, Int, (Ptr{UInt8}, Int, Ptr{UInt8}, Int, Cint, Ptr{Cvoid}, Ptr{Cvoid}),
                 str, sizeof(str), buffer, nwords, options,
                 @cfunction(utf8proc_custom_func, UInt32, (UInt32, Ptr{Cvoid})), C_NULL)
-    ret < 0 && utf8proc_error(ret)
+    ret < 0 && Base.Unicode.utf8proc_error(ret)
     return ret
 end
 
@@ -237,12 +237,11 @@ function utf8proc_map(str::Union{String,SubString{String}}, options::Integer)
     buffer = Base.StringVector(nwords*4)
     nwords = utf8proc_decompose(str, options, buffer, nwords)
     nbytes = ccall(:utf8proc_reencode, Int, (Ptr{UInt8}, Int, Cint), buffer, nwords, options)
-    nbytes < 0 && utf8proc_error(nbytes)
+    nbytes < 0 && Base.Unicode.utf8proc_error(nbytes)
     return String(resize!(buffer, nbytes))
 end
 
 function normalize_identifier(str)
     flags = Base.Unicode.UTF8PROC_STABLE | Base.Unicode.UTF8PROC_COMPOSE
     utf8proc_map(str, flags)
 end
-