Inference discards bounds on abstract parameters

[timholy]

Apologies, I'm sure this must have been reported before but a search didn't pick it up.

There appear to be cases where it would be "easy" to preserve bounds on abstract types. One that comes up a lot in my invalidation-squashing is Iterators.Stateful:

julia> code_typed(Iterators.Stateful, (AbstractString,))
1-element Array{Any,1}:
 CodeInfo(
1 ─ %1 = invoke Base.Iterators.approx_iter_type($(Expr(:static_parameter, 1))::Type{T} where T)::Type
│   %2 = Core.apply_type(Base.Iterators.Stateful, $(Expr(:static_parameter, 1)), %1)::Type{Base.Iterators.Stateful{_A,_B}} where _B where _A
│   %3 = Base.convert($(Expr(:static_parameter, 1)), itr)::Any
│   %4 = Core.fieldtype(%2, 2)::Type{var"#s428"} where var"#s428"<:(Union{Nothing, _B} where _B)
│   %5 = Base.Iterators.iterate(itr)::Any
│        Core.typeassert(%5, %1)::Any
│   %7 = Base.convert(%4, %5)::Any
│   %8 = %new(%2, %3, %7, 0)::Base.Iterators.Stateful{_A,_B} where _B where _A
└──      return %8
) => Base.Iterators.Stateful{_A,_B} where _B where _A

Given the definition

julia/base/iterators.jl

Lines 1243 to 1246 in d762e8c

	@inline function Stateful(itr::T) where {T}
	VS = approx_iter_type(T)
	return new{T, VS}(itr, iterate(itr)::VS, 0)
	end

it would naively seem fairly straightforward to retain _A<:AbstractString.

[martinholters]

The code to fix this is all there it seems, just disabled:

julia/base/compiler/tfuncs.jl

Lines 1100 to 1123 in 6185d24

	# These blocks improve type info but make compilation a bit slower.
	# XXX
	#unw = unwrap_unionall(ai)
	#isT = isType(unw)
	#if isT && isa(ai,UnionAll) && contains_is(outervars, ai.var)
	# ai = rename_unionall(ai)
	# unw = unwrap_unionall(ai)
	#end
	if istuple
	if i == largs
	push!(tparams, Vararg)
	# XXX
	#elseif isT
	# push!(tparams, rewrap_unionall(unw.parameters[1], ai))
	else
	push!(tparams, Any)
	end
	# XXX
	#elseif isT
	# push!(tparams, unw.parameters[1])
	# while isa(ai, UnionAll)
	# push!(outervars, ai.var)
	# ai = ai.body
	# end

If this came up in your invalidation hunt, maybe it's time to reconsider this?

[timholy]

Nice find. It's a difficult design decision; on one hand, doing more accurate inference makes inference slower. On the other hand, doing more accurate inference reduces the "vulnerability" of code to invalidation because fewer MethodInstances end up having mt_backedges to Any-instances of their dependent methods. Thereby, investing in better inference at the outset might save inference in the long run.

It's quite difficult to come up with reasonable benchmarks for these things, since it depends entirely on what new methods you define. Therefore what works in practice is a bit of a cultural issue of which packages often get used in which combinations.