Improve generation of typealiases (JuliaMath#233)

Author: kimikage

src/FixedPointNumbers.jl

@@ -261,13 +261,30 @@ function length(r::StepRange{<:FixedPoint})
     return div((stop - start) + step, step)
 end
 
-# Printing. These are used to generate type-symbols, so we need them
-# before we include any files.
-function showtype(io::IO, ::Type{X}) where {X <: FixedPoint}
-    print(io, typechar(X))
-    f = nbitsfrac(X)
-    m = bitwidth(X)-f-signbits(X)
-    print(io, m, 'f', f)
+hasalias(::Type) = false
+hasalias(::Type{X}) where {T<:NotBiggerThanInt64, f, X<:FixedPoint{T,f}} = f isa Int
+
+# `alias_symbol` is used to define type aliases, so we need this before we
+# include "src/fixed.jl" / "src/normed.jl".
+function alias_symbol(@nospecialize(X))
+    Symbol(type_prefix(X), nbitsint(X), 'f', nbitsfrac(X))
+end
+
+function _alias_symbol(::Type{X}) where {X <: FixedPoint}
+    if @generated
+        sym = string(alias_symbol(X))
+        return :(Symbol($sym))
+    else
+        return alias_symbol(X)
+    end
+end
+
+@inline function showtype(io::IO, ::Type{X}) where {X <: FixedPoint}
+    if hasalias(X)
+        write(io, _alias_symbol(X))
+    else
+        print(io, X)
+    end
     io
 end
 function show(io::IO, x::FixedPoint{T,f}) where {T,f}

src/deprecations.jl

@@ -7,3 +7,11 @@ function floattype(::Type{T}) where {T <: Real}
         """, :floattype)
     return T
 end
+
+function typechar(::Type{X}) where {X}
+    Base.depwarn("""
+        `typechar` was deprecated since the prefix may not be a single character in the future.
+        We recommend not using private functions, but if you need to, use `type_prefix` instead.
+        """, :typechar)
+    Char(string(type_prefix(X))[1])
+end

src/fixed.jl

@@ -24,14 +24,17 @@ struct Fixed{T <: Signed, f} <: FixedPoint{T, f}
     end
 end
 
-typechar(::Type{X}) where {X <: Fixed} = 'Q'
+# TODO: remove this
+hasalias(::Type{F}) where {F <: Union{Fixed{Int8,8},Fixed{Int16,16},Fixed{Int32,32},Fixed{Int64,64}}} = false
+
+type_prefix(::Type{F}) where {F <: Fixed{<:Signed}} = :Q
 
 for T in (Int8, Int16, Int32, Int64)
-    io = IOBuffer()
     for f in 0:bitwidth(T)-1
-        sym = Symbol(String(take!(showtype(io, Fixed{T,f}))))
+        F = Fixed{T,f}
+        sym = alias_symbol(F)
         @eval begin
-            const $sym = Fixed{$T,$f}
+            const $sym = $F
             export $sym
         end
     end

src/normed.jl

@@ -19,14 +19,14 @@ struct Normed{T <: Unsigned, f} <: FixedPoint{T, f}
     end
 end
 
-typechar(::Type{X}) where {X <: Normed} = 'N'
+type_prefix(::Type{N}) where {N <: Normed{<:Unsigned}} = :N
 
 for T in (UInt8, UInt16, UInt32, UInt64)
-    io = IOBuffer()
     for f in 1:bitwidth(T)
-        sym = Symbol(String(take!(showtype(io, Normed{T,f}))))
+        N = Normed{T,f}
+        sym = alias_symbol(N)
         @eval begin
-            const $sym = Normed{$T,$f}
+            const $sym = $N
             export $sym
         end
     end

test/fixed.jl

@@ -487,6 +487,8 @@ end
 end
 
 @testset "show" begin
+    @test (@test_deprecated FixedPointNumbers.typechar(Q0f7)) === 'Q'
+
     iob = IOBuffer()
     q0f7 = reinterpret(Q0f7, signed(0xaa))
     show(iob, q0f7)

test/normed.jl

@@ -512,6 +512,8 @@ end
 end
 
 @testset "show" begin
+    @test (@test_deprecated FixedPointNumbers.typechar(N0f8)) === 'N'
+
     iob = IOBuffer()
     n0f8 = reinterpret(N0f8, 0xaa)
     show(iob, n0f8)