fix: parse_guesses for custom AbstractPopMember

Author: MilesCranmer

src/ExpressionBuilder.jl

@@ -118,7 +118,6 @@ end
             options;
             complexity=compute_complexity(member, options),
             parent_ref=member.ref,
-            deterministic=options.deterministic,
         )
     end
     function embed_metadata(

src/MLJInterface.jl

@@ -39,8 +39,8 @@ using ..CoreModule:
     ExpressionSpec,
     get_expression_type,
     check_warm_start_compatibility
-using ..CoreModule.OptionsModule:
-    DEFAULT_OPTIONS, OPTION_DESCRIPTIONS, default_popmember_type
+using ..CoreModule.OptionsModule: DEFAULT_OPTIONS, OPTION_DESCRIPTIONS
+using ..PopMemberModule: default_popmember_type
 using ..ComplexityModule: compute_complexity
 using ..HallOfFameModule: HallOfFame, format_hall_of_fame
 using ..UtilsModule: subscriptify, @ignore

src/PopMember.jl

@@ -201,7 +201,7 @@ end
 
 """
     create_child(parent::P, tree::AbstractExpression{T}, cost, loss, options;
-                complexity::Union{Int,Nothing}=nothing, parent_ref, kwargs...) where {T,L,P<:PopMember{T,L}}
+                complexity::Union{Int,Nothing}=nothing, parent_ref) where {T,L,P<:PopMember{T,L}}
 
 Create a new PopMember with a potentially different expression type.
 Used by embed_metadata where the expression gains metadata.
@@ -214,7 +214,6 @@ function create_child(
     options;
     complexity::Union{Int,Nothing}=nothing,
     parent_ref,
-    kwargs...,
 ) where {T,L,P<:PopMember{T,L}}
     actual_complexity = @something complexity compute_complexity(tree, options)
     return PopMember(
@@ -230,7 +229,7 @@ end
 
 """
     create_child(parents::Tuple{P,P}, tree, cost, loss, options;
-                complexity::Union{Int,Nothing}=nothing, parent_ref, kwargs...) where P<:AbstractPopMember
+                complexity::Union{Int,Nothing}=nothing, parent_ref) where P<:AbstractPopMember
 
 Create a new PopMember from two parents (crossover case).
 Custom types should override to blend their additional fields.
@@ -243,7 +242,6 @@ function create_child(
     options;
     complexity::Union{Int,Nothing}=nothing,
     parent_ref,
-    kwargs...,
 ) where {T,L,P<:PopMember{T,L}}
     actual_complexity = @something complexity compute_complexity(tree, options)
     return PopMember(
@@ -263,4 +261,10 @@ function popmember_type end
 @unstable default_popmember_type() = PopMember
 @unstable constructorof(::Type{<:PopMember}) = PopMember
 
+@inline function with_expression_type(
+    ::Type{<:PopMember{T,L}}, ::Type{N}
+) where {T,L,N<:AbstractExpression{T}}
+    return PopMember{T,L,N}
+end
+
 end

src/SearchUtils.jl

@@ -12,12 +12,18 @@ using DispatchDoctor: @unstable
 using Logging: AbstractLogger
 
 using DynamicExpressions:
-    AbstractExpression, string_tree, parse_expression, EvalOptions, with_type_parameters
+    AbstractExpression,
+    string_tree,
+    parse_expression,
+    EvalOptions,
+    with_type_parameters,
+    constructorof
 using ..UtilsModule: subscriptify
-using ..CoreModule: Dataset, AbstractOptions, Options, RecordType, max_features
+using ..CoreModule:
+    Dataset, AbstractOptions, Options, RecordType, max_features, create_expression
 using ..ComplexityModule: compute_complexity
 using ..PopulationModule: Population
-using ..PopMemberModule: PopMember, AbstractPopMember
+using ..PopMemberModule: PopMember, AbstractPopMember, with_expression_type
 using ..HallOfFameModule: HallOfFame, string_dominating_pareto_curve
 using ..ConstantOptimizationModule: optimize_constants
 using ..ProgressBarsModule: WrappedProgressBar, manually_iterate!, barlen
@@ -800,7 +806,9 @@ function parse_guesses(
         dataset = datasets[j]
         for g in guess_lists[j]
             ex = _parse_guess_expression(T, g, dataset, options)
-            member = PopMember(dataset, ex, options; deterministic=options.deterministic)
+            member = constructorof(P)(
+                dataset, ex, options; deterministic=options.deterministic
+            )
             if options.should_optimize_constants
                 member, _ = optimize_constants(dataset, member, options)
             end
@@ -818,6 +826,21 @@ function parse_guesses(
     end
     return out
 end
+
+# Deal with non-concrete PopMember types
+function parse_guesses(
+    ::Type{P},
+    guesses::Union{AbstractVector,AbstractVector{<:AbstractVector}},
+    datasets::Vector{D},
+    options::AbstractOptions,
+) where {T,L,P<:AbstractPopMember{T,L},D<:Dataset{T,L}}
+    NodeType = with_type_parameters(options.node_type, T)
+    N = Base.promote_op(create_expression, NodeType, typeof(options), D)
+    N === Any && error("Failed to infer expression type")
+    ConcreteP = with_expression_type(P, N)
+    return parse_guesses(ConcreteP, guesses, datasets, options)
+end
+
 function _make_vector_vector(guesses, nout)
     if nout == 1
         if guesses isa AbstractVector{<:AbstractVector}

test/test_abstract_popmember.jl

@@ -101,7 +101,6 @@
         options;
         complexity::Union{Int,Nothing}=nothing,
         parent_ref,
-        kwargs...,
     ) where {T,L}
         actual_complexity = @something complexity SymbolicRegression.compute_complexity(
             tree, options
@@ -126,7 +125,6 @@
         options;
         complexity::Union{Int,Nothing}=nothing,
         parent_ref,
-        kwargs...,
     ) where {T,L,N<:AbstractExpression{T}}
         actual_complexity = @something complexity SymbolicRegression.compute_complexity(
             tree, options