rename hasinteger(x) -> has(x, Integer)

This will make it easy to test for something else than `Integer`.

Author: rfourquet

src/ReTest.jl

@@ -282,7 +282,7 @@ function resolve!(mod::Module, ts::TestsetExpr, pat::Pattern;
     desc = ts.desc
     ts.loopvalues = nothing # unnecessary ?
     ts.loopiters = nothing
-    if 0 != ts.id != id && !warned[] && hasinteger(pat)
+    if 0 != ts.id != id && !warned[] && has(pat, Integer)
         # this can happen when nested testsets are added and Revise is active
         @warn "testset IDs have changed since last run"
         warned[] = true
@@ -737,7 +737,7 @@ function retest(@nospecialize(args::ArgType...);
     end
 
     id = verbose > 0 && something(id, dry || any(modules) do (mod, pat)
-                                                 hasinteger(pat)
+                                                 has(pat, Integer)
                                              end)
 
     descwidth = maximum(x->x[2], tests_descs_hasbrokens)

src/patterns.jl

@@ -137,6 +137,14 @@ matches(::Union{Pass,Fail}, ::Missing, ts) =
     isempty(ts.marks) ? false : missing
 
 
+## has
+
+# has(pat, T) checks whether pat recursively "contains" something of type T
+has(pat, T::Type)  = pat isa T
+has(pat::Union{And,Or}, T::Type) = pat isa T || any(p -> has(p, T), pat.xs)
+has(pat::Union{Not,Reachable}, T::Type) = pat isa T || has(pat.x, T)
+
+
 ## make_pattern
 
 make_pattern(x::PatternX) = x
@@ -167,19 +175,6 @@ make_pattern(pat::AbstractArray{<:Integer}) = Or(pat)
 make_pattern(@nospecialize(pat::Tuple)) = And(PatternX[make_pattern(p) for p in pat])
 
 
-## hasinteger
-
-hasinteger(::Regex) = false
-hasinteger(::Integer) = true
-hasinteger(pat::Union{And,Or}) = any(hasinteger, pat.xs)
-hasinteger(pat::Not) = hasinteger(pat.x)
-hasinteger(::Interpolated) = false
-hasinteger(pat::Reachable) = hasinteger(pat.x)
-hasinteger(::Depth) = false
-hasinteger(::Pass) = false
-hasinteger(::Fail) = false
-
-
 ## exported pattern functions & singletons
 
 

test/test_patterns.jl

@@ -59,7 +59,7 @@ end
         @test ReTest.matches(a, "a", MockTestset()) isa Union{Missing, Bool}
         @test ReTest.matches(a, missing, MockTestset()) isa Union{Missing, Bool}
         @test ReTest.alwaysmatches(a, 1) isa Bool
-        @test ReTest.hasinteger(a) isa Bool
+        @test ReTest.has(a, Integer) isa Bool
     end
 end