test: custom operator parsing

Author: MilesCranmer

src/Parse.jl

@@ -249,38 +249,43 @@ Throws appropriate errors for ambiguous or missing matches.
 @unstable function _find_operator_by_name(func_symbol, args, operators)
     function_name_offset = 1
     degree = length(args) - function_name_offset
-    
+
     matches = Tuple{Function,Int}[]
-    
+
     for arity in 1:length(operators.ops)
         for op in operators.ops[arity]
             if nameof(op) == func_symbol
                 push!(matches, (op, arity))
             end
         end
     end
-    
+
     if isempty(matches)
-        throw(ArgumentError(
-            "Tried to interpolate function `$(func_symbol)` but failed. " *
-            "Function not found in operators."
-        ))
+        throw(
+            ArgumentError(
+                "Tried to interpolate function `$(func_symbol)` but failed. " *
+                "Function not found in operators.",
+            ),
+        )
     end
-    
+
     arity_matches = filter(m -> m[2] == degree, matches)
-    
+
     if length(arity_matches) > 1
-        ops_str = join([string(m[1]) for m in arity_matches], ", ")
-        throw(ArgumentError(
-            "Ambiguous operator `$(func_symbol)` with arity $(degree). " *
-            "Multiple matches found: $(ops_str)"
-        ))
+        throw(
+            ArgumentError(
+                "Ambiguous operator `$(func_symbol)` with arity $(degree). " *
+                "Multiple matches found: $(arity_matches)",
+            ),
+        )
     elseif length(arity_matches) == 0
         available_arities = [m[2] for m in matches]
-        throw(ArgumentError(
-            "Operator `$(func_symbol)` found but not with arity $(degree). " *
-            "Available arities: $(available_arities)"
-        ))
+        throw(
+            ArgumentError(
+                "Operator `$(func_symbol)` found but not with arity $(degree). " *
+                "Available arities: $(available_arities)",
+            ),
+        )
     end
 
     return arity_matches[1][1]::Function

test/test_parse.jl

@@ -340,3 +340,61 @@ end
     )
     @test string_tree(ex) == "x"
 end
+
+@testitem "custom operators without passing function object" begin
+    using DynamicExpressions
+
+    custom_mul(x, y) = x * y
+    custom_cos(x) = cos(x)
+    custom_max(x, y, z) = max(x, y, z)
+
+    operators = OperatorEnum(
+        1 => [custom_cos], 2 => [+, -, *, /, custom_mul], 3 => [custom_max]
+    )
+
+    # Test nested custom operators
+    ex = parse_expression(
+        "custom_max(custom_cos(x1), custom_mul(x2, x3), x4 + 1.5)";
+        operators=operators,
+        variable_names=["x1", "x2", "x3"],
+    )
+    @test typeof(ex) <: Expression
+    @test string_tree(ex) == "custom_max(custom_cos(x1), custom_mul(x2, x3), x4 + 1.5)"
+
+    # Test error cases for _find_operator_by_name
+    @test_throws(
+        ArgumentError(
+            "Tried to interpolate function `unknown_func` but failed. Function not found in operators.",
+        ),
+        parse_expression(
+            Meta.parse("unknown_func(x1)"), operators=operators, variable_names=["x1"]
+        )
+    )
+
+    # Test ambiguous operator - same name from different modules
+    module TestMod1
+    foo(x) = x + 1
+    end
+    module TestMod2
+    foo(x) = x - 1
+    end
+    same_name_ops = OperatorEnum(1 => [TestMod1.foo, TestMod2.foo])
+    @test_throws(
+        r"Ambiguous operator `foo` with arity 1\. Multiple matches found: Tuple\{Function, Int64\}\[.*foo.*1.*foo.*1.*\]",
+        parse_expression(
+            Meta.parse("foo(x1)"), operators=same_name_ops, variable_names=["x1"]
+        )
+    )
+
+    # Test wrong arity
+    @test_throws(
+        ArgumentError(
+            "Operator `custom_cos` found but not with arity 2. Available arities: [1]"
+        ),
+        parse_expression(
+            Meta.parse("custom_cos(x1, x2)"),
+            operators=operators,
+            variable_names=["x1", "x2"],
+        )
+    )
+end