ci: more test coverage cleanup

MilesCranmer · MilesCranmer · commit aa08eb1db6bc · 2025-06-15T01:25:58.000+01:00
diff --git a/src/Evaluate.jl b/src/Evaluate.jl
@@ -42,7 +42,7 @@ function Base.copy(buffer::ArrayBuffer)
 end
 
 reset_index!(buffer::ArrayBuffer) = buffer.index[] = 0
-reset_index!(::Nothing) = nothing
+reset_index!(::Nothing) = nothing  # COV_EXCL_LINE
 
 next_index!(buffer::ArrayBuffer) = buffer.index[] += 1
 
@@ -373,7 +373,7 @@ end
     nops = get_nops(O, Val(degree))
     return quote
         cs = get_children(tree, Val($degree))
-        Base.Cartesian.@nexprs(
+        Base.Cartesian.@nexprs(  # COV_EXCL_LINE
             $degree,
             i -> begin  # COV_EXCL_LINE
                 result_i = _eval_tree_array(cs[i], cX, operators, eval_options)
@@ -867,7 +867,7 @@ end
     nops = get_nops(operators, Val(degree))
     quote
         cs = get_children(tree, Val($degree))
-        Base.Cartesian.@nexprs(
+        Base.Cartesian.@nexprs(  # COV_EXCL_LINE
             $degree,
             i -> begin  # COV_EXCL_LINE
                 cumulator_i =
diff --git a/src/EvaluateDerivative.jl b/src/EvaluateDerivative.jl
@@ -129,7 +129,7 @@ end
 
     setup = quote
         cs = get_children(tree, Val($degree))
-        Base.Cartesian.@nexprs(
+        Base.Cartesian.@nexprs(  # COV_EXCL_LINE
             $degree,
             i -> begin  # COV_EXCL_LINE
                 result_i = _eval_diff_tree_array(cs[i], cX, operators, direction)
@@ -295,7 +295,7 @@ end
         cs = get_children(tree, Val($degree))
         index_cs =
             isnothing(index_tree) ? index_tree : get_children(index_tree, Val($degree))
-        Base.Cartesian.@nexprs(
+        Base.Cartesian.@nexprs(  # COV_EXCL_LINE
             $degree,
             i -> begin  # COV_EXCL_LINE
                 result_i = eval_grad_tree_array(
diff --git a/src/EvaluationHelpers.jl b/src/EvaluationHelpers.jl
@@ -1,17 +1,11 @@
 module EvaluationHelpersModule
 
-using ChainRulesCore: @non_differentiable
-
 import Base: adjoint
 import ..OperatorEnumModule: AbstractOperatorEnum, OperatorEnum, GenericOperatorEnum
 import ..NodeModule: AbstractExpressionNode
 import ..EvaluateModule: eval_tree_array
 import ..EvaluateDerivativeModule: eval_grad_tree_array
-
-function _set_nan!(out)
-    out .= convert(eltype(out), NaN)
-    return nothing
-end
+import ..UtilsModule: set_nan!
 
 # Evaluation:
 """
@@ -34,7 +28,7 @@ and triplets of operations for lower memory usage.
 """
 function (tree::AbstractExpressionNode)(X, operators::OperatorEnum; kws...)
     out, did_finish = eval_tree_array(tree, X, operators; kws...)
-    !did_finish && _set_nan!(out)
+    !did_finish && set_nan!(out)
     return out
 end
 """
@@ -63,7 +57,7 @@ function _grad_evaluator(
     tree::AbstractExpressionNode, X, operators::OperatorEnum; variable=Val(true), kws...
 )
     _, grad, did_complete = eval_grad_tree_array(tree, X, operators; variable, kws...)
-    !did_complete && _set_nan!(grad)
+    !did_complete && set_nan!(grad)
     return grad
 end
 function _grad_evaluator(
diff --git a/src/NodePreallocation.jl b/src/NodePreallocation.jl
@@ -49,12 +49,10 @@ function copy_into!(
         N,
     )
 end
-# COV_EXCL_START
 function leaf_copy_into!(dest::N, src::N) where {N<:AbstractExpressionNode}
     set_node!(dest, src)
     return dest
 end
-# COV_EXCL_STOP
 function branch_copy_into!(
     dest::N, src::N, children::Vararg{Any,M}
 ) where {T,D,N<:AbstractExpressionNode{T,D},M}
diff --git a/src/NodeUtils.jl b/src/NodeUtils.jl
@@ -179,7 +179,7 @@ end
 
 # Sharing is never needed for NodeIndex,
 # as we trace over the node we are indexing on.
-preserve_sharing(::Union{Type{<:NodeIndex},NodeIndex}) = false
+preserve_sharing(::Union{Type{<:NodeIndex},NodeIndex}) = false  # COV_EXCL_LINE
 
 function index_constant_nodes(
     tree::AbstractExpressionNode{Ti,D} where {Ti}, ::Type{T}=UInt16
diff --git a/src/NonDifferentiableDeclarations.jl b/src/NonDifferentiableDeclarations.jl
@@ -1,20 +1,24 @@
 module NonDifferentiableDeclarationsModule
 
+# COV_EXCL_START
+
 using ChainRulesCore: @non_differentiable
+import ..UtilsModule: set_nan!
 import ..OperatorEnumModule: AbstractOperatorEnum
 import ..NodeModule: AbstractExpressionNode, AbstractNode
 import ..NodeUtilsModule: tree_mapreduce
 import ..ExpressionModule:
     AbstractExpression, get_operators, get_variable_names, _validate_input
-import ..EvaluationHelpersModule: _set_nan!
 
 #! format: off
 @non_differentiable tree_mapreduce(f::Function, op::Function, tree::AbstractNode, result_type::Type)
 @non_differentiable tree_mapreduce(f::Function, f_branch::Function, op::Function, tree::AbstractNode, result_type::Type)
 @non_differentiable get_operators(ex::Union{AbstractExpression,AbstractExpressionNode}, operators::Union{AbstractOperatorEnum,Nothing})
 @non_differentiable get_variable_names(ex::AbstractExpression, variable_names::Union{AbstractVector{<:AbstractString},Nothing})
 @non_differentiable _validate_input(ex::AbstractExpression, X, operators::Union{AbstractOperatorEnum,Nothing})
-@non_differentiable _set_nan!(::Any)
+@non_differentiable set_nan!(::Any)
 #! format: on
 
+# COV_EXCL_STOP
+
 end
diff --git a/src/OperatorEnumConstruction.jl b/src/OperatorEnumConstruction.jl
@@ -318,7 +318,7 @@ function _extend_operators(operators, skip_user_operators, kws, __module__::Modu
 
     #! format: off
     return quote
-        local $type_requirements, $build_converters, $op_exists
+        local $type_requirements, $build_converters, $op_exists  # COV_EXCL_LINE
         $(_validate_no_ambiguous_broadcasts)($operators)
         lock($LATEST_LOCK)
         try
diff --git a/src/ParametricExpression.jl b/src/ParametricExpression.jl
@@ -125,7 +125,7 @@ end
 function default_node_type(::Type{N}) where {T,N<:ParametricExpression{T}}
     return ParametricNode{T,max_degree(N)}
 end
-preserve_sharing(::Union{Type{<:ParametricNode},ParametricNode}) = false # TODO: Change this?
+preserve_sharing(::Union{Type{<:ParametricNode},ParametricNode}) = false  # COV_EXCL_LINE
 function leaf_copy(t::ParametricNode{T}) where {T}
     if t.constant
         return constructorof(typeof(t))(; val=t.val)
@@ -368,9 +368,7 @@ function (ex::ParametricExpression)(
     kws...,
 ) where {T}
     (output, flag) = eval_tree_array(ex, X, classes, operators; kws...)
-    if !flag
-        output .= NaN
-    end
+    !flag && set_nan!(output)
     return output
 end
 function eval_tree_array(
diff --git a/src/Simplify.jl b/src/Simplify.jl
@@ -10,12 +10,14 @@ import ..ValueInterfaceModule: is_valid
 
 @inline _op_kernel(f::F, l::T, ls::T...) where {F,T} = f(l, ls...)
 
+# COV_EXCL_START
 is_commutative(::typeof(*)) = true
 is_commutative(::typeof(+)) = true
 is_commutative(_) = false
 
 is_subtraction(::typeof(-)) = true
 is_subtraction(_) = false
+# COV_EXCL_STOP
 
 combine_operators(tree::AbstractExpressionNode, ::AbstractOperatorEnum) = tree
 # This is only defined for `Node` as it is not possible for, e.g.,
diff --git a/src/Strings.jl b/src/Strings.jl
@@ -73,7 +73,7 @@ function get_pretty_op_name(op::F) where {F}
     return get_op_name(op)
 end
 
-@inline function strip_brackets(s::Vector{Char})::Vector{Char}
+@inline function strip_brackets(s::Vector{Char})
     if first(s) == '(' && last(s) == ')'
         return s[(begin + 1):(end - 1)]
     else
diff --git a/src/Utils.jl b/src/Utils.jl
@@ -70,4 +70,9 @@ end
     return Nullable(x.null, convert(T, x.x))
 end
 
+function set_nan!(out)
+    out .= convert(eltype(out), NaN)
+    return nothing
+end
+
 end
diff --git a/src/base.jl b/src/base.jl
@@ -357,7 +357,7 @@ Collect all nodes in a tree into a flat array in depth-first order.
 function collect(tree::AbstractNode; break_sharing::Val{BS}=Val(false)) where {BS}
     return filter(_ -> true, tree; break_sharing=Val(BS))
 end
-Base.IteratorSize(::Type{<:AbstractNode}) = Base.HasLength()
+Base.IteratorSize(::Type{<:AbstractNode}) = Base.HasLength()  # COV_EXCL_LINE
 
 """
     map(f::F, tree::AbstractNode, result_type::Type{RT}=Nothing; break_sharing::Val{BS}=Val(false)) where {F<:Function,RT,BS}
@@ -446,7 +446,7 @@ function mapreduce(
     return tree_mapreduce(f, op, tree, RT; f_on_shared, break_sharing=Val(BS))
 end
 
-isempty(::AbstractNode) = false
+isempty(::AbstractNode) = false  # COV_EXCL_LINE
 function iterate(root::AbstractNode)
     return (root, collect(root; break_sharing=Val(true))[(begin + 1):end])
 end
diff --git a/src/precompile.jl b/src/precompile.jl
@@ -1,5 +1,7 @@
 import PrecompileTools: @compile_workload, @setup_workload
 
+# COV_EXCL_START
+
 macro ignore_domain_error(ex)
     return esc(
         quote
@@ -198,3 +200,5 @@ function do_precompilation(; mode=:precompile)
         end
     end
 end
+
+# COV_EXCL_STOP
