refactor: prevent need for custom hash and ==

Author: MilesCranmer

src/Expression.jl

@@ -6,6 +6,7 @@ using ..NodeModule: AbstractExpressionNode, Node
 using ..OperatorEnumModule: AbstractOperatorEnum, OperatorEnum
 using ..UtilsModule: Undefined
 
+import ..NodeModule: copy_node, set_node!, count_nodes, tree_mapreduce, constructorof
 import ..NodeUtilsModule:
     preserve_sharing,
     count_constants,
@@ -128,12 +129,6 @@ end
 function Base.copy(ex::AbstractExpression; break_sharing::Val=Val(false))
     return error("`copy` function must be implemented for $(typeof(ex)) types.")
 end
-function Base.hash(ex::AbstractExpression, h::UInt)
-    return error("`hash` function must be implemented for $(typeof(ex)) types.")
-end
-function Base.:(==)(x::AbstractExpression, y::AbstractExpression)
-    return error("`==` function must be implemented for $(typeof(x)) types.")
-end
 function get_constants(ex::AbstractExpression)
     return error("`get_constants` function must be implemented for $(typeof(ex)) types.")
 end
@@ -199,25 +194,17 @@ end
 function Base.copy(ex::Expression; break_sharing::Val=Val(false))
     return Expression(copy(ex.tree; break_sharing), copy(ex.metadata))
 end
-function Base.hash(ex::Expression, h::UInt)
-    return hash(ex.tree, hash(ex.metadata, h))
+function Base.hash(ex::AbstractExpression, h::UInt)
+    return hash(get_contents(ex), hash(get_metadata(ex), h))
 end
-
-"""
-    Base.:(==)(x::Expression, y::Expression)
-
-Check equality of two expressions `x` and `y` by comparing their trees and metadata.
-"""
-function Base.:(==)(x::Expression, y::Expression)
-    return x.tree == y.tree && x.metadata == y.metadata
+function Base.:(==)(x::AbstractExpression, y::AbstractExpression)
+    return get_contents(x) == get_contents(y) && get_metadata(x) == get_metadata(y)
 end
 
 # Overload all methods on AbstractExpressionNode that return an aggregation, or can
 # return an entire tree. Methods that only return the nodes are *not* overloaded, so
 # that the user must use the low-level interface.
 
-import ..NodeModule: copy_node, set_node!, count_nodes, tree_mapreduce, constructorof
-
 #! format: off
 @unstable constructorof(::Type{E}) where {E<:AbstractExpression} = Base.typename(E).wrapper
 @unstable constructorof(::Type{<:Expression}) = Expression

src/ParametricExpression.jl

@@ -153,12 +153,6 @@ function Base.copy(ex::ParametricExpression; break_sharing::Val=Val(false))
         parameter_names=_copy_with_nothing(ex.metadata.parameter_names),
     )
 end
-function Base.hash(ex::ParametricExpression, h::UInt)
-    return hash(ex.tree, hash(ex.metadata, h))
-end
-function Base.:(==)(x::ParametricExpression, y::ParametricExpression)
-    return x.tree == y.tree && x.metadata == y.metadata
-end
 ###############################################################################
 
 ###############################################################################

test/test_multi_expression.jl

@@ -61,8 +61,6 @@
         )
         @test_throws "`get_tree` function must be implemented for" DE.get_tree(multi_ex)
         @test_throws "`copy` function must be implemented for" copy(multi_ex)
-        @test_throws "`hash` function must be implemented for" hash(multi_ex, UInt(0))
-        @test_throws "`==` function must be implemented for" multi_ex == multi_ex
         @test_throws "`get_constants` function must be implemented for" get_constants(
             multi_ex
         )