Add InvalidationFlagger

[IanButterworth]

A trial github action for flagging compilation invalidations during load

[github-actions]

InvalidationFlagger found 50 sources of compillation invalidation during using Plots

Click to expand invalidation points

>> Missings.IteratorSize(...) Tuple{Type{Base.IteratorSize}, Type{#s14} where #s14<:(Missings.EachReplaceMissing{T, U} where U)} where T
>> Missings.IteratorEltype(...) Tuple{Type{Base.IteratorEltype}, Type{#s14} where #s14<:(Missings.EachReplaceMissing{T, U} where U)} where T
>> JSON.Parser.resize!(...) Tuple{typeof(Base.resize!), JSON.Parser.PushVector{T, A} where A<:AbstractArray{T, 1} where T, Integer}
>> OrderedCollections.merge(...) Tuple{typeof(Base.merge), OrderedCollections.OrderedDict{K, V} where V where K, Vararg{Base.AbstractDict{K, V} where V where K, N} where N}
>> OrderedCollections.copy(...) Tuple{typeof(Base.copy), OrderedCollections.OrderedDict{K, V} where V where K}
>> OrderedCollections.copy(...) Tuple{typeof(Base.copy), OrderedCollections.OrderedSet{T} where T}
>> DataStructures.merge!(...) Tuple{typeof(Base.merge!), DataStructures.Accumulator{T, V} where V<:Number where T, DataStructures.Accumulator{T, V} where V<:Number where T}
>> DataStructures.eltype(...) Tuple{typeof(Base.eltype), Type{DataStructures.CircularBuffer{T}}} where T
>> DataStructures.iterate(...) Tuple{typeof(Base.iterate), Base.ValueIterator{T}, Int64} where T<:(DataStructures.DefaultDictBase{K, V, F, D} where D where F where V where K)
>> FixedPointNumbers.promote_rule(...) Tuple{typeof(Base.promote_rule), Type{T}, Type{Tf}} where Tf<:AbstractFloat where T<:(FixedPointNumbers.Normed{T, f} where f where T<:Unsigned)
>> FixedPointNumbers.sizeof(...) Tuple{typeof(Base.sizeof), Type{X}} where X<:(FixedPointNumbers.FixedPoint{T, f} where f where T<:Integer)
>> FixedPointNumbers.one(...) Tuple{typeof(Base.one), Type{X}} where X<:(FixedPointNumbers.FixedPoint{T, f} where f where T<:Integer)
>> FixedPointNumbers.reduce_empty(...) Tuple{typeof(Base.reduce_empty), typeof(Base.mul_prod), Type{F}} where F<:(FixedPointNumbers.FixedPoint{T, f} where f where T<:Integer)
>> FixedPointNumbers.FixedPoint(...) Tuple{Type{X}, Real} where X<:(FixedPointNumbers.FixedPoint{T, f} where f where T<:Integer)
>> ColorTypes.convert(...) Tuple{typeof(Base.convert), Type{T}, ColorTypes.Gray{T} where T<:Union{Bool, AbstractFloat, FixedPointNumbers.FixedPoint{T, f} where f where T<:Integer}} where T<:Real
>> ColorTypes.convert(...) Tuple{typeof(Base.convert), Type{C}, Any} where C<:(ColorTypes.Colorant{T, N} where N where T)
>> StaticArrays.getproperty(...) Tuple{typeof(Base.getproperty), StaticArrays.SOneTo{n}, Symbol} where n
>> StaticArrays._getindex(...) Tuple{typeof(Base._getindex), Base.IndexStyle, AbstractArray{T, N} where N where T, StaticArrays.StaticIndexing{I} where I, Vararg{StaticArrays.StaticIndexing{I} where I, N} where N}
>> StaticArrays.any(...) Tuple{typeof(Base.any), Function, StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple}
>> StaticArrays.all(...) Tuple{typeof(Base.all), Function, StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple}
>> StaticArrays._setindex!(...) Tuple{typeof(Base._setindex!), Base.IndexStyle, AbstractArray{T, N} where N where T, Any, StaticArrays.StaticIndexing{I} where I, Vararg{StaticArrays.StaticIndexing{I} where I, N} where N}
>> StaticArrays.getindex(...) Tuple{typeof(Base.getindex), Type{StaticArrays.SA{T}}, Vararg{Any, N} where N} where T
>> StaticArrays.to_indices(...) Tuple{typeof(Base.to_indices), Any, Tuple{Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N, StaticArrays.StaticArray{#s173, Int64, N} where N where #s173<:Tuple}, N} where N}}
>> StaticArrays.similar(...) Tuple{typeof(Base.similar), Type{A}, StaticArrays.Size{S}} where S where A<:(AbstractArray{T, N} where N where T)
>> StaticArrays.similar(...) Tuple{typeof(Base.similar), A, Type{T}, StaticArrays.Size{S}} where S where T where A<:(AbstractArray{T, N} where N where T)
>> StaticArrays.similar(...) Tuple{typeof(Base.similar), AbstractArray{T, N} where N where T, Type{T}, Tuple{Union{Integer, Base.OneTo{T} where T<:Integer, StaticArrays.SOneTo{n} where n}, Vararg{Union{Integer, Base.OneTo{T} where T<:Integer, StaticArrays.SOneTo{n} where n}, N} where N}} where T
>> StaticArrays.similar(...) Tuple{typeof(Base.similar), Type{A}, Tuple{Union{Integer, Base.OneTo{T} where T<:Integer, StaticArrays.SOneTo{n} where n}, Vararg{Union{Integer, Base.OneTo{T} where T<:Integer, StaticArrays.SOneTo{n} where n}, N} where N}} where A<:(AbstractArray{T, N} where N where T)
>> StaticArrays.unsafe_view(...) Tuple{typeof(Base.unsafe_view), AbstractArray{T, N} where N where T, StaticArrays.StaticIndexing{I} where I, Vararg{StaticArrays.StaticIndexing{I} where I, N} where N}
>> StaticArrays.parent(...) Tuple{typeof(Base.parent), Union{#s173, #s172} where #s172<:(LinearAlgebra.Adjoint{#s169, #s168} where #s168<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where #s169) where #s173<:(LinearAlgebra.Transpose{#s171, #s170} where #s170<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where #s171)}
>> StaticArrays.isassigned(...) Tuple{typeof(Base.isassigned), StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple, Vararg{Int64, N} where N}
>> StaticArrays.!=(...) Tuple{typeof(Base.:(!=)), StaticArrays.Size{S}, Tuple{Vararg{Int64, N} where N}} where S
>> StaticArrays.!=(...) Tuple{typeof(Base.:(!=)), StaticArrays.Length{L}, Int64} where L
>> StaticArrays.!=(...) Tuple{typeof(Base.:(!=)), Int64, StaticArrays.Length{L}} where L
>> StaticArrays.convert(...) Tuple{typeof(Base.convert), Type{SA}, Tuple} where SA<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple)
>> StaticArrays.unsafe_convert(...) Tuple{typeof(Base.unsafe_convert), Type{Ptr{T}}, Base.RefValue{FA}} where FA<:StaticArrays.FieldArray{N, T, D} where D where T where N
>> StaticArrays.cconvert(...) Tuple{typeof(Base.cconvert), Type{#s37} where #s37<:(Ptr{T} where T), StaticArrays.FieldArray{N, T, D} where D where T where N}
>> StaticArrays.SubArray(...) Tuple{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, AbstractArray{T, N} where N where T, Tuple{StaticArrays.StaticIndexing{I} where I, Vararg{StaticArrays.StaticIndexing{I} where I, N} where N}}
>> StaticArrays.SHermitianCompact(...) Tuple{Type{SSC}, AbstractArray{T, 1} where T} where SSC<:(StaticArrays.SHermitianCompact{N, T, L} where L where T where N)
>> StaticArrays.BroadcastStyle(...) Tuple{Type{Base.Broadcast.BroadcastStyle}, StaticArrays.StaticArrayStyle{M}, Base.Broadcast.DefaultArrayStyle{0}} where M
>> StaticArrays.StaticArray(...) Tuple{Type{SA}, Vararg{Any, N} where N} where SA<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple)
>> GeometryTypes.getindex(...) Tuple{typeof(Base.getindex), AbstractArray{T, N} where N where T, GeometryTypes.Face{N, T} where T} where N
>> GeometryTypes.promote_rule(...) Tuple{typeof(Base.promote_rule), Type{T1}, Type{GeometryTypes.OffsetInteger{O, T2}}} where T2 where O where T1<:Integer
>> GeometryTypes.show(...) Tuple{typeof(Base.show), IO, Type{#s28} where #s28<:GeometryTypes.HomogenousMesh{GeometryTypes.Point{3, Float32}, GeometryTypes.Face{3, GeometryTypes.OffsetInteger{-1, UInt32}}, Nothing, Nothing, Nothing, Nothing, Nothing}}
>> GeometryTypes.FixedSizeArrays.extrema(...) Tuple{typeof(Base.extrema), AbstractArray{T, 1}} where T<:(StaticArrays.StaticArray{Tuple{N}, T, 1} where T where N)
>> GeometryTypes.to_index(...) Tuple{typeof(Base.to_index), GeometryTypes.OffsetInteger{0, T} where T<:Integer}
>> GeometryTypes.to_index(...) Tuple{typeof(Base.to_index), AbstractArray{#s28, N} where N where #s28<:(GeometryTypes.Face{S, T} where T where S)}
>> GeometryTypes.Integer(...) Tuple{Type{IT}, GeometryTypes.OffsetInteger{O, T}} where T<:Integer where O where IT<:Integer
>> GeometryTypes.HomogenousMesh(...) Tuple{Type{HM1}, HM2} where HM2<:(GeometryTypes.HomogenousMesh{VertT, FaceT, NormalT, TexCoordT, ColorT, AttribT, AttribIDT} where AttribIDT where AttribT where ColorT where TexCoordT where NormalT where FaceT where VertT) where HM1<:(GeometryTypes.HomogenousMesh{VertT, FaceT, NormalT, TexCoordT, ColorT, AttribT, AttribIDT} where AttribIDT where AttribT where ColorT where TexCoordT where NormalT where FaceT where VertT)
>> GeometryTypes.AbstractFlexibleGeometry(...) Tuple{Type{F}, Tuple{Vararg{T, N}} where T where N} where F<:(GeometryTypes.AbstractFlexibleGeometry{T} where T)
>> GeometryTypes.AbstractMesh(...) Tuple{Type{M}, AbstractArray{P, N} where N} where P<:(GeometryTypes.Point{S, T} where T where S) where M<:(GeometryTypes.AbstractMesh{VertT, FaceT} where FaceT where VertT)

Full log available in job artifacts: invalidationdump

[codecov-io]

Codecov Report

❗ No coverage uploaded for pull request base (master@6ddf31d). Click here to learn what that means.
The diff coverage is n/a.

@@            Coverage Diff            @@
##             master       #1   +/-   ##
=========================================
  Coverage          ?   68.21%           
=========================================
  Files             ?       24           
  Lines             ?     6201           
  Branches          ?        0           
=========================================
  Hits              ?     4230           
  Misses            ?     1971           
  Partials          ?        0           

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 6ddf31d...9791469. Read the comment docs.

[ViralBShah]

Slightly related, in Plots, a lot of invalidations happen if you loaded DataFrames before Plots. This is what I recollect from some time to first plot experiments.

[IanButterworth]

Stale. Can be reimplemented if people find it helpful