fix CanonicalInt usage

Author: ChrisRackauckas

lib/ArrayInterfaceBandedMatrices/src/ArrayInterfaceBandedMatrices.jl

@@ -3,6 +3,8 @@ module ArrayInterfaceBandedMatrices
 using ArrayInterfaceCore
 using BandedMatrices
 
+const CanonicalInt = Union{Int,StaticInt}
+
 struct BandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
     count::Int
     rowsize::Int

lib/ArrayInterfaceBlockBandedMatrices/src/ArrayInterfaceBlockBandedMatrices.jl

@@ -5,6 +5,8 @@ using ArrayInterfaceBandedMatrices
 using BlockArrays
 using BlockBandedMatrices
 
+const CanonicalInt = Union{Int,StaticInt}
+
 struct BlockBandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
     count::Int
     refinds::Array{Int,1}
@@ -19,9 +21,9 @@ function BlockBandedMatrixIndex(nrowblock, ncolblock, rowsizes, colsizes, l, u)
     blockcolind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
     sortedinds = sort(
         [(blockrowind[i], blockcolind[i]) for i = 1:length(blockrowind)],
-        by = x -> x[1],
+        by=x -> x[1],
     )
-    sort!(sortedinds, by = x -> x[2], alg = InsertionSort)# stable sort keeps the second index in order
+    sort!(sortedinds, by=x -> x[2], alg=InsertionSort)# stable sort keeps the second index in order
     refinds = Array{Int,1}()
     refrowcoords = Array{Int,1}()
     refcolcoords = Array{Int,1}()
@@ -132,9 +134,9 @@ function BandedBlockBandedMatrixIndex(
     blockcolind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
     sortedinds = sort(
         [(blockrowind[i], blockcolind[i]) for i = 1:length(blockrowind)],
-        by = x -> x[1],
+        by=x -> x[1],
     )
-    sort!(sortedinds, by = x -> x[2], alg = InsertionSort)# stable sort keeps the second index in order
+    sort!(sortedinds, by=x -> x[2], alg=InsertionSort)# stable sort keeps the second index in order
     rowheights = pushfirst!(copy(rowsizes), 1)
     cumsum!(rowheights, rowheights)
     colwidths = pushfirst!(copy(colsizes), 1)
@@ -218,7 +220,7 @@ function ArrayInterfaceCore.matrix_colors(A::BlockBandedMatrices.BlockBandedMatr
         (startinds[blockcolors[i]]:endinds[blockcolors[i]])[1:cols[i]]
         for i = 1:nblock
     ]
-    return reduce(vcat,colors)
+    return reduce(vcat, colors)
 end
 
 function ArrayInterfaceCore.matrix_colors(A::BlockBandedMatrices.BandedBlockBandedMatrix)

lib/ArrayInterfaceCUDA/src/ArrayInterfaceCUDA.jl

@@ -4,6 +4,8 @@ using Adapt
 using ArrayInterfaceCore
 using CUDA
 
+const CanonicalInt = Union{Int,StaticInt}
+
 ArrayInterfaceCore.fast_scalar_indexing(::Type{<:CUDA.CuArray}) = false
 @inline ArrayInterfaceCore.allowed_getindex(x::CUDA.CuArray, i...) = CUDA.@allowscalar(x[i...])
 @inline ArrayInterfaceCore.allowed_setindex!(x::CUDA.CuArray, v, i...) = (CUDA.@allowscalar(x[i...] = v))

lib/ArrayInterfaceOffsetArrays/src/ArrayInterfaceOffsetArrays.jl

@@ -4,6 +4,8 @@ using ArrayInterfaceCore
 using OffsetArrays
 using Static
 
+const CanonicalInt = Union{Int,StaticInt}
+
 relative_offsets(r::OffsetArrays.IdOffsetRange) = (getfield(r, :offset),)
 relative_offsets(A::OffsetArrays.OffsetArray) = getfield(A, :offsets)
 function relative_offsets(A::OffsetArrays.OffsetArray, ::StaticInt{dim}) where {dim}

lib/ArrayInterfaceStaticArrays/src/ArrayInterfaceStaticArrays.jl

@@ -6,6 +6,8 @@ using LinearAlgebra
 using StaticArrays
 using Static
 
+const CanonicalInt = Union{Int,StaticInt}
+
 ArrayInterfaceCore.ismutable(::Type{<:StaticArrays.StaticArray}) = false
 ArrayInterfaceCore.ismutable(::Type{<:StaticArrays.MArray}) = true
 ArrayInterfaceCore.ismutable(::Type{<:StaticArrays.SizedArray}) = true
@@ -30,7 +32,7 @@ ArrayInterfaceCore.known_first(::Type{<:StaticArrays.SOneTo}) = 1
 ArrayInterfaceCore.known_last(::Type{StaticArrays.SOneTo{N}}) where {N} = N
 ArrayInterfaceCore.known_length(::Type{StaticArrays.SOneTo{N}}) where {N} = N
 ArrayInterfaceCore.known_length(::Type{StaticArrays.Length{L}}) where {L} = L
-function ArrayInterfaceCore.known_length(::Type{A}) where {A <: StaticArrays.StaticArray}
+function ArrayInterfaceCore.known_length(::Type{A}) where {A<:StaticArrays.StaticArray}
     ArrayInterfaceCore.known_length(StaticArrays.Length(A))
 end