Support subtype checks (#42)

* More performance tests (prevent inlining).

* Support subtype checks.

* Bump version.

Project.toml

@@ -1,7 +1,7 @@
 name = "ArgCheck"
 uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197"
 license = "MIT"
-version = "2.2.0"
+version = "2.3.0"
 
 [compat]
 julia = "1"

src/checks.jl

@@ -25,6 +25,7 @@ struct CheckFlavor    <: AbstractCheckFlavor end
 abstract type AbstractCodeFlavor end
 struct CallFlavor       <: AbstractCodeFlavor end
 struct ComparisonFlavor <: AbstractCodeFlavor end
+struct SubtypeFlavor    <: AbstractCodeFlavor end
 struct FallbackFlavor   <: AbstractCodeFlavor end
 
 struct Checker
@@ -49,6 +50,13 @@ struct ComparisonErrorInfo <: AbstractErrorInfo
     argument_values::Vector
     options::Tuple
 end
+struct SubtypeErrorInfo <: AbstractErrorInfo
+    code
+    checkflavor::AbstractCheckFlavor
+    argument_expressions::Vector
+    argument_values::Vector
+    options::Tuple
+end
 struct FallbackErrorInfo <: AbstractErrorInfo
     code
     checkflavor::AbstractCheckFlavor
@@ -97,6 +105,8 @@ function check(ex, checkflavor, options...)
         ComparisonFlavor()
     elseif isexpr(ex, :call)
         CallFlavor()
+    elseif isexpr(ex, :(<:))
+        SubtypeFlavor()
     else
         FallbackFlavor()
     end
@@ -180,7 +190,7 @@ function build_call(ana)
     return Expr(:call, f, callargs...)
 end
 
-function check(c, ::CallFlavor)
+function check(c::Checker, ::CallFlavor)
     ana = analyze_call(c.code)
     variables = []
     argument_expressions = []
@@ -236,6 +246,22 @@ function check(c::Checker, ::ComparisonFlavor)
     Expr(:block, ret...)
 end
 
+function check(c::Checker, ::SubtypeFlavor)
+    lhs, rhs = c.code.args
+    vlhs, vrhs = gensym(:lhs), gensym(:rhs)
+
+    condition = Expr(:(<:), vlhs, vrhs)
+    assignments = (Expr(:(=), vlhs, esc(lhs)), Expr(:(=), vrhs, esc(rhs)))
+    info = Expr(:call, :SubtypeErrorInfo,
+                QuoteNode(c.code),
+                c.checkflavor,
+                QuoteNode([lhs, rhs]),
+                Expr(:vect, vlhs, vrhs),
+                Expr(:tuple, esc.(c.options)...))
+
+    expr_error_block(info, condition, assignments...)
+end
+
 function expr_error_block(info, condition, preamble...)
     quote
         $(preamble...)
@@ -277,6 +303,7 @@ end
 error_message(info::FallbackErrorInfo) = "$(info.code) must hold."
 error_message(info::CallErrorInfo) = fancy_error_message(info)
 error_message(info::ComparisonErrorInfo) = fancy_error_message(info)
+error_message(info::SubtypeErrorInfo) = fancy_error_message(info)
 
 function pretty_string(data)
     io = IOBuffer()

test/checks.jl

@@ -195,7 +195,7 @@ end
         a = 1.0; b = 1.2; atol = 0.1; nvalue = false; rtol = 0.05;
         @check isapprox(a, b, atol=atol, nans=nvalue; rtol)
     end
-    locations = map(["a", "b", "atol", "nvalue", "rtol"]) do name
+    locations = map(["a =>", "b =>", "atol =>", "nvalue =>", "rtol =>"]) do name
         findfirst(name, err.msg)
     end
     @test all(x -> x isa UnitRange, locations)
@@ -206,6 +206,15 @@ end
     @test occursin(string(x), err.msg)
     err = @catch_exception_object @argcheck !isfinite(x)
     @test_broken occursin(string(x), err.msg)
+
+
+    t1 = Int32
+    t2 = Integer
+    err = @catch_exception_object @argcheck t2 <: t1
+    @test occursin(string(t1), err.msg)
+    @test occursin(string(t2), err.msg)
+    @test occursin("t1 =>", err.msg)
+    @test occursin("t2 =>", err.msg)
 end
 
 @testset "complicated calls" begin

test/perf.jl

@@ -3,38 +3,46 @@ module Perf
 using BenchmarkTools
 using ArgCheck
 
-truthy(x) = true
+@noinline truthy(x) = x == x
+truthy2(x) = true
 
-function fallback_argcheck(x)
+@noinline function fallback_argcheck(x)
     @argcheck x
 end
-function comparison_argcheck(x)
+@noinline function comparison_argcheck(x)
     @argcheck x == x
 end
-function call_argcheck(x)
+@noinline function call_argcheck(x)
     @argcheck truthy(x)
 end
-function fallback_assert(x)
+function call_argcheck2(x)
+    @argcheck truthy2(x)
+end
+@noinline function fallback_assert(x)
     @assert x
 end
-function comparison_assert(x)
+@noinline function comparison_assert(x)
     @assert x == x
 end
-function call_assert(x)
+@noinline function call_assert(x)
     @assert truthy(x)
 end
+function call_assert2(x)
+    @assert truthy2(x)
+end
 
 benchmarks =[
     (fallback_assert, fallback_argcheck, true),
     (call_assert, call_argcheck, 42),
+    (call_assert2, call_argcheck2, 42),
     (comparison_assert, comparison_argcheck, 42),
     ]
 
-for (f_argcheck, f_assert, arg) in benchmarks
-    println(f_argcheck)
-    @btime ($f_argcheck)($arg)
+for (f_assert, f_argcheck, arg) in benchmarks
     println(f_assert)
     @btime ($f_assert)($arg)
+    println(f_argcheck)
+    @btime ($f_argcheck)($arg)
 end
 
 end#module