This does not only apply to PHP internal functions, this code has the same behavior:
Test scripts:

<?php declare(strict_types=1); namespace a; var_dump(
    call_user_func(function(string $test) {
        return $test;
    }, 5)
);

<?php declare(strict_types=1); var_dump(
    call_user_func(function(string $test) {
        return $test;
    }, 5)
);

However in this scenario the desired behavior is different. Since we have strict types on user code I assume we would always want an error, even in namespaces.

From the PHP manual[1]:

| Strict typing applies to function calls made from within the
| file with strict typing enabled, not to the functions declared
| within that file.

So the behavior of the non-namespaced code is correct, but the
namespaced code behaves erroneously.

[1] <http://php.net/manual/en/functions.arguments.php>

> So the behavior of the non-namespaced code is correct, but the namespaced code behaves erroneously.
That's backwards. The bug is as reported.

Function calls made from within PHP do not use strict typing. call_user_func("strlen") should work as if strlen is being called from within call_user_func's stack frame and thus not use strict typing, however c_u_f used when not in a namespace is optimized into the equivalent function call - the second script compiles into a literal strlen(1) call - which is why strict_types kicked in.

Optimization or not, it should work just like a userland implementation of

<?php
// declare(strict_types=0);
function call_user_func_userland($function, ...$args) {
  return $function(...$args);
}
?>

> That's backwards. The bug is as reported.

I stand corrected.  Thanks!