From 276bc3b2a8f053e6ab0376833278e080a7ed6f5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Fri, 3 Nov 2023 15:59:00 +0100 Subject: [PATCH] Revert "Drop support for julia 1.0-1.3 (#221)" This reverts commit 69a76552dce31c8ca045819990aeccb023b40ac4. a --- .github/workflows/test.yml | 19 +- CHANGELOG.md | 1 - Project.toml | 8 +- src/Aqua.jl | 11 +- src/pkg/LICENSE.md | 23 ++ src/pkg/Versions.jl | 431 ++++++++++++++++++++++++++++++++ test/pkgs/PkgWithAmbiguities.jl | 12 +- test/test_ambiguities.jl | 54 ++-- test/test_smoke.jl | 5 +- 9 files changed, 525 insertions(+), 39 deletions(-) create mode 100644 src/pkg/LICENSE.md create mode 100644 src/pkg/Versions.jl diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index b8e64378..3bb50b8c 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -18,7 +18,7 @@ concurrency: jobs: test: runs-on: ${{ matrix.os }} - timeout-minutes: ${{ matrix.os == 'windows-latest' && 20 || 10 }} + timeout-minutes: 10 strategy: matrix: os: ["ubuntu-latest"] @@ -30,18 +30,22 @@ jobs: - '1.6' - '1.5' - '1.4' + - '1.3' + - '1.2' + - '1.1' + - '1.0' - 'nightly' include: - os: windows-latest julia-version: '1' - os: windows-latest - julia-version: '1.4' + julia-version: '1.0' - os: windows-latest julia-version: 'nightly' - os: macOS-latest julia-version: '1' - os: macOS-latest - julia-version: '1.4' + julia-version: '1.0' - os: macOS-latest julia-version: 'nightly' fail-fast: false @@ -52,6 +56,15 @@ jobs: uses: julia-actions/setup-julia@v1 with: version: ${{ matrix.julia-version }} + - name: Remove compat entry for old julia versions + # This is needed for julia 1.0-1.3, see https://julialang.slack.com/archives/C67910KEH/p1697548190422019?thread_ts=1697546952.011759&cid=C67910KEH + if: matrix.julia-version == '1.0' || matrix.julia-version == '1.1' || matrix.julia-version == '1.2' || matrix.julia-version == '1.3' + shell: julia --project=. --color=yes {0} + run: | + using Pkg.TOML + prj = TOML.parsefile("Project.toml") + delete!(prj["compat"], "Test") + open(io -> TOML.print(io, prj), "Project.toml", "w") - uses: julia-actions/julia-runtest@v1 - uses: julia-actions/julia-processcoverage@v1 - uses: codecov/codecov-action@v3 diff --git a/CHANGELOG.md b/CHANGELOG.md index 4b5857e9..07a16889 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,7 +15,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Changed -- The minimum requirement for julia was raised from `1.0` to `1.4`. ([#221](https://github.com/JuliaTesting/Aqua.jl/pull/221)) - `test_ambiguities` now excludes the keyword sorter of all `exclude`d functions with keyword arguments as well. ([#203](https://github.com/JuliaTesting/Aqua.jl/pull/204)) - In `test_deps_compat`, the two subtests `check_extras` and `check_weakdeps` are now run by default. ([#202](https://github.com/JuliaTesting/Aqua.jl/pull/202)) [BREAKING] - `test_deps_compat` now reqiures compat entries for all dependencies. Stdlibs no longer get ignored. This change is motivated by similar changes in the General registry. ([#215](https://github.com/JuliaTesting/Aqua.jl/pull/215)) [BREAKING] diff --git a/Project.toml b/Project.toml index e437e332..67b3b893 100644 --- a/Project.toml +++ b/Project.toml @@ -4,13 +4,15 @@ authors = ["Takafumi Arakaki and contributors"] version = "0.8.0-DEV" [deps] +Compat = "34da2185-b29b-5c13-b0c7-acf172513d20" Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [compat] -Pkg = "1.4" -Test = "1.4" -julia = "1.4" +Compat = "3.12, 4" +Pkg = "1.0" +Test = "1.0" +julia = "1.0" [extras] Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" diff --git a/src/Aqua.jl b/src/Aqua.jl index 0c0dd6c8..46ba3e41 100644 --- a/src/Aqua.jl +++ b/src/Aqua.jl @@ -4,14 +4,13 @@ using Base: PkgId, UUID using Pkg: Pkg, TOML, PackageSpec using Test -@static if VERSION >= v"1.7-" - const VersionSpec = Pkg.Versions.VersionSpec - const semver_spec = Pkg.Versions.semver_spec -else - const VersionSpec = Pkg.Types.VersionSpec - const semver_spec = Pkg.Types.semver_spec +@static if VERSION < v"1.3.0-DEV.349" + using Compat: findfirst end +include("pkg/Versions.jl") +using .Versions: VersionSpec, semver_spec + include("utils.jl") include("ambiguities.jl") include("unbound_args.jl") diff --git a/src/pkg/LICENSE.md b/src/pkg/LICENSE.md new file mode 100644 index 00000000..6cc75f19 --- /dev/null +++ b/src/pkg/LICENSE.md @@ -0,0 +1,23 @@ +The Pkg.jl package is licensed under the MIT "Expat" License: + +> Copyright (c) 2017-2021: Stefan Karpinski, Kristoffer Carlsson, Fredrik Ekre, David Varela, Ian Butterworth, and contributors: +> https://github.com/JuliaLang/Pkg.jl/graphs/contributors +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in all +> copies or substantial portions of the Software. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +> SOFTWARE. +> diff --git a/src/pkg/Versions.jl b/src/pkg/Versions.jl new file mode 100644 index 00000000..13003ed7 --- /dev/null +++ b/src/pkg/Versions.jl @@ -0,0 +1,431 @@ +# This file is a part of Julia. License is MIT: https://julialang.org/license + +module Versions + +export VersionBound, VersionRange, VersionSpec, semver_spec, isjoinable + +@static if VERSION < v"1.1.0-DEV.472" + using Compat: isnothing +end + +################ +# VersionBound # +################ +struct VersionBound + t::NTuple{3,UInt32} + n::Int + function VersionBound(tin::NTuple{n,Integer}) where {n} + n <= 3 || throw( + ArgumentError( + "VersionBound: you can only specify major, minor and patch versions", + ), + ) + n == 0 && return new((0, 0, 0), n) + n == 1 && return new((tin[1], 0, 0), n) + n == 2 && return new((tin[1], tin[2], 0), n) + n == 3 && return new((tin[1], tin[2], tin[3]), n) + error("invalid $n") + end +end +VersionBound(t::Integer...) = VersionBound(t) +VersionBound(v::VersionNumber) = VersionBound(v.major, v.minor, v.patch) + +Base.getindex(b::VersionBound, i::Int) = b.t[i] + +function ≲(v::VersionNumber, b::VersionBound) + b.n == 0 && return true + b.n == 1 && return v.major <= b[1] + b.n == 2 && return (v.major, v.minor) <= (b[1], b[2]) + return (v.major, v.minor, v.patch) <= (b[1], b[2], b[3]) +end + +function ≲(b::VersionBound, v::VersionNumber) + b.n == 0 && return true + b.n == 1 && return v.major >= b[1] + b.n == 2 && return (v.major, v.minor) >= (b[1], b[2]) + return (v.major, v.minor, v.patch) >= (b[1], b[2], b[3]) +end + +function isless_ll(a::VersionBound, b::VersionBound) + m, n = a.n, b.n + for i = 1:min(m, n) + a[i] < b[i] && return true + a[i] > b[i] && return false + end + return m < n +end + +stricterlower(a::VersionBound, b::VersionBound) = isless_ll(a, b) ? b : a + +# Comparison between two upper bounds +function isless_uu(a::VersionBound, b::VersionBound) + m, n = a.n, b.n + for i = 1:min(m, n) + a[i] < b[i] && return true + a[i] > b[i] && return false + end + return m > n +end + +stricterupper(a::VersionBound, b::VersionBound) = isless_uu(a, b) ? a : b + +# `isjoinable` compares an upper bound of a range with the lower bound of the next range +# to determine if they can be joined, as in [1.5-2.8, 2.5-3] -> [1.5-3]. Used by `union!`. +# The equal-length-bounds case is special since e.g. `1.5` can be joined with `1.6`, +# `2.3.4` can be joined with `2.3.5` etc. + +function isjoinable(up::VersionBound, lo::VersionBound) + up.n == 0 && lo.n == 0 && return true + if up.n == lo.n + n = up.n + for i = 1:(n-1) + up[i] > lo[i] && return true + up[i] < lo[i] && return false + end + up[n] < lo[n] - 1 && return false + return true + else + l = min(up.n, lo.n) + for i = 1:l + up[i] > lo[i] && return true + up[i] < lo[i] && return false + end + end + return true +end + +Base.hash(r::VersionBound, h::UInt) = hash(hash(r.t, h), r.n) + +# Hot code +function VersionBound(s::AbstractString) + s = strip(s) + s == "*" && return VersionBound() + first(s) == 'v' && (s = SubString(s, 2)) + l = lastindex(s) + + p = findnext('.', s, 1) + b = p === nothing ? l : (p - 1) + i = parse(Int64, SubString(s, 1, b)) + p === nothing && return VersionBound(i) + + a = p + 1 + p = findnext('.', s, a) + b = p === nothing ? l : (p - 1) + j = parse(Int64, SubString(s, a, b)) + p === nothing && return VersionBound(i, j) + + a = p + 1 + p = findnext('.', s, a) + b = p === nothing ? l : (p - 1) + k = parse(Int64, SubString(s, a, b)) + p === nothing && return VersionBound(i, j, k) + + error("invalid VersionBound string $(repr(s))") +end + +################ +# VersionRange # +################ +struct VersionRange + lower::VersionBound + upper::VersionBound + # NOTE: ranges are allowed to be empty; they are ignored by VersionSpec anyway + function VersionRange(lo::VersionBound, hi::VersionBound) + # lo.t == hi.t implies that digits past min(lo.n, hi.n) are zero + # lo.n < hi.n example: 1.2-1.2.0 => 1.2.0 + # lo.n > hi.n example: 1.2.0-1.2 => 1.2 + lo.t == hi.t && (lo = hi) + return new(lo, hi) + end +end +VersionRange(b::VersionBound = VersionBound()) = VersionRange(b, b) +VersionRange(t::Integer...) = VersionRange(VersionBound(t...)) +VersionRange(v::VersionNumber) = VersionRange(VersionBound(v)) +VersionRange(lo::VersionNumber, hi::VersionNumber) = + VersionRange(VersionBound(lo), VersionBound(hi)) + +# The vast majority of VersionRanges are in practice equal to "1" +const VersionRange_1 = VersionRange(VersionBound("1"), VersionBound("1")) +function VersionRange(s::AbstractString) + s == "1" && return VersionRange_1 + p = split(s, "-") + if length(p) != 1 && length(p) != 2 + throw(ArgumentError("invalid version range: $(repr(s))")) + end + lower = VersionBound(p[1]) + upper = length(p) == 1 ? lower : VersionBound(p[2]) + return VersionRange(lower, upper) +end + +function Base.isempty(r::VersionRange) + for i = 1:min(r.lower.n, r.upper.n) + r.lower[i] > r.upper[i] && return true + r.lower[i] < r.upper[i] && return false + end + return false +end + +function Base.print(io::IO, r::VersionRange) + m, n = r.lower.n, r.upper.n + if (m, n) == (0, 0) + print(io, '*') + elseif m == 0 + print(io, "0-") + join(io, r.upper.t, '.') + elseif n == 0 + join(io, r.lower.t, '.') + print(io, "-*") + else + join(io, r.lower.t[1:m], '.') + if r.lower != r.upper + print(io, '-') + join(io, r.upper.t[1:n], '.') + end + end +end +Base.show(io::IO, r::VersionRange) = print(io, "VersionRange(\"", r, "\")") + +Base.in(v::VersionNumber, r::VersionRange) = r.lower ≲ v ≲ r.upper + +Base.intersect(a::VersionRange, b::VersionRange) = + VersionRange(stricterlower(a.lower, b.lower), stricterupper(a.upper, b.upper)) + +function Base.union!(ranges::Vector{<:VersionRange}) + l = length(ranges) + l == 0 && return ranges + + sort!( + ranges, + lt = (a, b) -> ( + isless_ll(a.lower, b.lower) || + (a.lower == b.lower && isless_uu(a.upper, b.upper)) + ), + ) + + k0 = 1 + ks = findfirst(!isempty, ranges) + ks === nothing && return empty!(ranges) + + lo, up, k0 = ranges[ks].lower, ranges[ks].upper, 1 + for k = (ks+1):l + isempty(ranges[k]) && continue + lo1, up1 = ranges[k].lower, ranges[k].upper + if isjoinable(up, lo1) + isless_uu(up, up1) && (up = up1) + continue + end + vr = VersionRange(lo, up) + @assert !isempty(vr) + ranges[k0] = vr + k0 += 1 + lo, up = lo1, up1 + end + vr = VersionRange(lo, up) + if !isempty(vr) + ranges[k0] = vr + k0 += 1 + end + resize!(ranges, k0 - 1) + return ranges +end + +############### +# VersionSpec # +############### +struct VersionSpec + ranges::Vector{VersionRange} + VersionSpec(r::Vector{<:VersionRange}) = new(union!(r)) + VersionSpec(vs::VersionSpec) = vs +end + +VersionSpec(r::VersionRange) = VersionSpec(VersionRange[r]) +VersionSpec(v::VersionNumber) = VersionSpec(VersionRange(v)) +const _all_versionsspec = VersionSpec(VersionRange()) +VersionSpec() = _all_versionsspec +VersionSpec(s::AbstractString) = VersionSpec(VersionRange(s)) +VersionSpec(v::AbstractVector) = VersionSpec(map(VersionRange, v)) + +# Hot code +function Base.in(v::VersionNumber, s::VersionSpec) + for r in s.ranges + v in r && return true + end + return false +end + +Base.copy(vs::VersionSpec) = VersionSpec(vs) + +const empty_versionspec = VersionSpec(VersionRange[]) +const _empty_symbol = "∅" + +Base.isempty(s::VersionSpec) = all(isempty, s.ranges) +@assert isempty(empty_versionspec) +# Hot code, measure performance before changing +function Base.intersect(A::VersionSpec, B::VersionSpec) + (isempty(A) || isempty(B)) && return copy(empty_versionspec) + ranges = Vector{VersionRange}(undef, length(A.ranges) * length(B.ranges)) + i = 1 + @inbounds for a in A.ranges, b in B.ranges + ranges[i] = intersect(a, b) + i += 1 + end + VersionSpec(ranges) +end +Base.intersect(a::VersionNumber, B::VersionSpec) = + a in B ? VersionSpec(a) : empty_versionspec +Base.intersect(A::VersionSpec, b::VersionNumber) = intersect(b, A) + +function Base.union(A::VersionSpec, B::VersionSpec) + A == B && return A + Ar = copy(A.ranges) + append!(Ar, B.ranges) + union!(Ar) + return VersionSpec(Ar) +end + +Base.:(==)(A::VersionSpec, B::VersionSpec) = A.ranges == B.ranges +Base.hash(s::VersionSpec, h::UInt) = hash(s.ranges, h + (0x2fd2ca6efa023f44 % UInt)) + +function Base.print(io::IO, s::VersionSpec) + isempty(s) && return print(io, _empty_symbol) + length(s.ranges) == 1 && return print(io, s.ranges[1]) + print(io, '[') + for i = 1:length(s.ranges) + 1 < i && print(io, ", ") + print(io, s.ranges[i]) + end + print(io, ']') +end +Base.show(io::IO, s::VersionSpec) = print(io, "VersionSpec(\"", s, "\")") + + +################### +# Semver notation # +################### + +function semver_spec(s::String) + ranges = VersionRange[] + for ver in strip.(split(strip(s), ',')) + range = nothing + found_match = false + for (ver_reg, f) in ver_regs + if occursin(ver_reg, ver) + range = f(match(ver_reg, ver)) + found_match = true + break + end + end + found_match || error("invalid version specifier: $s") + push!(ranges, range) + end + return VersionSpec(ranges) +end + +function semver_interval(m::RegexMatch) + @assert length(m.captures) == 4 + n_significant = count(x -> x !== nothing, m.captures) - 1 + typ, _major, _minor, _patch = m.captures + major = parse(Int, _major) + minor = (n_significant < 2) ? 0 : parse(Int, _minor) + patch = (n_significant < 3) ? 0 : parse(Int, _patch) + if n_significant == 3 && major == 0 && minor == 0 && patch == 0 + error("invalid version: \"0.0.0\"") + end + # Default type is :caret + vertyp = (typ == "" || typ == "^") ? :caret : :tilde + v0 = VersionBound((major, minor, patch)) + if vertyp === :caret + if major != 0 + return VersionRange(v0, VersionBound((v0[1],))) + elseif minor != 0 + return VersionRange(v0, VersionBound((v0[1], v0[2]))) + else + if n_significant == 1 + return VersionRange(v0, VersionBound((0,))) + elseif n_significant == 2 + return VersionRange(v0, VersionBound((0, 0))) + else + return VersionRange(v0, VersionBound((0, 0, v0[3]))) + end + end + else + if n_significant == 3 || n_significant == 2 + return VersionRange(v0, VersionBound((v0[1], v0[2]))) + else + return VersionRange(v0, VersionBound((v0[1],))) + end + end +end + +const _inf = VersionBound("*") +function inequality_interval(m::RegexMatch) + @assert length(m.captures) == 4 + typ, _major, _minor, _patch = m.captures + n_significant = count(x -> x !== nothing, m.captures) - 1 + major = parse(Int, _major) + minor = (n_significant < 2) ? 0 : parse(Int, _minor) + patch = (n_significant < 3) ? 0 : parse(Int, _patch) + if n_significant == 3 && major == 0 && minor == 0 && patch == 0 + error("invalid version: 0.0.0") + end + v = VersionBound(major, minor, patch) + if occursin(r"^<\s*$", typ) + nil = VersionBound(0, 0, 0) + if v[3] == 0 + if v[2] == 0 + v1 = VersionBound(v[1] - 1) + else + v1 = VersionBound(v[1], v[2] - 1) + end + else + v1 = VersionBound(v[1], v[2], v[3] - 1) + end + return VersionRange(nil, v1) + elseif occursin(r"^=\s*$", typ) + return VersionRange(v) + elseif occursin(r"^>=\s*$", typ) || occursin(r"^≥\s*$", typ) + return VersionRange(v, _inf) + else + error("invalid prefix $typ") + end +end + +function hyphen_interval(m::RegexMatch) + @assert length(m.captures) == 6 + _lower_major, _lower_minor, _lower_patch, _upper_major, _upper_minor, _upper_patch = + m.captures + if isnothing(_lower_minor) + lower_bound = VersionBound(parse(Int, _lower_major)) + elseif isnothing(_lower_patch) + lower_bound = VersionBound(parse(Int, _lower_major), parse(Int, _lower_minor)) + else + lower_bound = VersionBound( + parse(Int, _lower_major), + parse(Int, _lower_minor), + parse(Int, _lower_patch), + ) + end + if isnothing(_upper_minor) + upper_bound = VersionBound(parse(Int, _upper_major)) + elseif isnothing(_upper_patch) + upper_bound = VersionBound(parse(Int, _upper_major), parse(Int, _upper_minor)) + else + upper_bound = VersionBound( + parse(Int, _upper_major), + parse(Int, _upper_minor), + parse(Int, _upper_patch), + ) + end + return VersionRange(lower_bound, upper_bound) +end + +const version = "v?([0-9]+?)(?:\\.([0-9]+?))?(?:\\.([0-9]+?))?" +const ver_regs = Pair{Regex,Any}[ + Regex("^([~^]?)?$version\$")=>semver_interval, # 0.5 ^0.4 ~0.3.2 + Regex( + "^((?:≥\\s*)|(?:>=\\s*)|(?:=\\s*)|(?:<\\s*)|(?:=\\s*))v?$version\$", + )=>inequality_interval,# < 0.2 >= 0.5,2 + Regex("^[\\s]*$version[\\s]*?\\s-\\s[\\s]*?$version[\\s]*\$")=>hyphen_interval, # 0.7 - 1.3 +] + +end diff --git a/test/pkgs/PkgWithAmbiguities.jl b/test/pkgs/PkgWithAmbiguities.jl index 9a51e654..83704057 100644 --- a/test/pkgs/PkgWithAmbiguities.jl +++ b/test/pkgs/PkgWithAmbiguities.jl @@ -42,11 +42,13 @@ ConcreteType(::Int, ::Any, ::Any) = 3 const num_ambs_ConcreteType = 4 -# 1 ambiguity -abstract type AbstractParameterizedType{T} end -struct ConcreteParameterizedType{T} <: AbstractParameterizedType{T} end -(::AbstractParameterizedType{T})(::Tuple{Tuple{Int}}) where {T} = 1 -(::ConcreteParameterizedType)(::Tuple) = 2 +@static if VERSION >= v"1.3-" + # 1 ambiguity if VERSION >= 1.3 + abstract type AbstractParameterizedType{T} end + struct ConcreteParameterizedType{T} <: AbstractParameterizedType{T} end + (::AbstractParameterizedType{T})(::Tuple{Tuple{Int}}) where {T} = 1 + (::ConcreteParameterizedType)(::Tuple) = 2 +end const num_ambs_ParameterizedType = 1 diff --git a/test/test_ambiguities.jl b/test/test_ambiguities.jl index 393aa830..05f2fb33 100644 --- a/test/test_ambiguities.jl +++ b/test/test_ambiguities.jl @@ -53,27 +53,41 @@ include("preamble.jl") # exclude abstract supertype without callables and constructors check_testcase([PkgWithAmbiguities.AbstractType], total) - # for ambiguities between abstract and concrete type callables, only one needs to be excluded - check_testcase( - [PkgWithAmbiguities.AbstractParameterizedType], - total - num_ambs_ParameterizedType, - ) - check_testcase( - [PkgWithAmbiguities.ConcreteParameterizedType], - total - num_ambs_ParameterizedType, - ) + @static if VERSION >= v"1.3-" + # for ambiguities between abstract and concrete type callables, only one needs to be excluded + check_testcase( + [PkgWithAmbiguities.AbstractParameterizedType], + total - num_ambs_ParameterizedType, + ) + check_testcase( + [PkgWithAmbiguities.ConcreteParameterizedType], + total - num_ambs_ParameterizedType, + ) + + # exclude everything + check_testcase( + [ + PkgWithAmbiguities.f, + PkgWithAmbiguities.g, + PkgWithAmbiguities.SingletonType, + PkgWithAmbiguities.ConcreteType, + PkgWithAmbiguities.ConcreteParameterizedType, + ], + 0, + ) + else + # exclude everything + check_testcase( + [ + PkgWithAmbiguities.f, + PkgWithAmbiguities.g, + PkgWithAmbiguities.SingletonType, + PkgWithAmbiguities.ConcreteType, + ], + 0, + ) + end - # exclude everything - check_testcase( - [ - PkgWithAmbiguities.f, - PkgWithAmbiguities.g, - PkgWithAmbiguities.SingletonType, - PkgWithAmbiguities.ConcreteType, - PkgWithAmbiguities.ConcreteParameterizedType, - ], - 0, - ) # It works with other tests: Aqua.test_unbound_args(PkgWithAmbiguities) diff --git a/test/test_smoke.jl b/test/test_smoke.jl index 481cfe7e..599677f2 100644 --- a/test/test_smoke.jl +++ b/test/test_smoke.jl @@ -3,7 +3,10 @@ module TestSmoke using Aqua # test defaults -Aqua.test_all(Aqua) +Aqua.test_all( + Aqua; + stale_deps = (; ignore = [:Compat]), # conditionally loaded +) # test everything else Aqua.test_all(