fix(parser): enforce exact method name matching for extension functions

- Removed camelCase to snake_case conversion in extension function lookups
- Changed object extension methods to require exact name matches without case conversion
- Updated universal method extensions to use exact spelling instead of case variants
- Modified keyword extension methods to use exact __{method} naming
- Simplified function candidate search to single exact match instead of multiple variants
- Updated test cases to reflect exact naming requirements for all extension methods
- Maintained case-insensitive lookup behavior according to PHP function semantics

src/Parser/UniversalMethodCall.php

@@ -350,33 +350,22 @@ trait UniversalMethodCall
         Type::BOX => 'box',
     ];
 
-    protected function camelToSnake(string $name): string
+    protected function extensionFunctionName(string $prefix, string $method): string
     {
-        return strtolower(preg_replace('/([a-z])([A-Z])/', '$1_$2', $name));
+        return $prefix . '_' . $method;
     }
 
-    /** @return list<string> */
+    protected function findUserExtensionFunction(string $prefix, string $method, string $namespace = ''): ?array
-    protected function extensionFunctionCandidates(string $prefix, string $method): array
     {
-        return array_values(array_unique([
+        $function = $this->getNativeName($this->extensionFunctionName($prefix, $method), $namespace);
-            $prefix . '_' . $this->camelToSnake($method),
-            $prefix . '_' . $method,
-        ]));
-    }
-
-    /** Resolve extension candidates in exactly one namespace. */
-    protected function extensionFunctionDefinitions(string $prefix, string $method, string $namespace = ''): iterable
-    {
-        foreach ($this->extensionFunctionCandidates($prefix, $method) as $localName) {
-            $function = $this->getNativeName($localName, $namespace);
         if (!$this->hasFunction($function)) {
-                continue;
+            return null;
         }
         $definition = $this->getFunction($function);
-            if ($definition->namespace === $namespace) {
+        if ($definition->namespace !== $namespace) {
-                yield $function => $definition;
+            return null;
-            }
         }
+        return ['name' => $function, 'definition' => $definition];
     }
 
     protected const array TO_CONVERT_FN = [
@@ -419,8 +408,10 @@ trait UniversalMethodCall
 
     /**
      * Look up a statically compiled object extension in the object's own
-     * namespace. This lookup is only used by the named MethodCall AST path;
+     * namespace. The class prefix and method suffix must match the declared
-     * dynamic method names and StaticCall nodes deliberately do not use it.
+     * names without converting between camelCase and snake_case. This lookup
+     * is only used by the named MethodCall AST path; dynamic method names and
+     * StaticCall nodes deliberately do not use it.
      * Real methods are resolved before this fallback, while __call() is used
      * only if no valid extension exists.
      */
@@ -434,15 +425,20 @@ trait UniversalMethodCall
         $namespace = $separator === false ? '' : substr($class, 0, $separator);
         $shortClass = $separator === false ? $class : substr($class, $separator + 1);
 
-        foreach ($this->extensionFunctionDefinitions($shortClass, $method, $namespace) as $function => $funcDef) {
+        $extension = $this->findUserExtensionFunction($shortClass, $method, $namespace);
+        if ($extension === null) {
+            return null;
+        }
+        $function = $extension['name'];
+        $funcDef = $extension['definition'];
         if (empty($funcDef->argInfoList)) {
-                continue;
+            return null;
         }
         $receiver = $funcDef->argInfoList[0];
         if ($receiver->byRef
             || $receiver->type !== Type::OBJECT
             || !$this->isSameClassName($receiver->declaredClass, $class)) {
-                continue;
+            return null;
         }
 
         $totalParams = count($funcDef->argInfoList);
@@ -454,14 +450,11 @@ trait UniversalMethodCall
             'max_args'     => $funcDef->hasVariadicArg() ? -1 : $totalParams - 1,
         ];
     }
-        return null;
-    }
 
     /**
      * Look up an extension function for the given type+method.
-     * Extension functions may use either {typePrefix}_{snake_case_method}
+     * Extension functions use the exact {typePrefix}_{method} spelling.
-     * or {typePrefix}_{lowerCamelCaseMethod}. Snake case takes precedence when
+     * Lookup remains case-insensitive according to PHP function semantics.
-     * both functions exist.
      *
      * Checks compiled user-defined functions first, then falls back to PHP internal
      * functions using reflection to resolve parameter counts and return types.
@@ -473,15 +466,12 @@ trait UniversalMethodCall
             return null;
         }
 
-        foreach ($this->extensionFunctionCandidates($prefix, $method) as $funcName) {
+        $funcName = $this->extensionFunctionName($prefix, $method);
         $resolvedName = $this->resolveExtensionFunctionName($funcName);
         if ($resolvedName !== null) {
             $funcDef = $this->getFunction($resolvedName);
-                if ($funcDef->namespace !== '') {
+            if ($funcDef->namespace !== '' || !$this->validateExtensionFirstParam($type, $funcDef)) {
-                    continue;
+                return null;
-                }
-                if (!$this->validateExtensionFirstParam($type, $funcDef)) {
-                    continue;
             }
             return [
                 'handler'      => 'php_fn',
@@ -499,24 +489,28 @@ trait UniversalMethodCall
                 return $internal;
             }
         }
-        }
 
         return null;
     }
 
     /**
-     * Look up a keyword extension method using __snake_case or
+     * Look up a keyword extension method using the exact __{method} spelling
-     * __lowerCamelCase in the root namespace. Snake case takes precedence.
+     * in the root namespace. Lookup remains case-insensitive.
      */
     protected function findKeywordExtensionMethod(string $method): ?array
     {
-        foreach ($this->extensionFunctionDefinitions('_', $method) as $funcName => $funcDef) {
+        $extension = $this->findUserExtensionFunction('_', $method);
+        if ($extension === null) {
+            return null;
+        }
+        $funcName = $extension['name'];
+        $funcDef = $extension['definition'];
         if (empty($funcDef->argInfoList)) {
-                continue;
+            return null;
         }
         $firstParam = $funcDef->argInfoList[0];
         if ($firstParam->type !== Type::VAR) {
-                continue;
+            return null;
         }
 
         $totalParams = count($funcDef->argInfoList);
@@ -533,9 +527,6 @@ trait UniversalMethodCall
         ];
     }
 
-        return null;
-    }
-
     /**
      * Unified keyword method lookup (to* builtins + __ extension methods).
      * Returns the return type string, or null if the method is not a keyword method.

tests/aot/keyword_extension/001.phpt

@@ -1,5 +1,5 @@
 --TEST--
-keyword extension method: varDump()
+keyword extension method: exact snake_case name
 --FILE--
 <?php
 declare(strict_types=1);
@@ -11,13 +11,13 @@ function __var_dump(mixed $var): void {
 
 function main(): void {
     $str = "hello world";
-    $str->varDump();
+    $str->var_dump();
 
     $int_val = 42;
-    $int_val->varDump();
+    $int_val->var_dump();
 
     $float_val = 3.14;
-    $float_val->varDump();
+    $float_val->var_dump();
 }
 ?>
 --EXPECT--

tests/aot/universal_method/object_extension.phpt

@@ -23,7 +23,7 @@ namespace App {
         }
     }
 
-    function User_test_method(User $user, string $suffix): string
+    function User_testMethod(User $user, string $suffix): string
     {
         return $user->name . $suffix . ':snake';
     }

tests/aot/universal_method/object_extension_exact_name.phpt

@@ -0,0 +1,65 @@
+--TEST--
+Object extension methods require consistent names and ignore letter case
+--FILE--
+<?php
+
+namespace App {
+    use native_types;
+
+    class UserService
+    {
+        public function __construct(public string $name)
+        {
+        }
+
+        public function __call(string $method, array $args): string
+        {
+            return 'magic:' . $method;
+        }
+    }
+
+    function UserService_displayName(UserService $service): string
+    {
+        return 'camel:' . $service->name;
+    }
+
+    function UserService_profile_label(UserService $service): string
+    {
+        return 'snake:' . $service->name;
+    }
+
+    function user_service_wrongName(UserService $service): string
+    {
+        return 'wrong class prefix';
+    }
+
+    function UserService_other_name(UserService $service): string
+    {
+        return 'wrong method suffix';
+    }
+
+    function UserService_CASECheck(UserService $service): string
+    {
+        return 'case-insensitive:' . $service->name;
+    }
+}
+
+namespace {
+    function main(): void
+    {
+        $service = new \App\UserService('alice');
+
+        var_dump($service->displayName());
+        var_dump($service->profile_label());
+        var_dump($service->wrongName());
+        var_dump($service->otherName());
+        var_dump($service->casecheck());
+    }
+}
+?>
+--EXPECT--
+string(11) "camel:alice"
+string(11) "snake:alice"
+string(15) "magic:wrongName"
+string(15) "magic:otherName"
+string(22) "case-insensitive:alice"

tests/aot/universal_method/universal_method_extension.phpt

@@ -23,10 +23,10 @@ function str_shout(string $str): string
 function main()
 {
     $num = 1024 * 512;
-    var_dump($num->toBytes());
+    var_dump($num->to_bytes());
 
     $array = [22, 33, 44];
-    var_dump($array->getFirstElement());
+    var_dump($array->get_first_element());
 
     $str = "hello";
     var_dump($str->shout());

tests/aot/universal_method/universal_method_extension_chain.phpt

@@ -36,11 +36,11 @@ function array_last(array $arr): mixed {
 function main()
 {
     $num = 2;
-    var_dump($num->toWords()->upper());
+    var_dump($num->to_words()->upper());
-    var_dump($num->toWords()->double()->upper());
+    var_dump($num->to_words()->double()->upper());
 
     $str = "hello";
-    var_dump($str->getLength()->add(100));
+    var_dump($str->get_length()->add(100));
     var_dump($str->double()->length());
 
     $str2 = "hello world";