refactor: rename with_tree to with_content

Author: MilesCranmer

src/DynamicExpressions.jl

@@ -67,7 +67,7 @@ import .NodeModule:
 @reexport import .ExtensionInterfaceModule: node_to_symbolic, symbolic_to_node
 @reexport import .RandomModule: NodeSampler
 @reexport import .ExpressionModule:
-    AbstractExpression, Expression, with_tree, with_metadata, get_contents, get_metadata
+    AbstractExpression, Expression, with_contents, with_metadata, get_contents, get_metadata
 import .ExpressionModule:
     get_tree, get_operators, get_variable_names, Metadata, default_node_type, node_type
 @reexport import .ParseModule: @parse_expression, parse_expression

src/Expression.jl

@@ -144,15 +144,15 @@ end
 ########################################################
 
 """
-    with_tree(ex::AbstractExpression, tree::AbstractExpressionNode)
-    with_tree(ex::AbstractExpression, tree::AbstractExpression)
+    with_contents(ex::AbstractExpression, tree::AbstractExpressionNode)
+    with_contents(ex::AbstractExpression, tree::AbstractExpression)
 
 Create a new expression based on `ex` but with a different `tree`
 """
-function with_tree(ex::AbstractExpression, tree::AbstractExpression)
-    return with_tree(ex, get_contents(tree))
+function with_contents(ex::AbstractExpression, tree::AbstractExpression)
+    return with_contents(ex, get_contents(tree))
 end
-function with_tree(ex::AbstractExpression, tree)
+function with_contents(ex::AbstractExpression, tree)
     return constructorof(typeof(ex))(tree, get_metadata(ex))
 end
 function get_contents(ex::Expression)

src/Interfaces.jl

@@ -45,7 +45,7 @@ using ..ExpressionModule:
     get_variable_names,
     get_contents,
     get_metadata,
-    with_tree,
+    with_contents,
     with_metadata,
     default_node_type
 using ..ParametricExpressionModule: ParametricExpression, ParametricNode
@@ -56,7 +56,7 @@ using ..ParametricExpressionModule: ParametricExpression, ParametricNode
 
 ## mandatory
 function _check_get_contents(ex::AbstractExpression)
-    new_ex = with_tree(ex, get_contents(ex))
+    new_ex = with_contents(ex, get_contents(ex))
     return new_ex == ex && new_ex isa typeof(ex)
 end
 function _check_get_metadata(ex::AbstractExpression)
@@ -78,9 +78,9 @@ function _check_copy(ex::AbstractExpression)
     # TODO: Could include checks for aliasing here
     return preserves
 end
-function _check_with_tree(ex::AbstractExpression)
-    new_ex = with_tree(ex, get_contents(ex))
-    new_ex2 = with_tree(ex, ex)
+function _check_with_contents(ex::AbstractExpression)
+    new_ex = with_contents(ex, get_contents(ex))
+    new_ex2 = with_contents(ex, ex)
     return new_ex == ex && new_ex isa typeof(ex) && new_ex2 == ex && new_ex2 isa typeof(ex)
 end
 function _check_with_metadata(ex::AbstractExpression)
@@ -142,7 +142,7 @@ ei_components = (
         get_operators = "returns the operators used in the expression (or pass `operators` explicitly to override)" => _check_get_operators,
         get_variable_names = "returns the variable names used in the expression (or pass `variable_names` explicitly to override)" => _check_get_variable_names,
         copy = "returns a copy of the expression" => _check_copy,
-        with_tree = "returns the expression with different tree" => _check_with_tree,
+        with_contents = "returns the expression with different tree" => _check_with_contents,
         with_metadata = "returns the expression with different metadata" => _check_with_metadata,
     ),
     optional = (

test/test_expressions.jl

@@ -168,14 +168,14 @@ end
     @test has_constants(ex) == false
 end
 
-@testitem "Expression with_tree" begin
+@testitem "Expression with_contents" begin
     using DynamicExpressions
 
     ex = @parse_expression(x1 + 1.5, binary_operators = [+, *], variable_names = ["x1"])
     ex2 = @parse_expression(x1 + 3.0, binary_operators = [+], variable_names = ["x1"])
 
-    t2 = DynamicExpressions.get_tree(ex2)
-    ex_modified = DynamicExpressions.with_tree(ex, t2)
+    t2 = DynamicExpressions.get_contents(ex2)
+    ex_modified = DynamicExpressions.with_contents(ex, t2)
     @test DynamicExpressions.get_tree(ex_modified) == t2
 end