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/exports.jl

@@ -1002,6 +1002,7 @@ export
     fieldoffset,
     fieldname,
     fieldnames,
+    isabstract,
     isleaftype,
     oftype,
     promote,

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,55 @@ are itself and `Union{}` (but `T` itself is not `Union{}`).
 """
 isleaftype(t::ANY) = (@_pure_meta; (isa(t, DataType) && t.isleaftype) || t === Union{})
 
+"""
+   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.:
+```
+julia> immutable Foo{T<:AbstractFloat, N}
+          x::Tuple{T, N}
+      end
+
+julia> Base.parameter_upper_bound(Foo, 1)
+AbstractFloat
+
+julia> parameter_upper_bound(Foo, 2)
+Any
+```
+"""
+function parameter_upper_bound(t::UnionAll, idx)
+   @_pure_meta
+   rewrap_unionall(unwrap_unionall(t).parameters[idx], t)
+end
+
+"""
+   Base.unparameterized_type(t)
+
+Given a (partially) specialized type, return the unspecialized type, e.g.:
+```
+julia> immutable Foo{T}
+          x::T
+      end
+
+julia> Base.unparameterized_type(Foo{Float64})
+Foo
+```
+"""
+unparameterized_type(t::DataType) = t.name.wrapper
+unparameterized_type(t::UnionAll) = unparameterized_type(unwrap_unionall(t))
+
 """
     typeintersect(T, S)
 

test/reflection.jl

@@ -610,3 +610,21 @@ 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 isabstract(AbstractArray)
+@test !isabstract(ReflectionExample)
+@test !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.unparameterized_type(ReflectionExample{Float64, Int64}) === ReflectionExample
+@test Base.unparameterized_type(ReflectionExample{Float64, N} where N) === ReflectionExample
+@test Base.unparameterized_type(ReflectionExample{T, Int64} where T) === ReflectionExample
+@test Base.unparameterized_type(ReflectionExample) === ReflectionExample