Well in the custom framework, both of these work:

        if ($e instanceof Exception) {
            self::newMessage($e);
        }

        if ($e instanceof Throwable) {
            self::newThrowMessage($e);  // messages if throwable
        }

But the top one always works first, I think since Exception implements the Throwable interface, and that's direct from the php manual, I can just use the top block of code.

I commented one out then the other, both work the same.

Edit:

Tried two more things:

1

    public static function exceptionHandler($e)
    {
        if (!$e instanceof Exception || !$e instanceof Throwable) {
            self::newMessage('Exception occured');
        }
        if ($e instanceof Throwable) {
            self::newThrowMessage($e);
        } elseif ($e instanceof Exception) {
            self::newMessage($e);
        } else {
            self::newMessage('Whoops');
        }
        
    }

The Throwable gets called.

And since I am using instanceof I need at top:

use Throwable;
use Exception;

2 then tried:

    public static function exceptionHandler($e)
    {
       self::newMessage($e);
    }

No "use" statement needed.

This also works.

So I still don't understand the using of Throwable in laravel now, when both error and exception already implement the Throwable interface. PHP itself takes care of it.

But any thoughts on setting up custom error and exception handlers in php 7.4 will be appreciated.

As for why Laravel changed to use Throwable is due to changes in Symfony 5 that requires it.

For example Symfony's HtmlErrorRenderer render(...) method expects a Throwable instead of Exception

The change was justified in this PR comment: https://github.com/laravel/framework/pull/30610#issuecomment-555079640

As for error and exceptions handlers in php 7.4, i don't have any info about it, sorry.

@rodrigo.pedra thanks for that reply, and yes I've read that PR.

And in my custom handling both errors and exceptions, I have retested throwing multiple types of errors and exceptions at it, and they seem to work fine in PHP, including PHP 7.4.

Bottom line, when throwable is already extended by exception and error, I'm still confused on why symfony had to do that.

I believe they are targeting only a certain type of error, which could be caught as a catch all if they wanted.

I imagine they wanted it to be specific.

I even had an issue

https://github.com/laravel/framework/issues/31673

But laravel uses symfony components.

I found some explanation here:

https://www.php.net/manual/en/language.errors.php7.php

The interesting parts are:

1 -

Using catch(\Throwable $e) in a try...catch block can catch both Errors and Exceptions, which wasn't possible before in a single catch block.

I guess (just guess, his wording was very terse) that is what Graham meant in his comment on the issue you linked:

https://github.com/laravel/framework/issues/31673#issuecomment-593292875

2 -

Per what is stated on the link at the top, Errors are now caught by set_exception_handler

As with normal exceptions, these Error exceptions will bubble up until they reach the first matching catch block. If there are no matching blocks, then any default exception handler installed with set_exception_handler() will be called...

Which wasn't the behavior before (so both set_exception_handler and set_error_handler were needed)

So my understanding is that using Throwable allows a more generic approach on error/exception handling.

@rodrigo.pedra what I am basically trying to figure out now is if I do the following:

    public static function exceptionHandler(Throwable $e)
    {
        self::newMessage($e);
    }

Would that work for both errors and exceptions.

And how the setting would have to be changed

set_exception_handler('Mini\Core\Logger::ExceptionHandler');
    set_error_handler('Mini\Core\Logger::ErrorHandler');

In other words leave out set_error_handler, or would that still be needed.

I cannot find a good definitive guide on setting up this stuff in modern PHP 7.4.

The PHP manual still has a reference to both of these.

But my current error and exception Handler does work. Yet I wouldn't mind bringing it more up to date.

After some digging, I finally see how Taylor is doing this:

https://github.com/laravel/framework/blob/7.x/src/Illuminate/Foundation/Bootstrap/HandleExceptions.php#L66

All I had to do is change my exception handler to:

    public static function exceptionHandler(Throwable $e)
    {
        self::newThrowMessage($e);
    }

And change the error handler to:

    public static function errorHandler($severity, $message, $file, $line)
    {
        if (!(error_reporting() & $severity)) {
            // This error code is not included in error_reporting
            return;
        }
        throw new ErrorException($message, 0, $severity, $file, $line);
    }

An example from the php docs. But the original error handler will still work, but I decided to change it to keep the custom framework up to date.

So if anyone is dealing with custom code or framework, study the github link above.

In earlier versions of laravel he had Exception instead of Throwable.

Both still work, just had to do this because Symfony changes. I just didn't understand the changes at first.

But that function from the php manual solved every thing. https://www.php.net/manual/en/class.errorexception.php