Added bitshift methods for Static, improved inferabiity of transposed dimnames.

Author: chriselrod

src/dimensions.jl

@@ -30,10 +30,20 @@ Return the names of the dimensions for `x`.
     end
 end
 @inline function dimnames(::Type{T}) where {T<:Union{Transpose,Adjoint}}
-    return _transpose_dimnames(dimnames(parent_type(T)))
+    return _transpose_dimnames(Val(dimnames(parent_type(T))))
 end
-_transpose_dimnames(x::Tuple{Symbol,Symbol}) = (last(x), first(x))
-_transpose_dimnames(x::Tuple{Symbol}) = (:_, first(x))
+# inserting the Val here seems to help inferability; I got a test failure without it.
+function _transpose_dimnames(::Val{S}) where {S}
+    if length(S) == 1
+        (:_, first(S))
+    elseif length(S) == 2
+        (last(S), first(S))
+    else
+        throw("Can't transpose $S of dim $(length(S)).")
+    end
+end
+@inline _transpose_dimnames(x::Tuple{Symbol,Symbol}) = (last(x), first(x))
+@inline _transpose_dimnames(x::Tuple{Symbol}) = (:_, first(x))
 
 @inline function dimnames(::Type{T}) where {I,T<:PermutedDimsArray{<:Any,<:Any,I}}
     return map(i -> dimnames(parent_type(T), i), I)
@@ -143,6 +153,8 @@ julia> ArrayInterface.size(A)
 """
 size(A) = Base.size(A)
 size(A, d) = Base.size(A, to_dims(A, d))
+size(x::LinearAlgebra.Adjoint{T,V}) where {T, V <: AbstractVector{T}} = (One(), static_length(x))
+size(x::LinearAlgebra.Transpose{T,V}) where {T, V <: AbstractVector{T}} = (One(), static_length(x))
 
 """
     axes(A, d)

src/static.jl

@@ -87,6 +87,12 @@ end
 for f ∈ [:(+), :(-), :(*), :(/), :(÷), :(%), :(<<), :(>>), :(>>>), :(&), :(|), :(⊻)]
     @eval @generated Base.$f(::StaticInt{M}, ::StaticInt{N}) where {M,N} = Expr(:call, Expr(:curly, :StaticInt, $f(M, N)))
 end
+for f ∈ [:(<<), :(>>), :(>>>)]
+    @eval begin
+        @inline Base.$f(::StaticInt{M}, x::UInt) where {M} = $f(M, x)
+        @inline Base.$f(x::Integer, ::StaticInt{M}) where {M} = $f(x, M)
+    end
+end
 for f ∈ [:(==), :(!=), :(<), :(≤), :(>), :(≥)]
     @eval begin
         @inline Base.$f(::StaticInt{M}, ::StaticInt{N}) where {M,N} = $f(M, N)

src/stridelayout.jl

@@ -249,24 +249,6 @@ permute(t::NTuple{N}, I::NTuple{N,Int}) where {N} = ntuple(n -> t[I[n]], Val{N}(
     Expr(:block, Expr(:meta, :inline), t)
 end
 
-"""
-  size(A)
-
-Returns the size of `A`. If the size of any axes are known at compile time,
-these should be returned as `Static` numbers. For example:
-```julia
-julia> using StaticArrays, ArrayInterface
-
-julia> A = @SMatrix rand(3,4);
-
-julia> ArrayInterface.size(A)
-(StaticInt{3}(), StaticInt{4}())
-```
-"""
-size(A) = Base.size(A)
-size(x::LinearAlgebra.Adjoint{T,V}) where {T, V <: AbstractVector{T}} = (One(), static_length(x))
-size(x::LinearAlgebra.Transpose{T,V}) where {T, V <: AbstractVector{T}} = (One(), static_length(x))
-
 """
   strides(A)