Use === for symbol comparisons

Author: c42f

src/diagnostics.jl

@@ -39,7 +39,7 @@ end
 
 first_byte(d::Diagnostic) = d.first_byte
 last_byte(d::Diagnostic)  = d.last_byte
-is_error(d::Diagnostic)   = d.level == :error
+is_error(d::Diagnostic)   = d.level === :error
 Base.range(d::Diagnostic) = first_byte(d):last_byte(d)
 
 # Make relative path into a file URL
@@ -54,9 +54,9 @@ function _file_url(filename)
 end
 
 function show_diagnostic(io::IO, diagnostic::Diagnostic, source::SourceFile)
-    color,prefix = diagnostic.level == :error   ? (:light_red, "Error")      :
-                   diagnostic.level == :warning ? (:light_yellow, "Warning") :
-                   diagnostic.level == :note    ? (:light_blue, "Note")      :
+    color,prefix = diagnostic.level === :error   ? (:light_red, "Error")      :
+                   diagnostic.level === :warning ? (:light_yellow, "Warning") :
+                   diagnostic.level === :note    ? (:light_blue, "Note")      :
                    (:normal, "Info")
     line, col = source_location(source, first_byte(diagnostic))
     linecol = "$line:$col"

src/expr.jl

@@ -69,7 +69,7 @@ function _to_expr(node::SyntaxNode; iteration_spec=false, need_linenodes=true,
         headsym = !isnothing(headstr) ? Symbol(headstr) :
             error("Can't untokenize head of kind $(nodekind)")
     end
-    if headsym == :string || headsym == :cmdstring
+    if headsym === :string || headsym === :cmdstring
         # Julia string literals may be interspersed with trivia in two situations:
         # 1. Triple quoted string indentation is trivia
         # 2. An \ before newline removes the newline and any following indentation
@@ -93,7 +93,7 @@ function _to_expr(node::SyntaxNode; iteration_spec=false, need_linenodes=true,
                 end
             else
                 e = _to_expr(node_args[i])
-                if e isa String && headsym == :string
+                if e isa String && headsym === :string
                     # Wrap interpolated literal strings in (string) so we can
                     # distinguish them from the surrounding text (issue #38501)
                     # Ie, "$("str")"  vs  "str"
@@ -117,22 +117,22 @@ function _to_expr(node::SyntaxNode; iteration_spec=false, need_linenodes=true,
     end
 
     # Convert children
-    insert_linenums = (headsym == :block || headsym == :toplevel) && need_linenodes
+    insert_linenums = (headsym === :block || headsym === :toplevel) && need_linenodes
     args = Vector{Any}(undef, length(node_args)*(insert_linenums ? 2 : 1))
-    if headsym == :for && length(node_args) == 2
+    if headsym === :for && length(node_args) == 2
         # No line numbers in for loop iteration spec
         args[1] = _to_expr(node_args[1], iteration_spec=true, need_linenodes=false)
         args[2] = _to_expr(node_args[2])
-    elseif headsym == :let && length(node_args) == 2
+    elseif headsym === :let && length(node_args) == 2
         # No line numbers in let statement binding list
         args[1] = _to_expr(node_args[1], need_linenodes=false)
         args[2] = _to_expr(node_args[2])
     else
         eq_to_kw_in_call =
-            ((headsym == :call || headsym == :dotcall) && is_prefix_call(node)) ||
-            headsym == :ref
-        eq_to_kw_all = headsym == :parameters && !map_kw_in_params
-        in_vcbr = headsym == :vect || headsym == :curly || headsym == :braces || headsym == :ref
+            ((headsym === :call || headsym === :dotcall) && is_prefix_call(node)) ||
+            headsym === :ref
+        eq_to_kw_all = headsym === :parameters && !map_kw_in_params
+        in_vcbr = headsym === :vect || headsym === :curly || headsym === :braces || headsym === :ref
         if insert_linenums && isempty(node_args)
             push!(args, source_location(LineNumberNode, node.source, node.position))
         else
@@ -143,8 +143,7 @@ function _to_expr(node::SyntaxNode; iteration_spec=false, need_linenodes=true,
                 end
                 eq_to_kw = eq_to_kw_in_call && i > 1 || eq_to_kw_all
                 args[insert_linenums ? 2*i : i] =
-                    _to_expr(n, eq_to_kw=eq_to_kw,
-                             map_kw_in_params=in_vcbr)
+                    _to_expr(n, eq_to_kw=eq_to_kw, map_kw_in_params=in_vcbr)
             end
             if nodekind == K"block" && has_flags(node, PARENS_FLAG)
                 popfirst!(args)
@@ -197,7 +196,7 @@ function _to_expr(node::SyntaxNode; iteration_spec=false, need_linenodes=true,
         end
     elseif headsym === :where
         reorder_parameters!(args, 2)
-    elseif headsym == :parens
+    elseif headsym === :parens
         # parens are used for grouping and don't appear in the Expr AST
         return only(args)
     elseif headsym in (:try, :try_finally_catch)
@@ -245,15 +244,15 @@ function _to_expr(node::SyntaxNode; iteration_spec=false, need_linenodes=true,
         pushfirst!(args, numeric_flags(flags(node)))
     elseif headsym === :typed_ncat
         insert!(args, 2, numeric_flags(flags(node)))
-    # elseif headsym == :string && length(args) == 1 && version <= (1,5)
+    # elseif headsym === :string && length(args) == 1 && version <= (1,5)
     #   Strip string from interpolations in 1.5 and lower to preserve
     #   "hi$("ho")" ==>  (string "hi" "ho")
     elseif headsym === :(=) && !is_decorated(node)
         if is_eventually_call(args[1]) && !iteration_spec && !Meta.isexpr(args[2], :block)
             # Add block for short form function locations
             args[2] = Expr(:block, loc, args[2])
         end
-    elseif headsym == :elseif
+    elseif headsym === :elseif
         # Block for conditional's source location
         args[1] = Expr(:block, loc, args[1])
     elseif headsym === :(->)
@@ -283,7 +282,7 @@ function _to_expr(node::SyntaxNode; iteration_spec=false, need_linenodes=true,
     elseif headsym === :module
         pushfirst!(args, !has_flags(node, BARE_MODULE_FLAG))
         pushfirst!(args[3].args, loc)
-    elseif headsym == :inert || (headsym == :quote && length(args) == 1 &&
+    elseif headsym === :inert || (headsym === :quote && length(args) == 1 &&
                  !(a1 = only(args); a1 isa Expr || a1 isa QuoteNode ||
                    a1 isa Bool  # <- compat hack, Julia 1.4+
                   ))

src/hooks.jl

@@ -288,7 +288,7 @@ function _fl_parse_hook(code, filename, lineno, offset, options)
                 ex = Expr(:toplevel, ex)
             end
             return ex, sizeof(code)
-        elseif options === :statement || options == :atom
+        elseif options === :statement || options === :atom
             ex, pos = Meta.parse(code, offset+1, greedy=options==:statement, raise=false)
             return ex, pos-1
         else

src/parse_stream.jl

@@ -890,14 +890,14 @@ function validate_tokens(stream::ParseStream)
                 # jl_strtod_c can return "underflow" even for valid cases such
                 # as `5e-324` where the source is an exact representation of
                 # `x`. So only warn when underflowing to zero.
-                underflow0 = code == :underflow && x == 0
+                underflow0 = code === :underflow && x == 0
             else
                 x, code = parse_float_literal(Float32, text, fbyte, nbyte)
-                underflow0 = code == :underflow && x == 0
+                underflow0 = code === :underflow && x == 0
             end
-            if code == :ok
+            if code === :ok
                 # pass
-            elseif code == :overflow
+            elseif code === :overflow
                 emit_diagnostic(stream, fbyte, lbyte,
                                 error="overflow in floating point literal")
                 error_kind = K"ErrorNumericOverflow"

src/syntax_tree.jl

@@ -60,11 +60,11 @@ function SyntaxNode(source::SourceFile, raw::GreenNode{SyntaxHead}, position::In
         elseif k == K"Float"
             v, code = parse_float_literal(Float64, source.code, position,
                                           position+span(raw))
-            (code == :ok || code == :underflow) ? v : ErrorVal()
+            (code === :ok || code === :underflow) ? v : ErrorVal()
         elseif k == K"Float32"
             v, code = parse_float_literal(Float32, source.code, position,
                                           position+span(raw))
-            (code == :ok || code == :underflow) ? v : ErrorVal()
+            (code === :ok || code === :underflow) ? v : ErrorVal()
         elseif k in KSet"BinInt OctInt HexInt"
             parse_uint_literal(val_str, k)
         elseif k == K"true"