Inference failure in negating a list of lists

[LilithHafner]

I feel like this should infer.

julia> Base.return_types(-, Tuple{Vector{Vector{Int64}}})
1-element Vector{Any}:
 Any

I ran into this because it caused dynamic dispatch that resulted in a performance bottleneck in some code I was writing. I'm switching to Vector{StaticArrays.SVector{2, Int64}} which does infer, so this is no longer an issue for me, but I'm still logging it because it seems odd and perhaps a place for inference to improve (if that wouldn't slow down inference time).

[nsajko]

Minimal example:

julia> bvv = Base.broadcasted(-, [[1],[2]])
Base.Broadcast.Broadcasted(-, ([[1], [2]],))

julia> @inferred Base.materialize(bvv)
ERROR: return type Vector{Vector{Int64}} does not match inferred return type Any
Stacktrace:
 [1] error(s::String)
   @ Base ./error.jl:35
 [2] top-level scope
   @ REPL[41]:1

julia> @code_warntype Base.materialize(bvv)
MethodInstance for Base.Broadcast.materialize(::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Vector{Int64}}}})
  from materialize(bc::Base.Broadcast.Broadcasted) @ Base.Broadcast broadcast.jl:903
Arguments
  #self#::Core.Const(Base.Broadcast.materialize)
  bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(-), Tuple{Vector{Vector{Int64}}}}
Body::Vector{Vector{Int64}}
1 ─      nothing
│   %2 = Base.Broadcast.instantiate(bc)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(-), Tuple{Vector{Vector{Int64}}}}
│   %3 = Base.Broadcast.copy(%2)::Vector{Vector{Int64}}
└──      return %3

How is it possible for @inferred to fail even though @code_warntype shows everything as correctly inferred?

[raminammour]

Is there a reason why broadcast is specialized on the type of the function but broadcast_preserving_zero_d isn't?

broadcast(f::Tf, As...) where {Tf} = ...
@inline function broadcast_preserving_zero_d(f, As...) ...

Naively specializing in the REPL infers after hitting some form of #35800

julia> @eval Base.Broadcast @inline function broadcast_preserving_zero_d(f::F, As...) where F
           bc = broadcasted(f, As...)
           r = materialize(bc)
           return length(axes(bc)) == 0 ? fill!(similar(bc, typeof(r)), r) : r
       end
broadcast_preserving_zero_d (generic function with 5 methods)

julia> @eval Base.Broadcast Base.:-(A::AbstractArray) = @inline broadcast_preserving_zero_d(-, A)

julia> @code_warntype  -[[-1]]
MethodInstance for -(::Vector{Vector{Int64}})
  from -(A::AbstractArray) @ Base.Broadcast REPL[2]:1
Arguments
  #self#::Core.Const(-)
  A::Vector{Vector{Int64}}
Locals
  val::Any
Body::Any
1 ─     nothing
│       (val = Base.Broadcast.broadcast_preserving_zero_d(Base.Broadcast.:-, A))
│       nothing
└──     return val


julia> -[[1]]
1-element Vector{Vector{Int64}}:
 [-1]

julia> @code_warntype  -[[-1]]
MethodInstance for -(::Vector{Vector{Int64}})
  from -(A::AbstractArray) @ Base.Broadcast REPL[2]:1
Arguments
  #self#::Core.Const(-)
  A::Vector{Vector{Int64}}
Locals
  val::Any
Body::Any
1 ─     nothing
│       (val = Base.Broadcast.broadcast_preserving_zero_d(Base.Broadcast.:-, A))
│       nothing
└──     return val


julia> @eval Base.Broadcast Base.:-(A::AbstractArray) = @inline broadcast_preserving_zero_d(-, A)

julia> @code_warntype  -[[-1]]
MethodInstance for -(::Vector{Vector{Int64}})
  from -(A::AbstractArray) @ Base.Broadcast REPL[6]:1
Arguments
  #self#::Core.Const(-)
  A::Vector{Vector{Int64}}
Locals
  val::Vector{Vector{Int64}}
Body::Vector{Vector{Int64}}
1 ─     nothing
│       (val = Base.Broadcast.broadcast_preserving_zero_d(Base.Broadcast.:-, A))
│       nothing
└──     return val

So there may be a lot going on here :)

[adienes]

this (specific MWE given) does not reproduce on master

[LilithHafner]

Great!