Nicer printing

- remove mangling in favor of native Julia printing
- include argnames in methods
- support and test name argument to ccallable

Author: timholy

contrib/juliac/juliac-buildscript.jl

@@ -51,13 +51,6 @@ function recursively_add_types!(types::Base.IdSet{DataType}, @nospecialize(T::Da
     end
 end
 
-function mangle_name(@nospecialize(T::DataType))
-    is_c_friendly(T) && return string(T)
-    pname = isempty(T.parameters) ? String(nameof(T)) :
-                                    join(pushfirst!(map(mangle_name, T.parameters), String(nameof(T)), "_"))
-    return "_" * pname * "_"
-end
-
 # Load user code
 
 import Base.Experimental.entrypoint
@@ -108,29 +101,34 @@ let mod = Base.include(Main, ARGS[1])
     # Export info about entrypoints and structs needed to create header files
     if length(ARGS) >= 4
         logfile = ARGS[4]
+        iotmp = IOBuffer()
         open(logfile, "w") do io
             types = Base.IdSet{DataType}()
             Base.visit(Core.GlobalMethods) do method
                 if isdefined(method, :ccallable)
                     rt, sig = method.ccallable
                     name = length(method.ccallable) > 2 ? Symbol(method.ccallable[3]) : method.name
-                    Base.show_tuple_as_call(io, name, sig)
-                    println(io, "::", rt)
+                    print(IOContext(iotmp, :print_method_signature_only => true), method)
+                    methodstr = String(take!(iotmp))
+                    if name !== method.name
+                        methodstr = replace(methodstr, String(method.name) => String(name))
+                    end
+                    println(io, methodstr, "::", rt)
                     for T in sig.parameters[2:end]
                         recursively_add_types!(types, T)
                     end
                 end
             end
-            println(io)
+            println(io)  # blank line separates methods from types
             for T in types
-                println(io, mangle_name(T))
+                println(io, T)
                 dtfd = Base.DataTypeFieldDesc(T)
                 local fd
                 for i = 1:Base.datatype_nfields(T)
                     fd = dtfd[i]
                     fn = fieldname(T, i)
                     ft = fieldtype(T, i)
-                    println(io, "  ", fn, "::", mangle_name(ft), "[", fd.offset, "]")
+                    println(io, "  ", fn, "::", ft, "[", fd.offset, "]")
                 end
                 println(io, fd.offset + fd.size, " bytes")
             end

test/trimming/simplelib.jl

@@ -11,10 +11,18 @@ struct CVectorPair{T}
     to::CVector{T}
 end
 
-Base.@ccallable function copyto_and_sum(fromto::CVectorPair{Float32})::Float32
+Base.@ccallable "copyto_and_sum" function badname(fromto::CVectorPair{Float32})::Float32
     from, to = unsafe_wrap(Array, fromto.from.data, fromto.from.length), unsafe_wrap(Array, fromto.to.data, fromto.to.length)
     copyto!(to, from)
     return sum(to)
 end
 
+# FIXME? varargs
+# Base.@ccallable function printints(x::Cint...)::Nothing
+#     for i in 1:length(x)
+#         print(x[i], " ")
+#     end
+#     println()
+# end
+
 end

test/trimming/trimming.jl

@@ -17,19 +17,27 @@ let exe_suffix = splitext(Base.julia_exename())[2]
     @test filesize(basic_jll_exe) < filesize(unsafe_string(Base.JLOptions().image_file))/10
 
     str = read(joinpath(bindir, "bindinginfo_simplelib.log"), String)
-    @test occursin("copyto_and_sum(::CVectorPair{Float32})::Float32", str)
+    @test occursin("copyto_and_sum(fromto::CVectorPair{Float32})::Float32", str)
     @test occursin(
         """
-        _CVector_Float32_
+        CVector{Float32}
           length::Int32[0]
           data::Ptr{Float32}[8]
         16 bytes""", str
     )
     @test occursin(
         """
-        _CVectorPair_Float32_
-          from::_CVector_Float32_[0]
-          to::_CVector_Float32_[16]
+        CVectorPair{Float32}
+          from::CVector{Float32}[0]
+          to::CVector{Float32}[16]
         32 bytes""", str
     )
+    # ensure that there is a blank line between methods and types
+    lines = split(str, '\n'; keepempty=true)
+    nblanks = 0
+    for line in lines
+        nblanks += isempty(line)
+        occursin("length", line) && break
+    end
+    @test nblanks == 1
 end