diff --git a/base/REPLCompletions.jl b/base/REPLCompletions.jl
index 02eb1f78756bcd..a39b6d1cb9e881 100644
--- a/base/REPLCompletions.jl
+++ b/base/REPLCompletions.jl
@@ -315,7 +315,7 @@ function get_type(sym, fn)
 end
 # Method completion on function call expression that look like :(max(1))
 function complete_methods(ex_org::Expr)
-    args_ex = DataType[]
+    args_ex = Any[]
     func, found = get_value(ex_org.args[1], Main)
     !found && return String[]
     for ex in ex_org.args[2:end]
@@ -330,7 +330,8 @@ function complete_methods(ex_org::Expr)
     io = IOBuffer()
     for method in ml
         # Check if the method's type signature intersects the input types
-        if typeintersect(Tuple{method.sig.parameters[1 : min(na, end)]...}, t_in) != Union{}
+        ms = method.sig
+        if typeintersect(Base.rewrap_unionall(Tuple{Base.unwrap_unionall(ms).parameters[1 : min(na, end)]...}, ms), t_in) != Union{}
             show(io, method, kwtype=kwtype)
             push!(out, String(take!(io)))
         end
diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 9dbc6b08a1531e..ca4e20115094f5 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -89,8 +89,7 @@ julia> extrema(b)
 """
 linearindices(A)                 = (@_inline_meta; OneTo(_length(A)))
 linearindices(A::AbstractVector) = (@_inline_meta; indices1(A))
-eltype{T}(::Type{AbstractArray{T}}) = T
-eltype{T,N}(::Type{AbstractArray{T,N}}) = T
+eltype(::Type{A}) where A<:AbstractArray{E} where E  = E
 elsize{T}(::AbstractArray{T}) = sizeof(T)
 
 """
@@ -204,7 +203,7 @@ julia> strides(A)
 ```
 """
 strides(A::AbstractArray) = _strides((1,), A)
-_strides{T,N}(out::NTuple{N}, A::AbstractArray{T,N}) = out
+_strides{T,N}(out::NTuple{N,Any}, A::AbstractArray{T,N}) = out
 function _strides{M,T,N}(out::NTuple{M}, A::AbstractArray{T,N})
     @_inline_meta
     _strides((out..., out[M]*size(A, M)), A)
@@ -267,6 +266,7 @@ should define `linearindexing` in the type-domain:
     Base.linearindexing{T<:MyArray}(::Type{T}) = Base.LinearFast()
 """
 linearindexing(A::AbstractArray) = linearindexing(typeof(A))
+linearindexing(::Type{Union{}}) = LinearFast()
 linearindexing{T<:AbstractArray}(::Type{T}) = LinearSlow()
 linearindexing{T<:Array}(::Type{T}) = LinearFast()
 linearindexing{T<:Range}(::Type{T}) = LinearFast()
@@ -997,8 +997,6 @@ promote_eltype(v1, vs...) = promote_type(eltype(v1), promote_eltype(vs...))
 #TODO: ERROR CHECK
 cat(catdim::Integer) = Array{Any,1}(0)
 
-vcat() = Array{Any,1}(0)
-hcat() = Array{Any,1}(0)
 typed_vcat{T}(::Type{T}) = Array{T,1}(0)
 typed_hcat{T}(::Type{T}) = Array{T,1}(0)
 
diff --git a/base/array.jl b/base/array.jl
index 5069913488581d..ab754d1e6d3e1c 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -1005,6 +1005,10 @@ end
 
 
 # concatenations of homogeneous combinations of vectors, horizontal and vertical
+
+vcat() = Array{Any,1}(0)
+hcat() = Array{Any,1}(0)
+
 function hcat{T}(V::Vector{T}...)
     height = length(V[1])
     for j = 2:length(V)
diff --git a/base/boot.jl b/base/boot.jl
index 2d48f7080464a7..adf1adf383097d 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -263,8 +263,7 @@ TypeVar(n::Symbol, ub::ANY) =
 TypeVar(n::Symbol, lb::ANY, ub::ANY) =
     ccall(:jl_new_typevar, Ref{TypeVar}, (Any, Any, Any), n, lb, ub)
 
-UnionAll(v::TypeVar, t::ANY) =
-    ccall(:jl_new_unionall_type, Ref{UnionAll}, (Any, Any), v, t)
+UnionAll(v::TypeVar, t::ANY) = ccall(:jl_type_unionall, Any, (Any, Any), v, t)
 
 Void() = nothing
 
diff --git a/base/broadcast.jl b/base/broadcast.jl
index 24eace38d2959f..f7916924d3b459 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -14,7 +14,7 @@ typealias ScalarType Union{Type{Any}, Type{Nullable}}
 ## Broadcasting utilities ##
 # fallbacks for some special cases
 @inline broadcast(f, x::Number...) = f(x...)
-@inline broadcast{N}(f, t::NTuple{N}, ts::Vararg{NTuple{N}}) = map(f, t, ts...)
+@inline broadcast{N}(f, t::NTuple{N,Any}, ts::Vararg{NTuple{N,Any}}) = map(f, t, ts...)
 
 # special cases for "X .= ..." (broadcast!) assignments
 broadcast!(::typeof(identity), X::AbstractArray, x::Number) = fill!(X, x)
diff --git a/base/deprecated.jl b/base/deprecated.jl
index 2b15c230c69efe..090b920611345c 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -125,14 +125,14 @@ end
 @deprecate get_rounding rounding
 
 #13465
-@deprecate cov(x::AbstractVector; corrected=true, mean=Base.mean(x)) Base.covm(x, mean, corrected)
-@deprecate cov(X::AbstractMatrix; vardim=1, corrected=true, mean=Base.mean(X, vardim)) Base.covm(X, mean, vardim, corrected)
-@deprecate cov(x::AbstractVector, y::AbstractVector; corrected=true, mean=(Base.mean(x), Base.mean(y))) Base.covm(x, mean[1], y, mean[2], corrected)
+#@deprecate cov(x::AbstractVector; corrected=true, mean=Base.mean(x)) Base.covm(x, mean, corrected)
+#@deprecate cov(X::AbstractMatrix; vardim=1, corrected=true, mean=Base.mean(X, vardim)) Base.covm(X, mean, vardim, corrected)
+#@deprecate cov(x::AbstractVector, y::AbstractVector; corrected=true, mean=(Base.mean(x), Base.mean(y))) Base.covm(x, mean[1], y, mean[2], corrected)
 @deprecate cov(X::AbstractVecOrMat, Y::AbstractVecOrMat; vardim=1, corrected=true, mean=(Base.mean(X, vardim), Base.mean(Y, vardim))) Base.covm(X, mean[1], Y, mean[2], vardim, corrected)
 
-@deprecate cor(x::AbstractVector; mean=Base.mean(x)) Base.corm(x, mean)
-@deprecate cor(X::AbstractMatrix; vardim=1, mean=Base.mean(X, vardim)) Base.corm(X, mean, vardim)
-@deprecate cor(x::AbstractVector, y::AbstractVector; mean=(Base.mean(x), Base.mean(y))) Base.corm(x, mean[1], y, mean[2])
+#@deprecate cor(x::AbstractVector; mean=Base.mean(x)) Base.corm(x, mean)
+#@deprecate cor(X::AbstractMatrix; vardim=1, mean=Base.mean(X, vardim)) Base.corm(X, mean, vardim)
+#@deprecate cor(x::AbstractVector, y::AbstractVector; mean=(Base.mean(x), Base.mean(y))) Base.corm(x, mean[1], y, mean[2])
 @deprecate cor(X::AbstractVecOrMat, Y::AbstractVecOrMat; vardim=1, mean=(Base.mean(X, vardim), Base.mean(Y, vardim))) Base.corm(X, mean[1], Y, mean[2], vardim)
 
 @deprecate_binding SparseMatrix SparseArrays
diff --git a/base/dict.jl b/base/dict.jl
index e62a44ed26fd83..3307ef3739e999 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -137,15 +137,14 @@ const AnyDict = Dict{Any,Any}
 
 Dict{K,V}(ps::Pair{K,V}...)            = Dict{K,V}(ps)
 Dict{K  }(ps::Pair{K}...,)             = Dict{K,Any}(ps)
-Dict{V  }(ps::Pair{TypeVar(:K),V}...,) = Dict{Any,V}(ps)
+Dict{V  }(ps::(Pair{K,V} where K)...,) = Dict{Any,V}(ps)
 Dict(     ps::Pair...)                 = Dict{Any,Any}(ps)
 
 function Dict(kv)
     try
         Base.associative_with_eltype(Dict, kv, eltype(kv))
     catch e
-        if any(x->isempty(methods(x, (typeof(kv),))), [start, next, done]) ||
-            !all(x->isa(x,Union{Tuple,Pair}),kv)
+        if !applicable(start, kv) || !all(x->isa(x,Union{Tuple,Pair}),kv)
             throw(ArgumentError("Dict(kv): kv needs to be an iterator of tuples or pairs"))
         else
             rethrow(e)
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 2ddcedfc0b07a8..afb0cdf3546a65 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -88,7 +88,11 @@ function signature(expr::Expr)
             end
             push!(sig.args[end].args, argtype(arg))
         end
-        Expr(:let, Expr(:block, sig), typevars(expr)...)
+        tv = typevars(expr)
+        for i = length(tv):-1:1
+            sig = Expr(:where, sig, tv[i])
+        end
+        sig
     else
         signature(expr.args[1])
     end
@@ -103,14 +107,11 @@ end
 argtype(other) = :Any
 
 function typevars(expr::Expr)
-    isexpr(expr, :curly) && return [tvar(x) for x in expr.args[2:end]]
+    isexpr(expr, :curly) && return expr.args[2:end]
     typevars(expr.args[1])
 end
 typevars(::Symbol) = []
 
-tvar(x::Expr)   = :($(x.args[1]) = TypeVar($(quot(x.args[1])), $(x.args[2]), true))
-tvar(s::Symbol) = :($(s) = TypeVar($(quot(s)), Any, true))
-
 # Docsystem types.
 # ================
 
@@ -283,6 +284,7 @@ function doc(binding::Binding, sig::Type = Union{})
 end
 
 # Some additional convenience `doc` methods that take objects rather than `Binding`s.
+doc(obj::UnionAll) = doc(Base.unwrap_unionall(obj))
 doc(object, sig::Type = Union{}) = doc(aliasof(object, typeof(object)), sig)
 doc(object, sig...)              = doc(object, Tuple{sig...})
 
diff --git a/base/essentials.jl b/base/essentials.jl
index efe5058c444f58..6ba31f62689566 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -76,6 +76,13 @@ function unwrap_unionall(a::ANY)
     return a
 end
 
+function rewrap_unionall(t::ANY, u::ANY)
+    if !isa(u, UnionAll)
+        return t
+    end
+    return UnionAll(u.var, rewrap_unionall(t, u.body))
+end
+
 const _va_typename = Vararg.body.body.name
 function isvarargtype(t::ANY)
     t = unwrap_unionall(t)
@@ -84,8 +91,8 @@ end
 
 isvatuple(t::DataType) = (n = length(t.parameters); n > 0 && isvarargtype(t.parameters[n]))
 function unwrapva(t::ANY)
-    t = unwrap_unionall(t)
-    isvarargtype(t) ? t.parameters[1] : t
+    t2 = unwrap_unionall(t)
+    isvarargtype(t2) ? t2.parameters[1] : t
 end
 
 convert{T<:Tuple{Any,Vararg{Any}}}(::Type{T}, x::Tuple{Any, Vararg{Any}}) =
@@ -105,6 +112,7 @@ ptr_arg_unsafe_convert(::Type{Ptr{Void}}, x) = x
 cconvert(T::Type, x) = convert(T, x) # do the conversion eagerly in most cases
 cconvert{P<:Ptr}(::Type{P}, x) = x # but defer the conversion to Ptr to unsafe_convert
 unsafe_convert{T}(::Type{T}, x::T) = x # unsafe_convert (like convert) defaults to assuming the convert occurred
+unsafe_convert{T<:Ptr}(::Type{T}, x::T) = x  # to resolve ambiguity with the next method
 unsafe_convert{P<:Ptr}(::Type{P}, x::Ptr) = convert(P, x)
 
 reinterpret{T}(::Type{T}, x) = box(T, x)
diff --git a/base/float.jl b/base/float.jl
index 87af6acc0b7e6d..c15b614fc0cc69 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -63,6 +63,7 @@ for t1 in (Float32,Float64)
         end
     end
 end
+convert(::Type{Integer}, x::Float16) = convert(Integer, Float32(x))
 convert{T<:Integer}(::Type{T}, x::Float16) = convert(T, Float32(x))
 
 
diff --git a/base/inference.jl b/base/inference.jl
index 166f4ed306836c..dc2fc792efd69f 100644
--- a/base/inference.jl
+++ b/base/inference.jl
@@ -117,7 +117,13 @@ type InferenceState
 
         if !toplevel && isempty(linfo.sparam_vals) && !isempty(linfo.def.sparam_syms)
             # linfo is unspecialized
-            sp = svec(Any[ TypeVar(sym, Any, true) for sym in linfo.def.sparam_syms ]...)
+            sp = Any[]
+            sig = linfo.def.sig
+            while isa(sig,UnionAll)
+                push!(sp, sig.var)
+                sig = sig.body
+            end
+            sp = svec(sp...)
         else
             sp = linfo.sparam_vals
         end
@@ -132,18 +138,21 @@ type InferenceState
         s_types[1] = Any[ VarState(Bottom, true) for i = 1:nslots ]
         s_edges = Any[ () for i = 1:n ]
 
-        atypes = linfo.specTypes
+        atypes = unwrap_unionall(linfo.specTypes)
         nargs = toplevel ? 0 : linfo.def.nargs
         la = nargs
         if la > 0
             if linfo.def.isva
-                if atypes === Tuple
+                if atypes == Tuple
                     if la > 1
                         atypes = Tuple{Any[Any for i = 1:(la - 1)]..., Tuple.parameters[1]}
                     end
                     s_types[1][la] = VarState(Tuple, false)
                 else
-                    s_types[1][la] = VarState(tuple_tfunc(limit_tuple_depth(params, tupletype_tail(atypes, la))), false)
+                    s_types[1][la] = VarState(rewrap_unionall(tuple_tfunc(limit_tuple_depth(params,
+                                                                                            tupletype_tail(atypes, la))),
+                                                              linfo.specTypes),
+                                              false)
                 end
                 la -= 1
             end
@@ -151,34 +160,30 @@ type InferenceState
 
         laty = length(atypes.parameters)
         if laty > 0
-            lastatype = atypes.parameters[laty]
-            if isvarargtype(lastatype)
-                lastatype = unwrap_unionall(lastatype)
-                lastatype = lastatype.parameters[1]
-                laty -= 1
-            end
-            if isa(lastatype, TypeVar)
-                lastatype = lastatype.ub
-            end
-            if isa(lastatype, DataType) && isdefined(lastatype, :instance)
-                # replace singleton types with their equivalent Const object
-                lastatype = Const(lastatype.instance)
-            end
             if laty > la
                 laty = la
             end
+            local lastatype
+            atail = laty
             for i = 1:laty
                 atyp = atypes.parameters[i]
+                if i == laty && isvarargtype(atyp)
+                    atyp = unwrap_unionall(atyp).parameters[1]
+                    atail -= 1
+                end
                 if isa(atyp, TypeVar)
                     atyp = atyp.ub
                 end
                 if isa(atyp, DataType) && isdefined(atyp, :instance)
                     # replace singleton types with their equivalent Const object
                     atyp = Const(atyp.instance)
+                else
+                    atyp = rewrap_unionall(atyp, linfo.specTypes)
                 end
+                i == laty && (lastatype = atyp)
                 s_types[1][i] = VarState(atyp, false)
             end
-            for i = (laty + 1):la
+            for i = (atail + 1):la
                 s_types[1][i] = VarState(lastatype, false)
             end
         else
@@ -288,7 +293,8 @@ function istopfunction(topmod, f::ANY, sym)
     return false
 end
 
-isknownlength(t::DataType) = !isvatuple(t) || (length(t.parameters) == 1 && isa(t.parameters[1].parameters[2],Int))
+isknownlength(t::DataType) = !isvatuple(t) ||
+    (length(t.parameters) > 0 && isa(unwrap_unionall(t.parameters[end]).parameters[2],Int))
 
 # t[n:end]
 tupletype_tail(t::ANY, n) = Tuple{t.parameters[n:end]...}
@@ -302,8 +308,8 @@ const _Type_name = Type.body.name
 isType(t::ANY) = isa(t,DataType) && (t::DataType).name === _Type_name
 
 # true if Type is inlineable as constant
-isconstType(t::ANY, b::Bool) =
-    isType(t) && !has_typevars(t.parameters[1],b) &&
+isconstType(t::ANY) =
+    isType(t) && !has_free_typevars(t.parameters[1]) &&
     !issubtype(Type{Tuple{Vararg}}, t)  # work around inference bug #18450
 
 const IInf = typemax(Int) # integer infinity
@@ -319,7 +325,12 @@ function add_tfunc(f::Function, minarg::Int, maxarg::Int, tfunc::ANY)
     push!(t_ffunc_val, (minarg, maxarg, tfunc))
 end
 add_tfunc(throw, 1, 1, x->Bottom)
-add_tfunc(box, 2, 2, (t,v)->(isType(t) ? t.parameters[1] : Any))
+# the inverse of typeof_tfunc
+function instanceof_tfunc(t::ANY)
+    # TODO improve
+    return isType(t) ? t.parameters[1] : Any
+end
+add_tfunc(box, 2, 2, (t,v)->instanceof_tfunc(t))
 add_tfunc(eq_int, 2, 2, cmp_tfunc)
 add_tfunc(ne_int, 2, 2, cmp_tfunc)
 add_tfunc(slt_int, 2, 2, cmp_tfunc)
@@ -365,7 +376,7 @@ add_tfunc(Core.Intrinsics.llvmcall, 3, IInf,
     (fptr::ANY, rt::ANY, at::ANY, a...)->(isType(rt) ? rt.parameters[1] : Any))
 add_tfunc(Core.Intrinsics.cglobal, 1, 2,
     (fptr::ANY, t::ANY...)->(isempty(t) ? Ptr{Void} :
-                   isType(t[1]) ? Ptr{t[1].parameters[1]} : Ptr))
+                             isType(t[1]) ? Ptr{t[1].parameters[1]} : Ptr))
 add_tfunc(Core.Intrinsics.select_value, 3, 3,
     function (cnd::ANY, x::ANY, y::ANY)
         if isa(cnd, Const)
@@ -414,7 +425,14 @@ add_tfunc(arraysize, 2, 2, (a::ANY, d::ANY)->Int)
 add_tfunc(pointerref, 3, 3,
           function (a::ANY, i::ANY, align::ANY)
               a = widenconst(a)
-              return isa(a,DataType) && a<:Ptr && isa(a.parameters[1],Union{Type,TypeVar}) ? a.parameters[1] : Any
+              if isa(a,DataType) && a<:Ptr
+                  if isa(a.parameters[1],Type)
+                      return a.parameters[1]
+                  elseif isa(a.parameters[1],TypeVar)
+                      return a.parameters[1].ub
+                  end
+              end
+              return Any
           end)
 add_tfunc(pointerset, 4, 4, (a::ANY, v::ANY, i::ANY, align::ANY) -> a)
 
@@ -434,12 +452,12 @@ function typeof_tfunc(t::ANY)
         elseif t === Any
             DataType
         else
-            Type{TypeVar(:_,t)}
+            Type{_} where _<:t
         end
     elseif isa(t,Union)
         Union{typeof_tfunc(t.a), typeof_tfunc(t.b)}
     elseif isa(t,TypeVar) && !(Any <: t.ub)
-        Type{t}
+        typeof_tfunc(t.ub)
     else
         DataType
     end
@@ -471,8 +489,11 @@ add_tfunc(isa, 2, 2,
           end)
 add_tfunc(issubtype, 2, 2,
           function (a::ANY, b::ANY)
-              if isType(a) && isType(b) && isleaftype(a) && isleaftype(b)
-                  return Const(issubtype(a.parameters[1], b.parameters[1]))
+              if isType(a) && isType(b)
+                  a1, b1 = a.parameters[1], b.parameters[1]
+                  if !has_free_typevars(a1) && !has_free_typevars(b1)
+                      return Const(issubtype(a1, b1))
+                  end
               end
               return Bool
           end)
@@ -484,146 +505,157 @@ function type_depth(t::ANY)
         return max(type_depth(t.a), type_depth(t.b)) + 1
     elseif isa(t, DataType)
         return (t::DataType).depth
+    elseif isa(t, UnionAll)
+        if t.var.ub === Any
+            return type_depth(t.body)
+        end
+        return max(type_depth(t.var.ub)+1, type_depth(t.body))
     end
     return 0
 end
 
-function limit_type_depth(t::ANY, d::Int, cov::Bool, vars::Vector{Any})
-    if isa(t,TypeVar) || isa(t,UnionAll)
-        return t
-    end
-    inexact = !cov && d > MAX_TYPE_DEPTH
-    if t === Bottom
-        return t
-    elseif isa(t,Union)
+function limit_type_depth(t::ANY, d::Int, cov::Bool=true, var::Union{Void,TypeVar}=nothing)
+    if isa(t,Union)
         if d > MAX_TYPE_DEPTH
-            R = Any
-        else
-            R = Union{map(x->limit_type_depth(x, d+1, cov, vars), (t.a,t.b))...}
+            return Any
         end
-    elseif isa(t,DataType)
-        P = t.parameters
-        isempty(P) && return t
-        if d > MAX_TYPE_DEPTH
-            R = t.name.wrapper
-        else
-            stillcov = cov && (t.name === Tuple.name)
-            Q = map(x->limit_type_depth(x, d+1, stillcov, vars), P)
-            if !cov && _any(p->contains_is(vars,p), Q)
-                R = t.name.wrapper
-                inexact = true
-            else
-                R = t.name.wrapper{Q...}
-            end
+        return Union{map(x->limit_type_depth(x, d+1, cov, var), (t.a,t.b))...}
+    elseif isa(t,UnionAll)
+        v = t.var
+        if v.ub === Any
+            return UnionAll(t.var, limit_type_depth(t.body, d, cov, var))
         end
-    else
+        ub = limit_type_depth(v.ub, d+1, true, nothing)
+        v2 = TypeVar(v.name, v.lb, ub)
+        return UnionAll(v2, limit_type_depth(t{v2}, d, cov, var))
+    elseif !isa(t,DataType)
         return t
     end
-    if inexact && (!cov || !isvarargtype(R))
-        R = TypeVar(:_,R)
-        push!(vars, R)
-    end
-    return R
+    P = t.parameters
+    isempty(P) && return t
+    if d > MAX_TYPE_DEPTH
+        cov && return t.name.wrapper
+        # TODO mutating a TypeVar is not great style
+        var.ub = t.name.wrapper
+        return var
+    end
+    stillcov = cov && (t.name === Tuple.name)
+    if cov && !stillcov
+        var = TypeVar(:_)
+    end
+    Q = map(x->limit_type_depth(x, d+1, stillcov, var), P)
+    R = t.name.wrapper{Q...}
+    return (cov && !stillcov) ? UnionAll(var, R) : R
 end
 
+const DataType_parameters_fieldindex = fieldindex(DataType, :parameters)
+const DataType_types_fieldindex = fieldindex(DataType, :types)
+const DataType_super_fieldindex = fieldindex(DataType, :super)
+
 # returns (type, isexact)
-function getfield_tfunc(s0::ANY, name)
-    if isa(s0, TypeVar)
-        s0 = s0.ub
+function getfield_tfunc(s00::ANY, name)
+    if isa(s00, TypeVar)
+        s00 = s00.ub
     end
-    s0 = unwrap_unionall(s0)
-    s = s0
+    s = s0 = unwrap_unionall(s00)
     if isType(s)
-        s = typeof(s.parameters[1])
+        p1 = s.parameters[1]
+        if isa(p1,UnionAll) && isa(name,Const)
+            if name.val === :var
+                return Const(p1.var)
+            elseif name.val === :body
+                return abstract_eval_constant(p1.body)
+            end
+        end
+        s = typeof(p1)
         if s === TypeVar
-            return Any, false
+            return Any
         end
+    elseif isa(s,Union)
+        return rewrap_unionall(tmerge(getfield_tfunc(s.a, name), getfield_tfunc(s.b, name)),
+                               s00)
     elseif isa(s,Const)
-        if isa(s.val, Module) && isa(name, Const) && isa(name.val, Symbol)
-            return abstract_eval_global(s.val, name.val), true
-        end
-        s = typeof(s.val)
-    end
-    if isa(s,Union)
-        return tmerge(getfield_tfunc(t.a, name)[1],
-                      getfield_tfunc(t.b, name)[1]), false
-    end
-    if isa(s,DataType)
-        if s.abstract
-            return Any, false
-        end
-        if s <: Tuple && name ⊑ Symbol
-            return Bottom, true
-        end
-    end
-    if isa(name,Const) && isa(name.val,Symbol)
-        fld = name.val
-        if isa(s0,Const) && isa(s0.val,Module) && isdefined(s0.val,fld) && isconst(s0.val,fld)
-            return abstract_eval_constant(getfield(s0.val,fld)), true
-        end
-        if s <: Module
-            return Any, false
-        end
-        if isType(s0)
-            sp = s0.parameters[1]
-            if isa(sp,DataType)
-                if fld === :parameters
-                    return Const(sp.parameters), true
-                elseif fld === :types
-                    return Const(sp.types), true
-                elseif fld === :super
-                    return Type{sp.super}, isleaftype(s)
-                end
+        sv = s.val
+        if isa(name,Const)
+            nv = name.val
+            if isa(sv, Module) && isa(nv, Symbol)
+                return abstract_eval_global(sv, nv)
             end
-        end
-        snames = s.name.names
-        for i = 1:length(snames)
-            if snames[i] === fld
-                R = s.types[i]
-                if isempty(s.parameters)
-                    return R, true
-                else
-                    # conservatively limit the type depth here,
-                    # since the UnionAll type bound is otherwise incorrect
-                    # in the current type system
-                    typ = limit_type_depth(R, 0, true,
-                                           filter!(x->isa(x,TypeVar), Any[s.parameters...]))
-                    return typ, isleaftype(s) && isa(R, Type) && typeof(R) === typeof(typ) && typeseq(R, typ)
+            if isa(sv,DataType) || isimmutable(sv)
+                try
+                    return abstract_eval_constant(getfield(sv, nv))
+                catch
                 end
             end
         end
-        return Bottom, true
-    elseif isa(name,Const) && isa(name.val,Int)
-        if s <: Module
-            return Bottom, true
+        s = typeof(sv)
+    end
+    if !isa(s,DataType) || s.abstract
+        return Any
+    end
+    if s <: Tuple && name ⊑ Symbol
+        return Bottom
+    end
+    if s <: Module
+        if name ⊑ Int
+            return Bottom
         end
-        i::Int = name.val
-        nf = s.types.length
-        if isvatuple(s) && i >= nf
-            return s.types[nf].parameters[1], false
+        return Any
+    end
+    if isempty(s.types)
+        return Bottom
+    end
+    if !isa(name,Const)
+        if !(Int <: name || Symbol <: name)
+            return Bottom
         end
-        if i < 1 || i > nf
-            return Bottom, true
+        if length(s.types) == 1
+            return rewrap_unionall(unwrapva(s.types[1]), s00)
         end
-        return s.types[i], false
-    elseif isempty(s.types)
-        return Bottom, true
-    elseif length(s.types) == 1 && isempty(s.parameters)
-        return s.types[1], true
-    else
-        R = reduce(tmerge, Bottom, map(unwrapva, s.types)) #=Union{s.types...}=#
-        alleq = isa(R, Type) && typeof(R) === typeof(s.types[1]) && typeseq(R, s.types[1])
+        R = reduce(tmerge, Bottom, map(t->rewrap_unionall(unwrapva(t),s00), s.types))
         # do the same limiting as the known-symbol case to preserve type-monotonicity
         if isempty(s.parameters)
-            return R, alleq
-        else
-            typ = limit_type_depth(R, 0, true,
-                                   filter!(x->isa(x,TypeVar), Any[s.parameters...]))
-            return typ, alleq && isleaftype(s) && typeof(R) === typeof(typ) && typeseq(R, typ)
+            return R
+        end
+        return limit_type_depth(R, 0)
+    end
+    fld = name.val
+    if isa(fld,Symbol)
+        fld = fieldindex(s, fld, false)
+    end
+    if !isa(fld,Int)
+        return Bottom
+    end
+    nf = length(s.types)
+    if s <: Tuple && fld >= nf && isvarargtype(s.types[nf])
+        return rewrap_unionall(unwrapva(s.types[nf]), s00)
+    end
+    if fld < 1 || fld > nf
+        return Bottom
+    end
+    if isType(s0)
+        sp = s0.parameters[1]
+        if isa(sp,DataType)
+            if fld == DataType_parameters_fieldindex
+                return Const(sp.parameters)
+            elseif fld == DataType_types_fieldindex
+                return Const(sp.types)
+            elseif fld == DataType_super_fieldindex
+                return rewrap_unionall(Type{sp.super}, s00)
+            end
         end
     end
+    R = s.types[fld]
+    if isempty(s.parameters)
+        return R
+    end
+    # TODO jb/subtype is this still necessary?
+    # conservatively limit the type depth here,
+    # since the UnionAll type bound is otherwise incorrect
+    # in the current type system
+    return rewrap_unionall(limit_type_depth(R, 0), s00)
 end
-add_tfunc(getfield, 2, 2, (s::ANY, name::ANY) -> getfield_tfunc(s, name)[1])
+add_tfunc(getfield, 2, 2, (s::ANY, name::ANY) -> getfield_tfunc(s, name))
 add_tfunc(setfield!, 3, 3, (o::ANY, f::ANY, v::ANY) -> v)
 function fieldtype_tfunc(s::ANY, name::ANY)
     if isType(s)
@@ -631,11 +663,15 @@ function fieldtype_tfunc(s::ANY, name::ANY)
     else
         return Type
     end
-    t, exact = getfield_tfunc(s, name)
+    t = getfield_tfunc(s, name)
     if t === Bottom
         return t
+    elseif isa(t,Const)
+        return Type{typeof(t.val)}
+    elseif isleaftype(t) || isvarargtype(t)
+        return Type{t}
     end
-    return Type{exact || isleaftype(t) || isa(t,TypeVar) || isvarargtype(t) ? t : TypeVar(:_, t)}
+    return Type{_} where _<:t
 end
 add_tfunc(fieldtype, 2, 2, fieldtype_tfunc)
 
@@ -649,7 +685,7 @@ function valid_tparam(x::ANY)
     return isa(x,Int) || isa(x,Symbol) || isa(x,Bool) || (!isa(x,Type) && isbits(x))
 end
 
-has_typevars(t::ANY, all=false) = ccall(:jl_has_free_typevars, Cint, (Any,), t)!=0
+has_free_typevars(t::ANY) = ccall(:jl_has_free_typevars, Cint, (Any,), t)!=0
 
 # TODO: handle e.g. apply_type(T, R::Union{Type{Int32},Type{Float64}})
 function apply_type_tfunc(args...)
@@ -675,14 +711,14 @@ function apply_type_tfunc(args...)
     elseif isa(headtype, Union)
         return Any
     end
-    istuple = (headtype === Tuple)
+    istuple = (headtype == Tuple)
     uncertain = false
     tparams = Any[]
     for i=2:largs
         ai = args[i]
         if isType(ai)
             aip1 = ai.parameters[1]
-            uncertain |= has_typevars(aip1)
+            uncertain |= has_free_typevars(aip1)
             push!(tparams, aip1)
         elseif isa(ai, Const) && valid_tparam(ai.val)
             push!(tparams, ai.val)
@@ -701,7 +737,6 @@ function apply_type_tfunc(args...)
         end
     end
     local appl
-    # good, all arguments understood
     try
         appl = apply_type(headtype, tparams...)
     catch
@@ -712,9 +747,9 @@ function apply_type_tfunc(args...)
     end
     !uncertain && return Type{appl}
     if type_too_complex(appl,0)
-        return Type{TypeVar(:_,headtype)}
+        return Type{_} where _<:headtype
     end
-    !(isa(appl,TypeVar) || isvarargtype(appl)) ? Type{TypeVar(:_,appl)} : Type{appl}
+    !isa(appl,TypeVar) ? (Type{_} where _<:appl) : Type{appl}
 end
 add_tfunc(apply_type, 1, IInf, apply_type_tfunc)
 
@@ -741,8 +776,8 @@ function invoke_tfunc(f::ANY, types::ANY, argtype::ANY, sv::InferenceState)
         return Any
     end
     meth = entry.func
-    (ti, env) = ccall(:jl_match_method, Ref{SimpleVector}, (Any, Any, Any),
-                      argtype, meth.sig, meth.tvars)
+    (ti, env) = ccall(:jl_match_method, Ref{SimpleVector}, (Any, Any),
+                      argtype, meth.sig)
     return typeinf_edge(meth::Method, ti, env, sv)
 end
 
@@ -775,7 +810,7 @@ function builtin_tfunction(f::ANY, argtypes::Array{Any,1}, sv::InferenceState)
         end
         a1 = argtypes[1]
         if isvarargtype(a1)
-            return a1.parameters[1]
+            return unwrap_unionall(a1).parameters[1]
         end
         return a1
     elseif f === arrayref
@@ -783,8 +818,14 @@ function builtin_tfunction(f::ANY, argtypes::Array{Any,1}, sv::InferenceState)
             return Bottom
         end
         a = widenconst(argtypes[1])
-        return (isa(a,DataType) && a<:Array && isa(a.parameters[1],Union{Type,TypeVar}) ?
-                a.parameters[1] : Any)
+        if isa(a,UnionAll)
+            a = unwrap_unionall(a)
+        end
+        if isa(a,DataType) && a<:Array && isa(a.parameters[1],Union{Type,TypeVar})
+            a = a.parameters[1]
+            return isa(a,TypeVar) ? a.ub : a
+        end
+        return Any
     elseif f === Expr
         if length(argtypes) < 1 && !isva
             return Bottom
@@ -833,14 +874,13 @@ function limit_tuple_depth_(params::InferenceParams, t::ANY, d::Int)
         # also limit within Union types.
         # may have to recur into other stuff in the future too.
         return Union{map(x->limit_tuple_depth_(params,x,d+1), (t.a,t.b))...}
-    end
-    if isa(t,TypeVar)
-        return limit_tuple_depth_(params, t.ub, d)
-    end
-    if !(isa(t,DataType) && t.name === Tuple.name)
+    elseif isa(t,UnionAll)
+        var = TypeVar(t.var.name, t.var.lb, limit_tuple_depth_(params, t.var.ub, d))
+        body = limit_tuple_depth_(params, t{var}, d)
+        return UnionAll(var, body)
+    elseif !(isa(t,DataType) && t.name === Tuple.name)
         return t
-    end
-    if d > params.MAX_TUPLE_DEPTH
+    elseif d > params.MAX_TUPLE_DEPTH
         return Tuple
     end
     p = map(x->limit_tuple_depth_(params,x,d+1), t.parameters)
@@ -850,6 +890,9 @@ end
 limit_tuple_type = (t::ANY, params::InferenceParams) -> limit_tuple_type_n(t, params.MAX_TUPLETYPE_LEN)
 
 function limit_tuple_type_n(t::ANY, lim::Int)
+    if isa(t,UnionAll)
+        return UnionAll(t.var, limit_tuple_type_n(t.body, lim))
+    end
     p = t.parameters
     n = length(p)
     if n > lim
@@ -872,18 +915,16 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
     # function, so we can still know that error() is always Bottom.
     # here I picked 4.
     argtype = limit_tuple_type(atype, sv.params)
-    argtypes = argtype.parameters
+    argtypes = unwrap_unionall(argtype).parameters
     ft = argtypes[1] # TODO: ccall jl_first_argument_datatype here
     isa(ft, DataType) || return Any # the function being called is unknown. can't properly handle this backedge right now
     isdefined(ft.name, :mt) || return Any # not callable. should be Bottom, but can't track this backedge right now
-    if ft.name === Type.name
+    if ft.name === _Type_name
         tname = ft.parameters[1]
         if isa(tname, TypeVar)
             tname = tname.ub
         end
-        if isa(tname, TypeConstructor)
-            tname = tname.body
-        end
+        tname = unwrap_unionall(tname)
         if !isa(tname, DataType)
             # can't track the backedge to the ctor right now
             # for things like Union
@@ -901,7 +942,8 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
     x::Array{Any,1} = applicable
     fullmatch = false
     for (m::SimpleVector) in x
-        sig = m[1]::DataType
+        sig = m[1]
+        sigtuple = unwrap_unionall(sig)::DataType
         method = m[3]::Method
         sparams = m[2]::SimpleVector
         recomputesvec = false
@@ -912,7 +954,7 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
         # limit argument type tuple growth
         msig = unwrap_unionall(m[3].sig)
         lsig = length(msig.parameters)
-        ls = length(sig.parameters)
+        ls = length(sigtuple.parameters)
         td = type_depth(sig)
         # look at the existing edges to detect growing argument lists
         mightlimitlength = ls > lsig + 1
@@ -922,7 +964,7 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
         if mightlimitlength
             for (callee, _) in sv.edges
                 callee = callee::InferenceState
-                if method === callee.linfo.def && ls > length(callee.linfo.specTypes.parameters)
+                if method === callee.linfo.def && ls > length(unwrap_unionall(callee.linfo.specTypes).parameters)
                     limitlength = true
                     break
                 end
@@ -936,17 +978,18 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
                 infstate === nothing && continue
                 infstate = infstate::InferenceState
                 if isdefined(infstate.linfo, :def) && method === infstate.linfo.def
-                    if mightlimitlength && ls > length(infstate.linfo.specTypes.parameters)
+                    if mightlimitlength && ls > length(unwrap_unionall(infstate.linfo.specTypes).parameters)
                         limitlength = true
                     end
                     if mightlimitdepth && td > type_depth(infstate.linfo.specTypes)
                         # impose limit if we recur and the argument types grow beyond MAX_TYPE_DEPTH
                         if td > MAX_TYPE_DEPTH
-                            sig = limit_type_depth(sig, 0, true, [])
+                            sig = limit_type_depth(sig, 0)
+                            sigtuple = unwrap_unionall(sig)
                             recomputesvec = true
                             break
                         else
-                            p1, p2 = sig.parameters, infstate.linfo.specTypes.parameters
+                            p1, p2 = sigtuple.parameters, unwrap_unionall(infstate.linfo.specTypes).parameters
                             if length(p2) == ls
                                 limitdepth = false
                                 newsig = Array{Any}(ls)
@@ -959,11 +1002,12 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
                                         newsig[i] = p1[i].name.wrapper
                                         limitdepth  = true
                                     else
-                                        newsig[i] = limit_type_depth(p1[i], 1, true, [])
+                                        newsig[i] = limit_type_depth(p1[i], 1)
                                     end
                                 end
                                 if limitdepth
-                                    sig = Tuple{newsig...}
+                                    sigtuple = Tuple{newsig...}
+                                    sig = rewrap_unionall(sigtuple, sig)
                                     recomputesvec = true
                                     break
                                 end
@@ -974,30 +1018,25 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
             end
         end
 
-#        # limit argument type size growth
-#        tdepth = type_depth(sig)
-#        if tdepth > MAX_TYPE_DEPTH
-#            sig = limit_type_depth(sig, 0, true, [])
-#        end
-
         # limit length based on size of definition signature.
         # for example, given function f(T, Any...), limit to 3 arguments
         # instead of the default (MAX_TUPLETYPE_LEN)
         if limitlength
             if !istopfunction(tm, f, :promote_typeof)
-                fst = sig.parameters[lsig + 1]
+                fst = sigtuple.parameters[lsig + 1]
                 allsame = true
                 # allow specializing on longer arglists if all the trailing
                 # arguments are the same, since there is no exponential
                 # blowup in this case.
                 for i = (lsig + 2):ls
-                    if sig.parameters[i] != fst
+                    if sigtuple.parameters[i] != fst
                         allsame = false
                         break
                     end
                 end
                 if !allsame
-                    sig = limit_tuple_type_n(sig, lsig + 1)
+                    sigtuple = limit_tuple_type_n(sigtuple, lsig + 1)
+                    sig = rewrap_unionall(sigtuple, sig)
                     recomputesvec = true
                 end
             end
@@ -1005,12 +1044,12 @@ function abstract_call_gf_by_type(f::ANY, atype::ANY, sv::InferenceState)
 
         # if sig changed, may need to recompute the sparams environment
         if recomputesvec && !isempty(sparams)
-            recomputed = ccall(:jl_type_intersection_env, Ref{SimpleVector}, (Any, Any, Any), sig, method.sig, method.tvars)
-            if !isa(recomputed[1], DataType) # probably Union{}
+            recomputed = ccall(:jl_type_intersection_env, Ref{SimpleVector}, (Any, Any), sig, method.sig)
+            sig = recomputed[1]
+            if !isa(unwrap_unionall(sig), DataType) # probably Union{}
                 rettype = Any
                 break
             end
-            sig = recomputed[1]::DataType
             sparams = recomputed[2]::SimpleVector
         end
         rt = typeinf_edge(method, sig, sparams, sv)
@@ -1063,10 +1102,10 @@ function precise_container_types(args, types, vtypes::VarTable, sv)
             end
         elseif isa(tti, Union)
             return nothing
-        elseif tti <: Tuple
+        elseif isa(tti,DataType) && tti <: Tuple
             if i == n
                 if isvatuple(tti) && length(tti.parameters) == 1
-                    result[i] = Any[Vararg{tti.parameters[1].parameters[1]}]
+                    result[i] = Any[Vararg{unwrapva(tti.parameters[1])}]
                 else
                     result[i] = tti.parameters
                 end
@@ -1107,8 +1146,8 @@ function pure_eval_call(f::ANY, argtypes::ANY, atype::ANY, vtypes::VarTable, sv:
         # NOTE: only considering calls to return_type without InferenceParams arg
         tt = argtypes[3]
         af = argtypes[2]
-        af_isconst = isa(af, Const) || isconstType(af, false)
-        if isconstType(tt, false) &&
+        af_isconst = isa(af, Const) || isconstType(af)
+        if isconstType(tt) &&
             (af_isconst || (isleaftype(af) &&
                             !(af <: Builtin) && !(af <: IntrinsicFunction)))
             af_argtype = tt.parameters[1]
@@ -1125,7 +1164,7 @@ function pure_eval_call(f::ANY, argtypes::ANY, atype::ANY, vtypes::VarTable, sv:
                 elseif isleaftype(rt) || isleaftype(af_argtype) || rt === Bottom
                     return Type{rt}
                 else
-                    return Type{TypeVar(:R, rt)}
+                    return Type{R} where R<:rt
                 end
             end
         end
@@ -1133,7 +1172,7 @@ function pure_eval_call(f::ANY, argtypes::ANY, atype::ANY, vtypes::VarTable, sv:
 
     for i = 2:length(argtypes)
         a = argtypes[i]
-        if !(isa(a,Const) || isconstType(a,false))
+        if !(isa(a,Const) || isconstType(a))
             return false
         end
     end
@@ -1163,6 +1202,17 @@ end
 
 argtypes_to_type(argtypes::Array{Any,1}) = Tuple{map(widenconst, argtypes)...}
 
+_Pair_name = nothing
+function Pair_name()
+    global _Pair_name
+    if _Pair_name === nothing
+        if isdefined(Main, :Base) && isdefined(Main.Base, :Pair)
+            _Pair_name = Main.Base.Pair.body.body.name
+        end
+    end
+    return _Pair_name
+end
+
 function abstract_call(f::ANY, fargs, argtypes::Vector{Any}, vtypes::VarTable, sv::InferenceState)
     if f === _apply
         length(fargs)>1 || return Any
@@ -1197,23 +1247,37 @@ function abstract_call(f::ANY, fargs, argtypes::Vector{Any}, vtypes::VarTable, s
             end
         end
         return Any
+    elseif f === UnionAll
+        if length(fargs) == 3 && isa(argtypes[2],Const)
+            if isType(argtypes[3])
+                body = argtypes[3].parameters[1]
+            elseif isa(argtypes[3],Const)
+                body = argtypes[3].val
+            else
+                return Any
+            end
+            try
+                return abstract_eval_constant(UnionAll(argtypes[2].val, body))
+            catch
+            end
+        end
+        return Any
     end
 
     tm = _topmod(sv)
     if length(argtypes)>2 && argtypes[3] ⊑ Int
         at2 = widenconst(argtypes[2])
         if (at2 <: Tuple ||
-            (isa(at2, DataType) && isdefined(Main, :Base) && isdefined(Main.Base, :Pair) &&
-             (at2::DataType).name === Main.Base.Pair.name))
+            (isa(at2, DataType) && (at2::DataType).name === Pair_name()))
             # allow tuple indexing functions to take advantage of constant
             # index arguments.
             if istopfunction(tm, f, :getindex)
-                return getfield_tfunc(argtypes[2], argtypes[3])[1]
+                return getfield_tfunc(argtypes[2], argtypes[3])
             elseif istopfunction(tm, f, :next)
-                t1 = getfield_tfunc(argtypes[2], argtypes[3])[1]
+                t1 = widenconst(getfield_tfunc(argtypes[2], argtypes[3]))
                 return t1===Bottom ? Bottom : Tuple{t1, Int}
             elseif istopfunction(tm, f, :indexed_next)
-                t1 = getfield_tfunc(argtypes[2], argtypes[3])[1]
+                t1 = widenconst(getfield_tfunc(argtypes[2], argtypes[3]))
                 return t1===Bottom ? Bottom : Tuple{t1, Int}
             end
         end
@@ -1299,12 +1363,7 @@ function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
     elseif e.head === :null
         t = Void
     elseif e.head === :new
-        t = abstract_eval(e.args[1], vtypes, sv)
-        if isType(t)
-            t = t.parameters[1]
-        else
-            t = Any
-        end
+        t = instanceof_tfunc(abstract_eval(e.args[1], vtypes, sv))
         for i = 2:length(e.args)
             abstract_eval(e.args[i], vtypes, sv)
         end
@@ -1321,7 +1380,7 @@ function abstract_eval(e::ANY, vtypes::VarTable, sv::InferenceState)
                 # if the tvar does not refer to anything more specific than Any,
                 # the static param might actually be an integer, symbol, etc.
                 if !(Any <: val.ub)
-                    t = Type{val}
+                    t = UnionAll(val, Type{val})
                 end
             else
                 t = abstract_eval_constant(val)
@@ -1356,8 +1415,9 @@ function abstract_eval_constant(x::ANY)
     if isa(x,Type)
         if x === Array
             return Type_Array
+        elseif !has_free_typevars(x)
+            return Type{x}
         end
-        return Type{x}
     end
     return Const(x)
 end
@@ -1415,19 +1475,17 @@ end
 function type_too_complex(t::ANY, d)
     if d > MAX_TYPE_DEPTH
         return true
-    end
-    if isa(t,Union)
+    elseif isa(t,Union)
         return type_too_complex(t.a, d+1) || type_too_complex(t.b, d+1)
-    elseif isa(t,DataType)
-        p = t.parameters
     elseif isa(t,TypeVar)
         return type_too_complex(t.lb,d+1) || type_too_complex(t.ub,d+1)
-    else
-        return false
-    end
-    for x in (p::SimpleVector)
-        if type_too_complex(x, d+1)
-            return true
+    elseif isa(t,UnionAll)
+        return type_too_complex(t.var, d) || type_too_complex(t.body, d)
+    elseif isa(t,DataType)
+        for x in (t.parameters)::SimpleVector
+            if type_too_complex(x, d+1)
+                return true
+            end
         end
     end
     return false
@@ -2250,7 +2308,7 @@ function optimize(me::InferenceState)
     end
     widen_all_consts!(me.src)
 
-    if isa(me.bestguess, Const) || isconstType(me.bestguess, true)
+    if isa(me.bestguess, Const) || isconstType(me.bestguess)
         me.const_ret = true
         ispure = me.src.pure
         if !ispure && length(me.src.code) < 10
@@ -2325,7 +2383,7 @@ function finish(me::InferenceState)
                 if isa(me.bestguess, Const)
                     inferred_const = (me.bestguess::Const).val
                 else
-                    @assert isconstType(me.bestguess, true)
+                    @assert isconstType(me.bestguess)
                     inferred_const = me.bestguess.parameters[1]
                 end
             else
@@ -2588,7 +2646,7 @@ function exprtype(x::ANY, src::CodeInfo, mod::Module)
 end
 
 # known affect-free calls (also effect-free)
-const _pure_builtins = Any[tuple, svec, fieldtype, apply_type, ===, isa, typeof]
+const _pure_builtins = Any[tuple, svec, fieldtype, apply_type, ===, isa, typeof, UnionAll]
 
 # known effect-free calls (might not be affect-free)
 const _pure_builtins_volatile = Any[getfield, arrayref]
@@ -2912,7 +2970,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     topmod = _topmod(sv)
     # special-case inliners for known pure functions that compute types
     if sv.params.inlining
-        if isconstType(e.typ,true)
+        if isconstType(e.typ)
             if (f === apply_type || f === fieldtype || f === typeof ||
                 istopfunction(topmod, f, :typejoin) ||
                 istopfunction(topmod, f, :promote_type))
@@ -3007,14 +3065,13 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
     else
         invoke_data = invoke_data::InvokeData
         method = invoke_data.entry.func
-        (metharg, methsp) = ccall(:jl_match_method, Ref{SimpleVector},
-                                  (Any, Any, Any),
-                                  atype_unlimited, method.sig, method.tvars)
+        (metharg, methsp) = ccall(:jl_match_method, Ref{SimpleVector}, (Any, Any),
+                                  atype_unlimited, method.sig)
         methsp = methsp::SimpleVector
     end
     # check whether call can be inlined to just a quoted constant value
     if isa(f, widenconst(ft)) && !method.isstaged && (method.source.pure || f === return_type)
-        if isconstType(e.typ,false)
+        if isconstType(e.typ)
             return inline_as_constant(e.typ.parameters[1], argexprs, sv,
                                       invoke_data)
         elseif isa(e.typ,Const)
@@ -3063,8 +3120,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
                 if length(atypes) > 2 && atypes[3] ⊑ Int
                     at2 = widenconst(atypes[2])
                     if (at2 <: Tuple ||
-                        (isa(at2, DataType) && isdefined(Main, :Base) && isdefined(Main.Base, :Pair) &&
-                         (at2::DataType).name === Main.Base.Pair.name))
+                        (isa(at2, DataType) && (at2::DataType).name === Pair_name()))
                         force_infer = true
                     end
                 end
@@ -3129,7 +3185,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
             if isa(frame.bestguess, Const)
                 inferred_const = (frame.bestguess::Const).val
             else
-                @assert isconstType(frame.bestguess, true)
+                @assert isconstType(frame.bestguess)
                 inferred_const = frame.bestguess.parameters[1]
             end
             return inline_as_constant(inferred_const, argexprs, sv, invoke_data)
@@ -3169,7 +3225,7 @@ function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::Inference
         end
     end
 
-    nm = length(metharg.parameters)
+    nm = length(unwrap_unionall(metharg).parameters)
 
     if !isa(ast, Array{Any,1})
         ast = ccall(:jl_uncompress_ast, Any, (Any, Any), method, ast)
@@ -3713,7 +3769,7 @@ function is_known_call_p(e::Expr, pred::ANY, src::CodeInfo, mod::Module)
         return false
     end
     f = exprtype(e.args[1], src, mod)
-    return isa(f, Const) && pred(f.val)
+    return (isa(f, Const) && pred(f.val)) || (isType(f) && pred(f.parameters[1]))
 end
 
 function delete_var!(src::CodeInfo, id, T)
diff --git a/base/interactiveutil.jl b/base/interactiveutil.jl
index 3f8c23825225a4..dc7c7b0b3879cb 100644
--- a/base/interactiveutil.jl
+++ b/base/interactiveutil.jl
@@ -517,11 +517,15 @@ excluding type `Any`.
 """
 function methodswith(t::Type, f::Function, showparents::Bool=false, meths = Method[])
     for d in methods(f)
-        if any(x -> (type_close_enough(x, t) ||
-                     (showparents ? (t <: x && (!isa(x,TypeVar) || x.ub != Any)) :
-                      (isa(x,TypeVar) && x.ub != Any && t == x.ub)) &&
-                     x != Any && x != ANY),
-               d.sig.parameters)
+        if any(function (x)
+                   let x = rewrap_unionall(x, d.sig)
+                       (type_close_enough(x, t) ||
+                        (showparents ? (t <: x && (!isa(x,TypeVar) || x.ub != Any)) :
+                         (isa(x,TypeVar) && x.ub != Any && t == x.ub)) &&
+                        x != Any && x != ANY)
+                   end
+               end,
+               unwrap_unionall(d.sig).parameters)
             push!(meths, d)
         end
     end
@@ -723,6 +727,10 @@ summarysize(obj; exclude = Union{Module,DataType,TypeName}) =
 
 summarysize(obj::Symbol, seen, excl) = 0
 
+function summarysize(obj::UnionAll, seen, excl)
+    return 2*sizeof(Int) + summarysize(obj.body, seen, excl) + summarysize(obj.var, seen, excl)
+end
+
 function summarysize(obj::DataType, seen, excl)
     key = pointer_from_objref(obj)
     haskey(seen, key) ? (return 0) : (seen[key] = true)
diff --git a/base/io.jl b/base/io.jl
index ec855c2a5e17bd..ca9336ca41bedb 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -113,7 +113,10 @@ flush(io::AbstractPipe) = flush(pipe_writer(io))
 read(io::AbstractPipe, byte::Type{UInt8}) = read(pipe_reader(io), byte)
 unsafe_read(io::AbstractPipe, p::Ptr{UInt8}, nb::UInt) = unsafe_read(pipe_reader(io), p, nb)
 read(io::AbstractPipe) = read(pipe_reader(io))
-readuntil{T<:AbstractPipe}(io::T, args...) = readuntil(pipe_reader(io), args...)
+readuntil(io::AbstractPipe, arg::UInt8)          = readuntil(pipe_reader(io), arg)
+readuntil(io::AbstractPipe, arg::Char)           = readuntil(pipe_reader(io), arg)
+readuntil(io::AbstractPipe, arg::AbstractString) = readuntil(pipe_reader(io), arg)
+readuntil(io::AbstractPipe, arg)                 = readuntil(pipe_reader(io), arg)
 readavailable(io::AbstractPipe) = readavailable(pipe_reader(io))
 
 isreadable(io::AbstractPipe) = isreadable(pipe_reader(io))
diff --git a/base/linalg/bunchkaufman.jl b/base/linalg/bunchkaufman.jl
index 316cebffbe9aea..ac155f1c3ed5fa 100644
--- a/base/linalg/bunchkaufman.jl
+++ b/base/linalg/bunchkaufman.jl
@@ -80,6 +80,7 @@ bkfact{T}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issymmetric(A),
 convert{T}(::Type{BunchKaufman{T}}, B::BunchKaufman{T}) = B
 convert{T}(::Type{BunchKaufman{T}}, B::BunchKaufman) =
     BunchKaufman(convert(Matrix{T}, B.LD), B.ipiv, B.uplo, B.symmetric, B.rook, B.info)
+convert{T}(::Type{Factorization{T}}, B::BunchKaufman{T}) = B
 convert{T}(::Type{Factorization{T}}, B::BunchKaufman) = convert(BunchKaufman{T}, B)
 
 size(B::BunchKaufman) = size(B.LD)
diff --git a/base/linalg/cholesky.jl b/base/linalg/cholesky.jl
index 05392abb17451a..f01d07d9f2fa90 100644
--- a/base/linalg/cholesky.jl
+++ b/base/linalg/cholesky.jl
@@ -395,9 +395,12 @@ function convert{T,S}(::Type{Cholesky{T,S}}, C::Cholesky)
     Cnew = convert(AbstractMatrix{T}, C.factors)
     Cholesky{T, typeof(Cnew)}(Cnew, C.uplo)
 end
+convert{T}(::Type{Factorization{T}}, C::Cholesky{T}) = C
 convert{T}(::Type{Factorization{T}}, C::Cholesky) = convert(Cholesky{T}, C)
+convert{T}(::Type{CholeskyPivoted{T}},C::CholeskyPivoted{T}) = C
 convert{T}(::Type{CholeskyPivoted{T}},C::CholeskyPivoted) =
     CholeskyPivoted(AbstractMatrix{T}(C.factors),C.uplo,C.piv,C.rank,C.tol,C.info)
+convert{T}(::Type{Factorization{T}}, C::CholeskyPivoted{T}) = C
 convert{T}(::Type{Factorization{T}}, C::CholeskyPivoted) = convert(CholeskyPivoted{T}, C)
 
 convert(::Type{AbstractMatrix}, C::Cholesky) = C.uplo == 'U' ? C[:U]'C[:U] : C[:L]*C[:L]'
diff --git a/base/linalg/ldlt.jl b/base/linalg/ldlt.jl
index 4d2c5b79fe8f78..27989efb184363 100644
--- a/base/linalg/ldlt.jl
+++ b/base/linalg/ldlt.jl
@@ -12,6 +12,7 @@ convert{T,S}(::Type{LDLt{T,S}}, F::LDLt) = LDLt{T,S}(convert(S, F.data))
 #       to avoid an ambiguity warning (see issue #6383)
 convert{T,S,U<:AbstractMatrix}(::Type{LDLt{T}}, F::LDLt{S,U}) = convert(LDLt{T,U}, F)
 
+convert{T}(::Type{Factorization{T}}, F::LDLt{T}) = F
 convert{T,S,U}(::Type{Factorization{T}}, F::LDLt{S,U}) = convert(LDLt{T,U}, F)
 
 # SymTridiagonal
diff --git a/base/linalg/lq.jl b/base/linalg/lq.jl
index 016394c091d52f..81d06d2d6cd4d6 100644
--- a/base/linalg/lq.jl
+++ b/base/linalg/lq.jl
@@ -48,6 +48,7 @@ end
 copy(A::LQ) = LQ(copy(A.factors), copy(A.τ))
 
 convert{T}(::Type{LQ{T}},A::LQ) = LQ(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ))
+convert{T}(::Type{Factorization{T}}, A::LQ{T}) = A
 convert{T}(::Type{Factorization{T}}, A::LQ) = convert(LQ{T}, A)
 convert(::Type{AbstractMatrix}, A::LQ) = A[:L]*A[:Q]
 convert(::Type{AbstractArray}, A::LQ) = convert(AbstractMatrix, A)
diff --git a/base/linalg/lu.jl b/base/linalg/lu.jl
index fab9618078f3a8..571949c5204808 100644
--- a/base/linalg/lu.jl
+++ b/base/linalg/lu.jl
@@ -196,6 +196,7 @@ function convert{T}(::Type{LU{T}}, F::LU)
     LU{T,typeof(M)}(M, F.ipiv, F.info)
 end
 convert{T,S}(::Type{LU{T,S}}, F::LU) = LU{T,S}(convert(S, F.factors), F.ipiv, F.info)
+convert{T}(::Type{Factorization{T}}, F::LU{T}) = F
 convert{T}(::Type{Factorization{T}}, F::LU) = convert(LU{T}, F)
 
 
diff --git a/base/linalg/qr.jl b/base/linalg/qr.jl
index 0e53bf65722193..5a866bcc32abf1 100644
--- a/base/linalg/qr.jl
+++ b/base/linalg/qr.jl
@@ -252,8 +252,10 @@ end
 
 # Conversions
 convert{T}(::Type{QR{T}}, A::QR) = QR(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ))
+convert{T}(::Type{Factorization{T}}, A::QR{T}) = A
 convert{T}(::Type{Factorization{T}}, A::QR) = convert(QR{T}, A)
 convert{T}(::Type{QRCompactWY{T}}, A::QRCompactWY) = QRCompactWY(convert(AbstractMatrix{T}, A.factors), convert(AbstractMatrix{T}, A.T))
+convert{T}(::Type{Factorization{T}}, A::QRCompactWY{T}) = A
 convert{T}(::Type{Factorization{T}}, A::QRCompactWY) = convert(QRCompactWY{T}, A)
 convert(::Type{AbstractMatrix}, F::Union{QR,QRCompactWY}) = F[:Q] * F[:R]
 convert(::Type{AbstractArray}, F::Union{QR,QRCompactWY}) = convert(AbstractMatrix, F)
@@ -261,6 +263,7 @@ convert(::Type{Matrix}, F::Union{QR,QRCompactWY}) = convert(Array, convert(Abstr
 convert(::Type{Array}, F::Union{QR,QRCompactWY}) = convert(Matrix, F)
 full(F::Union{QR,QRCompactWY}) = convert(AbstractArray, F)
 convert{T}(::Type{QRPivoted{T}}, A::QRPivoted) = QRPivoted(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ), A.jpvt)
+convert{T}(::Type{Factorization{T}}, A::QRPivoted{T}) = A
 convert{T}(::Type{Factorization{T}}, A::QRPivoted) = convert(QRPivoted{T}, A)
 convert(::Type{AbstractMatrix}, F::QRPivoted) = (F[:Q] * F[:R])[:,invperm(F[:p])]
 convert(::Type{AbstractArray}, F::QRPivoted) = convert(AbstractMatrix, F)
@@ -328,8 +331,10 @@ end
 QRCompactWYQ{S}(factors::AbstractMatrix{S}, T::Matrix{S}) = QRCompactWYQ{S,typeof(factors)}(factors, T)
 
 convert{T}(::Type{QRPackedQ{T}}, Q::QRPackedQ) = QRPackedQ(convert(AbstractMatrix{T}, Q.factors), convert(Vector{T}, Q.τ))
+convert{T}(::Type{AbstractMatrix{T}}, Q::QRPackedQ{T}) = Q
 convert{T}(::Type{AbstractMatrix{T}}, Q::QRPackedQ) = convert(QRPackedQ{T}, Q)
 convert{S}(::Type{QRCompactWYQ{S}}, Q::QRCompactWYQ) = QRCompactWYQ(convert(AbstractMatrix{S}, Q.factors), convert(AbstractMatrix{S}, Q.T))
+convert{S}(::Type{AbstractMatrix{S}}, Q::QRCompactWYQ{S}) = Q
 convert{S}(::Type{AbstractMatrix{S}}, Q::QRCompactWYQ) = convert(QRCompactWYQ{S}, Q)
 convert{T}(::Type{Matrix}, A::Union{QRPackedQ{T},QRCompactWYQ{T}}) = A_mul_B!(A, eye(T, size(A.factors, 1), minimum(size(A.factors))))
 convert(::Type{Array}, A::Union{QRPackedQ,QRCompactWYQ}) = convert(Matrix, A)
diff --git a/base/linalg/rowvector.jl b/base/linalg/rowvector.jl
index a87adf0be459a6..0ee1aeb1ba7032 100644
--- a/base/linalg/rowvector.jl
+++ b/base/linalg/rowvector.jl
@@ -87,7 +87,8 @@ parent(rowvec::RowVector) = rowvec.vec
 @inline size(rowvec::RowVector, d) = ifelse(d==2, length(rowvec.vec), 1)
 @inline indices(rowvec::RowVector) = (Base.OneTo(1), indices(rowvec.vec)[1])
 @inline indices(rowvec::RowVector, d) = ifelse(d == 2, indices(rowvec.vec)[1], Base.OneTo(1))
-linearindexing{V<:RowVector}(::Union{V,Type{V}}) = LinearFast()
+linearindexing(::RowVector) = LinearFast()
+linearindexing{V<:RowVector}(::Type{V}) = LinearFast()
 
 @propagate_inbounds getindex(rowvec::RowVector, i) = transpose(rowvec.vec[i])
 @propagate_inbounds setindex!(rowvec::RowVector, v, i) = setindex!(rowvec.vec, transpose(v), i)
diff --git a/base/linalg/triangular.jl b/base/linalg/triangular.jl
index 3af8ab2dc2b85f..44fd957f4ae8bd 100644
--- a/base/linalg/triangular.jl
+++ b/base/linalg/triangular.jl
@@ -26,7 +26,8 @@ for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular,
             Anew = convert(AbstractMatrix{Tnew}, A.data)
             $t(Anew)
         end
-        convert{Tnew,Told,S}(::Type{AbstractMatrix{Tnew}}, A::$t{Told,S}) = convert($t{Tnew}, A)
+        convert{Tnew     }(::Type{AbstractMatrix{Tnew}}, A::$t{Tnew}) = A
+        convert{Tnew,Told}(::Type{AbstractMatrix{Tnew}}, A::$t{Told}) = convert($t{Tnew}, A)
         convert{T,S}(::Type{Matrix}, A::$t{T,S}) = convert(Matrix{T}, A)
 
         function similar{T,S,Tnew}(A::$t{T,S}, ::Type{Tnew})
diff --git a/base/markdown/Julia/interp.jl b/base/markdown/Julia/interp.jl
index 3befec1f6953cd..26be8e4a180a48 100644
--- a/base/markdown/Julia/interp.jl
+++ b/base/markdown/Julia/interp.jl
@@ -43,6 +43,6 @@ toexpr(xs::Vector{Any}) = Expr(:call, GlobalRef(Base,:vector_any), map(toexpr, x
 
 for T in Any[MD, Paragraph, Header, Link, Bold, Italic]
     @eval function toexpr(md::$T)
-        Expr(:call, typeof(md), $(map(x->:(toexpr(md.$x)), fieldnames(T))...))
+        Expr(:call, typeof(md), $(map(x->:(toexpr(md.$x)), fieldnames(Base.unwrap_unionall(T)))...))
     end
 end
diff --git a/base/methodshow.jl b/base/methodshow.jl
index c4d9ce62a75410..473a8b50239d11 100644
--- a/base/methodshow.jl
+++ b/base/methodshow.jl
@@ -67,7 +67,7 @@ function arg_decl_parts(m::Method)
 end
 
 function kwarg_decl(m::Method, kwtype::DataType)
-    sig = Tuple{kwtype, Core.AnyVector, unwrap_unionall(m.sig).parameters...}
+    sig = rewrap_unionall(Tuple{kwtype, Core.AnyVector, unwrap_unionall(m.sig).parameters...}, m.sig)
     kwli = ccall(:jl_methtable_lookup, Any, (Any, Any, UInt), kwtype.name.mt, sig, max_world(m))
     if kwli !== nothing
         kwli = kwli::Method
diff --git a/base/mpfr.jl b/base/mpfr.jl
index 8349bdc8ab8f71..20397a09f3a38c 100644
--- a/base/mpfr.jl
+++ b/base/mpfr.jl
@@ -225,6 +225,10 @@ function convert(::Type{BigInt},x::BigFloat)
     trunc(BigInt,x)
 end
 
+function convert(::Type{Integer},x::BigFloat)
+    isinteger(x) || throw(InexactError())
+    trunc(Integer,x)
+end
 function convert{T<:Integer}(::Type{T},x::BigFloat)
     isinteger(x) || throw(InexactError())
     trunc(T,x)
diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index b49d0d72e77e98..647c236d083b81 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -157,9 +157,9 @@ module IteratorsMD
     @inline split{N}(t, V::Type{Val{N}}) = _split((), t, V)
     @inline _split(tN, trest, V) = _split((tN..., trest[1]), tail(trest), V)
     # exit either when we've exhausted the input tuple or when tN has length N
-    @inline _split{N}(tN::NTuple{N}, ::Tuple{}, ::Type{Val{N}}) = tN, ()  # ambig.
-    @inline _split{N}(tN,            ::Tuple{}, ::Type{Val{N}}) = tN, ()
-    @inline _split{N}(tN::NTuple{N},  trest,    ::Type{Val{N}}) = tN, trest
+    @inline _split{N}(tN::NTuple{N,Any}, ::Tuple{}, ::Type{Val{N}}) = tN, ()  # ambig.
+    @inline _split{N}(tN,                ::Tuple{}, ::Type{Val{N}}) = tN, ()
+    @inline _split{N}(tN::NTuple{N,Any},  trest,    ::Type{Val{N}}) = tN, trest
 end  # IteratorsMD
 
 
@@ -375,8 +375,8 @@ end
 _maybe_reshape(::LinearFast, A::AbstractArray, I...) = A
 _maybe_reshape(::LinearSlow, A::AbstractVector, I...) = A
 @inline _maybe_reshape(::LinearSlow, A::AbstractArray, I...) = __maybe_reshape(A, index_ndims(I...))
-@inline __maybe_reshape{T,N}(A::AbstractArray{T,N}, ::NTuple{N}) = A
-@inline __maybe_reshape{N}(A::AbstractArray, ::NTuple{N}) = reshape(A, Val{N})
+@inline __maybe_reshape{T,N}(A::AbstractArray{T,N}, ::NTuple{N,Any}) = A
+@inline __maybe_reshape{N}(A::AbstractArray, ::NTuple{N,Any}) = reshape(A, Val{N})
 
 @generated function _unsafe_getindex(::LinearIndexing, A::AbstractArray, I::Union{Real, AbstractArray}...)
     N = length(I)
diff --git a/base/nullable.jl b/base/nullable.jl
index de44f2eba97b51..b8a08d56868444 100644
--- a/base/nullable.jl
+++ b/base/nullable.jl
@@ -45,6 +45,7 @@ function convert{T}(::Type{Nullable{T}}, x::Nullable)
     return isnull(x) ? Nullable{T}() : Nullable{T}(convert(T, get(x)))
 end
 
+convert{T<:Nullable}(::Type{Nullable{T}}, x::T) = Nullable{T}(x)
 convert{T}(::Type{Nullable{T}}, x::T) = Nullable{T}(x)
 convert{T}(::Type{Nullable   }, x::T) = Nullable{T}(x)
 
diff --git a/base/operators.jl b/base/operators.jl
index 80b0cd27547c54..0df0d48e82c8f3 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -23,7 +23,15 @@ julia> supertype(Int32)
 Signed
 ```
 """
-supertype(T::DataType) = T.super
+function supertype(T::DataType)
+    @_pure_meta
+    T.super
+end
+
+function supertype(T::UnionAll)
+    @_pure_meta
+    UnionAll(T.var, supertype(T.body))
+end
 
 ## generic comparison ##
 
diff --git a/base/permuteddimsarray.jl b/base/permuteddimsarray.jl
index 286703b07f7947..29c71822c6a89d 100644
--- a/base/permuteddimsarray.jl
+++ b/base/permuteddimsarray.jl
@@ -38,7 +38,7 @@ end
 end
 
 # For some reason this is faster than ntuple(d->I[perm[d]], Val{N}) (#15276?)
-@inline genperm{N}(I::NTuple{N}, perm::Dims{N}) = _genperm((), I, perm...)
+@inline genperm{N}(I::NTuple{N,Any}, perm::Dims{N}) = _genperm((), I, perm...)
 _genperm(out, I) = out
 @inline _genperm(out, I, p, perm...) = _genperm((out..., I[p]), I, perm...)
 @inline genperm(I, perm::AbstractVector{Int}) = genperm(I, (perm...,))
diff --git a/base/promotion.jl b/base/promotion.jl
index 4850113f01c52e..81c502c0eb9beb 100644
--- a/base/promotion.jl
+++ b/base/promotion.jl
@@ -11,22 +11,19 @@ function typejoin(a::ANY, b::ANY)
         return b
     elseif b <: a
         return a
-    end
-    if isa(a,UnionAll); a = a.body; end
-    if isa(b,UnionAll); b = b.body; end
-    if isa(a,TypeVar)
+    elseif isa(a,UnionAll)
+        return UnionAll(a.var, typejoin(a.body, b))
+    elseif isa(b,UnionAll)
+        return UnionAll(b.var, typejoin(a, b.body))
+    elseif isa(a,TypeVar)
         return typejoin(a.ub, b)
-    end
-    if isa(b,TypeVar)
+    elseif isa(b,TypeVar)
         return typejoin(a, b.ub)
-    end
-    if isa(a,Union)
+    elseif isa(a,Union)
         return typejoin(typejoin(a.a,a.b), b)
-    end
-    if isa(b,Union)
+    elseif isa(b,Union)
         return typejoin(a, typejoin(b.a,b.b))
-    end
-    if a <: Tuple
+    elseif a <: Tuple
         if !(b <: Tuple)
             return Any
         end
@@ -40,7 +37,7 @@ function typejoin(a::ANY, b::ANY)
         if laf < lbf
             if isvarargtype(ap[lar]) && !afixed
                 c = Vector{Any}(laf)
-                c[laf] = Vararg{typejoin(ap[lar].parameters[1], tailjoin(bp,laf))}
+                c[laf] = Vararg{typejoin(unwrapva(ap[lar]), tailjoin(bp,laf))}
                 n = laf-1
             else
                 c = Vector{Any}(laf+1)
@@ -50,7 +47,7 @@ function typejoin(a::ANY, b::ANY)
         elseif lbf < laf
             if isvarargtype(bp[lbr]) && !bfixed
                 c = Vector{Any}(lbf)
-                c[lbf] = Vararg{typejoin(bp[lbr].parameters[1], tailjoin(ap,lbf))}
+                c[lbf] = Vararg{typejoin(unwrapva(bp[lbr]), tailjoin(ap,lbf))}
                 n = lbf-1
             else
                 c = Vector{Any}(lbf+1)
@@ -90,7 +87,7 @@ function typejoin(a::ANY, b::ANY)
                     p[i] = aprimary.parameters[i]
                 end
             end
-            return a.name.wrapper{p...}
+            return rewrap_unionall(a.name.wrapper{p...}, a.name.wrapper)
         end
         b = supertype(b)
     end
@@ -100,8 +97,9 @@ end
 # Returns length, isfixed
 function full_va_len(p)
     isempty(p) && return 0, true
-    if isvarargtype(p[end])
-        N = p[end].parameters[2]
+    last = p[end]
+    if isvarargtype(last)
+        N = unwrap_unionall(last).parameters[2]
         if isa(N, Integer)
             return (length(p) + N - 1)::Int, true
         end
diff --git a/base/rational.jl b/base/rational.jl
index b826d3c367dfa6..82ac9631071f79 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -68,6 +68,7 @@ convert(::Type{Rational}, x::Rational) = x
 convert(::Type{Rational}, x::Integer) = convert(Rational{typeof(x)},x)
 
 convert(::Type{Bool}, x::Rational) = x==0 ? false : x==1 ? true : throw(InexactError()) # to resolve ambiguity
+convert(::Type{Integer}, x::Rational) = (isinteger(x) ? convert(Integer, x.num) : throw(InexactError()))
 convert{T<:Integer}(::Type{T}, x::Rational) = (isinteger(x) ? convert(T, x.num) : throw(InexactError()))
 
 convert(::Type{AbstractFloat}, x::Rational) = float(x.num)/float(x.den)
diff --git a/base/reflection.jl b/base/reflection.jl
index 49bfa092df172b..932157fb56ee02 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -117,6 +117,7 @@ julia> fieldname(SparseMatrixCSC,5)
 ```
 """
 fieldname(t::DataType, i::Integer) = t.name.names[i]::Symbol
+fieldname(t::UnionAll, i::Integer) = fieldname(unwrap_unionall(t), i)
 fieldname{T<:Tuple}(t::Type{T}, i::Integer) = i < 1 || i > nfields(t) ? throw(BoundsError(t, i)) : Int(i)
 
 """
@@ -139,6 +140,7 @@ function fieldnames(v)
     return fieldnames(t)
 end
 fieldnames(t::DataType) = Symbol[fieldname(t, n) for n in 1:nfields(t)]
+fieldnames(t::UnionAll) = fieldnames(unwrap_unionall(t))
 fieldnames{T<:Tuple}(t::Type{T}) = Int[n for n in 1:nfields(t)]
 
 """
@@ -273,6 +275,16 @@ Determine the declared type of a field (specified by name or index) in a composi
 """
 fieldtype
 
+"""
+    fieldindex(T, name::Symbol, err:Bool=true)
+
+Get the index of a named field, throwing an error if the field does not exist (when err==true)
+or returning 0 (when err==false).
+"""
+function fieldindex(T::DataType, name::Symbol, err::Bool=true)
+    return Int(ccall(:jl_field_index, Cint, (Any, Any, Cint), T, name, err)+1)
+end
+
 type_alignment(x::DataType) = (@_pure_meta; ccall(:jl_get_alignment, Csize_t, (Any,), x))
 
 # return all instances, for types that can be enumerated
@@ -369,7 +381,7 @@ function _methods_by_ftype(t::ANY, lim::Int, world::UInt)
     return _methods_by_ftype(t, lim, world, UInt[typemin(UInt)], UInt[typemax(UInt)])
 end
 function _methods_by_ftype(t::ANY, lim::Int, world::UInt, min::Array{UInt,1}, max::Array{UInt,1})
-    tp = t.parameters::SimpleVector
+    tp = unwrap_unionall(t).parameters::SimpleVector
     nu = 1
     for ti in tp
         if isa(ti, Union)
@@ -377,16 +389,18 @@ function _methods_by_ftype(t::ANY, lim::Int, world::UInt, min::Array{UInt,1}, ma
         end
     end
     if 1 < nu <= 64
-        return _methods_by_ftype(Any[tp...], length(tp), lim, [], world, min, max)
+        return _methods_by_ftype(Any[tp...], t, length(tp), lim, [], world, min, max)
     end
     # XXX: the following can return incorrect answers that the above branch would have corrected
     return ccall(:jl_matching_methods, Any, (Any, Cint, Cint, UInt, Ptr{UInt}, Ptr{UInt}), t, lim, 0, world, min, max)
 end
 
-function _methods_by_ftype(t::Array, i, lim::Integer, matching::Array{Any,1}, world::UInt, min::Array{UInt,1}, max::Array{UInt,1})
+function _methods_by_ftype(t::Array, origt::ANY, i, lim::Integer, matching::Array{Any,1},
+                           world::UInt, min::Array{UInt,1}, max::Array{UInt,1})
     if i == 0
         world = typemax(UInt)
-        new = ccall(:jl_matching_methods, Any, (Any, Cint, Cint, UInt, Ptr{UInt}, Ptr{UInt}), Tuple{t...}, lim, 0, world, min, max)
+        new = ccall(:jl_matching_methods, Any, (Any, Cint, Cint, UInt, Ptr{UInt}, Ptr{UInt}),
+                    rewrap_unionall(Tuple{t...}, origt), lim, 0, world, min, max)
         new === false && return false
         append!(matching, new::Array{Any,1})
     else
@@ -394,14 +408,14 @@ function _methods_by_ftype(t::Array, i, lim::Integer, matching::Array{Any,1}, wo
         if isa(ti, Union)
             for ty in uniontypes(ti::Union)
                 t[i] = ty
-                if _methods_by_ftype(t, i - 1, lim, matching, world, min, max) === false
+                if _methods_by_ftype(t, origt, i - 1, lim, matching, world, min, max) === false
                     t[i] = ti
                     return false
                 end
             end
             t[i] = ti
         else
-            return _methods_by_ftype(t, i - 1, lim, matching, world, min, max)
+            return _methods_by_ftype(t, origt, i - 1, lim, matching, world, min, max)
         end
     end
     return matching
@@ -559,8 +573,7 @@ function _dump_function(f::ANY, t::ANY, native::Bool, wrapper::Bool,
     t = to_tuple_type(t)
     ft = isa(f, Type) ? Type{f} : typeof(f)
     tt = Tuple{ft, t.parameters...}
-    (ti, env) = ccall(:jl_match_method, Any, (Any, Any, Any),
-                      tt, meth.sig, meth.tvars)::SimpleVector
+    (ti, env) = ccall(:jl_match_method, Any, (Any, Any), tt, meth.sig)::SimpleVector
     meth = func_for_method_checked(meth, tt)
     linfo = ccall(:jl_specializations_get_linfo, Ref{Core.MethodInstance}, (Any, Any, Any, UInt), meth, tt, env, world)
     # get the code for it
diff --git a/base/replutil.jl b/base/replutil.jl
index 0f0a5c75d5530a..57b24b99771a58 100644
--- a/base/replutil.jl
+++ b/base/replutil.jl
@@ -469,14 +469,15 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs::Vector=Any[])
                 # If isvarargtype then it checks whether the rest of the input arguments matches
                 # the varargtype
                 if Base.isvarargtype(sig[i])
-                    sigstr = string(sig[i].parameters[1], "...")
+                    sigstr = string(unwrap_unionall(sig[i]).parameters[1], "...")
                     j = length(t_i)
                 else
                     sigstr = string(sig[i])
                     j = i
                 end
                 # Checks if the type of arg 1:i of the input intersects with the current method
-                t_in = typeintersect(Tuple{sig[1:i]...}, Tuple{t_i[1:j]...})
+                t_in = typeintersect(rewrap_unionall(Tuple{sig[1:i]...}, method.sig),
+                                     rewrap_unionall(Tuple{t_i[1:j]...}, method.sig))
                 # If the function is one of the special cased then it should break the loop if
                 # the type of the first argument is not matched.
                 t_in === Union{} && special && i == 1 && break
@@ -503,7 +504,7 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs::Vector=Any[])
                 # It ensures that methods like f(a::AbstractString...) gets the correct
                 # number of right_matches
                 for t in arg_types_param[length(sig):end]
-                    if t <: sig[end].parameters[1]
+                    if t <: rewrap_unionall(unwrap_unionall(sig[end]).parameters[1], method.sig)
                         right_matches += 1
                     end
                 end
diff --git a/base/reshapedarray.jl b/base/reshapedarray.jl
index fa00f37b0001b7..78ccedda733b49 100644
--- a/base/reshapedarray.jl
+++ b/base/reshapedarray.jl
@@ -47,8 +47,8 @@ end
 # Move elements from inds to out until out reaches the desired
 # dimensionality N, either filling with OneTo(1) or collapsing the
 # product of trailing dims into the last element
-@pure rdims{N}(out::NTuple{N}, inds::Tuple{}, ::Type{Val{N}}) = out
-@pure function rdims{N}(out::NTuple{N}, inds::Tuple{Any, Vararg{Any}}, ::Type{Val{N}})
+@pure rdims{N}(out::NTuple{N,Any}, inds::Tuple{}, ::Type{Val{N}}) = out
+@pure function rdims{N}(out::NTuple{N,Any}, inds::Tuple{Any, Vararg{Any}}, ::Type{Val{N}})
     l = length(last(out)) * prod(map(length, inds))
     (front(out)..., OneTo(l))
 end
diff --git a/base/serialize.jl b/base/serialize.jl
index 09e4a7a204955f..f71aa4696ba87a 100644
--- a/base/serialize.jl
+++ b/base/serialize.jl
@@ -4,7 +4,7 @@ module Serializer
 
 import Base: GMP, Bottom, unsafe_convert, uncompressed_ast, datatype_pointerfree
 import Core: svec
-using Base: ViewIndex, Slice, index_lengths
+using Base: ViewIndex, Slice, index_lengths, unwrap_unionall
 
 export serialize, deserialize, SerializationState
 
@@ -24,14 +24,13 @@ SerializationState(io::IO) = SerializationState{typeof(io)}(io)
 const TAGS = Any[
     Symbol, Int8, UInt8, Int16, UInt16, Int32, UInt32,
     Int64, UInt64, Int128, UInt128, Float32, Float64, Char, Ptr,
-    DataType, Union, TypeName,
-    Tuple, Array, Expr,
+    DataType, Union, TypeName, Tuple, Array, Expr,
     #LongSymbol, LongTuple, LongExpr,
     Symbol, Tuple, Expr,  # dummy entries, intentionally shadowed by earlier ones
     LineNumberNode, Slot, LabelNode, GotoNode,
     QuoteNode, CodeInfo, TypeVar, Core.Box, Core.MethodInstance,
     Module, #=UndefRefTag=#Symbol, Task, String, Float16,
-    SimpleVector, #=BackrefTag=#Symbol, Method, GlobalRef,
+    SimpleVector, #=BackrefTag=#Symbol, Method, GlobalRef, UnionAll,
 
     (), Bool, Any, :Any, Bottom, Core.BottomType, :reserved22, Type,
     :Array, :TypeVar, :Box,
@@ -50,7 +49,7 @@ const TAGS = Any[
     28, 29, 30, 31, 32
 ]
 
-const ser_version = 4 # do not make changes without bumping the version #!
+const ser_version = 5 # do not make changes without bumping the version #!
 
 const NTAGS = length(TAGS)
 
@@ -745,11 +744,6 @@ function deserialize(s::AbstractSerializer, ::Type{GlobalRef})
     end
 end
 
-function deserialize(s::AbstractSerializer, ::Type{Union})
-    types = deserialize(s)
-    Union{types...}
-end
-
 module __deserialized_types__ end
 
 function deserialize(s::AbstractSerializer, ::Type{TypeName})
@@ -840,8 +834,7 @@ function deserialize_datatype(s::AbstractSerializer)
         mod = deserialize(s)::Module
         ty = getfield(mod,name)
     end
-    assert(isa(ty,DataType))
-    if isempty(ty.parameters)
+    if isa(ty,DataType) && isempty(ty.parameters)
         t = ty
     else
         params = deserialize(s)
diff --git a/base/sharedarray.jl b/base/sharedarray.jl
index 0eea70ecba2a38..c06d71a4242d3b 100644
--- a/base/sharedarray.jl
+++ b/base/sharedarray.jl
@@ -310,7 +310,8 @@ for each worker process.
 """
 localindexes(S::SharedArray) = S.pidx > 0 ? range_1dim(S, S.pidx) : 1:0
 
-unsafe_convert{T}(::Type{Ptr{T}}, S::SharedArray) = unsafe_convert(Ptr{T}, sdata(S))
+unsafe_convert{T}(::Type{Ptr{T}}, S::SharedArray{T}) = unsafe_convert(Ptr{T}, sdata(S))
+unsafe_convert{T}(::Type{Ptr{T}}, S::SharedArray   ) = unsafe_convert(Ptr{T}, sdata(S))
 
 function convert(::Type{SharedArray}, A::Array)
     S = SharedArray{eltype(A),ndims(A)}(size(A))
@@ -398,7 +399,7 @@ end
 function serialize(s::AbstractSerializer, S::SharedArray)
     serialize_cycle(s, S) && return
     serialize_type(s, typeof(S))
-    for n in SharedArray.name.names
+    for n in fieldnames(SharedArray)
         if n in [:s, :pidx, :loc_subarr_1d]
             writetag(s.io, UNDEFREF_TAG)
         elseif n == :refs
diff --git a/base/sparse/cholmod.jl b/base/sparse/cholmod.jl
index 3cf3c0fc4d331f..cec3776140e7c1 100644
--- a/base/sparse/cholmod.jl
+++ b/base/sparse/cholmod.jl
@@ -1007,6 +1007,9 @@ function convert{T}(::Type{Matrix{T}}, D::Dense{T})
 end
 
 Base.copy!(dest::Base.PermutedDimsArrays.PermutedDimsArray, src::Dense) = _copy!(dest, src) # ambig
+Base.copy!{T<:VTypes}(dest::Dense{T}, D::Dense{T}) = _copy!(dest, D)
+Base.copy!{T<:VTypes}(dest::AbstractArray{T}, D::Dense{T}) = _copy!(dest, D)
+Base.copy!{T<:VTypes}(dest::AbstractArray{T,2}, D::Dense{T}) = _copy!(dest, D)
 Base.copy!(dest::AbstractArray, D::Dense) = _copy!(dest, D)
 
 function _copy!(dest::AbstractArray, D::Dense)
@@ -1136,7 +1139,7 @@ sparse{Tv}(FC::FactorComponent{Tv,:LD}) = sparse(Sparse(Factor(FC)))
 
 # Calculate the offset into the stype field of the cholmod_sparse_struct and
 # change the value
-let offset = fieldoffset(C_Sparse{Float64}, findfirst(name -> name === :stype, fieldnames(C_Sparse)))
+let offset = fieldoffset(C_Sparse{Float64}, findfirst(name -> name === :stype, fieldnames(C_Sparse{Float64})))
     global change_stype!
     function change_stype!(A::Sparse, i::Integer)
         unsafe_store!(convert(Ptr{Cint}, A.p), i, div(offset, 4) + 1)
diff --git a/base/sparse/higherorderfns.jl b/base/sparse/higherorderfns.jl
index ba10c59cc3d1bb..c22edda0138a1a 100644
--- a/base/sparse/higherorderfns.jl
+++ b/base/sparse/higherorderfns.jl
@@ -63,8 +63,12 @@ end
 
 # (2) map[!] entry points
 map{Tf}(f::Tf, A::SparseVecOrMat) = _noshapecheck_map(f, A)
+map{Tf,N}(f::Tf, A::SparseMatrixCSC, Bs::Vararg{SparseMatrixCSC,N}) =
+    (_checksameshape(A, Bs...); _noshapecheck_map(f, A, Bs...))
 map{Tf,N}(f::Tf, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) =
     (_checksameshape(A, Bs...); _noshapecheck_map(f, A, Bs...))
+map!{Tf,N}(f::Tf, C::SparseMatrixCSC, A::SparseMatrixCSC, Bs::Vararg{SparseMatrixCSC,N}) =
+    (_checksameshape(C, A, Bs...); _noshapecheck_map!(f, C, A, Bs...))
 map!{Tf,N}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N}) =
     (_checksameshape(C, A, Bs...); _noshapecheck_map!(f, C, A, Bs...))
 function _noshapecheck_map!{Tf,N}(f::Tf, C::SparseVecOrMat, A::SparseVecOrMat, Bs::Vararg{SparseVecOrMat,N})
diff --git a/base/sparse/sparsematrix.jl b/base/sparse/sparsematrix.jl
index 932c45b6a68f44..2b2b82191dbaa1 100644
--- a/base/sparse/sparsematrix.jl
+++ b/base/sparse/sparsematrix.jl
@@ -293,7 +293,9 @@ similar{Tv,Ti,TvNew,TiNew}(S::SparseMatrixCSC{Tv,Ti}, ::Type{TvNew}, ::Type{TiNe
 @inline similar{Tv}(S::SparseMatrixCSC, ::Type{Tv}, d::Dims) = spzeros(Tv, d...)
 
 # convert'ing between SparseMatrixCSC types
+convert{Tv}(::Type{AbstractMatrix{Tv}}, A::SparseMatrixCSC{Tv}) = A
 convert{Tv}(::Type{AbstractMatrix{Tv}}, A::SparseMatrixCSC) = convert(SparseMatrixCSC{Tv}, A)
+convert{Tv}(::Type{SparseMatrixCSC{Tv}}, S::SparseMatrixCSC{Tv}) = S
 convert{Tv}(::Type{SparseMatrixCSC{Tv}}, S::SparseMatrixCSC) = convert(SparseMatrixCSC{Tv,eltype(S.colptr)}, S)
 convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, S::SparseMatrixCSC{Tv,Ti}) = S
 function convert{Tv,Ti}(::Type{SparseMatrixCSC{Tv,Ti}}, S::SparseMatrixCSC)
diff --git a/base/sparse/sparsevector.jl b/base/sparse/sparsevector.jl
index afe0f62a4be6dd..ef94ec75c4006d 100644
--- a/base/sparse/sparsevector.jl
+++ b/base/sparse/sparsevector.jl
@@ -298,6 +298,8 @@ convert{Tv}(::Type{SparseVector}, s::AbstractVector{Tv}) =
 
 
 # convert between different types of SparseVector
+convert{Tv}(::Type{SparseVector{Tv}}, s::SparseVector{Tv}) = s
+convert{Tv,Ti}(::Type{SparseVector{Tv,Ti}}, s::SparseVector{Tv,Ti}) = s
 convert{Tv,Ti,TvS,TiS}(::Type{SparseVector{Tv,Ti}}, s::SparseVector{TvS,TiS}) =
     SparseVector{Tv,Ti}(s.n, convert(Vector{Ti}, s.nzind), convert(Vector{Tv}, s.nzval))
 
@@ -903,7 +905,9 @@ promote_to_arrays_{T}(n::Int, ::Type{SparseMatrixCSC}, J::UniformScaling{T}) = s
 
 # Concatenations strictly involving un/annotated dense matrices/vectors should yield dense arrays
 cat(catdims, xs::_DenseConcatGroup...) = Base.cat_t(catdims, promote_eltype(xs...), xs...)
+vcat(A::Vector...) = Base.typed_vcat(promote_eltype(A...), A...)
 vcat(A::_DenseConcatGroup...) = Base.typed_vcat(promote_eltype(A...), A...)
+hcat(A::Vector...) = Base.typed_hcat(promote_eltype(A...), A...)
 hcat(A::_DenseConcatGroup...) = Base.typed_hcat(promote_eltype(A...), A...)
 hvcat(rows::Tuple{Vararg{Int}}, xs::_DenseConcatGroup...) = Base.typed_hvcat(promote_eltype(xs...), rows, xs...)
 # For performance, specially handle the case where the matrices/vectors have homogeneous eltype
diff --git a/base/subarray.jl b/base/subarray.jl
index 54af2bd3d2dc71..8079cafc1b1dd8 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -21,11 +21,11 @@ function SubArray(parent::AbstractArray, indexes::Tuple)
     @_inline_meta
     SubArray(linearindexing(viewindexing(indexes), linearindexing(parent)), parent, ensure_indexable(indexes), index_dimsum(indexes...))
 end
-function SubArray{P, I, N}(::LinearSlow, parent::P, indexes::I, ::NTuple{N})
+function SubArray{P, I, N}(::LinearSlow, parent::P, indexes::I, ::NTuple{N,Any})
     @_inline_meta
     SubArray{eltype(P), N, P, I, false}(parent, indexes, 0, 0)
 end
-function SubArray{P, I, N}(::LinearFast, parent::P, indexes::I, ::NTuple{N})
+function SubArray{P, I, N}(::LinearFast, parent::P, indexes::I, ::NTuple{N,Any})
     @_inline_meta
     # Compute the stride and offset
     stride1 = compute_stride1(parent, indexes)
@@ -74,6 +74,7 @@ parentindexes(a::AbstractArray) = ntuple(i->OneTo(size(a,i)), ndims(a))
 # ReshapedArray view if necessary. The trouble is that arrays of `CartesianIndex`
 # can make the number of effective indices not equal to length(I).
 _maybe_reshape_parent(A::AbstractArray, ::NTuple{1, Bool}) = reshape(A, Val{1})
+_maybe_reshape_parent{_}(A::AbstractArray{_,1}, ::NTuple{1, Bool}) = reshape(A, Val{1})
 _maybe_reshape_parent{_,N}(A::AbstractArray{_,N}, ::NTuple{N, Bool}) = A
 _maybe_reshape_parent{N}(A::AbstractArray, ::NTuple{N, Bool}) = reshape(A, Val{N}) # TODO: DEPRECATE FOR #14770
 """
@@ -214,7 +215,7 @@ substrides(s, parent, dim, I::Tuple{Any, Vararg{Any}}) = throw(ArgumentError("st
 
 stride(V::SubArray, d::Integer) = d <= ndims(V) ? strides(V)[d] : strides(V)[end] * size(V)[end]
 
-compute_stride1{N}(parent::AbstractArray, I::NTuple{N}) =
+compute_stride1{N}(parent::AbstractArray, I::NTuple{N,Any}) =
     (@_inline_meta; compute_stride1(1, fill_to_length(indices(parent), OneTo(1), Val{N}), I))
 compute_stride1(s, inds, I::Tuple{}) = s
 compute_stride1(s, inds, I::Tuple{ScalarIndex, Vararg{Any}}) =
@@ -247,7 +248,7 @@ compute_offset1(parent, stride1::Integer, dims::Tuple{Int}, inds::Tuple{Slice},
 compute_offset1(parent, stride1::Integer, dims, inds, I::Tuple) =
     (@_inline_meta; compute_linindex(parent, I) - stride1)  # linear indexing starts with 1
 
-function compute_linindex{N}(parent, I::NTuple{N})
+function compute_linindex{N}(parent, I::NTuple{N,Any})
     @_inline_meta
     IP = fill_to_length(indices(parent), OneTo(1), Val{N})
     compute_linindex(1, 1, IP, I)
diff --git a/base/sysimg.jl b/base/sysimg.jl
index 5695eb950671b3..d4035fcc410d31 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -23,7 +23,6 @@ eval(x) = Core.eval(Base, x)
 eval(m, x) = Core.eval(m, x)
 (::Type{T}){T}(arg) = convert(T, arg)::T
 (::Type{VecElement{T}}){T}(arg) = VecElement{T}(convert(T, arg))
-(::Type{Union{}})(arg) = error("cannot convert type ", typeof(arg), " to Union{}")
 convert{T<:VecElement}(::Type{T}, arg) = T(arg)
 convert{T<:VecElement}(::Type{T}, arg::T) = arg
 
diff --git a/base/tuple.jl b/base/tuple.jl
index 52507335f3da8b..05fdd8bd256a63 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -49,7 +49,7 @@ first(t::Tuple) = t[1]
 # eltype
 
 eltype(::Type{Tuple{}}) = Bottom
-eltype{T}(::Type{Tuple{Vararg{T}}}) = T
+eltype{E, T <: Tuple{Vararg{E}}}(::Type{T}) = E
 
 # version of tail that doesn't throw on empty tuples (used in array indexing)
 safe_tail(t::Tuple) = tail(t)
@@ -95,7 +95,7 @@ function ntuple{F,N}(f::F, ::Type{Val{N}})
 end
 
 # Build up the output until it has length N
-_ntuple{F,N}(out::NTuple{N}, f::F, ::Type{Val{N}}) = out
+_ntuple{F,N}(out::NTuple{N,Any}, f::F, ::Type{Val{N}}) = out
 function _ntuple{F,N,M}(out::NTuple{M}, f::F, ::Type{Val{N}})
     @_inline_meta
     _ntuple((out..., f(M+1)), f, Val{N})
@@ -145,8 +145,8 @@ map(f, t1::Tuple, t2::Tuple, ts::Tuple...) = (f(heads(t1, t2, ts...)...), map(f,
 
 # type-stable padding
 fill_to_length{N}(t::Tuple, val, ::Type{Val{N}}) = _ftl((), val, Val{N}, t...)
-_ftl{N}(out::NTuple{N}, val, ::Type{Val{N}}) = out
-function _ftl{N}(out::NTuple{N}, val, ::Type{Val{N}}, t...)
+_ftl{N}(out::NTuple{N,Any}, val, ::Type{Val{N}}) = out
+function _ftl{N}(out::NTuple{N,Any}, val, ::Type{Val{N}}, t...)
     @_inline_meta
     throw(ArgumentError("input tuple of length $(N+length(t)), requested $N"))
 end
diff --git a/base/weakkeydict.jl b/base/weakkeydict.jl
index 46ed3e5f3fc0a0..87a3c6ecb52cd0 100644
--- a/base/weakkeydict.jl
+++ b/base/weakkeydict.jl
@@ -48,7 +48,7 @@ copy(d::WeakKeyDict) = WeakKeyDict(d)
 
 WeakKeyDict{K,V}(ps::Pair{K,V}...)            = WeakKeyDict{K,V}(ps)
 WeakKeyDict{K  }(ps::Pair{K}...,)             = WeakKeyDict{K,Any}(ps)
-WeakKeyDict{V  }(ps::Pair{TypeVar(:K),V}...,) = WeakKeyDict{Any,V}(ps)
+WeakKeyDict{V  }(ps::(Pair{K,V} where K)...,) = WeakKeyDict{Any,V}(ps)
 WeakKeyDict(     ps::Pair...)                 = WeakKeyDict{Any,Any}(ps)
 
 function WeakKeyDict(kv)
diff --git a/src/alloc.c b/src/alloc.c
index 5709545e9f594a..6b931f0315eb33 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -478,7 +478,7 @@ STATIC_INLINE jl_value_t *jl_call_staged(jl_svec_t *sparam_vals, jl_method_insta
 JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo)
 {
     JL_TIMING(STAGED_FUNCTION);
-    jl_tupletype_t *tt = linfo->specTypes;
+    jl_tupletype_t *tt = (jl_tupletype_t*)linfo->specTypes;
     jl_svec_t *env = linfo->sparam_vals;
     size_t i, l;
     jl_expr_t *ex = NULL;
@@ -681,24 +681,19 @@ jl_method_t *jl_new_method(jl_code_info_t *definition,
     m->min_world = ++jl_world_counter;
     m->isstaged = isstaged;
     m->name = name;
-    m->sig = sig;
+    m->sig = (jl_value_t*)sig;
     m->isva = isva;
     m->nargs = nargs;
     if (jl_svec_len(tvars) == 1)
         m->tvars = (jl_svec_t*)jl_svecref(tvars, 0);
     else
         m->tvars = tvars;
-    int j;
-    for(j=(int)jl_svec_len(tvars)-1; j >= 0 ; j--) {
-        m->sig = jl_new_unionall_type((jl_tvar_t*)jl_svecref(tvars,j), m->sig);
-        jl_gc_wb(m, m->sig);
-    }
     m->sparam_syms = sparam_syms;
     root = (jl_value_t*)m;
     jl_method_set_source(m, definition);
     if (isstaged) {
         // create and store generator for generated functions
-        m->generator = jl_get_specialized(m, jl_anytuple_type, jl_emptysvec);
+        m->generator = jl_get_specialized(m, (jl_value_t*)jl_anytuple_type, jl_emptysvec);
         jl_gc_wb(m, m->generator);
         m->generator->inferred = (jl_value_t*)m->source;
     }
@@ -1170,7 +1165,7 @@ JL_DLLEXPORT jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super
         int i;
         int np = jl_svec_len(parameters);
         for (i=np-1; i >= 0; i--) {
-            t->name->wrapper = (jl_value_t*)jl_new_unionall_type((jl_tvar_t*)jl_svecref(parameters,i), t->name->wrapper);
+            t->name->wrapper = jl_new_struct(jl_unionall_type, jl_svecref(parameters,i), t->name->wrapper);
             jl_gc_wb(t->name, t->name->wrapper);
         }
     }
@@ -1207,23 +1202,6 @@ JL_DLLEXPORT jl_datatype_t *jl_new_bitstype(jl_value_t *name, jl_datatype_t *sup
     return bt;
 }
 
-// unionall types -------------------------------------------------------------
-
-JL_DLLEXPORT jl_tvar_t *jl_new_typevar(jl_sym_t *name, jl_value_t *lb, jl_value_t *ub)
-{
-    jl_ptls_t ptls = jl_get_ptls_states();
-    jl_tvar_t *tv = (jl_tvar_t*)jl_gc_alloc(ptls, sizeof(jl_tvar_t), jl_tvar_type);
-    tv->name = name;
-    tv->lb = lb;
-    tv->ub = ub;
-    return tv;
-}
-
-JL_DLLEXPORT jl_unionall_t *jl_new_unionall_type(jl_tvar_t *v, jl_value_t *body)
-{
-    return (jl_unionall_t*)jl_new_struct(jl_unionall_type, v, body);
-}
-
 // bits constructors ----------------------------------------------------------
 
 #define BOXN_FUNC(nb,nw)                                                \
diff --git a/src/builtins.c b/src/builtins.c
index 24fd5530b305fd..f051a7cd1bb1b5 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -768,27 +768,41 @@ JL_CALLABLE(jl_f_setfield)
     return args[2];
 }
 
-JL_CALLABLE(jl_f_fieldtype)
+static jl_value_t *get_fieldtype(jl_value_t *t, jl_value_t *f)
 {
-    JL_NARGS(fieldtype, 2, 2);
-    jl_datatype_t *st = (jl_datatype_t*)args[0];
-    if (st == jl_module_type)
-        jl_error("cannot assign variables in other modules");
+    if (jl_is_unionall(t)) {
+        jl_value_t *u = t;
+        JL_GC_PUSH1(&u);
+        u = get_fieldtype(((jl_unionall_t*)t)->body, f);
+        u = jl_type_unionall(((jl_unionall_t*)t)->var, u);
+        JL_GC_POP();
+        return u;
+    }
+    jl_datatype_t *st = (jl_datatype_t*)t;
     if (!jl_is_datatype(st))
         jl_type_error("fieldtype", (jl_value_t*)jl_datatype_type, (jl_value_t*)st);
     int field_index;
-    if (jl_is_long(args[1])) {
-        field_index = jl_unbox_long(args[1]) - 1;
+    if (jl_is_long(f)) {
+        field_index = jl_unbox_long(f) - 1;
         if (field_index < 0 || field_index >= jl_field_count(st))
-            jl_bounds_error(args[0], args[1]);
+            jl_bounds_error(t, f);
     }
     else {
-        JL_TYPECHK(fieldtype, symbol, args[1]);
-        field_index = jl_field_index(st, (jl_sym_t*)args[1], 1);
+        JL_TYPECHK(fieldtype, symbol, f);
+        field_index = jl_field_index(st, (jl_sym_t*)f, 1);
     }
     return jl_field_type(st, field_index);
 }
 
+JL_CALLABLE(jl_f_fieldtype)
+{
+    JL_NARGS(fieldtype, 2, 2);
+    jl_datatype_t *st = (jl_datatype_t*)args[0];
+    if (st == jl_module_type)
+        jl_error("cannot assign variables in other modules");
+    return get_fieldtype(args[0], args[1]);
+}
+
 JL_CALLABLE(jl_f_nfields)
 {
     JL_NARGS(nfields, 1, 1);
@@ -1321,7 +1335,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         n += jl_printf(out, "%s", jl_symbol_name(dv->name->name));
         if (dv->parameters && (jl_value_t*)dv != dv->name->wrapper &&
             (jl_has_free_typevars(v) ||
-             !jl_types_equal((jl_value_t*)dv, (jl_value_t*)jl_tuple_type))) {
+             (jl_value_t*)dv != (jl_value_t*)jl_tuple_type)) {
             size_t j, tlen = jl_nparams(dv);
             if (tlen > 0) {
                 n += jl_printf(out, "{");
@@ -1633,6 +1647,11 @@ JL_DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type)
     }
     // TODO: better way to show method parameters
     type = jl_unwrap_unionall(type);
+    if (!jl_is_datatype(type)) {
+        n += jl_printf(s, " ");
+        n += jl_static_show(s, type);
+        return n;
+    }
     size_t tl = jl_nparams(type);
     n += jl_printf(s, "(");
     size_t i;
diff --git a/src/ccall.cpp b/src/ccall.cpp
index 88528ee69b6ab2..f94926e7aa6fbc 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1731,7 +1731,7 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
         if (isVa && ai >= nargt - 1) {
             largty = fargt.at(nargt - 1);
             toboxed = fargt_isboxed.at(nargt - 1);
-            jargty = jl_tparam0(jl_svecref(tt, nargt - 1));
+            jargty = jl_unwrap_vararg(jl_svecref(tt, nargt - 1));
             byRef = byRefList.at(nargt - 1);
         }
         else {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index b3a9f90fb377ae..99ad403d0d896c 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -4270,6 +4270,7 @@ static std::unique_ptr<Module> emit_function(
             needsparams = true;
     }
     if (!va && ctx.nargs > 0 && !needsparams && lam->specTypes != (jl_value_t*)jl_anytuple_type && src->inferred) {
+        assert(jl_is_datatype(lam->specTypes));
         // not vararg, consider specialized signature
         for(size_t i=0; i < jl_nparams(lam->specTypes); i++) {
             if (isbits_spec(jl_tparam(lam->specTypes, i))) { // assumes !va
diff --git a/src/dump.c b/src/dump.c
index 3439f7169b7011..f17e5e60ef0614 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -482,7 +482,7 @@ static int type_in_worklist(jl_datatype_t *dt)
         return 1;
     int i, l = jl_svec_len(dt->parameters);
     for (i = 0; i < l; i++) {
-        jl_value_t *p = jl_tparam(dt, i);
+        jl_value_t *p = jl_unwrap_unionall(jl_tparam(dt, i));
         if (type_in_worklist((jl_datatype_t*)(jl_is_datatype(p) ? p : jl_typeof(p))))
             return 1;
     }
@@ -499,12 +499,13 @@ static int type_recursively_external(jl_datatype_t *dt)
 
     int i, l = jl_svec_len(dt->parameters);
     for (i = 0; i < l; i++) {
-        jl_datatype_t *p = (jl_datatype_t*)jl_tparam(dt, i);
+        jl_value_t *p0 = jl_tparam(dt, i);
+        jl_datatype_t *p = (jl_datatype_t*)jl_unwrap_unionall(p0);
         if (!jl_is_datatype(p))
             return 0;
         if (module_in_worklist(p->name->module))
             return 0;
-        if (jl_unwrap_unionall(p->name->wrapper) != (jl_value_t*)p) {
+        if (p->name->wrapper != p0) {
             if (!type_recursively_external(p))
                 return 0;
         }
@@ -559,7 +560,7 @@ static void jl_serialize_datatype(jl_serializer_state *s, jl_datatype_t *dt)
         assert(tag == 0 || tag == 5 || tag == 6 || tag == 10);
         if (tag == 6) {
             jl_methtable_t *mt = dt->name->mt;
-            jl_datatype_t *primarydt = (jl_datatype_t*)jl_get_global(mt->module, mt->name);
+            jl_datatype_t *primarydt = (jl_datatype_t*)jl_unwrap_unionall(jl_get_global(mt->module, mt->name));
             assert(jl_is_datatype(primarydt));
             assert(jl_typeof(primarydt->name->mt->kwsorter) == (jl_value_t*)dt);
             dt = primarydt;
@@ -600,13 +601,13 @@ static void jl_serialize_datatype(jl_serializer_state *s, jl_datatype_t *dt)
 
     if (has_layout) {
         uint8_t layout = 0;
-        if (dt->layout == ((jl_datatype_t*)jl_unwrap_unionall(jl_array_type))->layout) {
+        if (dt->layout == ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_array_type))->layout) {
             layout = 1;
         }
         else if (dt->layout == jl_void_type->layout) {
             layout = 2;
         }
-        else if (dt->layout == ((jl_datatype_t*)jl_unwrap_unionall(jl_pointer_type))->layout) {
+        else if (dt->layout == ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_pointer_type))->layout) {
             layout = 3;
         }
         write_uint8(s->s, layout);
@@ -1066,6 +1067,19 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
                         return;
                     }
                 }
+                if (t == jl_unionall_type) {
+                    jl_datatype_t *d = (jl_datatype_t*)jl_unwrap_unionall(v);
+                    if (jl_is_datatype(d) && d->name->wrapper == v &&
+                        !module_in_worklist(d->name->module)) {
+                        write_uint8(s->s, 1);
+                        jl_serialize_value(s, d->name->module);
+                        jl_serialize_value(s, d->name->name);
+                        return;
+                    }
+                    else {
+                        write_uint8(s->s, 0);
+                    }
+                }
                 if (t == jl_typemap_level_type) {
                     // perform some compression on the typemap levels
                     // (which will need to be rehashed during deserialization anyhow)
@@ -1176,9 +1190,10 @@ static void jl_serialize_lambdas_from_mod(jl_serializer_state *s, jl_module_t *m
         if (table[i] != HT_NOTFOUND) {
             jl_binding_t *b = (jl_binding_t*)table[i];
             if (b->owner == m && b->value && b->constp) {
-                if (jl_is_datatype(b->value)) {
-                    jl_typename_t *tn = ((jl_datatype_t*)b->value)->name;
-                    if (tn->module == m && tn->name == b->name) {
+                jl_value_t *bv = jl_unwrap_unionall(b->value);
+                if (jl_is_datatype(bv)) {
+                    jl_typename_t *tn = ((jl_datatype_t*)bv)->name;
+                    if (tn->module == m && tn->name == b->name && tn->wrapper == b->value) {
                         jl_methtable_t *mt = tn->mt;
                         if (mt != NULL &&
                                 (jl_value_t*)mt != jl_nothing &&
@@ -1393,13 +1408,13 @@ static jl_value_t *jl_deserialize_datatype(jl_serializer_state *s, int pos, jl_v
     if (has_layout) {
         uint8_t layout = read_uint8(s->s);
         if (layout == 1) {
-            dt->layout = ((jl_datatype_t*)jl_unwrap_unionall(jl_array_type))->layout;
+            dt->layout = ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_array_type))->layout;
         }
         else if (layout == 2) {
             dt->layout = jl_void_type->layout;
         }
         else if (layout == 3) {
-            dt->layout = ((jl_datatype_t*)jl_unwrap_unionall(jl_pointer_type))->layout;
+            dt->layout = ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_pointer_type))->layout;
         }
         else {
             assert(layout == 0);
@@ -1604,7 +1619,7 @@ static jl_value_t *jl_deserialize_value_method(jl_serializer_state *s, jl_value_
     uintptr_t pos = backref_list.len;
     if (usetable)
         arraylist_push(&backref_list, m);
-    m->sig = (jl_tupletype_t*)jl_deserialize_value(s, (jl_value_t**)&m->sig);
+    m->sig = (jl_value_t*)jl_deserialize_value(s, (jl_value_t**)&m->sig);
     jl_gc_wb(m, m->sig);
     if (s->mode == MODE_MODULE) {
         int internal = read_uint8(s->s);
@@ -1672,7 +1687,7 @@ static jl_value_t *jl_deserialize_value_method_instance(jl_serializer_state *s,
     if (usetable)
         arraylist_push(&backref_list, li);
 
-    li->specTypes = (jl_tupletype_t*)jl_deserialize_value(s, (jl_value_t**)&li->specTypes);
+    li->specTypes = (jl_value_t*)jl_deserialize_value(s, (jl_value_t**)&li->specTypes);
     if (li->specTypes)
         jl_gc_wb(li, li->specTypes);
     li->def = (jl_method_t*)jl_deserialize_value(s, (jl_value_t**)&li->def);
@@ -1912,7 +1927,7 @@ static jl_value_t *jl_deserialize_value_any(jl_serializer_state *s, jl_value_t *
         if (ref_only) {
             jl_module_t *m = (jl_module_t*)jl_deserialize_value(s, NULL);
             jl_sym_t *sym = (jl_sym_t*)jl_deserialize_value(s, NULL);
-            jl_datatype_t *dt = (jl_datatype_t*)jl_get_global(m, sym);
+            jl_datatype_t *dt = (jl_datatype_t*)jl_unwrap_unionall(jl_get_global(m, sym));
             assert(jl_is_datatype(dt));
             jl_value_t *v = (jl_value_t*)dt->name;
             if (usetable)
@@ -1920,6 +1935,18 @@ static jl_value_t *jl_deserialize_value_any(jl_serializer_state *s, jl_value_t *
             return v;
         }
     }
+    if (s->mode == MODE_MODULE && dt == jl_unionall_type) {
+        int ref_only = read_uint8(s->s);
+        if (ref_only) {
+            jl_module_t *m = (jl_module_t*)jl_deserialize_value(s, NULL);
+            jl_sym_t *sym = (jl_sym_t*)jl_deserialize_value(s, NULL);
+            jl_value_t *v = jl_get_global(m, sym);
+            assert(jl_is_unionall(v));
+            if (usetable)
+                backref_list.items[pos] = v;
+            return v;
+        }
+    }
     jl_set_typeof(v, dt);
     if (jl_datatype_nfields(dt) == 0 && jl_datatype_size(dt)>0) {
         int nby = jl_datatype_size(dt);
@@ -2823,7 +2850,7 @@ static void jl_update_backref_list(jl_value_t *old, jl_value_t *_new, size_t sta
 
 jl_method_t *jl_recache_method(jl_method_t *m, size_t start)
 {
-    jl_datatype_t *sig = m->sig;
+    jl_datatype_t *sig = (jl_datatype_t*)m->sig;
     jl_datatype_t *ftype = jl_first_argument_datatype((jl_value_t*)sig);
     jl_methtable_t *mt = ftype->name->mt;
     jl_set_typeof(m, (void*)(intptr_t)0x30); // invalidate the old value to help catch errors
@@ -2835,21 +2862,20 @@ jl_method_t *jl_recache_method(jl_method_t *m, size_t start)
 
 jl_method_instance_t *jl_recache_method_instance(jl_method_instance_t *li, size_t start)
 {
-    assert(jl_is_datatype(li->def));
     jl_datatype_t *sig = (jl_datatype_t*)li->def;
     jl_datatype_t *ftype = jl_first_argument_datatype((jl_value_t*)sig);
     jl_methtable_t *mt = ftype->name->mt;
     jl_method_t *m = (jl_method_t*)jl_methtable_lookup(mt, sig, /*TODO*/jl_world_counter);
     assert(m && jl_is_method(m));
 
-    jl_datatype_t *argtypes = li->specTypes;
+    jl_datatype_t *argtypes = (jl_datatype_t*)li->specTypes;
     jl_set_typeof(li, (void*)(intptr_t)0x40); // invalidate the old value to help catch errors
     jl_svec_t *env = jl_emptysvec;
-    jl_value_t *ti = jl_type_intersection_matching((jl_value_t*)m->sig, (jl_value_t*)argtypes, &env, m->tvars);
+    jl_value_t *ti = jl_type_intersection_matching((jl_value_t*)argtypes, (jl_value_t*)m->sig, &env);
     //assert(ti != jl_bottom_type); (void)ti;
     if (ti == jl_bottom_type)
         env = jl_emptysvec; // the intersection may fail now if the type system had made an incorrect subtype env in the past
-    jl_method_instance_t *_new = jl_specializations_get_linfo(m, argtypes, env, /*TODO*/jl_world_counter);
+    jl_method_instance_t *_new = jl_specializations_get_linfo(m, (jl_value_t*)argtypes, env, /*TODO*/jl_world_counter);
     jl_update_backref_list((jl_value_t*)li, (jl_value_t*)_new, start);
     return _new;
 }
@@ -3050,13 +3076,13 @@ void jl_init_serializer(void)
                      jl_array_symbol_type, jl_anytuple_type, jl_tparam0(jl_anytuple_type),
                      jl_typeof(jl_emptytuple), jl_array_uint8_type, jl_symbol_type->name,
                      jl_ssavalue_type->name, jl_tuple_typename, jl_code_info_type, jl_bottomtype_type,
-                     ((jl_datatype_t*)jl_unwrap_unionall(jl_ref_type))->name,
+                     ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_ref_type))->name,
                      jl_pointer_typename, jl_simplevector_type->name, jl_datatype_type->name,
                      jl_uniontype_type->name, jl_array_typename, jl_expr_type->name,
                      jl_typename_type->name, jl_type_typename, jl_methtable_type->name,
                      jl_typemap_level_type->name, jl_typemap_entry_type->name, jl_tvar_type->name,
-                     ((jl_datatype_t*)jl_unwrap_unionall(jl_abstractarray_type))->name,
-                     ((jl_datatype_t*)jl_unwrap_unionall(jl_densearray_type))->name,
+                     ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_abstractarray_type))->name,
+                     ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_densearray_type))->name,
                      jl_vararg_typename, jl_void_type->name, jl_method_instance_type->name, jl_method_type->name,
                      jl_module_type->name, jl_function_type->name, jl_typedslot_type->name,
                      jl_abstractslot_type->name, jl_slotnumber_type->name, jl_unionall_type->name,
@@ -3103,8 +3129,8 @@ void jl_init_serializer(void)
     arraylist_push(&builtin_typenames, ((jl_datatype_t*)jl_ref_type->body)->name);
     arraylist_push(&builtin_typenames, jl_pointer_typename);
     arraylist_push(&builtin_typenames, jl_type_typename);
-    arraylist_push(&builtin_typenames, ((jl_datatype_t*)jl_unwrap_unionall(jl_abstractarray_type))->name);
-    arraylist_push(&builtin_typenames, ((jl_datatype_t*)jl_unwrap_unionall(jl_densearray_type))->name);
+    arraylist_push(&builtin_typenames, ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_abstractarray_type))->name);
+    arraylist_push(&builtin_typenames, ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_densearray_type))->name);
     arraylist_push(&builtin_typenames, jl_tuple_typename);
     arraylist_push(&builtin_typenames, jl_vararg_typename);
 }
diff --git a/src/gf.c b/src/gf.c
index f798a0549b6762..c69a2375a36750 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -144,8 +144,8 @@ JL_DLLEXPORT jl_method_instance_t *jl_specializations_get_linfo(jl_method_t *m,
 {
     assert(world >= m->min_world && world <= m->max_world && "typemap lookup is corrupted");
     JL_LOCK(&m->writelock);
-    jl_typemap_entry_t *sf = jl_typemap_assoc_by_type(
-            m->specializations, type, NULL, 2, /*subtype*/0, /*offs*/0, world);
+    jl_typemap_entry_t *sf =
+        jl_typemap_assoc_by_type(m->specializations, (jl_tupletype_t*)type, NULL, 1, /*subtype*/0, /*offs*/0, world);
     if (sf && jl_is_method_instance(sf->func.value)) {
         jl_method_instance_t *linfo = (jl_method_instance_t*)sf->func.value;
         assert(linfo->min_world <= sf->min_world && linfo->max_world >= sf->max_world);
@@ -169,7 +169,7 @@ JL_DLLEXPORT jl_method_instance_t *jl_specializations_get_linfo(jl_method_t *m,
     else {
         li->max_world = world;
     }
-    jl_typemap_insert(&m->specializations, (jl_value_t*)m, type, jl_emptysvec,
+    jl_typemap_insert(&m->specializations, (jl_value_t*)m, (jl_tupletype_t*)type, jl_emptysvec,
             NULL, jl_emptysvec, (jl_value_t*)li, 0, &tfunc_cache,
             li->min_world, li->max_world, NULL);
     JL_UNLOCK(&m->writelock);
@@ -180,7 +180,7 @@ JL_DLLEXPORT jl_method_instance_t *jl_specializations_get_linfo(jl_method_t *m,
 JL_DLLEXPORT jl_value_t *jl_specializations_lookup(jl_method_t *m, jl_tupletype_t *type, size_t world)
 {
     jl_typemap_entry_t *sf = jl_typemap_assoc_by_type(
-            m->specializations, type, NULL, 2, /*subtype*/0, /*offs*/0, world);
+            m->specializations, type, NULL, 1, /*subtype*/0, /*offs*/0, world);
     if (!sf)
         return jl_nothing;
     return sf->func.value;
@@ -526,20 +526,20 @@ static jl_tupletype_t *join_tsig(jl_tupletype_t *tt, jl_tupletype_t *sig)
     for (i = 0, np = jl_nparams(tt); i < np; i++) {
         jl_value_t *elt = jl_tparam(tt, i);
         jl_value_t *newelt = NULL;
-        jl_value_t *decl_i = jl_nth_slot_type(sig, i);
+        jl_value_t *decl_i = jl_nth_slot_type((jl_value_t*)sig, i);
 
         if (jl_is_type_type(elt)) {
             // if the declared type was not Any or Union{Type, ...},
-            // then the match must been with TypeConstructor or DataType
+            // then the match must been with UnionAll or DataType
             // and the result of matching the type signature
             // needs to be corrected to the leaf type 'kind'
             jl_value_t *kind = jl_typeof(jl_tparam0(elt));
             if (jl_subtype(kind, decl_i)) {
                 if (!jl_subtype((jl_value_t*)jl_type_type, decl_i)) {
-                    // TypeConstructors are problematic because they can be alternate
+                    // UnionAlls are problematic because they can be alternate
                     // representations of any type. If we matched this method because
-                    // it matched the leaf type TypeConstructor, then don't
-                    // cache something different since that doesn't necessarily actually apply
+                    // it matched the leaf type UnionAll, then don't cache something
+                    // different since that doesn't necessarily actually apply.
                     //
                     // similarly, if we matched Type{T<:Any}::DataType,
                     // then we don't want to cache it that way
@@ -580,7 +580,7 @@ static void jl_cacheable_sig(
     size_t i, np = jl_nparams(type);
     for (i = 0; i < np; i++) {
         jl_value_t *elt = jl_tparam(type, i);
-        jl_value_t *decl_i = jl_nth_slot_type(decl, i);
+        jl_value_t *decl_i = jl_nth_slot_type((jl_value_t*)decl, i);
         if ((tt != type && elt != jl_tparam(tt, i)) || // if join_tsig made a swap
                 is_kind(elt)) { // might see a kind if called at compile-time
             // kind slots always need guard entries (checking for subtypes of Type)
@@ -693,10 +693,13 @@ JL_DLLEXPORT int jl_is_cacheable_sig(
         // so assume the caller was intelligent about calling us
         return 1;
 
+    if (!jl_is_datatype(type))
+        return 0;
+
     size_t i, np = jl_nparams(type);
     for (i = 0; i < np; i++) {
         jl_value_t *elt = jl_tparam(type, i);
-        jl_value_t *decl_i = jl_nth_slot_type(decl, i);
+        jl_value_t *decl_i = jl_nth_slot_type((jl_value_t*)decl, i);
 
         if (jl_is_vararg_type(elt)) // varargs are always considered compilable
             continue;
@@ -810,7 +813,7 @@ static jl_method_instance_t *cache_method(jl_methtable_t *mt, union jl_typemap_t
 {
     // caller must hold the mt->writelock
     jl_method_t *definition = m->func.method;
-    jl_tupletype_t *decl = m->sig;
+    jl_value_t *decl = (jl_value_t*)m->sig;
     jl_value_t *temp = NULL;
     jl_value_t *temp2 = NULL;
     jl_value_t *temp3 = NULL;
@@ -820,15 +823,15 @@ static jl_method_instance_t *cache_method(jl_methtable_t *mt, union jl_typemap_t
 
     int need_guard_entries = 0;
     int makesimplesig = 0;
-    jl_cacheable_sig(type, tt, decl, definition,
-            (jl_svec_t**)&newparams, &need_guard_entries, &makesimplesig);
+    jl_cacheable_sig(type, tt, (jl_tupletype_t*)decl, definition,
+                     (jl_svec_t**)&newparams, &need_guard_entries, &makesimplesig);
 
     // for varargs methods, only specialize up to max_args.
     // in general, here we want to find the biggest type that's not a
     // supertype of any other method signatures. so far we are conservative
     // and the types we find should be bigger.
     if (!definition->isstaged && jl_nparams(type) > mt->max_args
-        && jl_va_tuple_kind(decl) == JL_VARARG_UNBOUND) {
+        && jl_va_tuple_kind((jl_datatype_t*)decl) == JL_VARARG_UNBOUND) {
         size_t i, nspec = mt->max_args + 2;
         jl_svec_t *limited = jl_alloc_svec(nspec);
         temp = (jl_value_t*)limited;
@@ -956,7 +959,7 @@ static jl_method_instance_t *cache_method(jl_methtable_t *mt, union jl_typemap_t
     }
 
     // here we infer types and specialize the method
-    newmeth = jl_specializations_get_linfo(definition, type, sparams, world);
+    newmeth = jl_specializations_get_linfo(definition, (jl_value_t*)type, sparams, world);
     if (newmeth->min_world > min_valid)
         min_valid = newmeth->min_world;
     if (newmeth->max_world < max_valid)
@@ -1031,7 +1034,7 @@ static jl_method_instance_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_datatype
     sig = join_tsig(tt, entry->sig);
     jl_method_instance_t *nf;
     if (!cache) {
-        nf = jl_specializations_get_linfo(m, sig, env, world);
+        nf = jl_specializations_get_linfo(m, (jl_value_t*)sig, env, world);
     }
     else {
         nf = cache_method(mt, &mt->cache, (jl_value_t*)mt, sig, tt, entry, world, env, allow_exec);
@@ -1087,7 +1090,7 @@ static int check_ambiguous_visitor(jl_typemap_entry_t *oldentry, struct typemap_
     jl_method_t *m = closure->newentry->func.method;
     jl_tupletype_t *sig = oldentry->sig;
     jl_value_t *isect = closure->match.ti;
-    if (sigs_eq(isect, (jl_value_t*)(closure->after ? sig : type), 1)) {
+    if (jl_types_equal(isect, (jl_value_t*)(closure->after ? sig : type))) {
         // we're ok if the new definition is actually the one we just
         // inferred to be required (see issue #3609). ideally this would
         // never happen, since if New ⊓ Old == New then we should have
@@ -1153,7 +1156,7 @@ static jl_value_t *check_ambiguous_matches(union jl_typemap_t defs,
                                            jl_typemap_entry_t *newentry)
 {
     jl_tupletype_t *type = newentry->sig;
-    jl_tupletype_t *ttypes = jl_unwrap_unionall(type);
+    jl_tupletype_t *ttypes = (jl_tupletype_t*)jl_unwrap_unionall((jl_value_t*)type);
     size_t l = jl_nparams(ttypes);
     jl_value_t *va = NULL;
     if (l > 0) {
@@ -1336,7 +1339,7 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
     JL_GC_PUSH1(&oldvalue);
     JL_LOCK(&mt->writelock);
     jl_typemap_entry_t *newentry = jl_typemap_insert(&mt->defs, (jl_value_t*)mt,
-            type, tvars, simpletype, jl_emptysvec, (jl_value_t*)method, 0, &method_defs,
+            (jl_tupletype_t*)type, tvars, simpletype, jl_emptysvec, (jl_value_t*)method, 0, &method_defs,
             method->min_world, method->max_world, &oldvalue);
     if (oldvalue) {
         method->ambig = ((jl_method_t*)oldvalue)->ambig;
@@ -1430,8 +1433,6 @@ void JL_NORETURN jl_method_error(jl_function_t *f, jl_value_t **args, size_t na,
     // not reached
 }
 
-jl_datatype_t *jl_wrap_Type(jl_value_t *t);
-
 jl_tupletype_t *arg_type_tuple(jl_value_t **args, size_t nargs)
 {
     jl_tupletype_t *tt;
@@ -1446,7 +1447,11 @@ jl_tupletype_t *arg_type_tuple(jl_value_t **args, size_t nargs)
             else
                 types[i] = jl_typeof(ai);
         }
-        tt = (jl_tupletype_t*)jl_inst_concrete_tupletype_v(types, nargs);
+        // if `ai` has free type vars this will not be a leaf type.
+        // TODO: it would be really nice to only dispatch and cache those as
+        // `jl_typeof(ai)`, but that will require some redesign of the caching
+        // logic.
+        tt = jl_apply_tuple_type_v(types, nargs);
         JL_GC_POP();
     }
     else {
@@ -1459,7 +1464,7 @@ jl_tupletype_t *arg_type_tuple(jl_value_t **args, size_t nargs)
             else
                 jl_svecset(types, i, jl_typeof(ai));
         }
-        tt = (jl_tupletype_t*)jl_inst_concrete_tupletype(types);
+        tt = jl_apply_tuple_type(types);
         JL_GC_POP();
     }
     return tt;
@@ -1539,22 +1544,16 @@ jl_method_instance_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, si
 // -1 for no limit.
 JL_DLLEXPORT jl_value_t *jl_matching_methods(jl_tupletype_t *types, int lim, int include_ambiguous, size_t world, size_t *min_valid, size_t *max_valid)
 {
-    assert(jl_nparams(types) > 0);
-    jl_value_t *matches = NULL;
-    if (jl_tparam0(types) == jl_bottom_type) {
-        matches = (jl_value_t*)jl_alloc_vec_any(0);
-    }
-    else if (!jl_is_datatype(jl_tparam0(types))) {
+    jl_value_t *unw = jl_unwrap_unionall((jl_value_t*)types);
+    if (jl_is_tuple_type(unw) && jl_tparam0(unw) == jl_bottom_type)
+        return (jl_value_t*)jl_alloc_vec_any(0);
+    jl_datatype_t *dt = jl_first_argument_datatype(unw);
+    if (dt == NULL || !jl_is_datatype(dt))
         return jl_false; // indeterminate - ml_matches can't deal with this case
-    }
-    else {
-        jl_methtable_t *mt = ((jl_datatype_t*)jl_tparam0(types))->name->mt;
-        if (mt == NULL)
-            matches = (jl_value_t*)jl_alloc_vec_any(0);
-        else
-            matches = ml_matches(mt->defs, 0, types, lim, include_ambiguous, world, min_valid, max_valid);
-    }
-    return matches;
+    jl_methtable_t *mt = dt->name->mt;
+    if (mt == NULL)
+        return (jl_value_t*)jl_alloc_vec_any(0);
+    return ml_matches(mt->defs, 0, types, lim, include_ambiguous, world, min_valid, max_valid);
 }
 
 jl_llvm_functions_t jl_compile_for_dispatch(jl_method_instance_t **pli, size_t world)
@@ -1615,15 +1614,16 @@ jl_llvm_functions_t jl_compile_for_dispatch(jl_method_instance_t **pli, size_t w
 jl_method_instance_t *jl_get_specialization1(jl_tupletype_t *types, size_t world)
 {
     JL_TIMING(METHOD_LOOKUP_COMPILE);
-    assert(jl_nparams(types) > 0);
     if (!jl_is_leaf_type((jl_value_t*)types) || jl_has_free_typevars((jl_value_t*)types))
         return NULL;
-    assert(jl_is_datatype(jl_tparam0(types)));
+
+    jl_value_t *args = jl_unwrap_unionall((jl_value_t*)types);
+    assert(jl_is_datatype(args));
 
     // make sure exactly 1 method matches (issue #7302).
     int i;
-    for (i = 0; i < jl_nparams(types); i++) {
-        jl_value_t *ti = jl_tparam(types, i);
+    for (i = 0; i < jl_nparams(args); i++) {
+        jl_value_t *ti = jl_tparam(args, i);
         // if one argument type is DataType, multiple Type{} definitions
         // might match. also be conservative with tuples rather than trying
         // to analyze them in detail.
@@ -1637,7 +1637,9 @@ jl_method_instance_t *jl_get_specialization1(jl_tupletype_t *types, size_t world
         }
     }
 
-    jl_methtable_t *mt = ((jl_datatype_t*)jl_tparam0(types))->name->mt;
+    jl_datatype_t *dt = jl_first_argument_datatype((jl_value_t*)types);
+    assert(dt != NULL);
+    jl_methtable_t *mt = dt->name->mt;
     // most of the time sf is rooted in mt, but if the method is staged it may
     // not be the case
     // TODO: the above should be false, but better safe than sorry?
@@ -1883,7 +1885,7 @@ static void _compile_all_deq(jl_array_t *found)
         jl_method_t *m = ml->func.method;
         jl_method_instance_t *linfo = m->unspecialized;
         if (!linfo) {
-            linfo = jl_get_specialized(m, ml->sig, jl_emptysvec);
+            linfo = jl_get_specialized(m, (jl_value_t*)ml->sig, jl_emptysvec);
             m->unspecialized = linfo;
             jl_gc_wb(m, linfo);
         }
@@ -2267,8 +2269,7 @@ jl_value_t *jl_gf_invoke(jl_tupletype_t *types0, jl_value_t **args, size_t nargs
         else {
             tt = arg_type_tuple(args, nargs);
             if (entry->tvars != jl_emptysvec) {
-                jl_value_t *ti =
-                    jl_lookup_match((jl_value_t*)tt, (jl_value_t*)entry->sig, &tpenv, entry->tvars);
+                jl_value_t *ti = jl_lookup_match((jl_value_t*)tt, (jl_value_t*)entry->sig, &tpenv);
                 assert(ti != (jl_value_t*)jl_bottom_type);
                 (void)ti;
             }
@@ -2351,7 +2352,7 @@ JL_DLLEXPORT jl_value_t *jl_get_invoke_lambda(jl_methtable_t *mt,
     JL_GC_PUSH2(&tpenv, &sig);
     if (entry->tvars != jl_emptysvec) {
         jl_value_t *ti =
-            jl_lookup_match((jl_value_t*)tt, (jl_value_t*)entry->sig, &tpenv, entry->tvars);
+            jl_lookup_match((jl_value_t*)tt, (jl_value_t*)entry->sig, &tpenv);
         assert(ti != (jl_value_t*)jl_bottom_type);
         (void)ti;
     }
@@ -2417,13 +2418,12 @@ jl_function_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module)
     return jl_new_generic_function_with_supertype(name, module, jl_function_type, 0);
 }
 
-JL_DLLEXPORT jl_svec_t *jl_match_method(jl_value_t *type, jl_value_t *sig,
-                                        jl_svec_t *tvars)
+JL_DLLEXPORT jl_svec_t *jl_match_method(jl_value_t *type, jl_value_t *sig)
 {
     jl_svec_t *env = jl_emptysvec;
     jl_value_t *ti=NULL;
     JL_GC_PUSH2(&env, &ti);
-    ti = jl_lookup_match(type, (jl_value_t*)sig, &env, tvars);
+    ti = jl_lookup_match(type, (jl_value_t*)sig, &env);
     jl_svec_t *result = jl_svec2(ti, env);
     JL_GC_POP();
     return result;
@@ -2434,7 +2434,7 @@ JL_DLLEXPORT jl_svec_t *jl_match_method(jl_value_t *type, jl_value_t *sig,
 // arguments.
 static int tvar_exists_at_top_level(jl_value_t *tv, jl_tupletype_t *sig, int attop)
 {
-    sig = jl_unwrap_unionall(sig);
+    sig = (jl_tupletype_t*)jl_unwrap_unionall((jl_value_t*)sig);
     int i, l=jl_nparams(sig);
     for(i=0; i < l; i++) {
         jl_value_t *a = jl_tparam(sig, i);
@@ -2572,8 +2572,7 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
                 jl_method_t *mambig = (jl_method_t*)jl_array_ptr_ref(meth->ambig, j);
                 env = jl_emptysvec;
                 jl_value_t *mti = jl_type_intersection_matching((jl_value_t*)closure->match.type,
-                                                                (jl_value_t*)mambig->sig,
-                                                                &env, mambig->tvars);
+                                                                (jl_value_t*)mambig->sig, &env);
                 if (mti != (jl_value_t*)jl_bottom_type) {
                     if (closure->include_ambiguous) {
                         assert(done);
@@ -2595,8 +2594,7 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
                         // the current method doesn't match if there is an intersection with an
                         // ambiguous method that covers our intersection with this one.
                         jl_value_t *ambi = jl_type_intersection_matching((jl_value_t*)ml->sig,
-                                                                         (jl_value_t*)mambig->sig,
-                                                                         &env, mambig->tvars);
+                                                                         (jl_value_t*)mambig->sig, &env);
                         if (jl_subtype(closure->match.ti, ambi)) {
                             return_this_match = 0;
                             break;
diff --git a/src/init.c b/src/init.c
index 59e601055e47ec..ccc0e3cefb1ce2 100644
--- a/src/init.c
+++ b/src/init.c
@@ -834,7 +834,7 @@ void jl_get_builtin_hooks(void)
 #endif
 
     jl_weakref_type = (jl_datatype_t*)core("WeakRef");
-    jl_vecelement_typename = ((jl_datatype_t*)core("VecElement"))->name;
+    jl_vecelement_typename = ((jl_datatype_t*)jl_unwrap_unionall(core("VecElement")))->name;
 }
 
 JL_DLLEXPORT void jl_get_system_hooks(void)
diff --git a/src/jltypes.c b/src/jltypes.c
index c0fb884d6bf8b5..dcea858db84bfe 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -93,8 +93,10 @@ static int typeenv_has(jl_typeenv_t *env, jl_tvar_t *v)
 
 static int has_free_typevars(jl_value_t *v, jl_typeenv_t *env)
 {
-    if (jl_typeis(v, jl_tvar_type))
+    if (jl_typeis(v, jl_tvar_type)) {
+        if (v == jl_ANY_flag) return 0;
         return !typeenv_has(env, (jl_tvar_t*)v);
+    }
     if (jl_is_uniontype(v))
         return has_free_typevars(((jl_uniontype_t*)v)->a, env) ||
             has_free_typevars(((jl_uniontype_t*)v)->b, env);
@@ -106,8 +108,8 @@ static int has_free_typevars(jl_value_t *v, jl_typeenv_t *env)
     }
     if (jl_is_datatype(v)) {
         int expect = ((jl_datatype_t*)v)->hasfreetypevars;
-        if (expect == 0)
-            return 0;
+        if (expect == 0 || env == NULL)
+            return expect;
         size_t i;
         for (i=0; i < jl_nparams(v); i++) {
             if (has_free_typevars(jl_tparam(v,i), env)) {
@@ -148,6 +150,8 @@ JL_DLLEXPORT int jl_has_bound_typevars(jl_value_t *v, jl_typeenv_t *env)
         return ans;
     }
     if (jl_is_datatype(v)) {
+        if (!((jl_datatype_t*)v)->hasfreetypevars)
+            return 0;
         size_t i;
         for (i=0; i < jl_nparams(v); i++) {
             if (jl_has_bound_typevars(jl_tparam(v,i), env))
@@ -275,7 +279,8 @@ JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n)
         int has_free = temp[i]!=NULL && jl_has_free_typevars(temp[i]);
         for(j=0; j < nt; j++) {
             if (j != i && temp[i] && temp[j]) {
-                if (temp[i] == temp[j] ||
+                if (temp[i] == temp[j] || temp[i] == jl_bottom_type ||
+                    temp[j] == (jl_value_t*)jl_any_type ||
                     (!has_free && !jl_has_free_typevars(temp[j]) &&
                      jl_subtype(temp[i], temp[j]))) {
                     temp[i] = NULL;
@@ -284,11 +289,11 @@ JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n)
         }
     }
     jl_value_t **ptu = &temp[nt];
-    *ptu = NULL;
+    *ptu = jl_bottom_type;
     int k;
     for (k = (int)nt-1; k >= 0; --k) {
         if (temp[k] != NULL) {
-            if (*ptu == NULL)
+            if (*ptu == jl_bottom_type)
                 *ptu = temp[k];
             else
                 *ptu = jl_new_struct(jl_uniontype_type, temp[k], *ptu);
@@ -300,6 +305,31 @@ JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n)
     return tu;
 }
 
+// unionall types -------------------------------------------------------------
+
+JL_DLLEXPORT jl_tvar_t *jl_new_typevar(jl_sym_t *name, jl_value_t *lb, jl_value_t *ub)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_tvar_t *tv = (jl_tvar_t*)jl_gc_alloc(ptls, sizeof(jl_tvar_t), jl_tvar_type);
+    tv->name = name;
+    tv->lb = lb;
+    tv->ub = ub;
+    return tv;
+}
+
+JL_DLLEXPORT jl_value_t *jl_type_unionall(jl_tvar_t *v, jl_value_t *body)
+{
+    // normalize `T where T<:S` => S
+    if (body == (jl_value_t*)v)
+        return v->ub;
+    // where var doesn't occur in body just return body
+    if (!jl_has_typevar(body, v))
+        return body;
+    //if (v->lb == v->ub)  // TODO maybe
+    //    return jl_substitute_var(body, v, v->ub);
+    return jl_new_struct(jl_unionall_type, v, body);
+}
+
 // --- type instantiation and cache ---
 
 static int contains_unions(jl_value_t *type)
@@ -315,6 +345,17 @@ static int contains_unions(jl_value_t *type)
     return 0;
 }
 
+static intptr_t wrapper_id(jl_value_t *t)
+{
+    // DataType wrappers occur often, e.g. when called as constructors.
+    // make sure any type equal to a wrapper gets a consistent, ordered ID.
+    if (!jl_is_unionall(t)) return 0;
+    jl_value_t *u = jl_unwrap_unionall(t);
+    if (jl_is_datatype(u) && ((jl_datatype_t*)u)->name->wrapper == t)
+        return ((jl_datatype_t*)u)->name->hash;
+    return 0;
+}
+
 // this function determines whether a type is simple enough to form
 // a total order based on UIDs and object_id.
 static int is_typekey_ordered(jl_value_t **key, size_t n)
@@ -324,9 +365,8 @@ static int is_typekey_ordered(jl_value_t **key, size_t n)
         jl_value_t *k = key[i];
         if (jl_is_typevar(k))
             return 0;
-        if (jl_is_type(k) && k != jl_bottom_type &&
+        if (jl_is_type(k) && k != jl_bottom_type && !wrapper_id(k) &&
             !(jl_is_datatype(k) && (((jl_datatype_t*)k)->uid ||
-                                    //k == ((jl_datatype_t*)k)->name->primary ||
                                     (!jl_has_free_typevars(k) && !contains_unions(k)))))
             return 0;
     }
@@ -344,9 +384,14 @@ static int typekey_compare(jl_datatype_t *tt, jl_value_t **key, size_t n)
     for(j=0; j < n; j++) {
         jl_value_t *kj = key[j], *tj = jl_svecref(tt->parameters,j);
         if (tj != kj) {
+            uint32_t tid=0, kid=0;
             int dtk = jl_is_datatype(kj);
             if (!jl_is_datatype(tj)) {
-                if (!dtk) {
+                tid = wrapper_id(tj);
+                if (tid) {
+                    kid = wrapper_id(kj);
+                }
+                else if (!dtk) {
                     if (jl_egal(tj, kj))
                         continue;
                     return (jl_object_id(kj) < jl_object_id(tj) ? -1 : 1);
@@ -356,15 +401,23 @@ static int typekey_compare(jl_datatype_t *tt, jl_value_t **key, size_t n)
                 }
             }
             else if (!dtk) {
-                return -1;
+                kid = wrapper_id(kj);
+                if (!kid)
+                    return -1;
             }
+            if (tid || kid) {
+                if (kid != tid)
+                    return kid < tid ? -1 : 1;
+                continue;
+            }
+            assert(dtk && jl_is_datatype(tj));
             jl_datatype_t *dt = (jl_datatype_t*)tj;
             jl_datatype_t *dk = (jl_datatype_t*)kj;
             if (dk->uid != dt->uid) {
                 return dk->uid < dt->uid ? -1 : 1;
             }
             else if (dk->uid != 0) {
-                continue;
+                assert(0);
             }
             else if (dk->name->hash != dt->name->hash) {
                 return dk->name->hash < dt->name->hash ? -1 : 1;
@@ -553,10 +606,10 @@ static int valid_type_param(jl_value_t *v)
     return jl_is_type(v) || jl_is_typevar(v) || jl_is_symbol(v) || jl_isbits(jl_typeof(v));
 }
 
-static int within_typevar(jl_value_t *t, jl_tvar_t *v)
+static int within_typevar(jl_value_t *t, jl_value_t *vlb, jl_value_t *vub)
 {
     jl_value_t *lb = t, *ub = t;
-    if (jl_is_typevar(t)) {
+    if (jl_is_typevar(t) || jl_has_free_typevars(t)) {
         // TODO: automatically restrict typevars in method definitions based on
         // types they are used in.
         return 1;
@@ -564,9 +617,9 @@ static int within_typevar(jl_value_t *t, jl_tvar_t *v)
         //ub = ((jl_tvar_t*)t)->ub;
     }
     else if (!jl_is_type(t)) {
-        return v->lb == jl_bottom_type && v->ub == jl_any_type;
+        return vlb == jl_bottom_type && vub == (jl_value_t*)jl_any_type;
     }
-    return jl_subtype(v->lb, lb) && jl_subtype(ub, v->ub);
+    return jl_subtype(vlb, lb) && jl_subtype(ub, vub);
 }
 
 jl_value_t *jl_apply_type(jl_value_t *tc, jl_value_t **params, size_t n)
@@ -583,17 +636,31 @@ jl_value_t *jl_apply_type(jl_value_t *tc, jl_value_t **params, size_t n)
         jl_value_t *pi = params[i];
 
         if (!valid_type_param(pi)) {
-            jl_type_error_rt("type", "parameter",
+            jl_type_error_rt("Type", "parameter",
                              jl_isa(pi, (jl_value_t*)jl_number_type) ?
                              (jl_value_t*)jl_long_type : (jl_value_t*)jl_type_type,
                              pi);
         }
 
         jl_unionall_t *ua = (jl_unionall_t*)tc;
-        if (jl_has_free_typevars(ua->var->lb) || jl_has_free_typevars(ua->var->ub))
-            jl_error("invalid instantiation");
-        if (!within_typevar(pi, ua->var))
-            jl_type_error_rt("type", "parameter", (jl_value_t*)ua->var, pi);
+        if (!jl_has_free_typevars(ua->var->lb) && !jl_has_free_typevars(ua->var->ub) &&
+            !within_typevar(pi, ua->var->lb, ua->var->ub)) {
+            jl_datatype_t *inner = (jl_datatype_t*)jl_unwrap_unionall(tc);
+            int iswrapper = 0;
+            if (jl_is_datatype(inner)) {
+                jl_value_t *temp = inner->name->wrapper;
+                while (jl_is_unionall(temp)) {
+                    if (temp == tc) {
+                        iswrapper = 1;
+                        break;
+                    }
+                    temp = ((jl_unionall_t*)temp)->body;
+                }
+            }
+            // if this is a wrapper, let check_datatype_parameters give the error
+            if (!iswrapper)
+                jl_type_error_rt("Type", jl_symbol_name(ua->var->name), (jl_value_t*)ua->var, pi);
+        }
 
         tc = jl_instantiate_unionall(ua, pi);
     }
@@ -631,7 +698,11 @@ JL_DLLEXPORT jl_value_t *jl_tupletype_fill(size_t n, jl_value_t *v)
 }
 
 typedef struct _jl_typestack_t {
-    jl_datatype_t *tt;
+    union {
+        jl_value_t *ua;
+        jl_datatype_t *tt;
+    };
+    jl_value_t *ua_new;
     struct _jl_typestack_t *prev;
 } jl_typestack_t;
 
@@ -664,7 +735,7 @@ jl_value_t *jl_rewrap_unionall(jl_value_t *t, jl_value_t *u)
         return t;
     JL_GC_PUSH1(&t);
     t = jl_rewrap_unionall(t, ((jl_unionall_t*)u)->body);
-    t = jl_new_unionall_type(((jl_unionall_t*)u)->var, t);
+    t = jl_new_struct(jl_unionall_type, ((jl_unionall_t*)u)->var, t);
     JL_GC_POP();
     return t;
 }
@@ -719,9 +790,56 @@ void jl_precompute_memoized_dt(jl_datatype_t *dt)
     }
 }
 
+static void check_datatype_parameters(jl_typename_t *tn, jl_value_t **params, size_t np)
+{
+    jl_value_t *wrapper = tn->wrapper;
+    jl_value_t **bounds;
+    JL_GC_PUSHARGS(bounds, np*2);
+    int i = 0;
+    while (jl_is_unionall(wrapper)) {
+        jl_tvar_t *tv = ((jl_unionall_t*)wrapper)->var;
+        bounds[i++] = tv->lb;
+        bounds[i++] = tv->ub;
+        wrapper = ((jl_unionall_t*)wrapper)->body;
+    }
+    assert(i == np*2);
+    wrapper = tn->wrapper;
+    for(i=0; i < np; i++) {
+        assert(jl_is_unionall(wrapper));
+        jl_tvar_t *tv = ((jl_unionall_t*)wrapper)->var;
+        if (!within_typevar(params[i], bounds[2*i], bounds[2*i+1])) {
+            // TODO: pass a new version of `tv` containing the instantiated bounds
+            jl_type_error_rt(jl_symbol_name(tn->name), jl_symbol_name(tv->name), (jl_value_t*)tv, params[i]);
+        }
+        int j;
+        for(j=2*i+2; j < 2*np; j++) {
+            jl_value_t*bj = bounds[j];
+            if (bj != (jl_value_t*)jl_any_type && bj != jl_bottom_type)
+                bounds[j] = jl_substitute_var(bj, tv, params[i]);
+        }
+        wrapper = ((jl_unionall_t*)wrapper)->body;
+    }
+    JL_GC_POP();
+}
+
 static arraylist_t partial_inst;
 int inside_typedef = 0;
 
+static jl_value_t *extract_wrapper(jl_value_t *t)
+{
+    t = jl_unwrap_unionall(t);
+    if (jl_is_datatype(t))
+        return ((jl_datatype_t*)t)->name->wrapper;
+    if (jl_is_uniontype(t)) {
+        jl_value_t *n1 = extract_wrapper(((jl_uniontype_t*)t)->a);
+        if (n1 != NULL) return n1;
+        return extract_wrapper(((jl_uniontype_t*)t)->b);
+    }
+    if (jl_is_typevar(t))
+        return extract_wrapper(((jl_tvar_t*)t)->ub);
+    return NULL;
+}
+
 static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **iparams, size_t ntp,
                                  int cacheable, jl_typestack_t *stack, jl_typeenv_t *env)
 {
@@ -732,6 +850,15 @@ static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **i
     // check type cache
     if (cacheable) {
         JL_LOCK(&typecache_lock); // Might GC
+        size_t i;
+        for(i=0; i < ntp; i++) {
+            jl_value_t *pi = iparams[i];
+            jl_value_t *tw = extract_wrapper(pi);
+            if (tw && jl_types_equal(pi, tw)) {
+                iparams[i] = tw;
+                if (p) jl_gc_wb(p, tw);
+            }
+        }
         jl_value_t *lkup = (jl_value_t*)lookup_type(tn, iparams, ntp);
         if (lkup != NULL) {
             JL_UNLOCK(&typecache_lock); // Might GC
@@ -750,8 +877,10 @@ static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **i
         jl_value_t *va = jl_unwrap_unionall(last);
         // return same `Tuple` object for types equal to it
         if (ntp == 1 && jl_tparam0(va) == (jl_value_t*)jl_any_type &&
-            jl_is_unionall(last) && jl_tparam1(va) == (jl_value_t*)((jl_unionall_t*)last)->var)
+            jl_is_unionall(last) && jl_tparam1(va) == (jl_value_t*)((jl_unionall_t*)last)->var) {
+            if (cacheable) JL_UNLOCK(&typecache_lock); // Might GC
             return (jl_value_t*)jl_anytuple_type;
+        }
         if (jl_is_long(jl_tparam1(va))) {
             ssize_t nt = jl_unbox_long(jl_tparam1(va));
             if (nt < 0)
@@ -793,6 +922,10 @@ static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **i
     jl_datatype_t *ndt = NULL;
     jl_svec_t *ftypes;
 
+    // check parameters against bounds in type definition
+    if (!istuple)
+        check_datatype_parameters(tn, iparams, ntp);
+
     // move array of instantiated parameters to heap; we need to keep it
     JL_GC_PUSH2(&p, &ndt);
     if (p == NULL) {
@@ -948,8 +1081,7 @@ static jl_value_t *inst_tuple_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_
     jl_svec_t *tp = tt->parameters;
     size_t ntp = jl_svec_len(tp);
     // Instantiate NTuple{3,Int}
-    // Note this does not instantiate Tuple{Vararg{Int,3}}; that's done in
-    // jl_apply_tuple_type_v_
+    // Note this does not instantiate Tuple{Vararg{Int,3}}; that's done in inst_datatype
     if (jl_is_va_tuple(tt) && ntp == 1) {
         // If this is a Tuple{Vararg{T,N}} with known N, expand it to
         // a fixed-length tuple
@@ -1011,10 +1143,11 @@ static jl_value_t *inst_type_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_t
         while (e != NULL) {
             if (e->var == (jl_tvar_t*)t) {
                 jl_value_t *val = e->val;
-                if (check && !jl_is_typevar(val) && !within_typevar(val, (jl_tvar_t*)t)) {
-                    jl_type_error_rt("type parameter",
-                                     jl_symbol_name(((jl_tvar_t*)t)->name), t, val);
-                }
+                // TODO jb/subtype this seems unnecessary
+                //if (check && !jl_is_typevar(val) && !within_typevar(val, (jl_tvar_t*)t)) {
+                //    jl_type_error_rt("type parameter",
+                //                     jl_symbol_name(((jl_tvar_t*)t)->name), t, val);
+                //}
                 return val;
             }
             e = e->prev;
@@ -1022,34 +1155,30 @@ static jl_value_t *inst_type_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_t
         return (jl_value_t*)t;
     }
     if (jl_is_unionall(t)) {
-        jl_unionall_t *ua = (jl_unionall_t*)t;
-        jl_value_t *res;
-        if (!jl_has_free_typevars(t)) {
-            return t;
+        jl_typestack_t *sp = stack;
+        while (sp != NULL) {
+            if (sp->ua == t)
+                return sp->ua_new;
+            sp = sp->prev;
         }
-        else if (typeenv_has(env, ua->var) || jl_has_bound_typevars(ua->var->lb, env) ||
-                 jl_has_bound_typevars(ua->var->ub, env)) {
-            jl_value_t *lb=NULL, *ub=NULL, *body=NULL;
-            jl_tvar_t *ntv=NULL;
-            JL_GC_PUSH4(&lb, &ub, &ntv, &body);
-            lb = inst_type_w_(ua->var->lb, env, stack, check);
-            ub = inst_type_w_(ua->var->ub, env, stack, check);
-            ntv = jl_new_typevar(ua->var->name, lb, ub);
-            jl_typeenv_t newenv = { ua->var, (jl_value_t*)ntv, env };
-            body = inst_type_w_(ua->body, &newenv, stack, check);
-            res = jl_new_struct(jl_unionall_type, ntv, body);
-            JL_GC_POP();
-        }
-        else {
-            jl_value_t *body=NULL;
-            JL_GC_PUSH1(&body);
-            body = inst_type_w_(ua->body, env, stack, check);
-            if (body == ua->body)
-                res = t;
-            else
-                res = jl_new_struct(jl_unionall_type, ua->var, body);
-            JL_GC_POP();
+        if (!jl_has_free_typevars(t))
+            return t;
+        jl_unionall_t *ua = (jl_unionall_t*)t;
+        jl_value_t *res=NULL, *lb=ua->var->lb, *ub=ua->var->ub;
+        JL_GC_PUSH3(&lb, &ub, &res);
+        res = jl_new_struct(jl_unionall_type, ua->var, NULL);
+        jl_typestack_t top = { {t}, res, stack };
+        if (jl_has_bound_typevars(ua->var->lb, env) || jl_has_bound_typevars(ua->var->ub, env)) {
+            lb = inst_type_w_(ua->var->lb, env, &top, check);
+            ub = inst_type_w_(ua->var->ub, env, &top, check);
         }
+        if (lb != ua->var->lb || ub != ua->var->ub)
+            ((jl_unionall_t*)res)->var = jl_new_typevar(ua->var->name, lb, ub);
+        jl_typeenv_t newenv = { ua->var, (jl_value_t*)((jl_unionall_t*)res)->var, env };
+        ((jl_unionall_t*)res)->body = inst_type_w_(ua->body, &newenv, &top, check);
+        if (((jl_unionall_t*)res)->body == ua->body)
+            res = t;
+        JL_GC_POP();
         return res;
     }
     if (jl_is_uniontype(t)) {
@@ -1079,20 +1208,12 @@ static jl_value_t *inst_type_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_t
     if (tn == jl_tuple_typename)
         return inst_tuple_w_(t, env, stack, check);
     size_t ntp = jl_svec_len(tp);
-    jl_value_t *wrapper = tn->wrapper;
     jl_value_t **iparams;
     JL_GC_PUSHARGS(iparams, ntp);
     int cacheable = 1, bound = 0;
     for(i=0; i < ntp; i++) {
         jl_value_t *elt = jl_svecref(tp, i);
         iparams[i] = (jl_value_t*)inst_type_w_(elt, env, stack, check);
-        assert(jl_is_unionall(wrapper));
-        jl_tvar_t *tv = ((jl_unionall_t*)wrapper)->var;
-        if (!within_typevar(iparams[i], tv)) {
-            jl_type_error_rt(jl_symbol_name(tn->name), jl_symbol_name(tv->name),
-                             tv, iparams[i]);
-        }
-        wrapper = ((jl_unionall_t*)wrapper)->body;
         bound |= (iparams[i] != elt);
         if (cacheable && jl_has_free_typevars(iparams[i]))
             cacheable = 0;
@@ -1172,9 +1293,12 @@ void jl_reinstantiate_inner_types(jl_datatype_t *t) // can throw!
                 env[i * 2 + 1] = jl_svecref(ndt->parameters, i);
 
             int k;
-            // TODO jb/subtype - might need to allocate a new svec here
+            if (ndt->types == NULL) {
+                ndt->types = jl_alloc_svec(jl_svec_len(t->types));
+                jl_gc_wb(ndt, ndt->types);
+            }
             for (k=0; k < jl_svec_len(t->types); k++) {
-                jl_svecset(t->types, k, instantiate_with(jl_svecref(t->types,k), env, n, NULL, &top));
+                jl_svecset(ndt->types, k, instantiate_with(jl_svecref(t->types,k), env, n, NULL, &top));
             }
             if (ndt->uid) { // cacheable
                 jl_compute_field_offsets(ndt);
@@ -1208,8 +1332,6 @@ static int type_eqv_with_ANY(jl_value_t *a, jl_value_t *b)
             jl_types_equal(a, b));
 }
 
-static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant);
-
 static jl_datatype_t *jl_fix_vararg_bound(jl_datatype_t *tt, int nfix)
 {
     assert(jl_is_va_tuple(tt));
@@ -1241,24 +1363,22 @@ typedef enum {
     JL_TUPLE_VAR   = 1
 } jl_tuple_lenkind_t;
 
-// Set the parameters for a single tuple
-// returns lenf, sets kind and lenkind
-static size_t data_vararg_params(jl_value_t **data, size_t lenr, jl_vararg_kind_t *kind, jl_tuple_lenkind_t *lenkind)
+static size_t tuple_vararg_params(jl_svec_t *a, jl_vararg_kind_t *kind, jl_tuple_lenkind_t *lenkind)
 {
+    jl_value_t **data = jl_svec_data(a); size_t lenr = jl_svec_len(a);
     size_t lenf = lenr;
-    int i;
     if (lenr == 0) {
         *kind = JL_VARARG_NONE;
         *lenkind = JL_TUPLE_FIXED;
         return lenf;
     }
     *lenkind = JL_TUPLE_VAR;
-    jl_value_t *last = jl_unwrap_unionall(data[lenr-1]);
+    jl_value_t *last = data[lenr-1];
     *kind = jl_vararg_kind(last);
     if (*kind == JL_VARARG_NONE || *kind == JL_VARARG_INT)
         *lenkind = JL_TUPLE_FIXED;
     if (*kind == JL_VARARG_INT || *kind == JL_VARARG_BOUND) {
-        jl_value_t *N = jl_tparam1(last);
+        jl_value_t *N = jl_tparam1(jl_unwrap_unionall(last));
         if (jl_is_long(N)) {
             lenf += jl_unbox_long(N)-1;
             *lenkind = JL_TUPLE_FIXED;
@@ -1267,12 +1387,9 @@ static size_t data_vararg_params(jl_value_t **data, size_t lenr, jl_vararg_kind_
     return lenf;
 }
 
-static size_t tuple_vararg_params(jl_svec_t *a, jl_vararg_kind_t *kind, jl_tuple_lenkind_t *lenkind)
-{
-    return data_vararg_params(jl_svec_data(a), jl_svec_len(a), kind, lenkind);
-}
+static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant, jl_typeenv_t *env);
 
-static int jl_tuple_morespecific(jl_datatype_t *cdt, jl_datatype_t *pdt, int invariant)
+static int tuple_morespecific(jl_datatype_t *cdt, jl_datatype_t *pdt, int invariant, jl_typeenv_t *env)
 {
     size_t clenr = jl_nparams(cdt);
     jl_value_t **child = jl_svec_data(cdt->parameters);
@@ -1295,7 +1412,7 @@ static int jl_tuple_morespecific(jl_datatype_t *cdt, jl_datatype_t *pdt, int inv
         if (ci >= clenf && !cseq)
             return 1;
         if (pi >= plenf && !pseq)
-            return 0;
+            return (clenf==plenf || cseq) && some_morespecific;
         if (ci < clenr) {
             ce = child[ci];
             if (jl_is_vararg_type(ce)) ce = jl_unwrap_vararg(ce);
@@ -1305,7 +1422,7 @@ static int jl_tuple_morespecific(jl_datatype_t *cdt, jl_datatype_t *pdt, int inv
             if (jl_is_vararg_type(pe)) pe = jl_unwrap_vararg(pe);
         }
 
-        if (!type_morespecific_(ce, pe, invariant)) {
+        if (!type_morespecific_(ce, pe, invariant, env)) {
             if (type_eqv_with_ANY(ce,pe)) {
                 if (ci==clenf-1 && pi==plenf-1) {
                     if (!cseq && pseq)
@@ -1350,33 +1467,120 @@ static int jl_tuple_morespecific(jl_datatype_t *cdt, jl_datatype_t *pdt, int inv
     return 0;
 }
 
-static int partially_morespecific(jl_value_t *a, jl_value_t *b, int invariant)
+// Called when a is a bound-vararg and b is not a vararg. Sets the vararg length
+// in a to match b, as long as this makes some earlier argument more specific.
+static int args_morespecific_fix1(jl_value_t *a, jl_value_t *b, int swap, jl_typeenv_t *env)
+{
+    jl_datatype_t *tta = (jl_datatype_t*)a;
+    jl_datatype_t *ttb = (jl_datatype_t*)b;
+    size_t n = jl_nparams(tta);
+    jl_datatype_t *newtta = jl_fix_vararg_bound(tta, jl_nparams(ttb)-n+1);
+    int changed = 0;
+    for (size_t i = 0; i < n-1; i++) {
+        if (jl_tparam(tta, i) != jl_tparam(newtta, i)) {
+            changed = 1;
+            break;
+        }
+    }
+    if (changed) {
+        JL_GC_PUSH1(&newtta);
+        int ret;
+        if (jl_types_equal(b, (jl_value_t*)newtta))
+            ret = swap;
+        else if (swap)
+            ret = type_morespecific_(b, (jl_value_t*)newtta, 0, env);
+        else
+            ret = type_morespecific_((jl_value_t*)newtta, b, 0, env);
+        JL_GC_POP();
+        return ret;
+    }
+    return -1;
+}
+
+static int partially_morespecific(jl_value_t *a, jl_value_t *b, int invariant, jl_typeenv_t *env)
 {
     if (jl_is_uniontype(b)) {
         jl_uniontype_t *u = (jl_uniontype_t*)b;
-        if ((type_morespecific_(a, u->a, invariant) &&
-             !type_morespecific_(u->a, a, invariant)) ||
-            (type_morespecific_(a, u->b, invariant) &&
-             !type_morespecific_(u->b, a, invariant)))
+        if ((type_morespecific_(a, u->a, invariant, env) &&
+             !type_morespecific_(u->a, a, invariant, env)) ||
+            (type_morespecific_(a, u->b, invariant, env) &&
+             !type_morespecific_(u->b, a, invariant, env)))
             return 1;
         return 0;
     }
-    return type_morespecific_(a, b, invariant);
+    return type_morespecific_(a, b, invariant, env);
+}
+
+static int count_occurs(jl_value_t *t, jl_tvar_t *v)
+{
+    if (t == (jl_value_t*)v)
+        return 1;
+    if (jl_is_uniontype(t)) {
+        int a = count_occurs(((jl_uniontype_t*)t)->a, v);
+        int b = count_occurs(((jl_uniontype_t*)t)->b, v);
+        return a > b ? a : b;
+    }
+    if (jl_is_unionall(t)) {
+        if (((jl_unionall_t*)t)->var == v)
+            return 0;
+        return count_occurs(((jl_unionall_t*)t)->body, v);
+    }
+    if (jl_is_datatype(t)) {
+        int i, c=0;
+        for(i=0; i < jl_nparams(t); i++)
+            c += count_occurs(jl_tparam(t,i), v);
+        return c;
+    }
+    return 0;
+}
+
+static int num_occurs(jl_tvar_t *v, jl_typeenv_t *env)
+{
+    jl_typeenv_t *e = env;
+    while (e != NULL) {
+        if (e->var == v)
+            return (int)(ssize_t)e->val;
+        e = e->prev;
+    }
+    return 0;
 }
 
-static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
+static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant, jl_typeenv_t *env)
 {
-    while (jl_is_unionall(a)) a = (jl_value_t*)((jl_unionall_t*)a)->body;
-    while (jl_is_unionall(b)) b = (jl_value_t*)((jl_unionall_t*)b)->body;
+    if (jl_is_unionall(a)) {
+        jl_unionall_t *ua = (jl_unionall_t*)a;
+        jl_typeenv_t newenv = { ua->var, 0x0, env };
+        newenv.val = (jl_value_t*)(intptr_t)count_occurs(ua->body, ua->var);
+        return type_morespecific_(ua->body, b, invariant, &newenv);
+    }
+    if (jl_is_unionall(b)) {
+        jl_unionall_t *ub = (jl_unionall_t*)b;
+        jl_typeenv_t newenv = { ub->var, 0x0, env };
+        newenv.val = (jl_value_t*)(intptr_t)count_occurs(ub->body, ub->var);
+        return type_morespecific_(a, ub->body, invariant, &newenv);
+    }
     if (a == b) {
         // TODO; maybe change this
         return 1;
     }
     size_t i;
-    if (jl_is_tuple_type(a)) {
-        if (jl_is_tuple_type(b)) {
-            return jl_tuple_morespecific((jl_datatype_t*)a, (jl_datatype_t*)b, invariant);
-        }
+    if (jl_is_tuple_type(a) && jl_is_tuple_type(b)) {
+        jl_datatype_t *tta = (jl_datatype_t*)a;
+        jl_datatype_t *ttb = (jl_datatype_t*)b;
+        size_t alenf, blenf;
+        jl_vararg_kind_t akind, bkind;
+        jl_tuple_lenkind_t alenkind, blenkind;
+        alenf = tuple_vararg_params(tta->parameters, &akind, &alenkind);
+        blenf = tuple_vararg_params(ttb->parameters, &bkind, &blenkind);
+        // When one is JL_VARARG_BOUND and the other has fixed length,
+        // allow the argument length to fix the tvar
+        int ans = -1;
+        if (akind == JL_VARARG_BOUND && blenkind == JL_TUPLE_FIXED && blenf >= alenf)
+            ans = args_morespecific_fix1(a, b, 0, env);
+        if (bkind == JL_VARARG_BOUND && alenkind == JL_TUPLE_FIXED && alenf >= blenf)
+            ans = args_morespecific_fix1(b, a, 1, env);
+        if (ans != -1) return ans;
+        return tuple_morespecific((jl_datatype_t*)a, (jl_datatype_t*)b, invariant, env);
     }
 
     if (jl_is_uniontype(a)) {
@@ -1392,13 +1596,13 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
         // more specific than b, and b is not more specific than any
         // element of a.
         jl_uniontype_t *u = (jl_uniontype_t*)a;
-        if (partially_morespecific(u->a, b, invariant) && !type_morespecific_(b, u->a, invariant)) {
-            if (partially_morespecific(b, a, invariant))
+        if (partially_morespecific(u->a, b, invariant, env) && !type_morespecific_(b, u->a, invariant, env)) {
+            if (partially_morespecific(b, a, invariant, env))
                 return 0;
             return 1;
         }
-        if (partially_morespecific(u->b, b, invariant) && !type_morespecific_(b, u->b, invariant)) {
-            if (partially_morespecific(b, a, invariant))
+        if (partially_morespecific(u->b, b, invariant, env) && !type_morespecific_(b, u->b, invariant, env)) {
+            if (partially_morespecific(b, a, invariant, env))
                 return 0;
             return 1;
         }
@@ -1409,13 +1613,11 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
         jl_value_t *tp0a = jl_tparam0(a);
         if (jl_is_typevar(tp0a)) {
             jl_value_t *ub = ((jl_tvar_t*)tp0a)->ub;
-            if (jl_subtype(ub, b) &&
-                !jl_subtype((jl_value_t*)jl_any_type, ub)) {
+            if (is_kind(b) && !jl_subtype((jl_value_t*)jl_any_type, ub))
                 return 1;
-            }
         }
         else {
-            if (jl_subtype(tp0a, b))
+            if (jl_isa(tp0a, b))
                 return 1;
         }
     }
@@ -1424,7 +1626,7 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
         if (invariant)
             return 0;
         jl_uniontype_t *u = (jl_uniontype_t*)b;
-        if (type_morespecific_(a, u->a, invariant) || type_morespecific_(a, u->b, invariant))
+        if (type_morespecific_(a, u->a, invariant, env) || type_morespecific_(a, u->b, invariant, env))
             return 1;
         return 0;
     }
@@ -1443,17 +1645,26 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
                         return 1;
                 }
                 if (super && ttb->name == jl_type_typename && jl_is_typevar(jl_tparam0(b))) {
-                    if (type_morespecific_(a, jl_tparam0(b), 1))
+                    if (type_morespecific_(a, jl_tparam0(b), 1, env))
                         return 1;
                 }
                 assert(jl_nparams(tta) == jl_nparams(ttb));
+                int ascore=0, bscore=0, ascore1=0, bscore1=0;
                 for(i=0; i < jl_nparams(tta); i++) {
                     jl_value_t *apara = jl_tparam(tta,i);
                     jl_value_t *bpara = jl_tparam(ttb,i);
-                    if (!type_morespecific_(apara, bpara, 1))
-                        return 0;
+                    ascore += type_morespecific_(apara, bpara, 1, env);
+                    bscore += type_morespecific_(bpara, apara, 1, env);
+                    if (jl_is_typevar(bpara) && !jl_is_typevar(apara) && !jl_is_type(apara))
+                        ascore1 += 1;
+                    if (jl_is_typevar(apara) && !jl_is_typevar(bpara) && !jl_is_type(bpara))
+                        bscore1 += 1;
                 }
-                return 1;
+                if (bscore1 == 0 && ascore1 > 0)
+                    return 1;
+                if (ascore1 == 0 && bscore1 > 0)
+                    return 0;
+                return ascore == jl_nparams(tta);
             }
             else if (invariant) {
                 return 0;
@@ -1466,15 +1677,23 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
     if (jl_is_typevar(a)) {
         if (jl_is_typevar(b)) {
             return type_morespecific_((jl_value_t*)((jl_tvar_t*)a)->ub,
-                                      (jl_value_t*)((jl_tvar_t*)b)->ub, 0) &&
+                                      (jl_value_t*)((jl_tvar_t*)b)->ub, 0, env) &&
                 type_morespecific_((jl_value_t*)((jl_tvar_t*)b)->lb,
-                                   (jl_value_t*)((jl_tvar_t*)a)->lb, 0);
+                                   (jl_value_t*)((jl_tvar_t*)a)->lb, 0, env) &&
+                num_occurs((jl_tvar_t*)a, env) >= num_occurs((jl_tvar_t*)b, env);
         }
-        if (invariant)
+        if (!jl_is_type(b))
+            return 0;
+        if (invariant && num_occurs((jl_tvar_t*)a, env) < 2)
             return 0;
         return jl_subtype((jl_value_t*)((jl_tvar_t*)a)->ub, b);
     }
     if (jl_is_typevar(b)) {
+        if (!jl_is_type(a))
+            return 1;
+        if (invariant)
+            return type_morespecific_(a, (jl_value_t*)((jl_tvar_t*)b)->ub, 0, env) &&
+                !type_morespecific_((jl_value_t*)((jl_tvar_t*)b)->ub, a, 0, env);
         return jl_subtype(a, (jl_value_t*)((jl_tvar_t*)b)->ub) &&
             jl_subtype((jl_value_t*)((jl_tvar_t*)b)->lb, a);
     }
@@ -1483,63 +1702,11 @@ static int type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
     return 0;
 }
 
-// Called when a is a bound-vararg and b is not a vararg. Sets the
-// vararg length in a to match b, as long as this makes some earlier
-// argument more specific.
-static int args_morespecific_fix1(jl_value_t *a, jl_value_t *b, int swap)
-{
-    jl_datatype_t *tta = (jl_datatype_t*)a;
-    jl_datatype_t *ttb = (jl_datatype_t*)b;
-    size_t n = jl_nparams(tta);
-    jl_datatype_t *newtta = jl_fix_vararg_bound(tta, jl_nparams(ttb)-n+1);
-    int changed = 0;
-    for (size_t i = 0; i < n-1; i++) {
-        if (jl_tparam(tta, i) != jl_tparam(newtta, i)) {
-            changed = 1;
-            break;
-        }
-    }
-    if (changed) {
-        JL_GC_PUSH1(&newtta);
-        int ret;
-        if (jl_types_equal(b, (jl_value_t*)newtta))
-            ret = swap;
-        else if (swap)
-            ret = type_morespecific_(b, (jl_value_t*)newtta, 0);
-        else
-            ret = type_morespecific_((jl_value_t*)newtta, b, 0);
-        JL_GC_POP();
-        return ret;
-    }
-    if (swap)
-        return type_morespecific_(b, a, 0);
-    return type_morespecific_(a, b, 0);
-}
-
 JL_DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b)
 {
-    if (jl_subtype(a, b))
-        return 1;
-    if (jl_subtype(b, a))
-        return 0;
-    if (jl_is_tuple_type(a) && jl_is_tuple_type(b)) {
-        jl_datatype_t *tta = (jl_datatype_t*)a;
-        jl_datatype_t *ttb = (jl_datatype_t*)b;
-        size_t alenf, blenf;
-        jl_vararg_kind_t akind, bkind;
-        jl_tuple_lenkind_t alenkind, blenkind;
-        alenf = tuple_vararg_params(tta->parameters, &akind, &alenkind);
-        blenf = tuple_vararg_params(ttb->parameters, &bkind, &blenkind);
-        // When one is JL_VARARG_BOUND and the other has fixed length,
-        // allow the argument length to fix the tvar
-        if (akind == JL_VARARG_BOUND && blenkind == JL_TUPLE_FIXED && blenf >= alenf) {
-            return args_morespecific_fix1(a, b, 0);
-        }
-        if (bkind == JL_VARARG_BOUND && alenkind == JL_TUPLE_FIXED && alenf >= blenf) {
-            return args_morespecific_fix1(b, a, 1);
-        }
-    }
-    return type_morespecific_(a, b, 0);
+    if (jl_subtype(a, b)) return 1;
+    if (jl_subtype(b, a)) return 0;
+    return type_morespecific_(a, b, 0, NULL);
 }
 
 // initialization -------------------------------------------------------------
@@ -1605,7 +1772,7 @@ void jl_init_types(void)
                                             jl_symbol("isleaftype"));
     jl_datatype_type->types = jl_svec(16,
                                       jl_typename_type,
-                                      jl_type_type,
+                                      jl_datatype_type,
                                       jl_simplevector_type,
                                       jl_simplevector_type,
                                       jl_any_type, // instance
@@ -1741,7 +1908,7 @@ void jl_init_types(void)
     jl_tvar_t *tttvar = tvar("T");
     ((jl_datatype_t*)jl_type_type)->parameters = jl_svec(1, tttvar);
     ((jl_datatype_t*)jl_type_type)->hasfreetypevars = 1;
-    jl_type_typename->wrapper = (jl_value_t*)jl_new_unionall_type(tttvar, (jl_value_t*)jl_type_type);
+    jl_type_typename->wrapper = jl_new_struct(jl_unionall_type, tttvar, (jl_value_t*)jl_type_type);
     jl_type_type = (jl_unionall_t*)jl_type_typename->wrapper;
 
     jl_tupletype_t *empty_tuple_type = jl_apply_tuple_type(jl_emptysvec);
@@ -2034,18 +2201,20 @@ void jl_init_types(void)
         jl_new_bitstype((jl_value_t*)jl_symbol("Ptr"),
                         (jl_datatype_t*)jl_apply_type((jl_value_t*)jl_ref_type, jl_svec_data(tv), 1), tv,
                         sizeof(void*)*8)->name->wrapper;
-    jl_pointer_typename = ((jl_datatype_t*)jl_unwrap_unionall(jl_pointer_type))->name;
+    jl_pointer_typename = ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_pointer_type))->name;
 
     // U T<:Tuple Type{T}
     tttvar = jl_new_typevar(jl_symbol("T"),
                             (jl_value_t*)jl_bottom_type,
                             (jl_value_t*)jl_anytuple_type);
-    jl_anytuple_type_type = jl_new_unionall_type(tttvar, (jl_value_t*)jl_wrap_Type((jl_value_t*)tttvar));
+    jl_anytuple_type_type = (jl_unionall_t*)jl_new_struct(jl_unionall_type,
+                                                          tttvar, (jl_value_t*)jl_wrap_Type((jl_value_t*)tttvar));
 
     // Type{T}
     jl_typetype_tvar = tvar("T");
-    jl_typetype_type = jl_new_unionall_type(jl_typetype_tvar,
-                                            jl_apply_type1((jl_value_t*)jl_type_type, (jl_value_t*)jl_typetype_tvar));
+    jl_typetype_type =
+        (jl_unionall_t*)jl_new_struct(jl_unionall_type, jl_typetype_tvar,
+                                      jl_apply_type1((jl_value_t*)jl_type_type, (jl_value_t*)jl_typetype_tvar));
 
     jl_ANY_flag = (jl_value_t*)tvar("ANY");
 
@@ -2071,6 +2240,7 @@ void jl_init_types(void)
     jl_svecset(jl_simplevector_type->types, 0, jl_long_type);
     jl_svecset(jl_typename_type->types, 1, jl_module_type);
     jl_svecset(jl_typename_type->types, 6, jl_long_type);
+    jl_svecset(jl_typename_type->types, 3, jl_type_type);
     jl_svecset(jl_methtable_type->types, 3, jl_long_type);
     jl_svecset(jl_methtable_type->types, 5, jl_module_type);
     jl_svecset(jl_methtable_type->types, 6, jl_array_any_type);
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 3cf40413b86593..f6020ae9ce7efc 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -345,8 +345,18 @@
                           ,body ,isstaged)
                  `(method ,name
                           (block
-                           ,@(map (lambda (l r) (make-assignment l (replace-vars r renames)))
-                                  temps (map bounds-to-TypeVar sparams))
+                           ,@(let loop ((n       names)
+                                        (t       temps)
+                                        (sp      (map bounds-to-TypeVar sparams))
+                                        (ren     '())
+                                        (assigns '()))
+                               (if (null? n)
+                                   (reverse! assigns)
+                                   (loop (cdr n) (cdr t) (cdr sp)
+                                         (cons (cons (car n) (car t)) ren)
+                                         ;; each static param can see just the previous ones
+                                         (cons (make-assignment (car t) (replace-vars (car sp) ren))
+                                               assigns))))
                            (call (core svec) (call (core svec)
                                                    ,@(dots->vararg
                                                       (map (lambda (ty)
@@ -420,10 +430,9 @@
                   sparams))
          (keyword-sparams
           (filter (lambda (s)
-                    (not (expr-contains-eq (car s) (cons 'list positional-sparams))))
-                  sparams))
-         (keyword-sparam-names
-          (map car keyword-sparams)))
+                    (not (any (lambda (p) (eq? (car p) (car s)))
+                              positional-sparams)))
+                  sparams)))
     (let ((kw (gensy)) (i (gensy)) (ii (gensy)) (elt (gensy))
           (rkw (if (null? restkw) '() (symbol (string (car restkw) "..."))))
           (mangled (symbol (string "#" (if name (undot-name name) 'call) "#"
@@ -497,15 +506,15 @@
                                    (rval0 `(call (core arrayref) ,kw
                                                  (call (top +) ,ii 1)))
                                    ;; note: if the "declared" type of a KW arg
-                                   ;; includes something from keyword-sparam-names,
+                                   ;; includes something from keyword-sparams
                                    ;; then don't assert it here, since those static
                                    ;; parameters don't have values yet.
                                    ;; instead, the type will be picked up when the
                                    ;; underlying method is called.
                                    (rval (if (and (decl? k)
                                                   (not (any (lambda (s)
-                                                              (expr-contains-eq s (caddr k)))
-                                                            keyword-sparam-names)))
+                                                              (expr-contains-eq (car s) (caddr k)))
+                                                            keyword-sparams)))
                                              `(call (core typeassert)
                                                     ,rval0
                                                     ,(caddr k))
diff --git a/src/julia.h b/src/julia.h
index 36a7ce2e4309de..aed6f1f6d79006 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -987,6 +987,7 @@ JL_DLLEXPORT int jl_isa(jl_value_t *a, jl_value_t *t);
 JL_DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b);
 JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n);
 JL_DLLEXPORT jl_value_t *jl_type_intersection(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_type_unionall(jl_tvar_t *v, jl_value_t *body);
 JL_DLLEXPORT const char *jl_typename_str(jl_value_t *v);
 JL_DLLEXPORT const char *jl_typeof_str(jl_value_t *v);
 JL_DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b);
@@ -1004,7 +1005,6 @@ STATIC_INLINE int jl_is_leaf_type_(jl_value_t *v)
 // type constructors
 JL_DLLEXPORT jl_typename_t *jl_new_typename(jl_sym_t *name);
 JL_DLLEXPORT jl_tvar_t *jl_new_typevar(jl_sym_t *name, jl_value_t *lb, jl_value_t *ub);
-JL_DLLEXPORT jl_unionall_t *jl_new_unionall_type(jl_tvar_t *v, jl_value_t *body);
 JL_DLLEXPORT jl_value_t *jl_instantiate_unionall(jl_unionall_t *u, jl_value_t *p);
 JL_DLLEXPORT jl_value_t *jl_apply_type(jl_value_t *tc, jl_value_t **params, size_t n);
 JL_DLLEXPORT jl_value_t *jl_apply_type1(jl_value_t *tc, jl_value_t *p1);
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 9beadd31caf99f..55e08b193ce8a2 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -329,8 +329,7 @@ jl_datatype_t *jl_inst_concrete_tupletype_v(jl_value_t **p, size_t np);
 jl_datatype_t *jl_inst_concrete_tupletype(jl_svec_t *p);
 JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype);
 void jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_t fptr);
-jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
-                                          jl_svec_t **penv, jl_svec_t *tvars);
+jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b, jl_svec_t **penv);
 jl_value_t *jl_instantiate_type_with(jl_value_t *t, jl_value_t **env, size_t n);
 jl_value_t *jl_substitute_var(jl_value_t *t, jl_tvar_t *var, jl_value_t *val);
 jl_datatype_t *jl_new_uninitialized_datatype(void);
@@ -768,7 +767,7 @@ jl_typemap_entry_t *jl_typemap_insert(union jl_typemap_t *cache, jl_value_t *par
                                       jl_value_t **overwritten);
 
 jl_typemap_entry_t *jl_typemap_assoc_by_type(union jl_typemap_t ml_or_cache, jl_tupletype_t *types, jl_svec_t **penv,
-        int8_t subtype_inexact__sigseq_useenv, int8_t subtype, int8_t offs, size_t world);
+        int8_t inexact, int8_t subtype, int8_t offs, size_t world);
 static jl_typemap_entry_t *const INEXACT_ENTRY = (jl_typemap_entry_t*)(uintptr_t)-1;
 jl_typemap_entry_t *jl_typemap_level_assoc_exact(jl_typemap_level_t *cache, jl_value_t **args, size_t n, int8_t offs, size_t world);
 jl_typemap_entry_t *jl_typemap_entry_assoc_exact(jl_typemap_entry_t *mn, jl_value_t **args, size_t n, size_t world);
@@ -800,9 +799,7 @@ struct typemap_intersection_env {
 };
 int jl_typemap_intersection_visitor(union jl_typemap_t a, int offs, struct typemap_intersection_env *closure);
 
-int sigs_eq(jl_value_t *a, jl_value_t *b, int useenv);
-
-jl_value_t *jl_lookup_match(jl_value_t *a, jl_value_t *b, jl_svec_t **penv, jl_svec_t *tvars);
+jl_value_t *jl_lookup_match(jl_value_t *a, jl_value_t *b, jl_svec_t **penv);
 
 unsigned jl_special_vector_alignment(size_t nfields, jl_value_t *field_type);
 
diff --git a/src/macroexpand.scm b/src/macroexpand.scm
index d91b00847f9086..36fec359a1b188 100644
--- a/src/macroexpand.scm
+++ b/src/macroexpand.scm
@@ -57,7 +57,7 @@
     (cons 'varlist (append (llist-vars (fix-arglist argl))
                            (apply nconc
                                   (map (lambda (v) (trycatch
-                                                    (list (sparam-name v))
+                                                    (list (typevar-expr-name v))
                                                     (lambda (e) '())))
                                        sparams)))))
 
@@ -164,9 +164,7 @@
       (cadr e)
       e))
 
-(define (typevar-expr-name e)
-  (if (symbol? e) e
-      (cadr e)))
+(define (typevar-expr-name e) (car (analyze-typevar e)))
 
 (define (new-expansion-env-for x env (outermost #f))
   (let ((introduced (pattern-expand1 vars-introduced-by-patterns x)))
diff --git a/src/stackwalk.c b/src/stackwalk.c
index 2b2526a5e852e5..d3b8cf12a2f133 100644
--- a/src/stackwalk.c
+++ b/src/stackwalk.c
@@ -92,7 +92,7 @@ JL_DLLEXPORT jl_value_t *jl_backtrace_from_here(int returnsp)
     jl_array_t *sp = NULL;
     JL_GC_PUSH2(&ip, &sp);
     if (array_ptr_void_type == NULL) {
-        array_ptr_void_type = jl_apply_type2((jl_value_t*)jl_array_type, jl_voidpointer_type, jl_box_long(1));
+        array_ptr_void_type = jl_apply_type2((jl_value_t*)jl_array_type, (jl_value_t*)jl_voidpointer_type, jl_box_long(1));
     }
     ip = jl_alloc_array_1d(array_ptr_void_type, 0);
     sp = returnsp ? jl_alloc_array_1d(array_ptr_void_type, 0) : NULL;
@@ -124,7 +124,7 @@ JL_DLLEXPORT jl_value_t *jl_get_backtrace(void)
     jl_array_t *bt = NULL;
     JL_GC_PUSH1(&bt);
     if (array_ptr_void_type == NULL) {
-        array_ptr_void_type = jl_apply_type2((jl_value_t*)jl_array_type, jl_voidpointer_type, jl_box_long(1));
+        array_ptr_void_type = jl_apply_type2((jl_value_t*)jl_array_type, (jl_value_t*)jl_voidpointer_type, jl_box_long(1));
     }
     bt = jl_alloc_array_1d(array_ptr_void_type, ptls->bt_size);
     memcpy(bt->data, ptls->bt_data, ptls->bt_size * sizeof(void*));
diff --git a/src/subtype.c b/src/subtype.c
index 9004075864a7d5..cef9911cf2b9cc 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -83,8 +83,8 @@ typedef struct {
     int envsz;                // length of envout
     int envidx;               // current index in envout
     int invdepth;             // current number of invariant constructors we're nested in
-    int ignore_free;
-    int intersection;
+    int ignore_free;          // treat free vars as black boxes; used during intersection
+    int intersection;         // true iff subtype is being called from intersection
 } jl_stenv_t;
 
 // state manipulation utilities
@@ -129,7 +129,12 @@ static void statestack_pop(jl_unionstate_t *st)
     st->stacksize--;
 }
 
-static void save_env(jl_stenv_t *e, jl_value_t **root, int8_t **buf)
+typedef struct {
+    int8_t *buf;
+    int rdepth;
+} jl_savedenv_t;
+
+static void save_env(jl_stenv_t *e, jl_value_t **root, jl_savedenv_t *se)
 {
     jl_varbinding_t *v = e->vars;
     int len=0;
@@ -138,32 +143,32 @@ static void save_env(jl_stenv_t *e, jl_value_t **root, int8_t **buf)
         v = v->prev;
     }
     *root = (jl_value_t*)jl_alloc_svec(len*2);
-    *buf = (int8_t*)malloc(len*2 + sizeof(int));
+    se->buf = (int8_t*)(len ? malloc(len*2) : NULL);
     int i=0; v = e->vars;
     while (v != NULL) {
-        jl_svecset(*root, i, v->lb); (*buf)[i] = v->occurs_inv;
+        jl_svecset(*root, i, v->lb); se->buf[i] = v->occurs_inv;
         i++;
-        jl_svecset(*root, i, v->ub); (*buf)[i] = v->occurs_cov;
+        jl_svecset(*root, i, v->ub); se->buf[i] = v->occurs_cov;
         i++;
         v = v->prev;
     }
-    *(int*)(&(*buf)[i]) = e->Runions.depth;
+    se->rdepth = e->Runions.depth;
 }
 
-static void restore_env(jl_stenv_t *e, jl_value_t *root, int8_t *buf)
+static void restore_env(jl_stenv_t *e, jl_value_t *root, jl_savedenv_t *se)
 {
     jl_varbinding_t *v = e->vars;
     int i = 0;
     while (v != NULL) {
         if (root) v->lb = jl_svecref(root, i);
-        v->occurs_inv = buf[i];
+        v->occurs_inv = se->buf[i];
         i++;
         if (root) v->ub = jl_svecref(root, i);
-        v->occurs_cov = buf[i];
+        v->occurs_cov = se->buf[i];
         i++;
         v = v->prev;
     }
-    e->Runions.depth = *(int*)(&buf[i]);
+    e->Runions.depth = se->rdepth;
 }
 
 // type utilities
@@ -188,16 +193,47 @@ static int obviously_egal(jl_value_t *a, jl_value_t *b)
         return obviously_egal(((jl_uniontype_t*)a)->a, ((jl_uniontype_t*)b)->a) &&
             obviously_egal(((jl_uniontype_t*)a)->b, ((jl_uniontype_t*)b)->b);
     }
-    /* // not clear whether this helps at all
     if (jl_is_unionall(a)) {
         return ((jl_unionall_t*)a)->var == ((jl_unionall_t*)b)->var &&
             obviously_egal(((jl_unionall_t*)a)->body, ((jl_unionall_t*)b)->body);
     }
-    */
     if (jl_is_typevar(a)) return 0;
     return !jl_is_type(a) && jl_egal(a,b);
 }
 
+static int obviously_unequal(jl_value_t *a, jl_value_t *b)
+{
+    if (jl_is_unionall(a)) a = jl_unwrap_unionall(a);
+    if (jl_is_unionall(b)) b = jl_unwrap_unionall(b);
+    if (jl_is_datatype(a)) {
+        if (b == jl_bottom_type) return 1;
+        if (jl_is_datatype(b)) {
+            jl_datatype_t *ad = (jl_datatype_t*)a, *bd = (jl_datatype_t*)b;
+            if (ad->name != bd->name)
+                return 1;
+            size_t i, np = jl_nparams(ad);
+            if (np != jl_nparams(bd)) return 1;
+            for(i=0; i < np; i++) {
+                if (obviously_unequal(jl_tparam(ad,i), jl_tparam(bd,i)))
+                    return 1;
+            }
+        }
+    }
+    else if (a == jl_bottom_type && jl_is_datatype(b)) {
+        return 1;
+    }
+    if (jl_is_typevar(a) && jl_is_typevar(b) && obviously_unequal(((jl_tvar_t*)a)->ub, ((jl_tvar_t*)b)->ub))
+        return 1;
+    if (jl_is_long(a)) {
+        if (jl_is_long(b) && jl_unbox_long(a) != jl_unbox_long(b))
+            return 1;
+    }
+    else if (jl_is_long(b)) return 1;
+    if ((jl_is_symbol(a) || jl_is_symbol(b)) && a != b)
+        return 1;
+    return 0;
+}
+
 static int in_union(jl_value_t *u, jl_value_t *x)
 {
     if (u == x) return 1;
@@ -218,6 +254,17 @@ static jl_value_t *simple_join(jl_value_t *a, jl_value_t *b)
         return a;
     if (jl_is_uniontype(b) && in_union(b, a))
         return b;
+    if (is_kind(a) && jl_is_type_type(b) && jl_typeof(jl_tparam0(b)) == a)
+        return a;
+    if (is_kind(b) && jl_is_type_type(a) && jl_typeof(jl_tparam0(a)) == b)
+        return b;
+    if (jl_is_type_type(a) && jl_is_type_type(b) && !jl_is_typevar(jl_tparam0(a)) &&
+        jl_typeof(jl_tparam0(a)) == jl_typeof(jl_tparam0(b)))
+        return jl_typeof(jl_tparam0(a));
+    if (!jl_has_free_typevars(a) && !jl_has_free_typevars(b)) {
+        if (jl_subtype(a, b)) return b;
+        if (jl_subtype(b, a)) return a;
+    }
     return jl_new_struct(jl_uniontype_type, a, b);
 }
 
@@ -296,16 +343,23 @@ static int var_lt(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int param)
     record_var_occurrence(bb, e, param);
     if (!bb->right)  // check ∀b . b<:a
         return subtype_ufirst(bb->ub, a, e);
+    if (bb->ub == a)
+        return 1;
     if (!((bb->lb == jl_bottom_type && !jl_is_type(a) && !jl_is_typevar(a)) || subtype_ufirst(bb->lb, a, e)))
         return 0;
     // for contravariance we would need to compute a meet here, but
     // because of invariance bb.ub ⊓ a == a here always. however for this
     // to work we need to compute issub(left,right) before issub(right,left),
     // since otherwise the issub(a, bb.ub) check in var_gt becomes vacuous.
-    if (e->intersection)
-        bb->ub = intersect_ufirst(bb->ub, a, e, bb->depth0);
-    else
+    if (e->intersection) {
+        jl_value_t *ub = intersect_ufirst(bb->ub, a, e, bb->depth0);
+        if (ub != (jl_value_t*)b)
+            bb->ub = ub;
+    }
+    else {
         bb->ub = a;  // meet(bb->ub, a)
+    }
+    assert(bb->ub != (jl_value_t*)b);
     if (jl_is_typevar(a)) {
         jl_varbinding_t *aa = lookup(e, (jl_tvar_t*)a);
         if (aa && !aa->right && in_union(bb->lb, a) && bb->depth0 != aa->depth0 && var_outside(e, b, (jl_tvar_t*)a)) {
@@ -329,6 +383,7 @@ static int var_gt(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int param)
     if (!((bb->ub == (jl_value_t*)jl_any_type && !jl_is_type(a) && !jl_is_typevar(a)) || subtype_ufirst(a, bb->ub, e)))
         return 0;
     bb->lb = simple_join(bb->lb, a);
+    assert(bb->lb != (jl_value_t*)b);
     return 1;
 }
 
@@ -382,7 +437,9 @@ static int subtype_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8
         // fill variable values into `envout` up to `envsz`
         if (e->envidx < e->envsz) {
             jl_value_t *val;
-            if (vb.lb == vb.ub)
+            if (!vb.occurs_inv && vb.lb != jl_bottom_type)
+                val = is_leaf_bound(vb.lb) ? vb.lb : (jl_value_t*)jl_new_typevar(u->var->name, jl_bottom_type, vb.lb);
+            else if (vb.lb == vb.ub)
                 val = vb.lb;
             else if (vb.lb != jl_bottom_type)
                 // TODO: for now return the least solution, which is what
@@ -392,6 +449,9 @@ static int subtype_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8
                 val = (jl_value_t*)u->var;
             else
                 val = (jl_value_t*)jl_new_typevar(u->var->name, vb.lb, vb.ub);
+            // widen Type{x} to typeof(x) in argument position
+            if (jl_is_type_type(val) && !vb.occurs_inv && !jl_is_typevar(jl_tparam0(val)))
+                val = jl_typeof(jl_tparam0(val));
             e->envout[e->envidx] = val;
         }
     }
@@ -434,6 +494,17 @@ static int subtype_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8
     }
 
     e->vars = vb.prev;
+
+    btemp = e->vars;
+    while (btemp != NULL) {
+        jl_value_t *vi = btemp->ub;
+        if (vi != (jl_value_t*)vb.var && jl_has_typevar(vi, vb.var)) {
+            btemp->ub = jl_new_struct(jl_unionall_type, vb.var, vi);
+            btemp->lb = jl_bottom_type;
+        }
+        btemp = btemp->prev;
+    }
+
     JL_GC_POP();
     return ans;
 }
@@ -461,7 +532,13 @@ static int check_vararg_length(jl_value_t *v, ssize_t n, jl_stenv_t *e)
     jl_value_t *N = jl_tparam1(tail);
     // only do the check if N is free in the tuple type's last parameter
     if (N != (jl_value_t*)va_p1 && N != (jl_value_t*)va_p2) {
-        if (!subtype(jl_box_long(n), N, e, 2))
+        jl_value_t *nn = jl_box_long(n);
+        JL_GC_PUSH1(&nn);
+        e->invdepth++;
+        int ans = subtype(nn, N, e, 2) && subtype(N, nn, e, 0);
+        e->invdepth--;
+        JL_GC_POP();
+        if (!ans)
             return 0;
     }
     return 1;
@@ -475,24 +552,55 @@ static int subtype_tuple(jl_datatype_t *xd, jl_datatype_t *yd, jl_stenv_t *e, in
     if (ly == 0)
         return 0;
     size_t i=0, j=0;
-    int vx=0, vy=0;
+    int vx=0, vy=0, vvx = (lx > 0 && jl_is_vararg_type(jl_tparam(xd, lx-1)));
+    int vvy = (ly > 0 && jl_is_vararg_type(jl_tparam(yd, ly-1)));
+    if (vvx) {
+        if ((vvy && ly > lx) || (!vvy && ly < lx-1))
+            return 0;
+    }
+    else if (!vvy && lx != ly) {
+        return 0;
+    }
     param = (param == 0 ? 1 : param);
+    jl_value_t *lastx=NULL, *lasty=NULL;
     while (i < lx) {
-        if (j >= ly) return 0;
+        if (j >= ly) return vx;
         jl_value_t *xi = jl_tparam(xd, i), *yi = jl_tparam(yd, j);
         if (jl_is_vararg_type(xi)) vx = 1;
         if (jl_is_vararg_type(yi)) vy = 1;
-        if (vx && !vy)
-            return 0;
-        if (!vx && vy) {
-            if (!subtype(xi, jl_unwrap_vararg(yi), e, param))
+        if (vx && !vy) {
+            if (!check_vararg_length(xi, ly+1-lx, e))
+                return 0;
+            jl_tvar_t *p1=NULL, *p2=NULL;
+            xi = unwrap_2_unionall(xi, &p1, &p2);
+            jl_value_t *N = jl_tparam1(xi);
+            if (N == (jl_value_t*)p1 || N == (jl_value_t*)p2)
                 return 0;
+            xi = jl_tparam0(xi);
         }
-        else {
-            if (!subtype(xi, yi, e, param))
+        else if (!vx && vy) {
+            jl_tvar_t *p1=NULL, *p2=NULL;
+            yi = jl_tparam0(unwrap_2_unionall(yi, &p1, &p2));
+            if (yi == (jl_value_t*)p1 || yi == (jl_value_t*)p2)
+                yi = ((jl_tvar_t*)yi)->ub;
+            if (!vvx && yi == (jl_value_t*)jl_any_type)
+                break;  // if y ends in `Vararg{Any}` skip checking everything
+        }
+        if (xi == lastx && yi == lasty && !jl_has_free_typevars(xi) && !jl_has_free_typevars(yi)) {
+            // fast path for repeated elements
+        }
+        else if (e->Runions.depth == 0 && e->Lunions.depth == 0 && !jl_has_free_typevars(xi) && !jl_has_free_typevars(yi)) {
+            // fast path for separable sub-formulas
+            if (!jl_subtype(xi, yi))
                 return 0;
         }
-        i++;
+        else if (!subtype(xi, yi, e, param)) {
+            return 0;
+        }
+        if (vx && vy) break;
+        lastx = xi; lasty = yi;
+        if (i < lx-1 || !vx)
+            i++;
         if (j < ly-1 || !vy)
             j++;
     }
@@ -544,6 +652,8 @@ static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
     }
     if (jl_is_typevar(y))
         return var_gt((jl_tvar_t*)y, x, e, param);
+    if (y == (jl_value_t*)jl_any_type && !jl_has_free_typevars(x))
+        return 1;
     if (jl_is_uniontype(x)) {
         if (x == y) return 1;
         if (param == 2) {
@@ -585,16 +695,28 @@ static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
             return 0;
         }
         if (jl_is_type_type(y) && !jl_is_type_type(x)) {
-            if (!jl_is_typevar(jl_tparam0(yd)))
+            jl_value_t *tp0 = jl_tparam0(yd);
+            if (!jl_is_typevar(tp0))
                 return 0;
             if (!is_kind(x)) return 0;
-            e->invdepth++;
-            int ans = subtype(x, jl_tparam0(yd), e, 2) && subtype(jl_tparam0(yd), x, e, 0);
-            e->invdepth--;
+            jl_varbinding_t *yy = lookup(e, (jl_tvar_t*)tp0);
+            jl_value_t *ub = yy ? yy->ub : ((jl_tvar_t*)tp0)->ub;
+            int ans;
+            if (ub == (jl_value_t*)jl_any_type) {
+                ans = subtype((jl_value_t*)jl_type_type, y, e, param);
+            }
+            else {
+                e->invdepth++;
+                ans = subtype(x, jl_tparam0(yd), e, 2) && subtype(jl_tparam0(yd), x, e, 0);
+                e->invdepth--;
+            }
             return ans;
         }
-        while (xd != jl_any_type && xd->name != yd->name)
+        while (xd != jl_any_type && xd->name != yd->name) {
+            if (xd->super == NULL)
+                jl_errorf("circular type parameter constraint in definition of %s", jl_symbol_name(xd->name->name));
             xd = xd->super;
+        }
         if (xd == jl_any_type) return 0;
         if (jl_is_tuple_type(xd))
             return subtype_tuple(xd, yd, e, param);
@@ -629,7 +751,7 @@ static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
     return x == y || jl_egal(x, y);
 }
 
-static int exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int8_t anyunions, jl_value_t *saved, int8_t *buf)
+static int exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int8_t anyunions, jl_value_t *saved, jl_savedenv_t *se)
 {
     int exists;
     for (exists=0; exists <= anyunions; exists++) {
@@ -652,11 +774,11 @@ static int exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int8_t an
         }
         if (e->Runions.more) {
             statestack_push(&e->Runions, 0);
-            found = exists_subtype(x, y, e, 1, saved, buf);
+            found = exists_subtype(x, y, e, 1, saved, se);
             statestack_pop(&e->Runions);
         }
         else {
-            if (!found) restore_env(e, saved, buf);
+            if (!found) restore_env(e, saved, se);
         }
         if (found) return 1;
     }
@@ -665,30 +787,30 @@ static int exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int8_t an
 
 static int forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int8_t anyunions)
 {
-    jl_value_t *saved=NULL; int8_t *buf;
+    jl_value_t *saved=NULL; jl_savedenv_t se;
     JL_GC_PUSH1(&saved);
     int forall;
     for (forall=0; forall <= anyunions; forall++) {
         if (e->Lunions.stacksize > 0)
             statestack_set(&e->Lunions, e->Lunions.stacksize-1, forall);
-        save_env(e, &saved, &buf);
-        if (!exists_subtype(x, y, e, 0, saved, buf)) {
-            free(buf);
+        save_env(e, &saved, &se);
+        if (!exists_subtype(x, y, e, 0, saved, &se)) {
+            free(se.buf);
             JL_GC_POP();
             return 0;
         }
         if (e->Lunions.more) {
-            restore_env(e, saved, buf);
+            restore_env(e, saved, &se);
             statestack_push(&e->Lunions, 0);
             int sub = forall_exists_subtype(x, y, e, 1);
             statestack_pop(&e->Lunions);
             if (!sub) {
-                free(buf);
+                free(se.buf);
                 JL_GC_POP();
                 return 0;
             }
         }
-        free(buf);
+        free(se.buf);
     }
     JL_GC_POP();
     return 1;
@@ -728,6 +850,8 @@ JL_DLLEXPORT int jl_subtype_env_size(jl_value_t *t)
 JL_DLLEXPORT int jl_subtype_env(jl_value_t *x, jl_value_t *y, jl_value_t **env, int envsz)
 {
     jl_stenv_t e;
+    if (envsz == 0 && (y == (jl_value_t*)jl_any_type || x == jl_bottom_type || x == y))
+        return 1;
     init_stenv(&e, env, envsz);
     return forall_exists_subtype(x, y, &e, 0);
 }
@@ -746,21 +870,28 @@ static int subtype_in_env(jl_value_t *x, jl_value_t *y, jl_stenv_t *e)
 
 JL_DLLEXPORT int jl_subtype(jl_value_t *x, jl_value_t *y)
 {
-    if (y == (jl_value_t*)jl_any_type || x == jl_bottom_type || x == y)
-        return 1;
     return jl_subtype_env(x, y, NULL, 0);
 }
 
 JL_DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b)
 {
-    if (obviously_egal(a, b))
-        return 1;
+    if (obviously_egal(a, b))    return 1;
+    if (obviously_unequal(a, b)) return 0;
     return jl_subtype(a, b) && jl_subtype(b, a);
 }
 
 int jl_tuple_isa(jl_value_t **child, size_t cl, jl_datatype_t *pdt)
 {
-    // TODO jb/subtype avoid allocation
+    if (jl_is_tuple_type(pdt) && !jl_is_va_tuple(pdt)) {
+        if (cl != jl_nparams(pdt))
+            return 0;
+        size_t i;
+        for(i=0; i < cl; i++) {
+            if (!jl_isa(child[i], jl_tparam(pdt,i)))
+                return 0;
+        }
+        return 1;
+    }
     jl_value_t *tu = (jl_value_t*)arg_type_tuple(child, cl);
     int ans;
     JL_GC_PUSH1(&tu);
@@ -776,16 +907,32 @@ JL_DLLEXPORT int jl_isa(jl_value_t *x, jl_value_t *t)
     if (jl_is_type(x)) {
         if (t == (jl_value_t*)jl_type_type)
             return 1;
-        if (jl_is_leaf_type(t)) {
-            if (jl_is_type_type(t))
-                return jl_types_equal(x, jl_tparam0(t));
-            return 0;
+        if (!jl_has_free_typevars(x)) {
+            if (jl_is_leaf_type(t)) {
+                if (jl_is_type_type(t))
+                    return jl_types_equal(x, jl_tparam0(t));
+                return 0;
+            }
+            jl_value_t *t2 = jl_unwrap_unionall(t);
+            if (jl_is_datatype(t2)) {
+                if (((jl_datatype_t*)t2)->name == jl_type_typename) {
+                    jl_value_t *tp = jl_tparam0(t2);
+                    if (jl_is_typevar(tp)) {
+                        while (jl_is_typevar(tp))
+                            tp = ((jl_tvar_t*)tp)->ub;
+                        return jl_subtype(x, tp);
+                    }
+                }
+                else {
+                    return 0;
+                }
+            }
+            JL_GC_PUSH1(&x);
+            x = (jl_value_t*)jl_wrap_Type(x);  // TODO jb/subtype avoid jl_wrap_Type
+            int ans = jl_subtype(x, t);
+            JL_GC_POP();
+            return ans;
         }
-        JL_GC_PUSH1(&x);
-        x = (jl_value_t*)jl_wrap_Type(x);
-        int ans = jl_subtype(x, t);
-        JL_GC_POP();
-        return ans;
     }
     if (jl_is_leaf_type(t))
         return 0;
@@ -798,14 +945,14 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
 
 static jl_value_t *intersect_union(jl_value_t *x, jl_uniontype_t *u, jl_stenv_t *e, int8_t R, int param)
 {
-    if (param == 2) {
-        jl_value_t *a=NULL, *b=NULL, *save=NULL; int8_t *buf;
+    if (param == 2 || (!jl_has_free_typevars(x) && !jl_has_free_typevars((jl_value_t*)u))) {
+        jl_value_t *a=NULL, *b=NULL, *save=NULL; jl_savedenv_t se;
         JL_GC_PUSH3(&a, &b, &save);
-        save_env(e, &save, &buf);
+        save_env(e, &save, &se);
         a = R ? intersect(x, u->a, e, param) : intersect(u->a, x, e, param);
-        restore_env(e, NULL, buf);
+        restore_env(e, NULL, &se);
         b = R ? intersect(x, u->b, e, param) : intersect(u->b, x, e, param);
-        free(buf);
+        free(se.buf);
         jl_value_t *i = simple_join(a,b);
         JL_GC_POP();
         return i;
@@ -867,6 +1014,7 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int
     if (!jl_is_type(a) && !jl_is_typevar(a))
         return set_var_to_const(bb, a, NULL);
     int d = bb->depth0;
+    jl_value_t *root=NULL; jl_savedenv_t se;
     if (param == 2) {
         if (bb->lb == bb->ub && jl_is_typevar(bb->lb))
             return intersect(a, bb->ub, e, param);
@@ -880,6 +1028,18 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int
         return ub;
     }
     else if (bb->constraintkind == 0) {
+        if (!jl_is_typevar(a)) {
+            jl_value_t *ret=NULL;
+            JL_GC_PUSH1(&root);
+            save_env(e, &root, &se);
+            if (subtype_in_env(bb->ub, a, e))
+                ret = (jl_value_t*)b;
+            else
+                restore_env(e, root, &se);
+            free(se.buf);
+            JL_GC_POP();
+            if (ret) return ret;
+        }
         return R ? intersect_ufirst(a, bb->ub, e, d) : intersect_ufirst(bb->ub, a, e, d);
     }
     else if (bb->concrete || bb->constraintkind == 1) {
@@ -893,7 +1053,9 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int
     else if (bb->constraintkind == 2) {
         if (!subtype_in_env(a, bb->ub, e))
             return jl_bottom_type;
-        bb->lb = simple_join(bb->lb, a);
+        jl_value_t *lb = simple_join(bb->lb, a);
+        if (lb != (jl_value_t*)b)
+            bb->lb = lb;
         return a;
     }
     assert(bb->constraintkind == 3);
@@ -902,17 +1064,21 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int
         return jl_bottom_type;
     if (jl_is_typevar(a))
         return (jl_value_t*)b;
-    jl_value_t *root; int8_t *buf;
+    if (ub == a) {
+        bb->ub = ub;
+        return (jl_value_t*)b;
+    }
+    root = NULL;
     JL_GC_PUSH2(&root, &ub);
-    save_env(e, &root, &buf);
+    save_env(e, &root, &se);
     jl_value_t *ii = R ? intersect_ufirst(a, bb->lb, e, d) : intersect_ufirst(bb->lb, a, e, d);
     if (ii == jl_bottom_type) {
-        restore_env(e, root, buf);
+        restore_env(e, root, &se);
         ii = (jl_value_t*)b;
         if (ub != (jl_value_t*)b)
             bb->ub = ub;
     }
-    free(buf);
+    free(se.buf);
     JL_GC_POP();
     return ii;
 }
@@ -987,14 +1153,25 @@ static jl_value_t *finish_unionall(jl_value_t *res, jl_varbinding_t *vb, jl_sten
     if (jl_has_typevar(res, vb->var)) {
         res = jl_new_struct(jl_unionall_type, vb->var, res);
         if (varval) {
-            res = jl_instantiate_unionall((jl_unionall_t*)res, varval);
+            JL_TRY {
+                // you can construct `T{x} where x` even if T's parameter is actually
+                // limited. in that case we might get an invalid instantiation here.
+                res = jl_instantiate_unionall((jl_unionall_t*)res, varval);
+            }
+            JL_CATCH {
+                res = jl_bottom_type;
+            }
         }
         else {
-            root = (jl_value_t*)jl_new_typevar(vb->var->name, vb->lb, vb->ub);
+            varval = root = (jl_value_t*)jl_new_typevar(vb->var->name, vb->lb, vb->ub);
             res = jl_instantiate_unionall((jl_unionall_t*)res, root);
             res = jl_new_struct(jl_unionall_type, (jl_tvar_t*)root, res);
         }
     }
+
+    if (vb->right && e->envidx < e->envsz)
+        e->envout[e->envidx] = varval ? varval : (jl_value_t*)vb->var;
+
     JL_GC_POP();
     return res;
 }
@@ -1013,35 +1190,19 @@ static jl_value_t *intersect_unionall_(jl_value_t *t, jl_unionall_t *u, jl_stenv
         }
         btemp = btemp->prev;
     }
+    JL_GC_PUSH1(&u);
     vb->var = u->var;
     e->vars = vb;
-    jl_value_t *res = R ? intersect(t, u->body, e, param) : intersect(u->body, t, e, param);
-    vb->concrete |= (!vb->occurs_inv && vb->occurs_cov > 1);
-    /*
+    jl_value_t *res;
     if (R) {
         e->envidx++;
-        ans = subtype(t, u->body, e, param);
+        res = intersect(t, u->body, e, param);
         e->envidx--;
-        // fill variable values into `envout` up to `envsz`
-        if (e->envidx < e->envsz) {
-            jl_value_t *val;
-            if (vb->lb == vb->ub)
-                val = vb->lb;
-            else if (vb->lb != jl_bottom_type)
-                // TODO: for now return the least solution, which is what
-                // method parameters expect.
-                val = vb->lb;
-            else if (vb->lb == u->var->lb && vb->ub == u->var->ub)
-                val = (jl_value_t*)u->var;
-            else
-                val = (jl_value_t*)jl_new_typevar(u->var->name, vb->lb, vb->ub);
-            e->envout[e->envidx] = val;
-        }
     }
     else {
-        ans = subtype(u->body, t, e, param);
+        res = intersect(u->body, t, e, param);
     }
-    */
+    vb->concrete |= (!vb->occurs_inv && vb->occurs_cov > 1);
 
     // handle the "diagonal dispatch" rule, which says that a type var occurring more
     // than once, and only in covariant position, is constrained to concrete types. E.g.
@@ -1068,47 +1229,47 @@ static jl_value_t *intersect_unionall_(jl_value_t *t, jl_unionall_t *u, jl_stenv
     }
     if (res != jl_bottom_type)
         res = finish_unionall(res, vb, e);
-
+    JL_GC_POP();
     return res;
 }
 
 static jl_value_t *intersect_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8_t R, int param)
 {
     jl_value_t *res=NULL, *res2=NULL, *save=NULL, *save2=NULL;
-    int8_t *buf=NULL, *buf2=NULL;
+    jl_savedenv_t se, se2;
     jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, NULL, 0, 0, 0, 0, e->invdepth, 0, e->vars };
     JL_GC_PUSH5(&res, &save2, &vb.lb, &vb.ub, &save);
-    save_env(e, &save, &buf);
+    save_env(e, &save, &se);
     res = intersect_unionall_(t, u, e, R, param, &vb);
     if (res != jl_bottom_type && !e->Runions.more) {
         if (vb.concrete || vb.occurs_inv>1 || (vb.occurs_inv && vb.occurs_cov)) {
-            restore_env(e, NULL, buf);
+            restore_env(e, NULL, &se);
             vb.occurs_cov = vb.occurs_inv = 0;
             vb.constraintkind = 3;
             res = intersect_unionall_(t, u, e, R, param, &vb);
         }
         else if (vb.occurs_cov) {
-            save_env(e, &save2, &buf2);
-            restore_env(e, save, buf);
+            save_env(e, &save2, &se2);
+            restore_env(e, save, &se);
             vb.occurs_cov = vb.occurs_inv = 0;
             vb.lb = u->var->lb; vb.ub = u->var->ub;
             vb.constraintkind = 2;
             res2 = intersect_unionall_(t, u, e, R, param, &vb);
             if (res2 == jl_bottom_type && !e->Runions.more) {
-                restore_env(e, save, buf);
+                restore_env(e, save, &se);
                 vb.occurs_cov = vb.occurs_inv = 0;
                 vb.lb = u->var->lb; vb.ub = u->var->ub;
                 vb.constraintkind = 1;
                 res2 = intersect_unionall_(t, u, e, R, param, &vb);
                 if (res2 == jl_bottom_type)
-                    restore_env(e, save2, buf2);
+                    restore_env(e, save2, &se2);
             }
             if (res2 != jl_bottom_type)
                 res = res2;
-            free(buf2);
+            free(se2.buf);
         }
     }
-    free(buf);
+    free(se.buf);
     JL_GC_POP();
     return res;
 }
@@ -1184,8 +1345,8 @@ static jl_value_t *intersect_tuple(jl_datatype_t *xd, jl_datatype_t *yd, jl_sten
         if (ii == jl_bottom_type) {
             if (vx && vy) {
                 int len = i > j ? i : j;
-                if ((xb && jl_is_long(xb->lb) && lx-1+jl_unbox_long(xb->lb) > len) ||
-                    (yb && jl_is_long(yb->lb) && ly-1+jl_unbox_long(yb->lb) > len))
+                if ((xb && jl_is_long(xb->lb) && lx-1+jl_unbox_long(xb->lb) != len) ||
+                    (yb && jl_is_long(yb->lb) && ly-1+jl_unbox_long(yb->lb) != len))
                     res = jl_bottom_type;
                 else
                     res = (jl_value_t*)jl_apply_tuple_type_v(jl_svec_data(params), len);
@@ -1231,15 +1392,33 @@ static jl_value_t *intersect_sub_datatype(jl_datatype_t *xd, jl_datatype_t *yd,
     super_pattern = jl_rewrap_unionall((jl_value_t*)((jl_datatype_t*)jl_unwrap_unionall(wrapper))->super,
                                        wrapper);
     int envsz = jl_subtype_env_size(super_pattern);
-    jl_value_t **env = (jl_value_t**)alloca(envsz * sizeof(jl_value_t*)); // TODO root this
-    jl_value_t *ii;
-    jl_stenv_t tempe;
-    init_stenv(&tempe, env, envsz);
-    tempe.ignore_free = 1;
-    if (!subtype_in_env(isuper, super_pattern, &tempe))
-        ii = jl_bottom_type;
-    else
-        ii = jl_apply_type(wrapper, env, envsz);
+    jl_value_t *ii = jl_bottom_type;
+    {
+        jl_value_t **env;
+        JL_GC_PUSHARGS(env, envsz);
+        jl_stenv_t tempe;
+        init_stenv(&tempe, env, envsz);
+        tempe.ignore_free = 1;
+        if (subtype_in_env(isuper, super_pattern, &tempe)) {
+            jl_value_t *wr = wrapper;
+            int i;
+            for(i=0; i<envsz; i++) {
+                // if a parameter is not constrained by the supertype, use the original
+                // parameter value from `x`. this is detected by the value in `env` being
+                // the exact typevar from the type's `wrapper`.
+                if (env[i] == (jl_value_t*)((jl_unionall_t*)wr)->var)
+                    env[i] = jl_tparam(xd,i);
+                wr = ((jl_unionall_t*)wr)->body;
+            }
+            JL_TRY {
+                ii = jl_apply_type(wrapper, env, envsz);
+            }
+            JL_CATCH {
+                ii = jl_bottom_type;
+            }
+        }
+        JL_GC_POP();
+    }
     JL_GC_POP();
     return ii;
 }
@@ -1266,9 +1445,9 @@ static jl_value_t *intersect_invariant(jl_value_t *x, jl_value_t *y, jl_stenv_t
         return ii;
     }
     jl_value_t *root=NULL;
-    int8_t *buf;
+    jl_savedenv_t se;
     JL_GC_PUSH2(&ii, &root);
-    save_env(e, &root, &buf);
+    save_env(e, &root, &se);
     if (!subtype_in_env(x, y, e)) {
         ii = NULL;
     }
@@ -1278,8 +1457,8 @@ static jl_value_t *intersect_invariant(jl_value_t *x, jl_value_t *y, jl_stenv_t
             ii = NULL;
         flip_vars(e);
     }
-    restore_env(e, root, buf);
-    free(buf);
+    restore_env(e, root, &se);
+    free(se.buf);
     JL_GC_POP();
     return ii;
 }
@@ -1291,12 +1470,17 @@ static jl_value_t *intersect_type_type(jl_value_t *x, jl_value_t *y, jl_stenv_t
     if (!jl_is_typevar(p0))
         return (jl_typeof(p0) == y) ? x : jl_bottom_type;
     if (!is_kind(y)) return jl_bottom_type;
+    if (((jl_tvar_t*)p0)->ub == (jl_value_t*)jl_any_type)
+        return y;
+    return x;
+    /*
     jl_value_t *ii = R ? intersect_invariant(y, jl_tparam0(x), e) : intersect_invariant(jl_tparam0(x), y, e);
     // NOTE: we cannot express e.g. DataType ∩ (UnionAll T<:Integer Type{T}), so returning `x`
     // here is a conservative over-estimate.
-    if (ii == NULL) return x;
+    if (ii == NULL || ii == jl_bottom_type) return x;
     if (ii == y) return ii;
     return (jl_value_t*)jl_wrap_Type(ii);
+    */
 }
 
 // `param` means we are currently looking at a parameter of a type constructor
@@ -1358,21 +1542,27 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
                     return jl_bottom_type;
                 jl_value_t *ub=NULL, *lb=NULL;
                 JL_GC_PUSH2(&lb, &ub);
-                ub = intersect_ufirst(xub, yub, e, xx->depth0);
+                ub = intersect_ufirst(xub, yub, e, xx ? xx->depth0 : 0);
                 lb = simple_join(xlb, ylb);
-                assert(yy);
-                yy->lb = lb;
-                yy->ub = ub;
-                xx->lb = y;
-                xx->ub = y;
-                assert(yy->ub != y);
-                assert(xx->ub != x);
+                if (yy) {
+                    if (lb != y)
+                        yy->lb = lb;
+                    if (ub != y)
+                        yy->ub = ub;
+                    assert(yy->ub != y);
+                    assert(yy->lb != y);
+                }
+                if (xx) {
+                    xx->lb = y;
+                    xx->ub = y;
+                    assert(xx->ub != x);
+                }
                 JL_GC_POP();
                 return y;
             }
             record_var_occurrence(xx, e, param);
             record_var_occurrence(yy, e, param);
-            if (xx->concrete && !yy->concrete) {
+            if (xx && yy && xx->concrete && !yy->concrete) {
                 return intersect_var((jl_tvar_t*)x, y, e, R, param);
             }
             return intersect_var((jl_tvar_t*)y, x, e, !R, param);
@@ -1384,11 +1574,11 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
         record_var_occurrence(lookup(e, (jl_tvar_t*)y), e, param);
         return intersect_var((jl_tvar_t*)y, x, e, 1, param);
     }
+    if (y == (jl_value_t*)jl_any_type) return x;
+    if (x == (jl_value_t*)jl_any_type) return y;
     if (!jl_has_free_typevars(x) && !jl_has_free_typevars(y)) {
-        if (jl_subtype(x, y))
-            return x;
-        if (jl_subtype(y, x))
-            return y;
+        if (jl_subtype(x, y)) return x;
+        if (jl_subtype(y, x)) return y;
     }
     if (jl_is_uniontype(x)) {
         if (y == ((jl_uniontype_t*)x)->a || y == ((jl_uniontype_t*)x)->b)
@@ -1406,8 +1596,8 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
         if (jl_is_unionall(y)) {
             jl_value_t *a=NULL, *b=jl_bottom_type, *res=NULL;
             JL_GC_PUSH2(&a,&b);
-            jl_value_t *unused; int8_t *buf;
-            save_env(e, &unused, &buf);
+            jl_value_t *unused; jl_savedenv_t se;
+            save_env(e, &unused, &se);
             a = intersect_unionall(y, (jl_unionall_t*)x, e, 0, param);
             if (jl_is_unionall(a)) {
                 jl_unionall_t *ua = (jl_unionall_t*)a;
@@ -1415,12 +1605,12 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
                     jl_unionall_t *ub = (jl_unionall_t*)ua->body;
                     if (jl_has_typevar(ub->var->ub, ua->var) ||
                         jl_has_typevar(ub->var->lb, ua->var)) {
-                        restore_env(e, NULL, buf); // restore counts
+                        restore_env(e, NULL, &se); // restore counts
                         b = intersect_unionall(x, (jl_unionall_t*)y, e, 1, param);
                     }
                 }
             }
-            free(buf);
+            free(se.buf);
             if (!jl_has_free_typevars(a) && !jl_has_free_typevars(b)) {
                 if (jl_subtype(a, b))
                     res = b;
@@ -1461,10 +1651,18 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
                     return jl_bottom_type;
                 jl_value_t *i2=NULL, *ii = intersect(xp1, yp1, e, 1);
                 if (ii == jl_bottom_type) return jl_bottom_type;
+                if (jl_is_typevar(xp1)) {
+                    jl_varbinding_t *xb = lookup(e, (jl_tvar_t*)xp1);
+                    if (xb) xb->concrete = 1;
+                }
+                if (jl_is_typevar(yp1)) {
+                    jl_varbinding_t *yb = lookup(e, (jl_tvar_t*)yp1);
+                    if (yb) yb->concrete = 1;
+                }
                 JL_GC_PUSH2(&ii, &i2);
                 // Vararg{T,N} <: Vararg{T2,N2}; equate N and N2
                 i2 = intersect_invariant(xp2, yp2, e);
-                if (i2 == NULL)
+                if (i2 == NULL || i2 == jl_bottom_type || (jl_is_long(i2) && jl_unbox_long(i2) < 0))
                     ii = jl_bottom_type;
                 else
                     ii = jl_apply_type2((jl_value_t*)jl_vararg_type, ii, i2);
@@ -1539,44 +1737,84 @@ JL_DLLEXPORT jl_value_t *jl_intersect_types(jl_value_t *x, jl_value_t *y)
     return intersect_all(x, y, &e, 0);
 }
 
-jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
-                                          jl_svec_t **penv, jl_svec_t *tvars)
+jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b, jl_svec_t **penv)
 {
-    int sza = jl_subtype_env_size(a);
     int szb = jl_subtype_env_size(b);
     int sz = 0, i = 0;
-    jl_value_t **env = (jl_value_t**)alloca((sza>szb?sza:szb)*sizeof(jl_value_t*));
-    jl_value_t *ans = b;
+    jl_value_t **env, **ans;
+    JL_GC_PUSHARGS(env, szb+1);
+    ans = &env[szb]; *ans = jl_bottom_type;
     if (jl_subtype_env(a, b, env, szb)) {
-        ans = a;
-        sz = szb;
+        *ans = a; sz = szb;
     }
     else if (jl_subtype(b, a)) {
+        *ans = b;
     }
-    else if (jl_is_leaf_type(a) || jl_is_leaf_type(b)) {
-        return jl_bottom_type;
+    else {
+        int lta = jl_is_leaf_type(a), ltb = jl_is_leaf_type(b);
+        if (lta && ltb)
+            goto bot;
+        jl_stenv_t e;
+        init_stenv(&e, NULL, 0);
+        e.intersection = 1;
+        e.envout = env;
+        e.envsz = szb;
+        *ans = intersect_all(a, b, &e, 0);
+        if (*ans == jl_bottom_type) goto bot;
+        // TODO: don't yet use the types returned by `intersect`, since it returns
+        // Unions of Tuples and other code can only handle direct Tuples.
+        if (!jl_is_datatype(jl_unwrap_unionall(*ans))) {
+            *ans = b;
+        }
+        else {
+            sz = szb;
+            // TODO: compute better `env` directly during intersection.
+            // we assume that if the intersection is a leaf type, we have
+            // full information in `env`. however the intersection algorithm
+            // does not yet provide that in all cases so use subtype.
+            if (szb > 0 && jl_is_leaf_type(*ans) && !jl_types_equal(b, (jl_value_t*)jl_type_type)) {
+                if (jl_subtype_env(*ans, b, env, szb)) {
+                    for(i=0; i < sz; i++) {
+                        if (jl_is_typevar(env[i])) {
+                            *ans = jl_bottom_type; goto bot;
+                        }
+                    }
+                }
+                else {
+                    sz = 0;
+                }
+            }
+        }
     }
-    if (sz == 0) {
-        sz = szb;
+    if (sz == 0 && szb > 0) {
         while (jl_is_unionall(b)) {
             env[i++] = (jl_value_t*)((jl_unionall_t*)b)->var;
             b = ((jl_unionall_t*)b)->body;
         }
+        sz = szb;
     }
-    jl_svec_t *e = jl_alloc_svec(sz);
-    *penv = e;
-    for(i=0; i < sz; i++)
-        jl_svecset(e, i, env[i]);
-    return ans;
+    if (penv) {
+        jl_svec_t *e = jl_alloc_svec(sz);
+        *penv = e;
+        for(i=0; i < sz; i++)
+            jl_svecset(e, i, env[i]);
+    }
+ bot:
+    JL_GC_POP();
+    return *ans;
 }
 
 JL_DLLEXPORT jl_value_t *jl_type_intersection(jl_value_t *a, jl_value_t *b)
 {
-    if (jl_subtype(a, b))
-        return a;
-    if (jl_subtype(b, a))
-        return b;
-    if (jl_is_leaf_type(a) || jl_is_leaf_type(b))
-        return jl_bottom_type;
-    return b;
+    return jl_type_intersection_matching(a, b, NULL);
+}
+
+JL_DLLEXPORT jl_svec_t *jl_type_intersection_env(jl_value_t *a, jl_value_t *b)
+{
+    jl_svec_t *env = jl_emptysvec;
+    JL_GC_PUSH1(&env);
+    jl_value_t *ti = jl_type_intersection_matching(a, b, &env);
+    jl_svec_t *pair = jl_svec2(ti, env);
+    JL_GC_POP();
+    return pair;
 }
diff --git a/src/timing.h b/src/timing.h
index 486606cd33ffef..e9677cc7da9bef 100644
--- a/src/timing.h
+++ b/src/timing.h
@@ -8,6 +8,9 @@
 extern "C" {
 #endif
 void jl_print_timings(void);
+void jl_init_timing(void);
+jl_timing_block_t *jl_pop_timing_block(jl_timing_block_t *cur_block);
+void jl_destroy_timing(void);
 extern jl_timing_block_t *jl_root_timing;
 void jl_timing_block_start(jl_timing_block_t *cur_block);
 void jl_timing_block_stop(jl_timing_block_t *cur_block);
diff --git a/src/toplevel.c b/src/toplevel.c
index 1f3d44a02f5575..3ed7e0533db1ff 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -517,7 +517,7 @@ static jl_method_instance_t *jl_new_thunk(jl_code_info_t *src)
 {
     jl_method_instance_t *li = jl_new_method_instance_uninit();
     li->inferred = (jl_value_t*)src;
-    li->specTypes = (jl_tupletype_t*)jl_typeof(jl_emptytuple);
+    li->specTypes = jl_typeof(jl_emptytuple);
     return li;
 }
 
@@ -792,7 +792,7 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
     jl_methtable_t *mt;
     jl_sym_t *name;
     jl_method_t *m = NULL;
-    jl_tupletype_t *argtype = jl_apply_tuple_type(atypes);
+    jl_value_t *argtype = (jl_value_t*)jl_apply_tuple_type(atypes);
     JL_GC_PUSH3(&f, &m, &argtype);
 
     if (!jl_is_code_info(f)) {
@@ -803,7 +803,7 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
     }
 
     assert(jl_is_code_info(f));
-    jl_datatype_t *ftype = jl_first_argument_datatype((jl_value_t*)argtype);
+    jl_datatype_t *ftype = jl_first_argument_datatype(argtype);
     if (ftype == NULL ||
         !(jl_is_type_type((jl_value_t*)ftype) ||
           (jl_is_datatype(ftype) &&
@@ -816,12 +816,29 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
     if (jl_subtype((jl_value_t*)ftype, (jl_value_t*)jl_builtin_type))
         jl_error("cannot add methods to a builtin function");
 
-    m = jl_new_method(f, name, argtype, nargs, isva, tvars, isstaged == jl_true);
+    int j;
+    for(j=(int)jl_svec_len(tvars)-1; j >= 0 ; j--) {
+        jl_value_t *tv = jl_svecref(tvars,j);
+        if (!jl_is_typevar(tv))
+            jl_type_error_rt(jl_symbol_name(name), "method definition", (jl_value_t*)jl_tvar_type, tv);
+        argtype = jl_new_struct(jl_unionall_type, tv, argtype);
+    }
+
+    m = jl_new_method(f, name, (jl_tupletype_t*)argtype, nargs, isva, tvars, isstaged == jl_true);
+
+    if (jl_has_free_typevars(argtype)) {
+        jl_exceptionf(jl_argumenterror_type,
+                      "method definition for %s at %s:%d has free type variables",
+                      jl_symbol_name(name),
+                      jl_symbol_name(m->file),
+                      m->line);
+    }
+
     jl_check_static_parameter_conflicts(m, tvars);
 
-    size_t i, na = jl_nparams(argtype);
+    size_t i, na = jl_svec_len(atypes);
     for (i = 0; i < na; i++) {
-        jl_value_t *elt = jl_tparam(argtype, i);
+        jl_value_t *elt = jl_svecref(atypes, i);
         if (!jl_is_type(elt) && !jl_is_typevar(elt)) {
             jl_sym_t *argname = (jl_sym_t*)jl_array_ptr_ref(f->slotnames, i);
             if (argname == unused_sym)
@@ -842,17 +859,17 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
     }
 
     int ishidden = !!strchr(jl_symbol_name(name), '#');
-    for (size_t i=0; i < jl_svec_len(tvars); i++) {
-        jl_value_t *tv = jl_svecref(tvars,i);
-        if (!jl_is_typevar(tv))
-            jl_type_error_rt(jl_symbol_name(name), "method definition", (jl_value_t*)jl_tvar_type, tv);
-        if (!ishidden && !jl_has_typevar((jl_value_t*)argtype, (jl_tvar_t*)tv)) {
+    jl_value_t *atemp = argtype;
+    while (jl_is_unionall(atemp)) {
+        jl_unionall_t *ua = (jl_unionall_t*)atemp;
+        jl_tvar_t *tv = ua->var;
+        if (!ishidden && !jl_has_typevar(ua->body, tv)) {
             jl_printf(JL_STDERR, "WARNING: static parameter %s does not occur in signature for %s",
-                      jl_symbol_name(((jl_tvar_t*)tv)->name),
-                      jl_symbol_name(name));
+                      jl_symbol_name(tv->name), jl_symbol_name(name));
             print_func_loc(JL_STDERR, m);
             jl_printf(JL_STDERR, ".\nThe method will not be callable.\n");
         }
+        atemp = ua->body;
     }
 
     jl_method_table_insert(mt, m, NULL);
diff --git a/src/typemap.c b/src/typemap.c
index c280e0ac21d1e9..d5fa5d444cba97 100644
--- a/src/typemap.c
+++ b/src/typemap.c
@@ -19,13 +19,9 @@ extern "C" {
 // compute whether the specificity of this type is equivalent to Any in the sort order
 static int jl_is_any(jl_value_t *t1)
 {
-    return (t1 == (jl_value_t*)jl_any_type || t1 == jl_ANY_flag);
-    // TODO jb/subtype
-    /*
+    return (t1 == (jl_value_t*)jl_any_type || t1 == jl_ANY_flag ||
             (jl_is_typevar(t1) &&
-             ((jl_tvar_t*)t1)->ub == (jl_value_t*)jl_any_type &&
-             !((jl_tvar_t*)t1)->bound));
-    */
+             ((jl_tvar_t*)t1)->ub == (jl_value_t*)jl_any_type));
 }
 
 // ----- Type Signature Subtype Testing ----- //
@@ -91,6 +87,7 @@ static int sig_match_by_type_simple(jl_value_t **types, size_t n, jl_tupletype_t
                 return 0;
         }
         jl_value_t *t = jl_tparam0(decl);
+        if (jl_is_typevar(t)) t = ((jl_tvar_t*)t)->ub;
         for(; i < n; i++) {
             if (!jl_subtype(types[i], t))
                 return 0;
@@ -127,16 +124,17 @@ static inline int sig_match_simple(jl_value_t **args, size_t n, jl_value_t **sig
     for (i = 0; i < lensig; i++) {
         jl_value_t *decl = sig[i];
         jl_value_t *a = args[i];
-        if (decl == (jl_value_t*)jl_any_type || decl == jl_ANY_flag) {
-        }
-        else if ((jl_value_t*)jl_typeof(a) == decl) {
+        if (decl == (jl_value_t*)jl_any_type || decl == jl_ANY_flag ||
+            ((jl_value_t*)jl_typeof(a) == decl)) {
             /*
               we are only matching concrete types here, and those types are
               hash-consed, so pointer comparison should work.
             */
+            continue;
         }
-        else if (jl_is_type_type(decl) && jl_is_type(a)) {
-            jl_value_t *tp0 = jl_tparam0(decl);
+        jl_value_t *unw = jl_is_unionall(decl) ? ((jl_unionall_t*)decl)->body : decl;
+        if (jl_is_type_type(unw) && jl_is_type(a)) {
+            jl_value_t *tp0 = jl_tparam0(unw);
             if (tp0 == (jl_value_t*)jl_typetype_tvar) {
                 // in the case of Type{T}, the types don't have
                 // to match exactly either. this is cached as Type{T}.
@@ -257,7 +255,7 @@ union jl_typemap_t mtcache_hash_lookup(const struct jl_ordereddict_t *a, jl_valu
         }
         else {
             assert(jl_typeof(ml.unknown) == (jl_value_t*)jl_typemap_entry_type);
-            t = jl_field_type(jl_unwrap_unionall(ml.leaf->sig), offs);
+            t = jl_field_type(jl_unwrap_unionall((jl_value_t*)ml.leaf->sig), offs);
             if (tparam)
                 t = jl_tparam0(t);
         }
@@ -282,7 +280,7 @@ static void mtcache_rehash(struct jl_ordereddict_t *pa, size_t newlen, jl_value_
         }
         else {
             assert(jl_typeof(ml.unknown) == (jl_value_t*)jl_typemap_entry_type);
-            t = jl_field_type(jl_unwrap_unionall(ml.leaf->sig), offs);
+            t = jl_field_type(jl_unwrap_unionall((jl_value_t*)ml.leaf->sig), offs);
             if (tparam)
                 t = jl_tparam0(t);
         }
@@ -360,7 +358,7 @@ static union jl_typemap_t *mtcache_hash_bp(struct jl_ordereddict_t *pa, jl_value
             }
             else {
                 assert(jl_typeof(pml->unknown) == (jl_value_t*)jl_typemap_entry_type);
-                t = jl_field_type(jl_unwrap_unionall(pml->leaf->sig), offs);
+                t = jl_field_type(jl_unwrap_unionall((jl_value_t*)pml->leaf->sig), offs);
                 if (tparam)
                     t = jl_tparam0(t);
             }
@@ -374,9 +372,9 @@ static union jl_typemap_t *mtcache_hash_bp(struct jl_ordereddict_t *pa, jl_value
 
 // ----- Sorted Type Signature Lookup Matching ----- //
 
-jl_value_t *jl_lookup_match(jl_value_t *a, jl_value_t *b, jl_svec_t **penv, jl_svec_t *tvars)
+jl_value_t *jl_lookup_match(jl_value_t *a, jl_value_t *b, jl_svec_t **penv)
 {
-    jl_value_t *ti = jl_type_intersection_matching(a, b, penv, tvars);
+    jl_value_t *ti = jl_type_intersection_matching(a, b, penv);
     if (ti == (jl_value_t*)jl_bottom_type)
         return ti;
     JL_GC_PUSH1(&ti);
@@ -464,7 +462,7 @@ static int jl_typemap_intersection_array_visitor(struct jl_ordereddict_t *a, jl_
             t = ml.node->key;
         }
         else {
-            t = jl_field_type(jl_unwrap_unionall(ml.leaf->sig), offs);
+            t = jl_field_type(jl_unwrap_unionall((jl_value_t*)ml.leaf->sig), offs);
             if (tparam)
                 t = jl_tparam0(t);
         }
@@ -505,7 +503,7 @@ static int jl_typemap_intersection_node_visitor(jl_typemap_entry_t *ml, struct t
             jl_value_t *ti;
             if (closure->env) {
                 closure->env = jl_emptysvec;
-                ti = jl_lookup_match(closure->type, (jl_value_t*)ml->sig, &closure->env, ml->tvars);
+                ti = jl_lookup_match(closure->type, (jl_value_t*)ml->sig, &closure->env);
             }
             else {
                 ti = jl_type_intersection(closure->type, (jl_value_t*)ml->sig);
@@ -528,6 +526,7 @@ int jl_typemap_intersection_visitor(union jl_typemap_t map, int offs,
         jl_typemap_level_t *cache = map.node;
         jl_value_t *ty = NULL;
         jl_value_t *ttypes = jl_unwrap_unionall(closure->type);
+        assert(jl_is_datatype(ttypes));
         size_t l = jl_field_count(ttypes);
         if (closure->va && l <= offs + 1) {
             ty = closure->va;
@@ -577,14 +576,6 @@ int jl_typemap_intersection_visitor(union jl_typemap_t map, int offs,
     }
 }
 
-int sigs_eq(jl_value_t *a, jl_value_t *b, int useenv)
-{
-    // useenv == 0 : subtyping + ensure typevars correspond
-    // useenv == 1 : subtyping + ensure typevars correspond + fail if bound != bound in some typevar match
-    // useenv == 2 : ignore typevars (because UnionAll getting lost in intersection can cause jl_types_equal to fail in the wrong direction for some purposes)
-    return jl_types_equal(a, b);
-}
-
 /*
   Method caches are divided into three parts: one for signatures where
   the first argument is a singleton kind (Type{Foo}), one indexed by the
@@ -603,7 +594,7 @@ static jl_typemap_entry_t *jl_typemap_assoc_by_type_(jl_typemap_entry_t *ml, jl_
     for (; ml != (void*)jl_nothing; ml = ml->next) {
         if (world < ml->min_world || world > ml->max_world)
             continue; // ignore replaced methods
-        size_t lensig = jl_field_count(jl_unwrap_unionall(ml->sig));
+        size_t lensig = jl_field_count(jl_unwrap_unionall((jl_value_t*)ml->sig));
         if (lensig == n || (ml->va && lensig <= n+1)) {
             int resetenv = 0, ismatch = 1;
             if (ml->simplesig != (void*)jl_nothing) {
@@ -631,7 +622,7 @@ static jl_typemap_entry_t *jl_typemap_assoc_by_type_(jl_typemap_entry_t *ml, jl_
                 // which works currently because types is typically a leaf tt,
                 // or inexact is set (which then does a sort of subtype test via jl_types_equal)
                 // but this isn't entirely general
-                jl_value_t *ti = jl_lookup_match((jl_value_t*)types, (jl_value_t*)ml->sig, penv, ml->tvars);
+                jl_value_t *ti = jl_lookup_match((jl_value_t*)types, (jl_value_t*)ml->sig, penv);
                 resetenv = 1;
                 ismatch = (ti != (jl_value_t*)jl_bottom_type);
                 if (ismatch) {
@@ -684,13 +675,13 @@ static jl_typemap_entry_t *jl_typemap_assoc_by_type_(jl_typemap_entry_t *ml, jl_
     return NULL;
 }
 
-static jl_typemap_entry_t *jl_typemap_lookup_by_type_(jl_typemap_entry_t *ml, jl_tupletype_t *types, int8_t useenv, size_t world)
+static jl_typemap_entry_t *jl_typemap_lookup_by_type_(jl_typemap_entry_t *ml, jl_tupletype_t *types, size_t world)
 {
     for (; ml != (void*)jl_nothing; ml = ml->next) {
         if (world < ml->min_world || world > ml->max_world)
             continue;
         // TODO: more efficient
-        if (sigs_eq((jl_value_t*)types, (jl_value_t*)ml->sig, useenv)) {
+        if (jl_types_equal((jl_value_t*)types, (jl_value_t*)ml->sig)) {
             return ml;
         }
     }
@@ -701,13 +692,14 @@ static jl_typemap_entry_t *jl_typemap_lookup_by_type_(jl_typemap_entry_t *ml, jl
 // this is the general entry point for looking up a type in the cache
 // (as a subtype, or with typeseq)
 jl_typemap_entry_t *jl_typemap_assoc_by_type(union jl_typemap_t ml_or_cache, jl_tupletype_t *types, jl_svec_t **penv,
-                                             int8_t subtype_inexact__sigseq_useenv, int8_t subtype, int8_t offs, size_t world)
+                                             int8_t inexact, int8_t subtype, int8_t offs, size_t world)
 {
     if (jl_typeof(ml_or_cache.unknown) == (jl_value_t*)jl_typemap_level_type) {
         jl_typemap_level_t *cache = ml_or_cache.node;
         // called object is the primary key for constructors, otherwise first argument
         jl_value_t *ty = NULL;
-        jl_value_t *ttypes = jl_unwrap_unionall(types);
+        jl_value_t *ttypes = jl_unwrap_unionall((jl_value_t*)types);
+        assert(jl_is_datatype(ttypes));
         size_t l = jl_field_count(ttypes);
         int isva = 0;
         // compute the type at offset `offs` into `types`, which may be a Vararg
@@ -727,7 +719,7 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(union jl_typemap_t ml_or_cache, jl_
         // If there is a type at offs, look in the optimized caches
         if (!subtype) {
             if (ty && jl_is_any(ty))
-                return jl_typemap_assoc_by_type(cache->any, types, penv, subtype_inexact__sigseq_useenv, subtype, offs+1, world);
+                return jl_typemap_assoc_by_type(cache->any, types, penv, inexact, subtype, offs+1, world);
             if (isva) // in lookup mode, want to match Vararg exactly, not as a subtype
                 ty = NULL;
         }
@@ -737,8 +729,8 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(union jl_typemap_t ml_or_cache, jl_
                 if (cache->targ.values != (void*)jl_nothing && jl_is_datatype(a0)) {
                     union jl_typemap_t ml = mtcache_hash_lookup(&cache->targ, a0, 1, offs);
                     if (ml.unknown != jl_nothing) {
-                        jl_typemap_entry_t *li = jl_typemap_assoc_by_type(ml, types, penv,
-                                subtype_inexact__sigseq_useenv, subtype, offs+1, world);
+                        jl_typemap_entry_t *li =
+                            jl_typemap_assoc_by_type(ml, types, penv, inexact, subtype, offs+1, world);
                         if (li) return li;
                     }
                 }
@@ -747,8 +739,8 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(union jl_typemap_t ml_or_cache, jl_
             if (cache->arg1.values != (void*)jl_nothing && jl_is_datatype(ty)) {
                 union jl_typemap_t ml = mtcache_hash_lookup(&cache->arg1, ty, 0, offs);
                 if (ml.unknown != jl_nothing) {
-                    jl_typemap_entry_t *li = jl_typemap_assoc_by_type(ml, types, penv,
-                            subtype_inexact__sigseq_useenv, subtype, offs+1, world);
+                    jl_typemap_entry_t *li =
+                        jl_typemap_assoc_by_type(ml, types, penv, inexact, subtype, offs+1, world);
                     if (li) return li;
                 }
             }
@@ -756,18 +748,18 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(union jl_typemap_t ml_or_cache, jl_
         }
         // Always check the list (since offs doesn't always start at 0)
         if (subtype) {
-            jl_typemap_entry_t *li = jl_typemap_assoc_by_type_(cache->linear, types, subtype_inexact__sigseq_useenv, penv, world);
+            jl_typemap_entry_t *li = jl_typemap_assoc_by_type_(cache->linear, types, inexact, penv, world);
             if (li) return li;
-            return jl_typemap_assoc_by_type(cache->any, types, penv, subtype_inexact__sigseq_useenv, subtype, offs+1, world);
+            return jl_typemap_assoc_by_type(cache->any, types, penv, inexact, subtype, offs+1, world);
         }
         else {
-            return jl_typemap_lookup_by_type_(cache->linear, types, subtype_inexact__sigseq_useenv, world);
+            return jl_typemap_lookup_by_type_(cache->linear, types, world);
         }
     }
     else {
         return subtype ?
-            jl_typemap_assoc_by_type_(ml_or_cache.leaf, types, subtype_inexact__sigseq_useenv, penv, world) :
-            jl_typemap_lookup_by_type_(ml_or_cache.leaf, types, subtype_inexact__sigseq_useenv, world);
+            jl_typemap_assoc_by_type_(ml_or_cache.leaf, types, inexact, penv, world) :
+            jl_typemap_lookup_by_type_(ml_or_cache.leaf, types, world);
     }
 }
 
@@ -908,7 +900,8 @@ static jl_typemap_level_t *jl_new_typemap_level(void)
     return cache;
 }
 
-static jl_typemap_level_t *jl_method_convert_list_to_cache(jl_typemap_entry_t *ml, jl_value_t *key, int8_t offs)
+static jl_typemap_level_t *jl_method_convert_list_to_cache(jl_typemap_entry_t *ml, jl_value_t *key, int8_t offs,
+                                                           const struct jl_typemap_info *tparams)
 {
     jl_typemap_level_t *cache = jl_new_typemap_level();
     cache->key = key;
@@ -917,7 +910,7 @@ static jl_typemap_level_t *jl_method_convert_list_to_cache(jl_typemap_entry_t *m
     while (ml != (void*)jl_nothing) {
         next = ml->next;
         ml->next = (jl_typemap_entry_t*)jl_nothing;
-        jl_typemap_level_insert_(cache, ml, offs, 0);
+        jl_typemap_level_insert_(cache, ml, offs, tparams);
         ml = next;
     }
     JL_GC_POP();
@@ -927,7 +920,7 @@ static jl_typemap_level_t *jl_method_convert_list_to_cache(jl_typemap_entry_t *m
 static void jl_typemap_list_insert_(jl_typemap_entry_t **pml, jl_value_t *parent,
                                     jl_typemap_entry_t *newrec, const struct jl_typemap_info *tparams)
 {
-    if (*pml == (void*)jl_nothing || newrec->isleafsig) {
+    if (*pml == (void*)jl_nothing || newrec->isleafsig || (tparams && tparams->unsorted)) {
         newrec->next = *pml;
         jl_gc_wb(newrec, newrec->next);
         *pml = newrec;
@@ -949,7 +942,7 @@ static void jl_typemap_insert_generic(union jl_typemap_t *pml, jl_value_t *paren
 
     unsigned count = jl_typemap_list_count(pml->leaf);
     if (count > MAX_METHLIST_COUNT) {
-        pml->node = jl_method_convert_list_to_cache(pml->leaf, key, offs);
+        pml->node = jl_method_convert_list_to_cache(pml->leaf, key, offs, tparams);
         jl_gc_wb(parent, pml->node);
         jl_typemap_level_insert_(pml->node, newrec, offs, tparams);
         return;
@@ -971,7 +964,7 @@ static int jl_typemap_array_insert_(struct jl_ordereddict_t *cache, jl_value_t *
 static void jl_typemap_level_insert_(jl_typemap_level_t *cache, jl_typemap_entry_t *newrec, int8_t offs,
                                      const struct jl_typemap_info *tparams)
 {
-    jl_value_t *ttypes = jl_unwrap_unionall(newrec->sig);
+    jl_value_t *ttypes = jl_unwrap_unionall((jl_value_t*)newrec->sig);
     size_t l = jl_field_count(ttypes);
     // compute the type at offset `offs` into `sig`, which may be a Vararg
     jl_value_t *t1 = NULL;
@@ -1020,7 +1013,7 @@ jl_typemap_entry_t *jl_typemap_insert(union jl_typemap_t *cache, jl_value_t *par
     assert(min_world > 0 && max_world > 0);
     if (!simpletype)
         simpletype = (jl_tupletype_t*)jl_nothing;
-    jl_value_t *ttype = jl_unwrap_unionall(type);
+    jl_value_t *ttype = jl_unwrap_unionall((jl_value_t*)type);
 
     if ((jl_value_t*)simpletype == jl_nothing) {
         jl_typemap_entry_t *ml = jl_typemap_assoc_by_type(*cache, type, NULL, 1, 0, offs, min_world);
@@ -1047,7 +1040,7 @@ jl_typemap_entry_t *jl_typemap_insert(union jl_typemap_t *cache, jl_value_t *par
     newrec->min_world = min_world;
     newrec->max_world = max_world;
     // compute the complexity of this type signature
-    newrec->va = jl_is_va_tuple(ttype);
+    newrec->va = jl_is_va_tuple((jl_datatype_t*)ttype);
     newrec->issimplesig = (tvars == jl_emptysvec); // a TypeVar environment needs an complex matching test
     newrec->isleafsig = newrec->issimplesig && !newrec->va; // entirely leaf types don't need to be sorted
     JL_GC_PUSH1(&newrec);
@@ -1099,7 +1092,7 @@ static void jl_typemap_list_insert_sorted(jl_typemap_entry_t **pml, jl_value_t *
         if (!l->isleafsig) { // quickly ignore all of the leafsig entries (these were handled by caller)
             if (jl_type_morespecific((jl_value_t*)newrec->sig, (jl_value_t*)l->sig)) {
                 if (l->simplesig == (void*)jl_nothing ||
-                    newrec->simplesig != (void*)jl_nothing || !sigs_eq((jl_value_t*)l->sig, (jl_value_t*)newrec->sig, 1)) {
+                    newrec->simplesig != (void*)jl_nothing || !jl_types_equal((jl_value_t*)l->sig, (jl_value_t*)newrec->sig)) {
                     // might need to insert multiple entries for a lookup differing only by their simplesig
                     // when simplesig contains a kind
                     // TODO: make this test more correct or figure out a better way to compute this
@@ -1119,7 +1112,7 @@ static void jl_typemap_list_insert_sorted(jl_typemap_entry_t **pml, jl_value_t *
     jl_gc_wb(pa, newrec);
     // if this contains Union types, methods after it might actually be
     // more specific than it. we need to re-sort them.
-    if (has_unions(newrec->sig)) {
+    if (has_unions((jl_value_t*)newrec->sig)) {
         jl_value_t *item_parent = (jl_value_t*)newrec;
         jl_value_t *next_parent = 0;
         jl_typemap_entry_t *item = newrec->next, *next;
diff --git a/test/TestHelpers.jl b/test/TestHelpers.jl
index 4501468505ed32..56f6e59ac70414 100644
--- a/test/TestHelpers.jl
+++ b/test/TestHelpers.jl
@@ -95,7 +95,7 @@ function Base.similar(A::AbstractArray, T::Type, inds::Tuple{UnitRange,Vararg{Un
     OffsetArray(B, map(indsoffset, inds))
 end
 
-Base.similar(f::Union{Function,DataType}, shape::Tuple{UnitRange,Vararg{UnitRange}}) = OffsetArray(f(map(length, shape)), map(indsoffset, shape))
+Base.similar(f::Union{Function,Type}, shape::Tuple{UnitRange,Vararg{UnitRange}}) = OffsetArray(f(map(length, shape)), map(indsoffset, shape))
 
 Base.reshape(A::AbstractArray, inds::Tuple{UnitRange,Vararg{UnitRange}}) = OffsetArray(reshape(A, map(length, inds)), map(indsoffset, inds))
 
diff --git a/test/ambiguous.jl b/test/ambiguous.jl
index 4027759624ba62..8470d9a4ad5247 100644
--- a/test/ambiguous.jl
+++ b/test/ambiguous.jl
@@ -133,7 +133,8 @@ ambs = detect_ambiguities(Ambig5)
 @test length(ambs) == 2
 
 # Test that Core and Base are free of ambiguities
-@test detect_ambiguities(Core, Base; imported=true) == []
+# TODO jb/subtype: we now detect a lot more
+@test_broken detect_ambiguities(Core, Base; imported=true) == []
 # not using isempty so this prints more information when it fails
 
 amb_1(::Int8, ::Int) = 1
@@ -172,7 +173,7 @@ g16493{T<:Number}(x::T, y::Integer) = 0
 g16493{T}(x::Complex{T}, y) = 1
 let ms = methods(g16493, (Complex, Any))
     @test length(ms) == 1
-    @test first(ms).sig == Tuple{typeof(g16493), Complex{TypeVar(:T, Any, true)}, Any}
+    @test first(ms).sig == (Tuple{typeof(g16493), Complex{T}, Any} where T)
 end
 
 # issue #17350
diff --git a/test/bitarray.jl b/test/bitarray.jl
index 8e88c2dd8aef57..7112189d31c56d 100644
--- a/test/bitarray.jl
+++ b/test/bitarray.jl
@@ -5,7 +5,7 @@ module BitArrayTests
 using Base.Test
 using Base: findprevnot, findnextnot
 
-tc{N}(r1::NTuple{N}, r2::NTuple{N}) = all(x->tc(x...), [zip(r1,r2)...])
+tc{N}(r1::NTuple{N,Any}, r2::NTuple{N,Any}) = all(x->tc(x...), [zip(r1,r2)...])
 tc{N}(r1::BitArray{N}, r2::Union{BitArray{N},Array{Bool,N}}) = true
 tc(r1::RowVector{Bool,BitVector}, r2::Union{RowVector{Bool,BitVector},RowVector{Bool,Vector{Bool}}}) = true
 tc{T}(r1::T, r2::T) = true
diff --git a/test/compile.jl b/test/compile.jl
index 044bd21281e183..0270dc56d13c11 100644
--- a/test/compile.jl
+++ b/test/compile.jl
@@ -179,14 +179,13 @@ try
                     some_method, Tuple{typeof(Base.include), String}, Core.svec(), typemax(UInt))
         @test Foo.some_linfo::Core.MethodInstance === some_linfo
 
-        PV = Foo.Value18343{Nullable}.types[1]
+        PV = Foo.Value18343{Nullable}.body.types[1]
         VR = PV.types[1].parameters[1]
         @test PV.types[1] === Array{VR,1}
         @test pointer_from_objref(PV.types[1]) ===
-              pointer_from_objref(PV.types[1].parameters[1].types[1].types[1]) ===
-              pointer_from_objref(Array{VR,1})
+              pointer_from_objref(PV.types[1].parameters[1].types[1].types[1])
         @test PV === PV.types[1].parameters[1].types[1]
-        @test pointer_from_objref(PV) !== pointer_from_objref(PV.types[1].parameters[1].types[1])
+        @test pointer_from_objref(PV) === pointer_from_objref(PV.types[1].parameters[1].types[1])
     end
 
     Baz_file = joinpath(dir, "Baz.jl")
diff --git a/test/core.jl b/test/core.jl
index 39354bd3b7c3e9..dc74a02275633a 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -11,32 +11,32 @@ f47{T}(x::Vector{Vector{T}}) = 0
 @test f47(Array{Vector{Int}}(0)) == 0
 
 # issue #8652
-args_morespecific(a, b) = ccall(:jl_args_morespecific, Cint, (Any,Any), a, b) != 0
-let T1 = TypeVar(:T, Integer, true), T2 = TypeVar(:T, Integer, true)
-    a = Tuple{Type{T1}, T1}
-    b2 = Tuple{Type{T2}, Integer}
+args_morespecific(a, b) = ccall(:jl_type_morespecific, Cint, (Any,Any), a, b) != 0
+let
+    a = Tuple{Type{T1}, T1} where T1<:Integer
+    b2 = Tuple{Type{T2}, Integer} where T2<:Integer
     @test args_morespecific(a, b2)
     @test !args_morespecific(b2, a)
-    a = Tuple{Type{T1}, Ptr{T1}}
-    b2 = Tuple{Type{T2}, Ptr{Integer}}
+    a = Tuple{Type{T1}, Ptr{T1}} where T1<:Integer
+    b2 = Tuple{Type{T2}, Ptr{Integer}} where T2<:Integer
     @test args_morespecific(a, b2)
     @test !args_morespecific(b2, a)
 end
 
 # issue #11534
-let T = TypeVar(:T, Tuple{Vararg{RangeIndex}}, true)
+let
     t1 = Tuple{AbstractArray, Tuple{Vararg{RangeIndex}}}
-    t2 = Tuple{Array, T}
+    t2 = Tuple{Array, T} where T<:Tuple{Vararg{RangeIndex}}
     @test !args_morespecific(t1, t2)
     @test  args_morespecific(t2, t1)
 end
 
-let T = TypeVar(:T, Any, true), N = TypeVar(:N, Any, true)
-    a = Tuple{Array{T,N}, Vararg{Int,N}}
+let
+    a = Tuple{Array{T,N}, Vararg{Int,N}} where T where N
     b = Tuple{Array,Int}
     @test  args_morespecific(a, b)
     @test !args_morespecific(b, a)
-    a = Tuple{Array, Vararg{Int,N}}
+    a = Tuple{Array, Vararg{Int,N}} where N
     @test !args_morespecific(a, b)
     @test  args_morespecific(b, a)
 end
@@ -52,9 +52,11 @@ _bound_vararg_specificity_1{T}(::Type{Array{T,1}}, d::Int) = 1
 typealias TT11840{T} Tuple{T,T}
 f11840(::Type) = "Type"
 f11840(::DataType) = "DataType"
+f11840(::UnionAll) = "UnionAll"
 f11840{T<:Tuple}(::Type{T}) = "Tuple"
-@test f11840(Type) == "DataType"
-@test f11840(AbstractVector) == "Type"
+@test f11840(Type) == "UnionAll"
+@test f11840(Type.body) == "DataType"
+@test f11840(Union{Int,Int8}) == "Type"
 @test f11840(Tuple) == "Tuple"
 @test f11840(TT11840) == "Tuple"
 
@@ -82,7 +84,7 @@ g11840b(::Type) = 2
 
 h11840(::DataType) = '1'
 h11840(::Type) = '2'
-h11840(::TypeConstructor) = '3'
+h11840(::UnionAll) = '3'
 h11840{T<:Tuple}(::Type{T}) = '4'
 @test h11840(Vector) == '3'
 @test h11840(Vector.body) == '1'
@@ -132,10 +134,10 @@ nttest1{n}(x::NTuple{n,Int}) = n
 @test nttest1(()) == 0
 @test nttest1((1,2)) == 2
 @test NTuple <: Tuple
-@test NTuple{TypeVar(:T),Int32} <: Tuple{Vararg{Int32}}
-@test !(NTuple{TypeVar(:T),Int32} <: Tuple{Int32,Vararg{Int32}})
-@test Tuple{Vararg{Int32}} <: NTuple{TypeVar(:T),Int32}
-@test Tuple{Int32,Vararg{Int32}} <: NTuple{TypeVar(:T),Int32}
+@test (NTuple{T,Int32} where T) <: Tuple{Vararg{Int32}}
+@test !((NTuple{T,Int32} where T) <: Tuple{Int32,Vararg{Int32}})
+@test Tuple{Vararg{Int32}} <: (NTuple{T,Int32} where T)
+@test Tuple{Int32,Vararg{Int32}} <: (NTuple{T,Int32} where T)
 
 # #17198
 @test_throws MethodError convert(Tuple{Int}, (1.0, 2.0, 3.0))
@@ -152,14 +154,14 @@ abstract Qux_{T} <: Sup_{Qux_{Int},T}
 @test ===(Qux_{Int}, Qux_{Char}.super.parameters[1])
 @test ===(Qux_{Char}.super.parameters[2], Char)
 
-@test Qux_.super.parameters[1].super <: Sup_
-@test ===(Qux_{Int}, Qux_.super.parameters[1].super.parameters[1])
-@test ===(Int, Qux_.super.parameters[1].super.parameters[2])
+@test Qux_.body.super.parameters[1].super <: Sup_
+@test ===(Qux_{Int}, Qux_.body.super.parameters[1].super.parameters[1])
+@test ===(Int, Qux_.body.super.parameters[1].super.parameters[2])
 
 type Foo_{T} x::Foo_{Int} end
 
-@test ===(Foo_.types[1], Foo_{Int})
-@test ===(Foo_.types[1].types[1], Foo_{Int})
+@test ===(Foo_.body.types[1], Foo_{Int})
+@test ===(Foo_.body.types[1].types[1], Foo_{Int})
 
 type Circ_{T} x::Circ_{T} end
 @test ===(Circ_{Int}, Circ_{Int}.types[1])
@@ -477,12 +479,14 @@ end
 # isassigned, issue #11167
 type Type11167{T,N} end
 Type11167{Int,2}
-@test !isassigned(Type11167.name.cache, 0)
-@test isassigned(Type11167.name.cache, 1)
-@test !isassigned(Type11167.name.cache, 2)
-Type11167{Float32,5}
-@test isassigned(Type11167.name.cache, 2)
-@test !isassigned(Type11167.name.cache, 3)
+let tname = Type11167.body.body.name
+    @test !isassigned(tname.cache, 0)
+    @test isassigned(tname.cache, 1)
+    @test !isassigned(tname.cache, 2)
+    Type11167{Float32,5}
+    @test isassigned(tname.cache, 2)
+    @test !isassigned(tname.cache, 3)
+end
 
 # dispatch
 let
@@ -784,21 +788,21 @@ let
     # issue #1131
     baar(x::DataType) = 0
     baar(x::Union) = 1
-    baar(x::TypeConstructor) = 2
+    baar(x::UnionAll) = 2
     @test baar(StridedArray) == 2
-    @test baar(StridedArray.body) == 1
+    @test baar(Base.unwrap_unionall(StridedArray)) == 1
     @test baar(Vector) == 2
     @test baar(Vector.body) == 0
 
     boor(x) = 0
     boor(x::Union) = 1
     @test boor(StridedArray) == 0
-    @test boor(StridedArray.body) == 1
+    @test boor(Base.unwrap_unionall(StridedArray)) == 1
 
     # issue #1202
     foor(x::Union) = 1
     @test_throws MethodError foor(StridedArray)
-    @test foor(StridedArray.body) == 1
+    @test foor(Base.unwrap_unionall(StridedArray)) == 1
     @test_throws MethodError foor(StridedArray)
 end
 
@@ -1275,8 +1279,8 @@ g4413(::Union{A4413, B4413, C4413}) = "ABC"
 # tuple argument, but it shouldn't do that for an argument that a static
 # parameter depends on.
 f4482{T}(x::T) = T
-@test f4482((Ptr,Ptr)) === Tuple{DataType,DataType}
-@test f4482((Ptr,))    === Tuple{DataType,}
+@test f4482((Ptr,Ptr)) === Tuple{UnionAll,UnionAll}
+@test f4482((Ptr,))    === Tuple{UnionAll,}
 
 # issue #4486
 try
@@ -1397,6 +1401,9 @@ end
 end # module
 @test (Lib4771.@make_closure)(0) == 1
 
+# issue #4805
+abstract IT4805{N, T}
+
 let
     test0{T <: Int64}(::Type{IT4805{1, T}}, x) = x
     test1() = test0(IT4805{1, Int64}, 1)
@@ -1602,11 +1609,6 @@ macro m6031(x); x; end
 @test @m6031([2,4,6])[3] == 6
 @test (@m6031 [2,4,6])[2] == 4
 
-# issue #6050
-@test Core.Inference.getfield_tfunc(
-          Dict{Int64,Tuple{UnitRange{Int64},UnitRange{Int64}}},
-          Core.Inference.Const(:vals)) == (Array{Tuple{UnitRange{Int64},UnitRange{Int64}},1},true)
-
 # issue #6068
 x6068 = 1
 function test6068()
@@ -2820,7 +2822,7 @@ function f11355(arg::DataType)
 end
 let t = Tuple{Type{Vector{Int}}}
     @test f11355(t) == 100
-    t = Tuple{Type{Dict{TypeVar(:K, true)}}}
+    t = Tuple{Type{Dict{K} where K}}
     @test f11355(t) == 100
 end
 
@@ -3035,17 +3037,6 @@ f12092(x::Int,) = 1
 f12092(x::Int, y::Int...) = 2
 @test f12092(1) == 1
 
-# issue #12096
-let a = Val{Val{TypeVar(:_,Int,true)}}
-    @test_throws UndefRefError a.instance
-    @test !isleaftype(a)
-end
-
-# PR #12058
-let N = TypeVar(:N,true)
-    @test typeintersect(NTuple{N,Int}, NTuple{N,Float64}) === Tuple{}
-end
-
 # issue #12063
 # NOTE: should have > MAX_TUPLETYPE_LEN arguments
 f12063{T}(tt, g, p, c, b, v, cu::T, d::AbstractArray{T, 2}, ve) = 1
@@ -3150,7 +3141,7 @@ typealias PossiblyInvalidUnion{T} Union{T,Int}
 # issue #13007
 call13007{T,N}(::Type{Array{T,N}}) = 0
 call13007(::Type{Array}) = 1
-@test length(Base._methods(call13007, Tuple{Type{TypeVar(:_,Array)}}, 4, typemax(UInt))) == 2
+@test length(Base._methods(call13007, Tuple{Type{_} where _<:Array}, 4, typemax(UInt))) == 2
 
 # detecting cycles during type intersection, e.g. #1631
 cycle_in_solve_tvar_constraints{S}(::Type{Nullable{S}}, x::S) = 0
@@ -3267,9 +3258,6 @@ abstract A11327
 abstract B11327 <: A11327
 f11327{T}(::Type{T},x::T) = x
 @test_throws MethodError f11327(Type{A11327},B11327)
-let T=TypeVar(:T,true)
-    @test typeintersect(Tuple{Type{T},T}, Tuple{Type{Type{Float64}},Type{Int}}) === Union{}
-end
 
 # issue 13855
 macro m13855()
@@ -3393,12 +3381,6 @@ let z1 = Z14477()
     @test isa(z1.fld, Z14477)
 end
 
-# issue #14482
-let T = TypeVar(:T, true)
-    @test typeintersect(T, Type{Int8}) == Type{Int8}
-    @test typeintersect(Tuple{T}, Tuple{Type{Int8}}) == Tuple{Type{Int8}}
-end
-
 # issue #8846, generic macros
 macro m8846(a, b=0)
     a, b
@@ -4162,8 +4144,9 @@ type A12238{T} end
 type B12238{T,S}
     a::A12238{B12238{Int,S}}
 end
-@test B12238.types[1] === A12238{B12238{Int}}
-@test A12238{B12238{Int}}.instance === B12238.types[1].instance
+@test B12238.body.body.types[1] === A12238{B12238{Int}.body}
+@test isa(A12238{B12238{Int}}.instance, A12238{B12238{Int}})
+@test !isdefined(B12238.body.body.types[1], :instance)  # has free type vars
 
 # issue #16315
 let a = Any[]
@@ -4173,8 +4156,8 @@ let a = Any[]
 end
 
 # issue #12096
-let a = Val{Val{TypeVar(:_, Int, true)}},
-    b = Val{Val{TypeVar(:_, Int)}}
+let a = Val{Val{TypeVar(:_, Int)}},
+    b = Val{Val{_} where _<:Int}
 
     @test !isdefined(a, :instance)
     @test  isdefined(b, :instance)
@@ -4259,8 +4242,8 @@ end
 type C16767{T}
     b::A16767{C16767{:a}}
 end
-@test B16767.types[1].types[1].parameters[1].types === Core.svec(A16767{B16767})
-@test C16767.types[1].types[1].parameters[1].types === Core.svec(A16767{C16767{:a}})
+@test B16767.body.types[1].types[1].parameters[1].types[1] === A16767{B16767.body}
+@test C16767.body.types[1].types[1].parameters[1].types[1] === A16767{C16767{:a}}
 
 # issue #16340
 function f16340{T}(x::T)
@@ -4270,7 +4253,7 @@ function f16340{T}(x::T)
     return g
 end
 let g = f16340(1)
-    @test isa(typeof(g).name.mt.defs.tvars, TypeVar)
+    @test isa(typeof(g).name.mt.defs.sig, UnionAll)
 end
 
 # issue #16793
@@ -4646,10 +4629,6 @@ using Base.Test
 io = IOBuffer()
 @test_throws ErrorException show(io, Sgnd(1))  #12007
 
-@test_throws ErrorException convert(Union{}, 1) #10326
-
-@test_throws ErrorException permutedims(rand(()), ()) #15736
-
 immutable MyTime <: Dates.TimeType
     value::Int
 end
diff --git a/test/docs.jl b/test/docs.jl
index c54b2127dbd6ab..02a5408f4262dd 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -26,7 +26,7 @@ end
 docstring_startswith(d1::DocStr, d2) = docstring_startswith(parsedoc(d1), d2)
 
 @doc "Doc abstract type" ->
-abstract C74685 <: AbstractArray
+abstract C74685{T,N} <: AbstractArray{T,N}
 @test stringmime("text/plain", Docs.doc(C74685))=="Doc abstract type\n"
 
 macro macro_doctest() end
@@ -602,7 +602,7 @@ Base.collect{T}(::Type{EmptyType{T}}) = "borked"
 end
 
 let fd = meta(I12515)[@var(Base.collect)]
-    @test fd.order[1] == Tuple{Type{I12515.EmptyType{TypeVar(:T, Any, true)}}}
+    @test fd.order[1] == (Tuple{Type{I12515.EmptyType{T}}} where T)
 end
 
 # PR #12593
diff --git a/test/inference.jl b/test/inference.jl
index d26e3d355f11a4..0f0f7d0f5cbc3c 100644
--- a/test/inference.jl
+++ b/test/inference.jl
@@ -60,7 +60,7 @@ function g3182(t::DataType)
     # however the ::Type{T} method should still match at run time.
     return f3182(t)
 end
-@test g3182(Complex) == 0
+@test g3182(Complex.body) == 0
 
 
 # issue #5906
@@ -103,6 +103,10 @@ barTuple2() = fooTuple{tuple(:y)}()
 
 @test Base.return_types(barTuple1,Tuple{})[1] == Base.return_types(barTuple2,Tuple{})[1] == fooTuple{(:y,)}
 
+# issue #6050
+@test Core.Inference.getfield_tfunc(
+          Dict{Int64,Tuple{UnitRange{Int64},UnitRange{Int64}}},
+          Core.Inference.Const(:vals)) == Array{Tuple{UnitRange{Int64},UnitRange{Int64}},1}
 
 # issue #12476
 function f12476(a)
@@ -139,7 +143,7 @@ end
 
 # issue #12826
 f12826{I<:Integer}(v::Vector{I}) = v[1]
-@test Base.return_types(f12826,Tuple{Array{TypeVar(:I, Integer),1}})[1] == Integer
+@test Base.return_types(f12826,Tuple{Array{I,1} where I<:Integer})[1] == Integer
 
 
 # non-terminating inference, issue #14009
@@ -160,7 +164,7 @@ code_llvm(DevNull, f14009, (Int,))
 arithtype9232{T<:Real}(::Type{T},::Type{T}) = arithtype9232(T)
 result_type9232{T1<:Number,T2<:Number}(::Type{T1}, ::Type{T2}) = arithtype9232(T1, T2)
 # this gave a "type too large", but not reliably
-@test length(code_typed(result_type9232, Tuple{Type{TypeVar(:_, Union{Float32,Float64})}, Type{TypeVar(:T2, Number)}})) == 1
+@test length(code_typed(result_type9232, Tuple{(Type{_} where _<:Union{Float32,Float64}), Type{T2} where T2<:Number})) == 1
 
 
 # issue #10878
@@ -318,8 +322,8 @@ f16530a(c) = fieldtype(Foo16530a, c)
 f16530b() = fieldtype(Foo16530b, :c)
 f16530b(c) = fieldtype(Foo16530b, c)
 
-let T = Array{Tuple{Vararg{Float64,TypeVar(:dim)}},1},
-    TTlim = Type{TypeVar(:_,Array{TypeVar(:_,Tuple),1})}
+let T = Array{Tuple{Vararg{Float64,dim}}, 1} where dim,
+    TTlim = Type{_} where _<:T
 
     @test f16530a() == T
     @test f16530a(:c) == T
@@ -342,7 +346,7 @@ let T1 = Tuple{Int, Float64},
     @test f18037(2) === T2
 
     @test Base.return_types(f18037, ()) == Any[Type{T1}]
-    @test Base.return_types(f18037, (Int,)) == Any[Type{TypeVar(:T, Tuple{Int, AbstractFloat})}]
+    @test Base.return_types(f18037, (Int,)) == Any[Type{T} where T<:Tuple{Int, AbstractFloat}]
 end
 
 # issue #18015
@@ -399,7 +403,7 @@ f18450() = ifelse(true, Tuple{Vararg{Int}}, Tuple{Vararg})
 @test f18450() == Tuple{Vararg{Int}}
 
 # issue #18569
-@test Core.Inference.isconstType(Type{Tuple},true)
+@test Core.Inference.isconstType(Type{Tuple})
 
 # ensure pure attribute applies correctly to all signatures of fpure
 Base.@pure function fpure(a=rand(); b=rand())
@@ -484,3 +488,9 @@ test_fast_le(a, b) = @fastmath a <= b
 @inferred test_fast_ne(1.0, 1.0)
 @inferred test_fast_lt(1.0, 1.0)
 @inferred test_fast_le(1.0, 1.0)
+
+abstract AbstractMyType18457{T,F,G}
+immutable MyType18457{T,F,G}<:AbstractMyType18457{T,F,G} end
+tpara18457{I}(::Type{AbstractMyType18457{I}}) = I
+tpara18457{A<:AbstractMyType18457}(::Type{A}) = tpara18457(supertype(A))
+@test tpara18457(MyType18457{true}) === true
diff --git a/test/nullable.jl b/test/nullable.jl
index 7f7ac55c122d27..025522312427fd 100644
--- a/test/nullable.jl
+++ b/test/nullable.jl
@@ -296,7 +296,7 @@ for T in types
 end
 
 # Operators
-TestTypes = [[T.parameters[1] for T in Base.NullSafeTypes.types];
+TestTypes = [[T.parameters[1] for T in Base.uniontypes(Base.NullSafeTypes)];
              [BigInt, BigFloat,
               Complex{Int}, Complex{Float64}, Complex{BigFloat},
               Rational{Int}, Rational{BigInt}]]
diff --git a/test/numbers.jl b/test/numbers.jl
index a64aeb43cb0cff..400e08b006a928 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -2502,7 +2502,7 @@ function allsubtypes!(m::Module, x::DataType, sts::Set)
     for s in names(m, true)
         if isdefined(m, s) && !Base.isdeprecated(m, s)
             t = getfield(m, s)
-            if isa(t, Type) && t <: x
+            if isa(t, Type) && t <: x && t != Union{}
                 push!(sts, t)
             elseif isa(t, Module) && t !== m && module_name(t) === s && module_parent(t) === m
                 allsubtypes!(t, x, sts)
diff --git a/test/reflection.jl b/test/reflection.jl
index d7c1493b317095..6257d213adba7c 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -141,10 +141,10 @@ end
 @test isleaftype(Type{Vector})
 
 # issue #10165
-i10165(::DataType) = 0
+i10165(::Type) = 0
 i10165{T,n}(::Type{AbstractArray{T,n}}) = 1
-@test i10165(AbstractArray{Int}) == 0
-@test which(i10165, Tuple{Type{AbstractArray{Int}},}).sig == Tuple{typeof(i10165),DataType}
+@test i10165(AbstractArray{Int,n} where n) == 0
+@test which(i10165, Tuple{Type{AbstractArray{Int,n} where n},}).sig == Tuple{typeof(i10165),Type}
 
 # fullname
 @test fullname(Base) == (:Base,)
@@ -283,7 +283,7 @@ let ex = :(a + b)
 end
 foo13825{T,N}(::Array{T,N}, ::Array, ::Vector) = nothing
 @test startswith(string(first(methods(foo13825))),
-                 "foo13825{T,N}(::Array{T,N}, ::Array, ::Array{T<:Any,1})")
+                 "foo13825{T,N}(::Array{T,N}, ::Array, ::Array{T,1} where T)")
 
 type TLayout
     x::Int8
diff --git a/test/replutil.jl b/test/replutil.jl
index 31ac32ff2c5bcc..ed4489a923bacc 100644
--- a/test/replutil.jl
+++ b/test/replutil.jl
@@ -280,13 +280,13 @@ let undefvar
     err_str = @except_str 0::AbstractFloat TypeError
     @test err_str == "TypeError: typeassert: expected AbstractFloat, got $Int"
     err_str = @except_str 0::7 TypeError
-    @test err_str == "TypeError: typeassert: expected Type{T}, got $Int"
+    @test err_str == "TypeError: typeassert: expected Type, got $Int"
     err_str = @except_str "" <: AbstractString TypeError
-    @test err_str == "TypeError: subtype: expected Type{T}, got String"
+    @test err_str == "TypeError: issubtype: expected Type, got String"
     err_str = @except_str AbstractString <: "" TypeError
-    @test err_str == "TypeError: subtype: expected Type{T}, got String"
+    @test err_str == "TypeError: issubtype: expected Type, got String"
     err_str = @except_str Type{""} TypeError
-    @test err_str == "TypeError: Type: in parameter, expected Type{T}, got String"
+    @test err_str == "TypeError: Type: in parameter, expected Type, got String"
     err_str = @except_str TypeWithIntParam{Any} TypeError
     @test err_str == "TypeError: TypeWithIntParam: in T, expected T<:Integer, got Type{Any}"
 
@@ -335,7 +335,7 @@ let err_str,
     err_str = @except_str i() MethodError
     @test contains(err_str, "MethodError: objects of type $(curmod_prefix)EightBitType are not callable")
     err_str = @except_str EightBitTypeT() MethodError
-    @test contains(err_str, "MethodError: no method matching $(curmod_prefix)EightBitTypeT{T}()")
+    @test contains(err_str, "MethodError: no method matching $(curmod_prefix)EightBitTypeT()")
     err_str = @except_str EightBitTypeT{Int32}() MethodError
     @test contains(err_str, "MethodError: no method matching $(curmod_prefix)EightBitTypeT{Int32}()")
     err_str = @except_str j() MethodError
@@ -389,7 +389,7 @@ let err_str,
     err_str = @except_stackframe i() ErrorException
     @test err_str == " in (::$(curmod_prefix)EightBitType)() at $sn:$(method_defs_lineno + 3)"
     err_str = @except_stackframe EightBitTypeT() ErrorException
-    @test err_str == " in $(curmod_prefix)EightBitTypeT{T}() at $sn:$(method_defs_lineno + 4)"
+    @test err_str == " in $(curmod_prefix)EightBitTypeT() at $sn:$(method_defs_lineno + 4)"
     err_str = @except_stackframe EightBitTypeT{Int32}() ErrorException
     @test err_str == " in $(curmod_prefix)EightBitTypeT{Int32}() at $sn:$(method_defs_lineno + 5)"
     err_str = @except_stackframe j() ErrorException
diff --git a/test/serialize.jl b/test/serialize.jl
index af19ca4aac31f1..c5f1d84a8d7836 100644
--- a/test/serialize.jl
+++ b/test/serialize.jl
@@ -4,8 +4,8 @@ using Base.Test
 
 # Check that serializer hasn't gone out-of-frame
 @test Serializer.sertag(Symbol) == 2
-@test Serializer.sertag(()) == 44
-@test Serializer.sertag(false) == 120
+@test Serializer.sertag(()) == 45
+@test Serializer.sertag(false) == 121
 
 function create_serialization_stream(f::Function)
     s = IOBuffer()
@@ -151,7 +151,7 @@ create_serialization_stream() do s # user-defined type
     utype = eval(parse("$(usertype)"))
     serialize(s, utype)
     seek(s, 0)
-    @test deserialize(s) === utype
+    @test deserialize(s) == utype
 end
 
 create_serialization_stream() do s # immutable type with 1 field
@@ -160,7 +160,7 @@ create_serialization_stream() do s # immutable type with 1 field
     utype = eval(parse("$(usertype)"))
     serialize(s, utype)
     seek(s, 0)
-    @test deserialize(s) === utype
+    @test deserialize(s) == utype
 end
 
 create_serialization_stream() do s # immutable type with 2 field
diff --git a/test/show.jl b/test/show.jl
index 2e64276caefc34..e99ef8d5a9a1de 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -524,10 +524,10 @@ end
 
 # PR 16221
 # Printing of upper and lower bound of a TypeVar
-@test string(TypeVar(:V, Signed, Real, false)) == "Signed<:V<:Real"
+@test string(TypeVar(:V, Signed, Real)) == "Signed<:V<:Real"
 # Printing of primary type in type parameter place should not show the type
 # parameter names.
-@test string(Array) == "Array{T,N}"
+@test string(Array) == "Array"
 @test string(Tuple{Array}) == "Tuple{Array}"
 
 # PR #16651
@@ -553,8 +553,8 @@ end
 let repr = sprint(dump, :(x = 1))
     @test repr == "Expr\n  head: Symbol =\n  args: Array{Any}((2,))\n    1: Symbol x\n    2: $Int 1\n  typ: Any\n"
 end
-let repr = sprint(dump, Pair)
-    @test repr == "Pair{A,B} <: Any\n  first::A\n  second::B\n"
+let repr = sprint(dump, Pair{String,Int64})
+    @test repr == "Pair{String,Int64} <: Any\n  first::String\n  second::Int64\n"
 end
 let repr = sprint(dump, Tuple)
     @test repr == "Tuple <: Any\n"
@@ -568,7 +568,7 @@ let repr = sprint(dump, Any)
     @test length(repr) > 100000
     @test ismatch(r"^Any\n  [^ \t\n]", repr)
     @test endswith(repr, '\n')
-    @test contains(repr, "     Base.Vector{T} = Array{T,1}\n")
+    #@test contains(repr, "     Base.Vector{T} = Array{T,1}\n")
     @test !contains(repr, "Core.Vector{T}")
 end
 let repr = sprint(dump, Integer)
diff --git a/test/sparse/umfpack.jl b/test/sparse/umfpack.jl
index dbfe2dfae03871..3c901486d4362b 100644
--- a/test/sparse/umfpack.jl
+++ b/test/sparse/umfpack.jl
@@ -13,7 +13,7 @@ A0 = sparse(increment!([0,4,1,1,2,2,0,1,2,3,4,4]),
            [2.,1.,3.,4.,-1.,-3.,3.,6.,2.,1.,4.,2.], 5, 5)
 
 for Tv in (Float64, Complex128)
-    for Ti in Base.SparseArrays.UMFPACK.UMFITypes.types
+    for Ti in Base.uniontypes(Base.SparseArrays.UMFPACK.UMFITypes)
         A = convert(SparseMatrixCSC{Tv,Ti}, A0)
         lua = lufact(A)
         @test nnz(lua) == 18
@@ -70,7 +70,7 @@ for Tv in (Float64, Complex128)
 end
 
 Ac0 = complex.(A0,A0)
-for Ti in Base.SparseArrays.UMFPACK.UMFITypes.types
+for Ti in Base.uniontypes(Base.SparseArrays.UMFPACK.UMFITypes)
     Ac = convert(SparseMatrixCSC{Complex128,Ti}, Ac0)
     lua = lufact(Ac)
     L,U,p,q,Rs = lua[:(:)]
diff --git a/test/subtype.jl b/test/subtype.jl
index d9b27c75619063..8d6c007dfea1df 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -2,7 +2,7 @@ using Base.Bottom
 using Base.Test
 
 macro UnionAll(var, expr)
-    Expr(:where, expr, var)
+    Expr(:where, esc(expr), esc(var))
 end
 
 const issub = issubtype
@@ -63,6 +63,11 @@ function test_2()
     @test !(Tuple{Int,Vararg{Int,2}} <: Tuple{Int,Int,Int,Vararg{Int,1}})
     @test Tuple{Int,Vararg{Int}} == Tuple{Int,Vararg{Int}}
     @test (@UnionAll N Tuple{Int,Vararg{Int,N}}) == (@UnionAll N Tuple{Int,Vararg{Int,N}})
+
+    @test issub_strict(Tuple{Tuple{Int,Int},Tuple{Int,Int}}, Tuple{NTuple{N,Int},NTuple{N,Int}} where N)
+    @test !issub(Tuple{Tuple{Int,Int},Tuple{Int,}}, Tuple{NTuple{N,Int},NTuple{N,Int}} where N)
+
+    @test issub(Type{Tuple{VecElement{Bool}}}, (Type{Tuple{Vararg{VecElement{T},N}}} where T where N))
 end
 
 function test_diagonal()
@@ -257,7 +262,7 @@ function test_4()
     # nested unions
     @test !issub(Union{Int,Ref{Union{Int,Int8}}}, Union{Int,Ref{Union{Int8,Int16}}})
 
-    A = Int;   B = Int8
+    A = Int64; B = Int8
     C = Int16; D = Int32
     @test  issub(Union{Union{A,Union{A,Union{B,C}}}, Union{D,Bottom}},
                  Union{Union{A,B},Union{C,Union{B,D}}})
@@ -307,13 +312,13 @@ function test_5()
     @test !issub(Array{Tuple{Array{Int},Array{Vector{Int16}},Array{Vector{Int}},Array{Int}}},
                  @UnionAll T<:(@UnionAll S Tuple{Vararg{Union{Array{S}, Array{Array{S,1}}}}}) Array{T})
 
-    @test  issub(Array{Tuple{Array{Int},Array{Vector{Int  }},Array{Vector{Int}},Array{Int}}},
+    @test  issub(Array{Tuple{Array{Int},Array{Vector{Int}},Array{Vector{Int}},Array{Int}}},
                  @UnionAll T<:(@UnionAll S Tuple{Vararg{Union{Array{S}, Array{Array{S,1}}}}}) Array{T})
 
     @test !issub(Tuple{Array{Int},Array{Vector{Int16}},Array{Vector{Int}},Array{Int}},
                  @UnionAll S Tuple{Vararg{Union{Array{S},Array{Array{S,1}}}}})
 
-    @test  issub(Tuple{Array{Int},Array{Vector{Int  }},Array{Vector{Int}},Array{Int}},
+    @test  issub(Tuple{Array{Int},Array{Vector{Int}},Array{Vector{Int}},Array{Int}},
                  @UnionAll S Tuple{Vararg{Union{Array{S},Array{Array{S,1}}}}})
 
     B = @UnionAll S<:u Tuple{S, Tuple{Any,Any,Any}, Ref{S}}
@@ -329,6 +334,13 @@ function test_5()
     @test !issub(Ref{Union{Ref{Int},Ref{Int8}}}, @UnionAll T Ref{Ref{T}})
     @test  issub(Tuple{Union{Ref{Int},Ref{Int8}}}, @UnionAll T Tuple{Ref{T}})
     @test !issub(Ref{Union{Ref{Int},Ref{Int8}}}, Union{Ref{Ref{Int}}, Ref{Ref{Int8}}})
+
+    @test isequal_type(Ref{Tuple{Union{Int,Int8},Int16}}, Ref{Union{Tuple{Int,Int16},Tuple{Int8,Int16}}})
+    @test isequal_type(Ref{T} where T<:Tuple{Union{Int,Int8},Int16},
+                       Ref{T} where T<:Union{Tuple{Int,Int16},Tuple{Int8,Int16}})
+
+    @test_broken isequal_type(Ref{Tuple{Union{Int,Int8},Int16,T}} where T,
+                              Ref{Union{Tuple{Int,Int16,S},Tuple{Int8,Int16,S}}} where S)
 end
 
 # tricky type variable lower bounds
@@ -417,6 +429,9 @@ function test_Type()
     @test isa(Tuple{},Type{Tuple{}})
     @test !(Tuple{Int,} <: (@UnionAll T<:Tuple Type{T}))
     @test isa(Tuple{Int}, (@UnionAll T<:Tuple Type{T}))
+
+    # this matches with T==DataType, since DataType is concrete
+    @test issub(Tuple{Type{Int},Type{Int8}}, Tuple{T,T} where T)
 end
 
 # old subtyping tests from test/core.jl
@@ -446,6 +461,7 @@ function test_old()
     @test !(Type{Ptr{Bottom}} <: Type{Ptr})
     @test !(Type{Rational{Int}} <: Type{Rational})
     @test Tuple{} <: Tuple{Vararg}
+    @test Tuple{Int,Int} <: Tuple{Vararg}
     @test Tuple{} <: @UnionAll N NTuple{N}
     @test !(Type{Tuple{}} <: Type{Tuple{Vararg}})
     @test !(Type{Tuple{}} <: (@UnionAll N Type{NTuple{N}}))
@@ -582,7 +598,7 @@ macro testintersect(a, b, result)
     end)
 end
 
-abstract IT4805{N, T}
+abstract IT4805_2{N, T}
 abstract AbstractThing{T,N}
 type ConcreteThing{T<:AbstractFloat,N} <: AbstractThing{T,N}
 end
@@ -590,6 +606,10 @@ type A11136 end
 type B11136 end
 abstract Foo11367
 
+abstract AbstractTriangular{T,S<:AbstractMatrix} <: AbstractMatrix{T}
+immutable UpperTriangular{T,S<:AbstractMatrix} <: AbstractTriangular{T,S} end
+immutable UnitUpperTriangular{T,S<:AbstractMatrix} <: AbstractTriangular{T,S} end
+
 function test_intersection()
     @testintersect(Vector{Float64}, Vector{Union{Float64,Float32}}, Bottom)
 
@@ -716,11 +736,15 @@ function test_intersection()
     @testintersect((@UnionAll N Tuple{Array{Int,N},Vararg{Int,N}}),
                    Tuple{Matrix{Int},Int,Vararg{Float64}}, Bottom)
 
+    @testintersect(Tuple{Array{Any,1}, Tuple{Int64, Int64, Vararg{Int64, N} where N}},
+                   Tuple{Array{T,N}, Tuple{Vararg{Int64,N}}} where N where T,
+                   Bottom)
+
     @testintersect((@UnionAll T<:Union{Float64,Array{Float64,1}} T), Real, Float64)
 
     # issue #4805
-    @testintersect((@UnionAll T<:Int Type{IT4805{1,T}}),
-                   (@UnionAll S<:(@UnionAll N IT4805{N,Int}) Type{S}),
+    @testintersect((@UnionAll T<:Int Type{IT4805_2{1,T}}),
+                   (@UnionAll S<:(@UnionAll N IT4805_2{N,Int}) Type{S}),
                    !Bottom)
 
     # issue #8851
@@ -732,11 +756,13 @@ function test_intersection()
     @testintersect((@UnionAll T Tuple{T, T}), (@UnionAll TB<:B11136 Tuple{A11136, TB}), Bottom)
     @testintersect((@UnionAll T Tuple{T, T}), (@UnionAll T2<:Foo11367 Tuple{Type{BigInt}, T2}), Bottom)
 
+    # PR #12058
     @testintersect((@UnionAll N NTuple{N,Int}), (@UnionAll N NTuple{N,Float64}), Tuple{})
 
     @testintersect((@UnionAll T Tuple{Type{T},T}), Tuple{Type{Type{Float64}},Type{Int}}, Bottom)
 
     @testintersect((@UnionAll T T), Type{Int8}, Type{Int8})
+    # issue #14482
     @testintersect((@UnionAll T Tuple{T}), Tuple{Type{Int8}}, Tuple{Type{Int8}})
 
     @testintersect((@UnionAll T Tuple{Union{Int,T}, Union{Vector{T},Vector{String}}}),
@@ -758,6 +784,29 @@ function test_intersection()
                    (@UnionAll X<:(@UnionAll T Tuple{T,T}) Ref{X}))
     @testintersect(Ref{@UnionAll T @UnionAll S Tuple{T,S}},
                    Ref{@UnionAll T Tuple{T,T}}, Bottom)
+
+    @testintersect(Tuple{T,T} where T<:Union{UpperTriangular, UnitUpperTriangular},
+                   Tuple{AbstractArray{T,N}, AbstractArray{T,N}} where N where T,
+                   Union{Tuple{T,T} where T<:UpperTriangular,
+                         Tuple{T,T} where T<:UnitUpperTriangular})
+
+    @testintersect(DataType, Type, DataType)
+    @testintersect(DataType, Type{T} where T<:Integer, Type{T} where T<:Integer)
+    @testintersect(Union{DataType,Int}, Type, DataType)
+    @testintersect(Union{DataType,Int}, Type{T} where T, DataType)
+    # test typeintersect wrapper as well as _type_intersect
+    @test typeintersect(Union{DataType,Int}, Type) === DataType
+    @test typeintersect(Union{DataType,Int}, Type{T} where T) === DataType
+
+    @testintersect((Type{Tuple{Vararg{T}}} where T), Type{Tuple}, Bottom)
+    @testintersect(Tuple{Type{S}, Tuple{Any, Vararg{Any}}} where S<:Tuple{Any, Vararg{Any}},
+                   Tuple{Type{T}, T} where T,
+                   Tuple{Type{S},S} where S<:Tuple{Any,Vararg{Any,N} where N})
+
+    @test_broken isequal_type(_type_intersect(Tuple{T,T} where T,
+                                              Union{Tuple{S,Array{Int64,1}},Tuple{S,Array{S,1}}} where S),
+                              Union{Tuple{Vector{Int64},Vector{Int64}},
+                                    Tuple{Vector{T},Vector{T}} where T>:Vector})
 end
 
 function test_intersection_properties()
diff --git a/test/workspace.jl b/test/workspace.jl
index 6fe618486a7022..3fc35bfab69f0c 100644
--- a/test/workspace.jl
+++ b/test/workspace.jl
@@ -10,7 +10,7 @@ LastMain.f(2)
 # PR #12990
 io = IOBuffer()
 show(io, Pair)
-@assert String(take!(io)) == "Pair{A,B}"
+@assert String(take!(io)) == "Pair"
 @assert !Base.inbase(LastMain)
 """
 exename = Base.julia_cmd()