Broken Aqua test on Julia 1.10 due to method ambiguities

Author: OlivierHnt

src/IntervalArithmetic.jl

@@ -159,22 +159,15 @@ end
 function configure_matmul(matmul::Symbol)
     matmul ∈ (:slow, :fast) || return throw(ArgumentError("only the matrix multiplication mode `:slow` and `:fast` are available"))
 
-    for T ∈ (:AbstractVector, :AbstractMatrix) # needed to resolve method ambiguities
-        @eval begin
-            function LinearAlgebra.mul!(C::AbstractVecOrMat{<:RealOrComplexI}, A::AbstractMatrix{<:RealOrComplexI}, B::$T{<:RealOrComplexI}, α::Number, β::Number)
-                size(A, 2) == size(B, 1) || return throw(DimensionMismatch("The number of columns of A must match the number of rows of B."))
-                return _mul!(MatMulMode{$(QuoteNode(matmul))}(), C, A, B, α, β)
-            end
-
-            function LinearAlgebra.mul!(C::AbstractVecOrMat{<:RealOrComplexI}, A::AbstractMatrix, B::$T{<:RealOrComplexI}, α::Number, β::Number)
-                size(A, 2) == size(B, 1) || return throw(DimensionMismatch("The number of columns of A must match the number of rows of B."))
-                return _mul!(MatMulMode{$(QuoteNode(matmul))}(), C, A, B, α, β)
-            end
-
-            function LinearAlgebra.mul!(C::AbstractVecOrMat{<:RealOrComplexI}, A::AbstractMatrix{<:RealOrComplexI}, B::$T, α::Number, β::Number)
-                size(A, 2) == size(B, 1) || return throw(DimensionMismatch("The number of columns of A must match the number of rows of B."))
-                return _mul!(MatMulMode{$(QuoteNode(matmul))}(), C, A, B, α, β)
-            end
+    @eval begin
+        function LinearAlgebra.mul!(C::$AbstractVector{<:RealOrComplexI}, A::AbstractVecOrMat, B::AbstractVector, α::Number, β::Number)
+            size(A, 2) == size(B, 1) || return throw(DimensionMismatch("The number of columns of A must match the number of rows of B."))
+            return _mul!(MatMulMode{$(QuoteNode(matmul))}(), C, A, B, α, β)
+        end
+
+        function LinearAlgebra.mul!(C::$AbstractMatrix{<:RealOrComplexI}, A::AbstractVecOrMat, B::AbstractVecOrMat, α::Number, β::Number)
+            size(A, 2) == size(B, 1) || return throw(DimensionMismatch("The number of columns of A must match the number of rows of B."))
+            return _mul!(MatMulMode{$(QuoteNode(matmul))}(), C, A, B, α, β)
         end
     end
 

src/matmul.jl

@@ -174,9 +174,11 @@ struct MatMulMode{T} end
 
 #
 
-function LinearAlgebra.mul!(C::AbstractVecOrMat{<:RealOrComplexI}, A::AbstractMatrix{<:RealOrComplexI}, B::AbstractVecOrMat{<:RealOrComplexI})
-    return LinearAlgebra.mul!(C, A, B, interval(true), interval(false))
-end
+LinearAlgebra.mul!(C::AbstractVector{<:RealOrComplexI}, A::AbstractVecOrMat, B::AbstractVector) =
+    LinearAlgebra.mul!(C, A, B, interval(true), interval(false))
+
+LinearAlgebra.mul!(C::AbstractMatrix{<:RealOrComplexI}, A::AbstractVecOrMat, B::AbstractVecOrMat) =
+    LinearAlgebra.mul!(C, A, B, interval(true), interval(false))
 
 function _mul!(::MatMulMode{:slow}, C, A::AbstractMatrix, B::AbstractVecOrMat, α, β)
     for j ∈ axes(B, 2)

test/aqua.jl

@@ -2,27 +2,29 @@ using Test
 using IntervalArithmetic
 using Aqua
 
-if VERSION ≥ v"1.10"
-    @testset "Aqua tests (performance)" begin
-        # This tests that we don't accidentally run into
-        # https://github.com/JuliaLang/julia/issues/29393
-        # Aqua.test_unbound_args(IntervalArithmetic)
-        ua = Aqua.detect_unbound_args_recursively(IntervalArithmetic)
-        @test length(ua) == 0
+@testset "Aqua tests (performance)" begin
+    # This tests that we don't accidentally run into
+    # https://github.com/JuliaLang/julia/issues/29393
+    # Aqua.test_unbound_args(IntervalArithmetic)
+    ua = Aqua.detect_unbound_args_recursively(IntervalArithmetic)
+    @test length(ua) == 0
 
-        # See: https://github.com/SciML/OrdinaryDiffEq.jl/issues/1750
-        # Test that we're not introducing method ambiguities across deps
-        ambs = Aqua.detect_ambiguities(IntervalArithmetic; recursive = true)
-        pkg_match(pkgname, pkdir::Nothing) = false
-        pkg_match(pkgname, pkdir::AbstractString) = occursin(pkgname, pkdir)
-        filter!(x -> pkg_match("IntervalArithmetic", pkgdir(last(x).module)), ambs)
-        for method_ambiguity ∈ ambs
-            @show method_ambiguity
-        end
+    # See: https://github.com/SciML/OrdinaryDiffEq.jl/issues/1750
+    # Test that we're not introducing method ambiguities across deps
+    ambs = Aqua.detect_ambiguities(IntervalArithmetic; recursive = true)
+    pkg_match(pkgname, pkdir::Nothing) = false
+    pkg_match(pkgname, pkdir::AbstractString) = occursin(pkgname, pkdir)
+    filter!(x -> pkg_match("IntervalArithmetic", pkgdir(last(x).module)), ambs)
+    for method_ambiguity ∈ ambs
+        @show method_ambiguity
+    end
+    if VERSION ≥ v"1.11"
         @test length(ambs) == 0
+    else # version 1.10
+        @test_broken length(ambs) == 0
     end
+end
 
-    @testset "Aqua tests (additional)" begin
-        Aqua.test_all(IntervalArithmetic)
-    end
+@testset "Aqua tests (additional)" begin
+    Aqua.test_all(IntervalArithmetic)
 end