Callabes - How to have rename safety? - php

Question

Is there any way to use callables in PHP that won't break if you rename the underlying function (or the class, or namespace for that matter)? I find it incredibly irksome to rely on string search renaming and constant vigilance to make sure that renaming a function doesn't result in an undefined function error.
What I really want is something like C#'s nameof operator (why the hell isn't this in PHP already??), but I'm open to any solution that offers safety without impacting performance or torturing PHP. The solution being "IDE-friendly", as in static analysis friendly, is a plus, but not required.
So far I've identified a few ways of improving the situation, but all have tradeoffs:
1. Using ClassName::class
Pros:
Class can be safely renamed.
Namespace can be safely renamed.
Cons:
Function still can't be safely renamed and relies on string searching.
This doesn't solve the underlying problem, but now at least the class and namespace can be safely renamed. The only tradeoff is that it makes it harder for an IDE to figure out who this function belongs to.
namespace NS1;
class ClassOrigin {
public static function foobar() {
//...
}
}
namespace NS2;
class ClassUser {
private static function callable_user() {
$pre = "\\" . \NS1\ClassOrigin::class . "::";
$callable = $pre . 'foobar';
// ... Do stuff with the callable
}
}
2. Using variable functions
Pros:
Perfectly safe.
Cons:
Variable functions are not the same as a function. They're semantically fundamentally different and can for example be reassigned, which can be catastrophic.
Function declarations are considered expressions and cannot be assigned as a default value to a class member. This means the class needs to be initialized or needs to have a constructor. Both are undesirable when really you just want to be dealing with static functions.
namespace NS1;
class ClassOrigin {
public static $foobar;
public static function Init() {
self::$foobar = function() {
// ...
};
}
}
namespace NS2;
class ClassUser {
private static function callable_user() {
$callable = \NS1\ClassOrigin::$foobar;
// ... Do stuff with the callable
}
}
3. Using a helper function to get the function name
Pros:
Perfectly safe as long as the two functions are kept in sync.
Cons:
Needs two functions to be maintained.
This kind of convention is weird and would make some coders go "?". There are alternative conventions and possibly ways to automate the adding of the _callable() function, but it's still just pretty hacky.
namespace NS1;
class ClassOrigin {
public static function foobar_callable() {
$funcname_callable = __CLASS__ . "::" . __FUNCTION__;
$funcname = preg_replace("/_callable$/", "", $funcname_callable);
return new $funcname;
}
public static function foobar() {
//...
}
}
namespace NS2;
class ClassUser {
private static function callable_user() {
$callable = \NS1\ClassOrigin::foobar_callable();
// ... Do stuff with the callable
}
}
4. Using a parameter to conditionally return function name
Pros:
Perfectly safe.
Cons:
Pollutes the parameter list.
namespace NS1;
class ClassOrigin {
public static function foobar($return_callable = false) {
if ($return_callable) {
return __CLASS__ . "::" . __FUNCTION__;
}
else {
//...
}
}
}
namespace NS2;
class ClassUser {
private static function callable_user() {
$callable = \NS1\ClassOrigin::foobar(true);
// ... Do stuff with the callable
}
}
Other methods I've considered:
Using debug methods to get the function name. Seems like an abuse of debug functionality and probably bound to be slow, not sure if it even works out in the end.
Using the reflection library. Doesn't seem to offer a way to get the function name that isn't equally as vulnerable as just using a string directly.
Dynamically add the functions to the class and name them off of constants, thus ensuring the callables never break on rename. This is awful for too many reasons to count.
If anyone has a better idea or if I've missed some PHP functionality that could help with this, I'd love to hear it. I'm using PHPStorm and it doesn't seem like it's been able to statically determine that a string is a callable and factor that into renaming operations.