Use @testinferred

Author: lkdvos

Project.toml

@@ -19,7 +19,7 @@ Random = "1"
 Reexport = "1"
 TensorOperations = "5"
 Test = "1"
-TestExtras = "0.3"
+TestExtras = "0.3.2"
 WignerSymbols = "1,2"
 
 [extras]

test/runtests.jl

@@ -48,17 +48,17 @@ foreach(SectorTestSuite.test_sector, sectorlist)
         a = first(smallset(I1))
         b = first(smallset(I2))
 
-        @constinferred a ⊠ b
-        @constinferred a ⊠ b ⊠ a
-        @constinferred a ⊠ b ⊠ a ⊠ b
-        @constinferred I1 ⊠ I2
+        @testinferred a ⊠ b
+        @testinferred a ⊠ b ⊠ a
+        @testinferred a ⊠ b ⊠ a ⊠ b
+        @testinferred I1 ⊠ I2
         @test typeof(a ⊠ b) == I1 ⊠ I2
 
-        @test @constinferred(length(allunits(I1 ⊠ I2))) == 1
-        @test @constinferred(unit(I1 ⊠ I2)) == leftunit(a ⊠ b) == rightunit(a ⊠ b)
+        @test @testinferred(length(allunits(I1 ⊠ I2))) == 1
+        @test @testinferred(unit(I1 ⊠ I2)) == leftunit(a ⊠ b) == rightunit(a ⊠ b)
     end
-    @test @constinferred(Tuple(SU2Irrep(1) ⊠ U1Irrep(0))) == (SU2Irrep(1), U1Irrep(0))
-    @test @constinferred(length(FermionParity(1) ⊠ SU2Irrep(1 // 2) ⊠ U1Irrep(1))) == 3
+    @test @testinferred(Tuple(SU2Irrep(1) ⊠ U1Irrep(0))) == (SU2Irrep(1), U1Irrep(0))
+    @test @testinferred(length(FermionParity(1) ⊠ SU2Irrep(1 // 2) ⊠ U1Irrep(1))) == 3
 end
 
 @testset "Issue that came up in #11" begin

test/testsuite.jl

@@ -48,7 +48,7 @@ macro testsuite(name, ex)
     fn = Symbol("test_$(safe_name)")
     return quote
         $(esc(fn))(I) = $(esc(ex))(I)
-        @assert !haskey(tests, $name)
+        @assert !haskey(tests, $name) "duplicate testsuite name: $name"
         tests[$name] = $fn
     end
 end
@@ -69,64 +69,6 @@ function test_sector(I::Type)
     end
 end
 
-"""
-    @testinferred [AllowedTypes] ex
-
-Like `Test.@inferred`, but registers failures through a test, rather than an error.
-"""
-macro testinferred(ex)
-    return _inferred(ex, __module__)
-end
-macro testinferred(ex, allow)
-    return _inferred(ex, __module__, allow)
-end
-
-# Implementation copied from Test._inferred:
-function _inferred(ex, mod, allow = :(Union{}))
-    if Meta.isexpr(ex, :ref)
-        ex = Expr(:call, :getindex, ex.args...)
-    end
-    Meta.isexpr(ex, :call)|| error("@testinferred requires a call expression")
-    farg = ex.args[1]
-    if isa(farg, Symbol) && farg !== :.. && first(string(farg)) == '.'
-        farg = Symbol(string(farg)[2:end])
-        ex = Expr(
-            :call, GlobalRef(Test, :_materialize_broadcasted),
-            farg, ex.args[2:end]...
-        )
-    end
-    result = let ex = ex
-        quote
-            let allow = $(esc(allow))
-                allow isa Type || throw(ArgumentError("@inferred requires a type as second argument"))
-                $(
-                    if any(@nospecialize(a) -> (Meta.isexpr(a, :kw) || Meta.isexpr(a, :parameters)), ex.args)
-                        # Has keywords
-                        # Create the call expression with escaped user expressions
-                        call_expr = :($(esc(ex.args[1]))(args...; kwargs...))
-                        quote
-                            args, kwargs, result = $(esc(Expr(:call, _args_and_call, ex.args[2:end]..., ex.args[1])))
-                            # wrap in dummy hygienic-scope to work around scoping issues with `call_expr` already having `esc` on the necessary parts
-                            inftype = $(Expr(:var"hygienic-scope", Base.gen_call_with_extracted_types(mod, Base.infer_return_type, call_expr; is_source_reflection = false), Test))
-                        end
-                    else
-                        # No keywords
-                        quote
-                            args = ($([esc(ex.args[i]) for i in 2:length(ex.args)]...),)
-                            result = $(esc(ex.args[1]))(args...)
-                            inftype = Base.infer_return_type($(esc(ex.args[1])), Base.typesof(args...))
-                        end
-                    end
-                )
-                rettype = result isa Type ? Type{result} : typeof(result)
-                @test rettype <: allow || rettype == Base.typesplit(inftype, allow)
-                result
-            end
-        end
-    end
-    return Base.remove_linenums!(result)
-end
-
 smallset(::Type{I}) where {I <: Sector} = take(values(I), 5)
 function smallset(::Type{ProductSector{Tuple{I1, I2}}}) where {I1, I2}
     iter = product(smallset(I1), smallset(I2))