Improve performance of Symbol concatenation

[BioTurboNick]

# current: Symbol(x...) = Symbol(string(x...))
@btime Symbol(:test, :me)
  111.024 ns (3 allocations: 176 bytes)

Symbol(x::Symbol, y::Symbol) = Symbol(string(x), string(y))
@btime Symbol(:test, :me)
  84.826 ns (3 allocations: 96 bytes) - 25% better in time, 45% better in memory space

This concatenation method is used a lot in Plots.jl and has a material impact on performance: JuliaPlots/Plots.jl#3763

[oscardssmith]

Looks good.

[mbauman]

Seems like we should be able to do even better by going deeper. I seem to have a slower system than you:

Before:

julia> @btime Symbol(:test, :me)
  152.419 ns (3 allocations: 160 bytes)
:testme

lower level hackery

julia> @eval Base begin
       @inline function __unsafe_string!(out, s::Symbol, offs::Integer)
           n = sizeof(s)
           GC.@preserve s out unsafe_copyto!(pointer(out, offs), unsafe_convert(Ptr{UInt8},s), n)
           return n
       end

       function string(a::Union{Char, String, SubString{String}, Symbol}...)
           n = 0
           for v in a
               if v isa Char
                   n += ncodeunits(v)
               else
                   n += sizeof(v)
               end
           end
           out = _string_n(n)
           offs = 1
           for v in a
               offs += __unsafe_string!(out, v, offs)
           end
           return out
       end
       end
string (generic function with 21 methods)

After:

julia> @btime Symbol(:test, :me)
  119.850 ns (1 allocation: 32 bytes)
:testme

Similar ratio in time improvement, but 2 fewer allocations, 1/5th the space, and hugely more versatile.

[BioTurboNick]

Oh nice, so shall I change to the low-level hackery? I can add some tests to make sure nothing breaks.

[mbauman]

I just pushed it — I already had it locally. It'd be good to ensure we have testing that includes heterogeneous combinations of a Symbol or two with chars and strings; if you could add that or verify it it'd be great!

[BioTurboNick]

I took a look and I think the existing tests seem comprehensive enough?

@testset "Symbol and gensym" begin
    @test Symbol("asdf") === :asdf
    @test Symbol(:abc,"def",'g',"hi",0) === :abcdefghi0
    @test :a < :b
    @test startswith(string(gensym("asdf")),"##asdf#")
    @test gensym("asdf") != gensym("asdf")
    @test gensym() != gensym()
    @test startswith(string(gensym()),"##")
    @test_throws ArgumentError Symbol("ab\0")
    @test_throws ArgumentError gensym("ab\0")
end

Maybe the only thing useful to add would be empties?

@test Symbol("", :"") == :""
@test Symbol(:"", :"") == :""
@test Symbol(a, :"") == :a
@test Symbol(:"", a) == :a