aot
/
compiler
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
- 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
pull/17/head
韩天峰 2 months ago
parent 995e223915
commit 30ebc309da
6 changed files with 161 additions and 105 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 179
      src/Parser/UniversalMethodCall.php
  2. 8
      tests/aot/keyword_extension/001.phpt
  3. 2
      tests/aot/universal_method/object_extension.phpt
  4. 65
      tests/aot/universal_method/object_extension_exact_name.phpt
  5. 4
      tests/aot/universal_method/universal_method_extension.phpt
  6. 8
      tests/aot/universal_method/universal_method_extension_chain.phpt

179
src/Parser/UniversalMethodCall.php
Unescape View File

@ -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 extensionFunctionCandidates(string $prefix, string $method): array
protected function findUserExtensionFunction(string $prefix, string $method, string $namespace = ''): ?array
{
return array_values(array_unique([
$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;
}
$definition = $this->getFunction($function);
if ($definition->namespace === $namespace) {
yield $function => $definition;
}
$function = $this->getNativeName($this->extensionFunctionName($prefix, $method), $namespace);
if (!$this->hasFunction($function)) {
return null;
}
$definition = $this->getFunction($function);
if ($definition->namespace !== $namespace) {
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;
* dynamic method names and StaticCall nodes deliberately do not use it.
* namespace. The class prefix and method suffix must match the declared
* 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,34 +425,36 @@ 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) {
if (empty($funcDef->argInfoList)) {
continue;
}
$receiver = $funcDef->argInfoList[0];
if ($receiver->byRef
|| $receiver->type !== Type::OBJECT
|| !$this->isSameClassName($receiver->declaredClass, $class)) {
continue;
}
$totalParams = count($funcDef->argInfoList);
return [
'handler' => 'object_extension_fn',
'fn' => $function,
'return_type' => $funcDef->returnType,
'min_args' => max(0, $funcDef->argCountRequired - 1),
'max_args' => $funcDef->hasVariadicArg() ? -1 : $totalParams - 1,
];
$extension = $this->findUserExtensionFunction($shortClass, $method, $namespace);
if ($extension === null) {
return null;
}
return null;
$function = $extension['name'];
$funcDef = $extension['definition'];
if (empty($funcDef->argInfoList)) {
return null;
}
$receiver = $funcDef->argInfoList[0];
if ($receiver->byRef
|| $receiver->type !== Type::OBJECT
|| !$this->isSameClassName($receiver->declaredClass, $class)) {
return null;
}
$totalParams = count($funcDef->argInfoList);
return [
'handler' => 'object_extension_fn',
'fn' => $function,
'return_type' => $funcDef->returnType,
'min_args' => max(0, $funcDef->argCountRequired - 1),
'max_args' => $funcDef->hasVariadicArg() ? -1 : $totalParams - 1,
];
}
/**
* Look up an extension function for the given type+method.
* Extension functions may use either {typePrefix}_{snake_case_method}
* or {typePrefix}_{lowerCamelCaseMethod}. Snake case takes precedence when
* both functions exist.
* Extension functions use the exact {typePrefix}_{method} spelling.
* Lookup remains case-insensitive according to PHP function semantics.
*
* Checks compiled user-defined functions first, then falls back to PHP internal
* functions using reflection to resolve parameter counts and return types.
@ -473,31 +466,27 @@ trait UniversalMethodCall
return null;
}
foreach ($this->extensionFunctionCandidates($prefix, $method) as $funcName) {
$resolvedName = $this->resolveExtensionFunctionName($funcName);
if ($resolvedName !== null) {
$funcDef = $this->getFunction($resolvedName);
if ($funcDef->namespace !== '') {
continue;
}
if (!$this->validateExtensionFirstParam($type, $funcDef)) {
continue;
}
return [
'handler' => 'php_fn',
'fn' => $resolvedName,
'receiver_pos' => 1,
'return_type' => $funcDef->returnType,
'min_args' => 0,
'max_args' => -1,
];
$funcName = $this->extensionFunctionName($prefix, $method);
$resolvedName = $this->resolveExtensionFunctionName($funcName);
if ($resolvedName !== null) {
$funcDef = $this->getFunction($resolvedName);
if ($funcDef->namespace !== '' || !$this->validateExtensionFirstParam($type, $funcDef)) {
return null;
}
return [
'handler' => 'php_fn',
'fn' => $resolvedName,
'receiver_pos' => 1,
'return_type' => $funcDef->returnType,
'min_args' => 0,
'max_args' => -1,
];
}
if ($this->isInternalFunction($funcName)) {
$internal = $this->buildInternalExtensionMethod($type, $funcName);
if ($internal !== null) {
return $internal;
}
if ($this->isInternalFunction($funcName)) {
$internal = $this->buildInternalExtensionMethod($type, $funcName);
if ($internal !== null) {
return $internal;
}
}
@ -505,35 +494,37 @@ trait UniversalMethodCall
}
/**
* Look up a keyword extension method using __snake_case or
* __lowerCamelCase in the root namespace. Snake case takes precedence.
* Look up a keyword extension method using the exact __{method} spelling
* in the root namespace. Lookup remains case-insensitive.
*/
protected function findKeywordExtensionMethod(string $method): ?array
{
foreach ($this->extensionFunctionDefinitions('_', $method) as $funcName => $funcDef) {
if (empty($funcDef->argInfoList)) {
continue;
}
$firstParam = $funcDef->argInfoList[0];
if ($firstParam->type !== Type::VAR) {
continue;
}
$totalParams = count($funcDef->argInfoList);
$minArgs = max(0, $funcDef->argCountRequired - 1);
$maxArgs = $funcDef->hasVariadicArg() ? -1 : $totalParams - 1;
return [
'handler' => 'php_fn',
'fn' => $funcName,
'receiver_pos' => 1,
'return_type' => $funcDef->returnType,
'min_args' => $minArgs,
'max_args' => $maxArgs,
];
$extension = $this->findUserExtensionFunction('_', $method);
if ($extension === null) {
return null;
}
$funcName = $extension['name'];
$funcDef = $extension['definition'];
if (empty($funcDef->argInfoList)) {
return null;
}
$firstParam = $funcDef->argInfoList[0];
if ($firstParam->type !== Type::VAR) {
return null;
}
return null;
$totalParams = count($funcDef->argInfoList);
$minArgs = max(0, $funcDef->argCountRequired - 1);
$maxArgs = $funcDef->hasVariadicArg() ? -1 : $totalParams - 1;
return [
'handler' => 'php_fn',
'fn' => $funcName,
'receiver_pos' => 1,
'return_type' => $funcDef->returnType,
'min_args' => $minArgs,
'max_args' => $maxArgs,
];
}
/**

8
tests/aot/keyword_extension/001.phpt
Unescape View File

@ -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--

2
tests/aot/universal_method/object_extension.phpt
Unescape View File

@ -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';
}

65
tests/aot/universal_method/object_extension_exact_name.phpt
Unescape View File

@ -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"

4
tests/aot/universal_method/universal_method_extension.phpt
Unescape View File

@ -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());

8
tests/aot/universal_method/universal_method_extension_chain.phpt
Unescape View File

@ -36,11 +36,11 @@ function array_last(array $arr): mixed {
function main()
{
$num = 2;
var_dump($num->toWords()->upper());
var_dump($num->toWords()->double()->upper());
var_dump($num->to_words()->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";
@ -52,4 +52,4 @@ string(3) "TWO"
string(6) "TWOTWO"
int(105)
int(10)
string(5) "world"
string(5) "world"

Write Preview
Loading…
Cancel
Save