show: improve handling of . syntax printing (#24994)

Author: vtjnash

base/show.jl

@@ -813,7 +813,16 @@ show_unquoted(io::IO, sym::Symbol, ::Int, ::Int)        = print(io, sym)
 show_unquoted(io::IO, ex::LineNumberNode, ::Int, ::Int) = show_linenumber(io, ex.line, ex.file)
 show_unquoted(io::IO, ex::LabelNode, ::Int, ::Int)      = print(io, ex.label, ": ")
 show_unquoted(io::IO, ex::GotoNode, ::Int, ::Int)       = print(io, "goto ", ex.label)
-show_unquoted(io::IO, ex::GlobalRef, ::Int, ::Int)      = print(io, ex.mod, '.', ex.name)
+function show_unquoted(io::IO, ex::GlobalRef, ::Int, ::Int)
+    print(io, ex.mod)
+    print(io, '.')
+    quoted = !isidentifier(ex.name)
+    parens = quoted && !isoperator(ex.name)
+    quoted && print(io, ':')
+    parens && print(io, '(')
+    print(io, ex.name)
+    parens && print(io, ')')
+end
 
 function show_unquoted(io::IO, ex::Slot, ::Int, ::Int)
     typ = isa(ex,TypedSlot) ? ex.typ : Any
@@ -908,11 +917,29 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
     if !emphstate && ex.typ === Any
         show_type = false
     end
+    unhandled = false
     # dot (i.e. "x.y"), but not compact broadcast exps
-    if head === :(.) && !is_expr(args[2], :tuple)
-        func_prec = operator_precedence(head)
-        args_ = (args[1], (is_quoted(arg) && !is_quoted(unquoted(arg)) ? unquoted(arg) : arg for arg in args[2:end])...)
-        show_list(io, args_, head, indent, func_prec)
+    if head === :(.) && (length(args) != 2 || !is_expr(args[2], :tuple))
+        if length(args) == 2 && is_quoted(args[2])
+            item = args[1]
+            # field
+            field = unquoted(args[2])
+            parens = !is_quoted(item) && !(item isa Symbol && isidentifier(item))
+            parens && print(io, '(')
+            show_unquoted(io, item, indent)
+            parens && print(io, ')')
+            # .
+            print(io, '.')
+            # item
+            parens = !(field isa Symbol)
+            quoted = parens || isoperator(field)
+            quoted && print(io, ':')
+            parens && print(io, '(')
+            show_unquoted(io, field, indent)
+            parens && print(io, ')')
+        else
+            unhandled = true
+        end
 
     # infix (i.e. "x <: y" or "x = y")
     elseif (head in expr_infix_any && nargs==2) || (head === :(:) && nargs==3)
@@ -1236,6 +1263,9 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         show_type = false
     # print anything else as "Expr(head, args...)"
     else
+        unhandled = true
+    end
+    if unhandled
         if head !== :invoke
             show_type = false
         end

src/rtutils.c

@@ -764,7 +764,8 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     }
     else if (vt == jl_globalref_type) {
         n += jl_static_show_x(out, (jl_value_t*)jl_globalref_mod(v), depth);
-        n += jl_printf(out, ".%s", jl_symbol_name(jl_globalref_name(v)));
+        char *name = jl_symbol_name(jl_globalref_name(v));
+        n += jl_printf(out, jl_is_identifier(name) ? ".%s" : ".:(%s)", name);
     }
     else if (vt == jl_labelnode_type) {
         n += jl_printf(out, "%" PRIuPTR ":", jl_labelnode_label(v));

test/show.jl

@@ -35,24 +35,24 @@ end
 # expression printing
 
 macro test_repr(x)
-    quote
-        # Note: We can't just compare x1 and x2 because interpolated
-        # strings get converted to string Exprs by the first show().
-        # This could produce a few false positives, but until string
-        # interpolation works we don't really have a choice.
-        let
-            local x1 = Meta.parse($x)
-            local x2 = eval(Meta.parse(repr(x1)))
-            local x3 = eval(Meta.parse(repr(x2)))
-            if x3 != x1
-                error(string(
-                    "repr test failed:",
-                    "\noriginal: ", $x,
-                    "\n\nparsed: ", x2, "\n", sprint(dump, x2),
-                    "\n\nreparsed: ", x3, "\n", sprint(dump, x3)
-                    ))
-            end
-        end
+    # this is a macro instead of function so we can avoid getting useful backtraces :)
+    return :(test_repr($(esc(x))))
+end
+function test_repr(x::String)
+    # Note: We can't just compare x1 and x2 because interpolated
+    # strings get converted to string Exprs by the first show().
+    # This could produce a few false positives, but until string
+    # interpolation works we don't really have a choice.
+    x1 = Meta.parse(x)
+    x2 = eval(Meta.parse(repr(x1)))
+    x3 = eval(Meta.parse(repr(x2)))
+    if x3 != x1
+        error(string(
+            "repr test failed:",
+            "\noriginal: ", x,
+            "\n\nparsed: ", x2, "\n", sprint(dump, x2),
+            "\n\nreparsed: ", x3, "\n", sprint(dump, x3)
+            ))
     end
 end
 
@@ -83,7 +83,8 @@ end
 @test_repr "x^-(y+z)"
 @test_repr "x^-f(y+z)"
 @test_repr "+(w-x)^-f(y+z)"
-#@test_repr "w = (x = y) = z" # Doesn't pass, but it's an invalid assignment loc
+@test_repr "w = ((x = y) = z)" # parens aren't necessary, but not wrong
+@test_repr "w = ((x, y) = z)" # parens aren't necessary, but not wrong
 @test_repr "a & b && c"
 @test_repr "a & (b && c)"
 @test_repr "(a => b) in c"
@@ -782,6 +783,22 @@ end
 @test repr(:(f.(X))) == ":(f.(X))"
 @test repr(:(f.())) == ":(f.())"
 
+# pretty-printing of other `.` exprs
+test_repr("a.b")
+test_repr("a.in")
+test_repr(":a.b")
+test_repr("a.:+")
+test_repr("(+).a")
+test_repr("(+).:-")
+test_repr("(!).:~")
+test_repr("a.:(begin
+        #= none:3 =#
+    end)")
+@test repr(Expr(:., :a, :b, :c)) == ":(\$(Expr(:., :a, :b, :c)))"
+@test repr(Expr(:., :a, :b)) == ":(\$(Expr(:., :a, :b)))"
+@test repr(Expr(:., :a)) == ":(\$(Expr(:., :a)))"
+@test repr(Expr(:.)) == ":(\$(Expr(:.)))"
+
 # Test compact printing of homogeneous tuples
 @test repr(NTuple{7,Int64}) == "NTuple{7,Int64}"
 @test repr(Tuple{Float64, Float64, Float64, Float64}) == "NTuple{4,Float64}"