Fix user-defined rules not overriding built-in functions

User-defined DownValues (via Unprotect + SetDelayed) were ignored for
built-in functions because built-in dispatch ran before checking
FUNC_DEFS. Reorder evaluation so user-defined rules are matched first,
falling through to built-in implementations only when no user rule matches.

Author: ad-si

src/evaluator/dispatch/mod.rs

@@ -359,89 +359,8 @@ pub fn evaluate_function_call_ast_inner(
     _ => {}
   }
 
-  // Dispatch through submodules in order
-  if let Some(result) = structural::dispatch_structural(name, args) {
-    return result;
-  }
-  if let Some(result) = attributes::dispatch_attributes(name, args) {
-    return result;
-  }
-  if let Some(result) =
-    evaluation_control::dispatch_evaluation_control(name, args)
-  {
-    return result;
-  }
-  if let Some(result) = list_operations::dispatch_list_operations(name, args) {
-    return result;
-  }
-  if let Some(result) = string_functions::dispatch_string_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) = image_functions::dispatch_image_functions(name, args) {
-    return result;
-  }
-  if let Some(result) = io_functions::dispatch_io_functions(name, args) {
-    return result;
-  }
-  if let Some(result) =
-    datetime_functions::dispatch_datetime_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) = plotting::dispatch_plotting(name, args) {
-    return result;
-  }
-  if let Some(result) =
-    predicate_functions::dispatch_predicate_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) =
-    association_functions::dispatch_association_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) =
-    quantity_functions::dispatch_quantity_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) =
-    interval_functions::dispatch_interval_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) = math_functions::dispatch_math_functions(name, args) {
-    return result;
-  }
-  if let Some(result) =
-    boolean_functions::dispatch_boolean_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) =
-    polynomial_functions::dispatch_polynomial_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) =
-    calculus_functions::dispatch_calculus_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) =
-    linear_algebra_functions::dispatch_linear_algebra_functions(name, args)
-  {
-    return result;
-  }
-  if let Some(result) =
-    complex_and_special::dispatch_complex_and_special(name, args)
-  {
-    return result;
-  }
-
-  // Check for user-defined functions
+  // Check for user-defined functions (before built-in dispatch, so user
+  // overrides take precedence — matching Wolfram Language semantics)
   // Clone overloads to avoid holding the borrow across evaluate calls
   let overloads = crate::FUNC_DEFS.with(|m| {
     let defs = m.borrow();
@@ -782,6 +701,88 @@ pub fn evaluate_function_call_ast_inner(
     }
   }
 
+  // Dispatch through built-in submodules (after user-defined functions)
+  if let Some(result) = structural::dispatch_structural(name, args) {
+    return result;
+  }
+  if let Some(result) = attributes::dispatch_attributes(name, args) {
+    return result;
+  }
+  if let Some(result) =
+    evaluation_control::dispatch_evaluation_control(name, args)
+  {
+    return result;
+  }
+  if let Some(result) = list_operations::dispatch_list_operations(name, args) {
+    return result;
+  }
+  if let Some(result) = string_functions::dispatch_string_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) = image_functions::dispatch_image_functions(name, args) {
+    return result;
+  }
+  if let Some(result) = io_functions::dispatch_io_functions(name, args) {
+    return result;
+  }
+  if let Some(result) =
+    datetime_functions::dispatch_datetime_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) = plotting::dispatch_plotting(name, args) {
+    return result;
+  }
+  if let Some(result) =
+    predicate_functions::dispatch_predicate_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) =
+    association_functions::dispatch_association_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) =
+    quantity_functions::dispatch_quantity_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) =
+    interval_functions::dispatch_interval_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) = math_functions::dispatch_math_functions(name, args) {
+    return result;
+  }
+  if let Some(result) =
+    boolean_functions::dispatch_boolean_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) =
+    polynomial_functions::dispatch_polynomial_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) =
+    calculus_functions::dispatch_calculus_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) =
+    linear_algebra_functions::dispatch_linear_algebra_functions(name, args)
+  {
+    return result;
+  }
+  if let Some(result) =
+    complex_and_special::dispatch_complex_and_special(name, args)
+  {
+    return result;
+  }
+
   // Check if the variable stores a value that can be called as a function
   // (e.g., anonymous function stored in a variable: f = (# + 1) &; f[5])
   let stored_value = crate::ENV.with(|e| {

tests/interpreter_tests/functions.rs

@@ -459,6 +459,35 @@ mod protect_unprotect {
       "{}"
     );
   }
+
+  #[test]
+  fn override_builtin_function_with_user_rule() {
+    // Regression test: user-defined rules should take precedence over built-in
+    // implementations when the function is Unprotected and a matching rule exists.
+    clear_state();
+    assert_eq!(
+      interpret(
+        "Unprotect[PolynomialQ]; PolynomialQ[u_List, x_Symbol] := Foo[u, x]; \
+         Protect[PolynomialQ]; PolynomialQ[{x + 2}, x]"
+      )
+      .unwrap(),
+      "Foo[{2 + x}, x]"
+    );
+  }
+
+  #[test]
+  fn override_builtin_falls_through_to_builtin() {
+    // When user rule doesn't match, built-in should still work
+    clear_state();
+    assert_eq!(
+      interpret(
+        "Unprotect[PolynomialQ]; PolynomialQ[u_List, x_Symbol] := Foo[u, x]; \
+         Protect[PolynomialQ]; PolynomialQ[x^2 + 1, x]"
+      )
+      .unwrap(),
+      "True"
+    );
+  }
 }
 
 mod attributes_assignment {