feat(extension): add support for lowerCamelCase extension method names

- Allow extension functions to use either snake_case or lowerCamelCase naming
- Implement function name candidate generation with both naming conventions
- Prioritize snake_case over lowerCamelCase when both exist
- Add test cases for camel case keyword extension methods
- Add test cases for universal method extension with camel case names
- Refactor extension method lookup to iterate through both naming patterns
- Update documentation to reflect dual naming convention support

src/UniversalMethodCall.php

@@ -350,6 +350,15 @@ trait UniversalMethodCall
         return strtolower(preg_replace('/([a-z])([A-Z])/', '$1_$2', $name));
     }
 
+    /** @return list<string> */
+    protected function extensionFunctionCandidates(string $prefix, string $method): array
+    {
+        return array_values(array_unique([
+            $prefix . '_' . $this->camelToSnake($method),
+            $prefix . '_' . $method,
+        ]));
+    }
+
     protected const array TO_CONVERT_FN = [
         CompilerBase::TYPE_BIGINT   => ['toInt' => 'php::BigInt::toInt', 'toFloat' => 'php::BigInt::toFloat', 'toString' => 'php::BigInt::toString'],
         CompilerBase::TYPE_BIGFLOAT => ['toInt' => 'php::BigFloat::toInt', 'toFloat' => 'php::BigFloat::toFloat', 'toString' => 'php::BigFloat::toString'],
@@ -390,7 +399,9 @@ trait UniversalMethodCall
 
     /**
      * Look up an extension function for the given type+method.
-     * Extension functions follow the naming convention: {typePrefix}_{snake_case_method}
+     * Extension functions may use either {typePrefix}_{snake_case_method}
+     * or {typePrefix}_{lowerCamelCaseMethod}. Snake case takes precedence when
+     * 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.
@@ -402,14 +413,12 @@ trait UniversalMethodCall
             return null;
         }
 
-        $snakeMethod = $this->camelToSnake($method);
-        $funcName = $prefix . '_' . $snakeMethod;
-
+        foreach ($this->extensionFunctionCandidates($prefix, $method) as $funcName) {
             $resolvedName = $this->resolveExtensionFunctionName($funcName);
             if ($resolvedName !== null) {
                 $funcDef = $this->getFunction($resolvedName);
                 if (!$this->validateExtensionFirstParam($type, $funcDef)) {
-                return null;
+                    continue;
                 }
                 return [
                     'handler'      => 'php_fn',
@@ -422,47 +431,39 @@ trait UniversalMethodCall
             }
 
             if ($this->isInternalFunction($funcName)) {
-            return $this->buildInternalExtensionMethod($type, $funcName);
+                $internal = $this->buildInternalExtensionMethod($type, $funcName);
+                if ($internal !== null) {
+                    return $internal;
+                }
+            }
         }
 
         return null;
     }
 
     /**
-     * Look up a keyword extension method: function __snake_case in root namespace
-     * whose first parameter is mixed/any. Callable as $receiver->camelCase() on any type.
+     * Look up a keyword extension method using __snake_case or
+     * __lowerCamelCase in the root namespace. Snake case takes precedence.
      */
     protected function findKeywordExtensionMethod(string $method): ?array
     {
-        $snakeMethod = $this->camelToSnake($method);
-        $funcName = '__' . $snakeMethod;
-
+        foreach ($this->extensionFunctionCandidates('_', $method) as $funcName) {
             if (!$this->hasFunction($funcName)) {
-            return null;
+                continue;
             }
 
             $funcDef = $this->getFunction($funcName);
-
-        // Must be in root namespace
-        if ($funcDef->namespace !== '') {
-            return null;
-        }
-
-        // First param must be mixed/any (TYPE_VAR)
-        if (empty($funcDef->argInfoList)) {
-            return null;
+            if ($funcDef->namespace !== '' || empty($funcDef->argInfoList)) {
+                continue;
             }
             $firstParam = $funcDef->argInfoList[0];
             if ($firstParam->type !== CompilerBase::TYPE_VAR) {
-            return null;
+                continue;
             }
 
             $totalParams = count($funcDef->argInfoList);
             $minArgs = max(0, $funcDef->argCountRequired - 1);
-        $maxArgs = $totalParams - 1;
-        if ($funcDef->hasVariadicArg()) {
-            $maxArgs = -1;
-        }
+            $maxArgs = $funcDef->hasVariadicArg() ? -1 : $totalParams - 1;
 
             return [
                 'handler'      => 'php_fn',
@@ -474,6 +475,9 @@ 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/camel.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Keyword extension methods support lowerCamelCase function names
+--FILE--
+<?php
+
+declare(strict_types=1);
+use native_types;
+
+function __inspectValue(mixed $value, string $prefix): void
+{
+    echo $prefix, ':', $value, "\n";
+}
+
+function main(): void
+{
+    $value = 42;
+    $value->inspectValue('number');
+}
+?>
+--EXPECT--
+number:42

tests/aot/universal_method/universal_method_extension_camel.phpt

@@ -0,0 +1,28 @@
+--TEST--
+Universal extension methods support lowerCamelCase function names
+--FILE--
+<?php
+
+use native_types;
+
+function int_toBytes(int $value): string
+{
+    return ($value / 1024) . 'Kb';
+}
+
+function array_getFirstElement(array $value): mixed
+{
+    return $value[0];
+}
+
+function main(): void
+{
+    $size = 2048;
+    $values = [42, 43];
+    var_dump($size->toBytes());
+    var_dump($values->getFirstElement());
+}
+?>
+--EXPECT--
+string(3) "2Kb"
+int(42)