remove bad convert

Author: bvdmitri

src/rule.jl

@@ -853,7 +853,7 @@ Base.copy(entry::TestRuleEntryInputSpecification) = TestRuleEntryInputSpecificat
 Base.values(entry::TestRuleEntryInputSpecification) = Base.Generator((arg) -> arg.second, entry.arguments)
 
 # Convert the `TestRuleEntryInputSpecification` back into the `Expr` form, e.g `(m_x = ..., q_y = ..., meta = ...)`
-function Base.convert(::Type{Expr}, test_entry::TestRuleEntryInputSpecification)
+function rule_macro_convert_to_expr(test_entry::TestRuleEntryInputSpecification)
     tuple = Expr(:tuple)
     tuple.args = map((arg) -> Expr(:(=), arg.first, arg.second), test_entry.arguments)
     if !isnothing(test_entry.meta)
@@ -889,8 +889,8 @@ struct TestRuleEntry
 end
 
 # Convert the `TestRuleEntry` back into the `Expr` form, e.g `(input = ..., output = ...)`
-function Base.convert(::Type{Expr}, test_entry::TestRuleEntry)
-    return Expr(:tuple, Expr(:(=), :input, convert(Expr, test_entry.input)), Expr(:(=), :output, test_entry.output))
+function rule_macro_convert_to_expr(test_entry::TestRuleEntry)
+    return Expr(:tuple, Expr(:(=), :input, rule_macro_convert_to_expr(test_entry.input)), Expr(:(=), :output, test_entry.output))
 end
 
 # This function takes a `test` parameter which is expected to be an expression of single test entry.
@@ -937,8 +937,8 @@ end
 
 function test_rules_generate_testset(test_entry::TestRuleEntry, invoke_test_fn, call_macro_fn, rule_specification, configuration)
     # `nothing` here is a `LineNumberNode`, macrocall expects a `line` number, but we do not have it here
-    actual_inputs = convert(Expr, test_entry.input)
-    actual_output = Expr(:macrocall, call_macro_fn, nothing, rule_specification, convert(Expr, actual_inputs))
+    actual_inputs = rule_macro_convert_to_expr(test_entry.input)
+    actual_output = Expr(:macrocall, call_macro_fn, nothing, rule_specification, actual_inputs)
     expected_output = test_entry.output
     rule_spec_str = "$rule_specification"
     rule_inputs_str = "$actual_inputs"
@@ -1108,9 +1108,8 @@ struct RuleMethodError
     node
 end
 
-rule(fform, on, vconstraint, mnames, messages, qnames, marginals, meta, addons, __node) = RuleMethodError(
-    fform, on, vconstraint, mnames, messages, qnames, marginals, meta, addons, __node
-)
+rule(fform, on, vconstraint, mnames, messages, qnames, marginals, meta, addons, __node) =
+    RuleMethodError(fform, on, vconstraint, mnames, messages, qnames, marginals, meta, addons, __node)
 
 function Base.showerror(io::IO, error::RuleMethodError)
     print(io, "RuleMethodError: no method matching rule for the given arguments")

test/rule_tests.jl

@@ -10,6 +10,7 @@
         import ReactiveMP: float_tolerance, float_tolerance!
         import ReactiveMP: extra_float_types, extra_float_types!
         import ReactiveMP: test_rules_parse_configuration
+        import ReactiveMP: rule_macro_convert_to_expr
 
         @testset "TestRulesConfiguration" begin
 
@@ -59,7 +60,8 @@
             @test_throws ErrorException test_rules_parse_configuration(:configuration, :([options = value = broken]))
 
             for name in (:configuration, :blabla),
-                check in (true, false), atol in (1e-4, :([Float64 => 1e-11, Float32 => 1e-4])),
+                check in (true, false),
+                atol in (1e-4, :([Float64 => 1e-11, Float32 => 1e-4])),
                 extra_types in (:([Float64]), :([Float32, BigFloat]))
 
                 expression = test_rules_parse_configuration(name, :([check_type_promotion = $check, atol = $atol, extra_float_types = $extra_types]))
@@ -95,11 +97,11 @@
             import ReactiveMP: TestRuleEntryInputSpecification
 
             let spec = TestRuleEntryInputSpecification([:m_x => 1], nothing)
-                @test convert(Expr, spec) == :((m_x = 1,))
+                @test rule_macro_convert_to_expr(spec) == :((m_x = 1,))
             end
 
             let spec = TestRuleEntryInputSpecification([:q_x => 1, :m_y => :(Normal(1.0, 1.0))], :(Meta(2)))
-                @test convert(Expr, spec) == :((q_x = 1, m_y = Normal(1.0, 1.0), meta = Meta(2)))
+                @test rule_macro_convert_to_expr(spec) == :((q_x = 1, m_y = Normal(1.0, 1.0), meta = Meta(2)))
             end
         end
 
@@ -120,11 +122,11 @@
             import ReactiveMP: TestRuleEntry
 
             let spec = TestRuleEntry(TestRuleEntryInputSpecification([:m_x => 1], nothing), :(Normal(0.0, 3.0)))
-                @test convert(Expr, spec) == :((input = (m_x = 1,), output = Normal(0.0, 3.0)))
+                @test rule_macro_convert_to_expr(spec) == :((input = (m_x = 1,), output = Normal(0.0, 3.0)))
             end
 
             let spec = TestRuleEntry(TestRuleEntryInputSpecification([:q_x => 1, :m_y => :(Normal(1.0, 1.0))], :(Meta(2))), :(Gamma(2.0, 3.0)))
-                @test convert(Expr, spec) == :((input = (q_x = 1, m_y = Normal(1.0, 1.0), meta = Meta(2)), output = Gamma(2.0, 3.0)))
+                @test rule_macro_convert_to_expr(spec) == :((input = (q_x = 1, m_y = Normal(1.0, 1.0), meta = Meta(2)), output = Gamma(2.0, 3.0)))
             end
         end
 
@@ -176,7 +178,7 @@
 
             for m in (1, :(Normal(0.0, 1.0))), v in (2, Gamma(2.0, 3.0)), output in (3, :(Normal(2.0, 3.0))), eltype in (:Float32, Float64)
                 let test_entry = TestRuleEntry(TestRuleEntryInputSpecification([:m => m, :v => v], :(Meta(1))), output)
-                    modified_inputs = map(e -> convert(Expr, e), test_rules_convert_paramfloattype_for_test_entry(test_entry, eltype))
+                    modified_inputs = map(e -> rule_macro_convert_to_expr(e), test_rules_convert_paramfloattype_for_test_entry(test_entry, eltype))
 
                     modified_m = :(ReactiveMP.BayesBase.convert_paramfloattype($eltype, $m))
                     modified_v = :(ReactiveMP.BayesBase.convert_paramfloattype($eltype, $v))