Add a few new reflection methods

This is informed by attempting to port some packages to the new type system.
I have abstracted out the functionality required by those packages into
documented/tested functions. The hope is to avoid introducing too many
implementation details to packages. These functions can also be implemented
in Compat for older julia versions, such that packages can immediate replace
their use of internal APIs with these functions.

Author: Keno

base/essentials.jl

@@ -95,6 +95,15 @@ function unwrapva(t::ANY)
     isvarargtype(t2) ? t2.parameters[1] : t
 end
 
+typename(a) = error("typename does not apply to this type")
+typename(a::DataType) = a.name
+function typename(a::Union)
+    ta = typename(a.a)
+    tb = typename(a.b)
+    ta === tb ? tb : error("typename does not apply to unions whose components have different typenames")
+end
+typename(union::UnionAll) = typename(union.body)
+
 convert{T<:Tuple{Any,Vararg{Any}}}(::Type{T}, x::Tuple{Any, Vararg{Any}}) =
     tuple(convert(tuple_type_head(T),x[1]), convert(tuple_type_tail(T), tail(x))...)
 convert{T<:Tuple{Any,Vararg{Any}}}(::Type{T}, x::T) = x

base/reflection.jl

@@ -144,11 +144,12 @@ fieldnames(t::UnionAll) = fieldnames(unwrap_unionall(t))
 fieldnames{T<:Tuple}(t::Type{T}) = Int[n for n in 1:nfields(t)]
 
 """
-    Base.datatype_name(t::DataType) -> Symbol
+    Base.datatype_name(t) -> Symbol
 
-Get the name of a `DataType` (without its parent module) as a symbol.
+Get the name of a (potentially UnionAll-wrapped) `DataType` (without its parent module) as a symbol.
 """
 datatype_name(t::DataType) = t.name.name
+datatype_name(t::UnionAll) = datatype_name(unwrap_unionall(t))
 
 """
     Base.datatype_module(t::DataType) -> Module
@@ -232,6 +233,39 @@ a concrete type that can have instances.
 """
 isleaftype(t::ANY) = (@_pure_meta; isa(t, DataType) && t.isleaftype)
 
+"""
+    Base.isabstract(T)
+
+Determine whether `T` was declared as an abstract type (i.e. using the
+`abstract` keyword).
+"""
+function isabstract(t::ANY)
+   @_pure_meta
+   t = unwrap_unionall(t)
+   isa(t,DataType) && t.abstract
+end
+
+"""
+    Base.parameter_upper_bound(t::UnionAll, idx)
+
+Determine the upper bound of a type parameter in the underlying type. E.g.:
+```jldoctest
+julia> immutable Foo{T<:AbstractFloat, N}
+           x::Tuple{T, N}
+       end
+
+julia> Base.parameter_upper_bound(Foo, 1)
+AbstractFloat
+
+julia> Base.parameter_upper_bound(Foo, 2)
+Any
+```
+"""
+function parameter_upper_bound(t::UnionAll, idx)
+   @_pure_meta
+   rewrap_unionall(unwrap_unionall(t).parameters[idx], t)
+end
+
 """
     typeintersect(T, S)
 

test/reflection.jl

@@ -608,3 +608,23 @@ end
 @generated f18883() = nothing
 @test !isempty(sprint(io->code_llvm(io, f18883, Tuple{})))
 @test !isempty(sprint(io->code_native(io, f18883, Tuple{})))
+
+# New reflection methods in 0.6
+immutable ReflectionExample{T<:AbstractFloat, N}
+    x::Tuple{T, N}
+end
+
+@test Base.isabstract(AbstractArray)
+@test !Base.isabstract(ReflectionExample)
+@test !Base.isabstract(Int)
+
+@test Base.parameter_upper_bound(ReflectionExample, 1) === AbstractFloat
+@test Base.parameter_upper_bound(ReflectionExample, 2) === Any
+@test Base.parameter_upper_bound(ReflectionExample{T, N} where T where N <: Real, 2) === Real
+
+@test Base.typename(ReflectionExample{Float64, Int64}).wrapper === ReflectionExample
+@test Base.typename(ReflectionExample{Float64, N} where N).wrapper === ReflectionExample
+@test Base.typename(ReflectionExample{T, Int64} where T).wrapper === ReflectionExample
+@test Base.typename(ReflectionExample).wrapper === ReflectionExample
+@test Base.typename(Union{ReflectionExample{Union{},1},ReflectionExample{Float64,1}}).wrapper === ReflectionExample
+@test_throws ErrorException Base.typename(Union{Int, Float64})