Add Aqua and resolve some method ambiguities (#606)

* add Aqua and resolve some ambiguities

This resolves several ambiguities detected by Aqua.

* Update test/runtests.jl

Co-authored-by: Sebastian Stock <[email protected]>

* Update src/types.jl

Co-authored-by: Sebastian Stock <[email protected]>

* Update Project.toml

---------

Co-authored-by: Sebastian Stock <[email protected]>

Author: sjkelly

Project.toml

@@ -9,13 +9,15 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [compat]
+Aqua = "0.6"
 ConstructionBase = "1"
 julia = "1"
 
 [extras]
+Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["LinearAlgebra", "Test", "Random"]
+test = ["Aqua", "LinearAlgebra", "Test", "Random"]

src/logarithm.jl

@@ -202,24 +202,24 @@ Base. -(x::Gain, y::Level) = throw(ArgumentError("cannot subtract a level from a
 leveltype(x::Level{L,S}) where {L,S} = Level{L,S}
 Base. *(x::Level, y::Number) = (leveltype(x))(x.val * y)
 Base. *(x::Level, y::Bool) = (leveltype(x))(x.val * y)    # for method ambiguity
-Base. *(x::Level, y::Quantity) = *(x.val, y)
+Base. *(x::Level, y::AbstractQuantity) = *(x.val, y)
 Base. *(x::Level, y::Level) = *(x.val, y.val)
 Base. *(x::Level, y::Gain) = *(promote(x,y)...)
 
 Base. *(x::Number, y::Level) = *(y,x)
 Base. *(x::Bool, y::Level) = *(y,x)                       # for method ambiguity
-Base. *(x::Quantity, y::Level) = *(y,x)                   # for method ambiguity
+Base. *(x::AbstractQuantity, y::Level) = *(y,x)           # for method ambiguity
 
 gaintype(::Gain{L,S}) where {L,S} = Gain{L,S}
 Base. *(x::Gain, y::Number) = (gaintype(x))(x.val * y)
 Base. *(x::Gain, y::Bool) = (gaintype(x))(x.val * y)      # for method ambiguity
-Base. *(x::Gain, y::Quantity) = *(y,x)
+Base. *(x::Gain, y::AbstractQuantity) = *(y,x)
 Base. *(x::Gain, y::Level) = *(promote(x,y)...)
 Base. *(x::Gain, y::Gain) = *(promote(x,y)...)
 
 Base. *(x::Number, y::Gain) = *(y,x)
 Base. *(x::Bool, y::Gain) = *(y,x)                        # for method ambiguity
-Base. *(x::Quantity, y::Gain) =
+Base. *(x::AbstractQuantity, y::Gain) =
     isrootpower(x) ? uconvertrp(NoUnits, y) * x : uconvertp(NoUnits, y) * x
 
 for (op1,op2) in ((:*, :+), (:/, :-))
@@ -242,18 +242,18 @@ Base. /(x::Gain, y::Level) = throw(ArgumentError("cannot divide a gain by a leve
 
 Base. /(x::Level, y::Number) = (leveltype(x))(linear(x) / y)
 Base. //(x::Level, y::Number) = (leveltype(x))(linear(x) // y)
-Base. /(x::Level, y::Quantity) = linear(x) / y
-Base. //(x::Level, y::Quantity) = linear(x) // y
+Base. /(x::Level, y::AbstractQuantity) = linear(x) / y
+Base. //(x::Level, y::AbstractQuantity) = linear(x) // y
 Base. /(x::Level, y::Level) = linear(x) / linear(y)
 Base. //(x::Level, y::Level) = linear(x) // linear(y)
 Base. //(x::Level, y::Complex) = linear(x) // y     # ambiguity resolution
 
 Base. //(x::Number, y::Level) = x // linear(y)
-Base. /(x::Quantity, y::Level) = x / linear(y)
-Base. //(x::Quantity, y::Level) = x // linear(y)
-Base. /(x::Quantity, y::Gain) =
+Base. /(x::AbstractQuantity, y::Level) = x / linear(y)
+Base. //(x::AbstractQuantity, y::Level) = x // linear(y)
+Base. /(x::AbstractQuantity, y::Gain) =
     isrootpower(x) ? x / uconvertrp(NoUnits, y) : x / uconvertp(NoUnits, y)
-Base. //(x::Quantity, y::Gain) =
+Base. //(x::AbstractQuantity, y::Gain) =
     isrootpower(x) ? x // uconvertrp(NoUnits, y) : x // uconvertp(NoUnits, y)
 
 Base. //(x::Level, y::Units) = x/y

src/quantities.jl

@@ -189,8 +189,7 @@ for (_x,_y) in [(:fma, :_fma), (:muladd, :_muladd)]
     @eval @inline ($_x)(x::AbstractQuantity, y::Number, z::AbstractQuantity) = ($_y)(x,y,z)
 
     # Post-promotion
-    @eval @inline ($_x)(x::AbstractQuantity{A}, y::AbstractQuantity{B}, z::AbstractQuantity{C}) where {
-        A <: Number, B <: Number, C <: Number} = ($_y)(x,y,z)
+    @eval @inline ($_x)(x::AbstractQuantity, y::AbstractQuantity, z::AbstractQuantity) = ($_y)(x,y,z)
 
     # It seems like most of this is optimized out by the compiler, including the
     # apparent runtime check of dimensions, which does not appear in @code_llvm.

src/types.jl

@@ -267,6 +267,7 @@ For example, given a gain of `20dB`, we have `val===20`. This type differs from
 struct Gain{L, S, T<:Real} <: LogScaled{L}
     val::T
 end
+Unitful.Gain{L, S, T}(x::Unitful.Gain{L, S, T}) where {L,S,T<:Real} = x # for ambiguity resolution
 
 """
     struct MixedUnits{T<:LogScaled, U<:Units}

test/runtests.jl

@@ -2145,3 +2145,7 @@ finally
     rm(load_path, recursive=true)
     rm(load_cache_path, recursive=true)
 end
+
+using Aqua
+
+Aqua.test_all(Unitful, ambiguities=false, unbound_args=false, piracy=VERSION≥v"1.8")