Fix type ambiguities on master.

Author: chriselrod

src/static.jl

@@ -7,22 +7,42 @@ struct Static{N} <: Integer
     Static{N}() where {N} = new{N::Int}()
 end
 Base.@pure Static(N::Int) = Static{N}()
-Static(N) = Static(convert(Int, N))
+Static(N::Integer) = Static(convert(Int, N))
+Static(::Static{N}) where {N} = Static{N}()
 Static(::Val{N}) where {N} = Static{N}()
 Base.Val(::Static{N}) where {N} = Val{N}()
 Base.convert(::Type{T}, ::Static{N}) where {T<:Number,N} = convert(T, N)
 Base.convert(::Type{Static{N}}, ::Static{N}) where {N} = Static{N}()
-Base.promote_rule(::Type{<:Static}, ::Type{T}) where {T} = promote_rule(Int, T)
-Base.promote_rule(::Type{T}, ::Type{<:Static}) where {T} = promote_rule(T, Int)
-Base.promote_rule(::Type{<:Static}, ::Type{<:Static}) where {T} = Int
+for S ∈ [:Any, :AbstractIrrational]#, :(Complex{<:Real})]
+# let S = :Any    
+    @eval begin
+        Base.promote_rule(::Type{<:Static}, ::Type{T}) where {T <: $S} = promote_rule(Int, T)
+        Base.promote_rule(::Type{T}, ::Type{<:Static}) where {T <: $S} = promote_rule(T, Int)
+    end
+end
+for (S,T) ∈ [(:Complex,:Real), (:Rational, :Integer), (:(Base.TwicePrecision),:Any)]
+    @eval Base.promote_rule(::Type{$S{T}}, ::Type{<:Static}) where {T <: $T} = promote_rule($S{T}, Int)
+end
+Base.promote_rule(::Type{Union{Nothing,Missing}}, ::Type{<:Static}) = Union{Nothing, Missing, Int}
+Base.promote_rule(::Type{T}, ::Type{<:Static}) where {T >: Union{Missing,Nothing}} = promote_rule(T, Int)
+Base.promote_rule(::Type{T}, ::Type{<:Static}) where {T >: Nothing} = promote_rule(T, Int)
+Base.promote_rule(::Type{T}, ::Type{<:Static}) where {T >: Missing} = promote_rule(T, Int)
+for T ∈ [:Bool, :Missing, :BigFloat, :BigInt, :Nothing]
+# let S = :Any    
+    @eval begin
+        Base.promote_rule(::Type{<:Static}, ::Type{$T}) = promote_rule(Int, $T)
+        Base.promote_rule(::Type{$T}, ::Type{<:Static}) = promote_rule($T, Int)
+    end
+end
+Base.promote_rule(::Type{<:Static}, ::Type{<:Static}) = Int
 Base.:(%)(::Static{N}, ::Type{Integer}) where {N} = N
 
 Base.iszero(::Static{0}) = true
 Base.iszero(::Static) = false
 Base.isone(::Static{1}) = true
 Base.isone(::Static) = false
 
-for T ∈ [:Any, :Number, :Integer]
+for T = [:Real, :Rational, :Integer]
     @eval begin
         @inline Base.:(+)(i::$T, ::Static{0}) = i
         @inline Base.:(+)(i::$T, ::Static{M}) where {M} = i + M
@@ -38,18 +58,28 @@ for T ∈ [:Any, :Number, :Integer]
         @inline Base.:(*)(::Static{M}, i::$T) where {M} = M * i
     end
 end
+@inline Base.:(+)(::Static{0}, ::Static{0}) = Static{0}()
+@inline Base.:(+)(::Static{0}, ::Static{M}) where {M} = Static{M}()
+@inline Base.:(+)(::Static{M}, ::Static{0}) where {M} = Static{M}()
+
+@inline Base.:(-)(::Static{M}, ::Static{0}) where {M} = Static{M}()
+
 @inline Base.:(*)(::Static{0}, ::Static{0}) = Static{0}()
 @inline Base.:(*)(::Static{1}, ::Static{0}) = Static{0}()
 @inline Base.:(*)(::Static{0}, ::Static{1}) = Static{0}()
 @inline Base.:(*)(::Static{1}, ::Static{1}) = Static{1}()
+@inline Base.:(*)(::Static{M}, ::Static{0}) where {M} = Static{0}()
+@inline Base.:(*)(::Static{0}, ::Static{M}) where {M} = Static{0}()
+@inline Base.:(*)(::Static{M}, ::Static{1}) where {M} = Static{M}()
+@inline Base.:(*)(::Static{1}, ::Static{M}) where {M} = Static{M}()
 for f ∈ [:(+), :(-), :(*), :(/), :(÷), :(%), :(<<), :(>>), :(>>>), :(&), :(|), :(⊻)]
     @eval @generated Base.$f(::Static{M}, ::Static{N}) where {M,N} = Expr(:call, Expr(:curly, :Static, $f(M, N)))
 end
 for f ∈ [:(==), :(!=), :(<), :(≤), :(>), :(≥)]
     @eval begin
         @inline Base.$f(::Static{M}, ::Static{N}) where {M,N} = $f(M, N)
-        @inline Base.$f(::Static{M}, x::Integer) where {M} = $f(M, x)
-        @inline Base.$f(x::Integer, ::Static{M}) where {M} = $f(x, M)
+        @inline Base.$f(::Static{M}, x::Int) where {M} = $f(M, x)
+        @inline Base.$f(x::Int, ::Static{M}) where {M} = $f(x, M)
     end
 end
 

test/runtests.jl

@@ -269,9 +269,5 @@ end
             @test convert(typeof(y), @inferred(f(1.4, i))) === y # if f is division and i === Static(0), returns `NaN`; hence use of ==== in check.
         end
     end
-    @test @inferred("Hello world!" * Static(0)) === Static(0)
-    @test @inferred("Hello world!" * Static(1)) === "Hello world!"
-    @test @inferred(Static(0) * "Hello world!") === Static(0)
-    @test @inferred(Static(1) * "Hello world!") === "Hello world!"
 end