This causes a serious problem when you try something like this:

<?PHP class Insecure {}
(
   function ( stdClass $Object = null )
   {
      # Some stuff only for `stdClass` inheritants...
      return $Object;
   }
) ( new Insecure );

PHP does not have an implicit base class like C#'s System.Object or Java's java.lang.Object. stdClass is just a built-in, empty class.

If you want to know whether something is an object then use is_object().

requinix@php.net

You missed my comment right after publishing.. All classes defined without the `extends` expression should be implied as an extension of `stdClass`.

The following code should produce no error, but it does:
<?PHP class UserLand {}

$f = function ( stdClass $Object = null )
{
   # I want any object here that is not built-in classes like those: Closure, Exception, PDO, etc...
}

$f(new UserLand); // Doesn't work as of `UserLand` do not explicit extends `stdClass`.

// So it should be reasonable to UserLand pass an `instanceof` test against `stdClass`.

?>

Should I change this to "Feature/Change Request" instead?

> All classes defined without the `extends` expression should be implied as an
> extension of `stdClass`.
That only works if stdClass is an implied base class. It is not. UserLand and stdClass are completely and entirely unrelated classes; they have as much in common as UserLand and SplFileInfo do.

If you want this as a feature request, that's fine, but a change like this would probably require an RFC. https://wiki.php.net/rfc/howto

And I still don't understand why you can't just use is_object().

Probably I'll do this RFC.

Ahh.. I can't use is_object() to typecast a parameter like this:

function ( is_object($Param) )
{
}

Also, I can't use something like this:

function ( Object $Param )
{
}

Or this:

function ( object $Param )
{
}

I only can typecast objects that I explicit know the class or one of its interface names, like:

function ( UserLand $Object = null ) : UserLand
{
   return $Object;
}

Also, if you just typecast any other kind of value to an object, a stdClass object will be created. Looking at this behaviour, it just make sense that any user defined class should be a stdClass extension if ommited.

The stdClass is not used by other built-in classes. Also it has no properties or methods, having only the magic methods defined by core that does nothing. As you said, it's an empty class. So any new class should come from this empty class if not specified an ancestor. This should permit correctly test an Object to see if it is a Standard Class (stdClass) or not. Closures, Exceptions and other non-standard classes have core limitations: like the prohibition of assigning a property to a closure object. I don't want this kind of object passed as parameter, only stdClass compatible. But classes that do not explicit it will fail parameter typecasting unless I know the class name.