It's called "exception chaining": How to implement exception chaining in PHP

Only really useful if you need to do something specific when the exception is thrown. There's a slight performance cost to catching and throwing exceptions, so you generally only do it if you really have to

Why would it not make sense? Isn't throwing an exception the whole purpose of try block?

As you wrote "It does not make sense, as the first exception message is not used at all, only the second one. That's the problem.", something with your code seems to be incorrect.
So while this topic might be interesting generally for discussions, to solve your specific problem you should create additionally a question related to your distinct code problem perhaps.

See https://stackoverflow.com/a/2606074/22873487 and what @Olivier added to the discussion: https://stackoverflow.com/collectives/php/beta/discussions/77811015/77811129

Context is important with these things. Yes there are some cases where it does make sense e.g. you want to catch an exception and wrap it in a different exception that you have implemented specific behaviour. The 3rd parameter of the exception constructor is there for this exact use case. Now when it actually makes sense is another story.

In my mind I see the Symfony HttpException class as a good example where you can catch one exception and then wrap it in an HttpException of a given status and let your exception handler return the appropriate response code to the client. When this exception is logged it should ideally include the wrapped exception as well.

I'm sure there's more potential valid use cases but again, context is very important .

Taken as the code is, it does not make sense. The simple reason is that the visible outcome is only caused by the second throw .. statement, the rest could be stripped.

However, I'm halfway sure this is not what you really wanted to ask or it is not really representative for the real code that prompted the question.

Correct me if I'm wrong, but isn't that's the reason why there's a stack trace ?

It makes no sense to throw an exception in the catch block. You would rather have a long list of different types of exceptions to catch for efficiency.

Doesn't make sense since php 7.1. Multiple catches allow you to catch different classes of exceptions.

It's not ideal, but you can still do it. There is no defined rule for it.

First, this code does not make sense because the first exception does not print the message. But, the first exception will be thrown, and the catch block executes.

If you want to print the message of the first exception, you can add $e->getMessage().

But, your code does make sense in some situations.

try {
    $result = 0/0;
} catch(Exception $e) {
    // echo $e->getMessage();
    throw new Exception('The second exception...');
}

This code will throw an exception in the try block. It will be caught by the catch block. And you can throw a custom exception, other than printing the default exception. This code is also the same as your code.

One of the use cases when this might make sense is when the first exception might contain sensitive data that you don't want to get displayed or written in plain text log.

In case like that you catch the exception that might contain sensitive data and throw new exception that describe the problem without revealing sensitive data.

In short: That code, as is, makes no sense at all - no ifs or buts.

Long point: as Olivier mentions, it almost looks like exception chaining (which is a quite normal thing to do).

Proper chaining requires throwing a new exception with the old exception as the previous one. For example: throw new \Exception('Second exception...', 0, $e) (notice the $e).

Additionally, typically you would rethrow as a more specific exception, to be more useful.

And finally, also consider if you really need to catch all \Exception's. In your current case, it is clearly not needed.

Yes, the code makes sense in the context of exception handling in PHP. It demonstrates a scenario where an exception is explicitly thrown inside a try block, which is then caught by the catch block. The catch block itself throws a new exception.

This pattern can be useful in a situation where you want to transform or reclassify an exception. For instance, you might catch a generic exception and then throw a more specific exception type that is more meaningful for the surrounding code or the application's error handling strategy.

However, it's important to note that this approach will lose the original exception's stack trace unless it's explicitly preserved or logged. This could potentially make debugging more challenging.

Technically, there is nothing wrong with that.

Semantically, you also need it, but it can involve quite subtle considerations.

Here is the idea: catch should be used rarely and placed only in some strategic points in the scope that I usually call the scope of competency.

I'll explain: the point of throwing the exception can be placed in an agnostic level of the code, for example, general I/O. Sometimes, you need to catch the exception on the same or another agnostic level, say, adjust some data, or recover from something. But the issue remains unresolved, and you need to delegate further exception processing up the stack. And next catch point may come at some semantic layer.

In that layer, a technical, say, I/O exception will be not informative enough. Let's jump to the very top of the stack: the exception exposed to the final user. This user has no idea of the existence of some stream or file, that person needs to find out what it means semantically. To achieve that, you need to catch an exception in some intermediate level that knows the consequences of the exception in some semantic sense, known by the user. To achieve that, this semantic layer catches the abstract-layer exception and throws another exception, defined in a semantic layer. In principle, the original exception can be packed in a new exception instance as an internal exception but this is not the rule. The point is that the presence of those competency points requires the developers to throw an exception of a more semantic type.

It can make sense if you need to catch, manipulate, in short work on an exception that might be thrown by a library or some third-party code (that you can't or don't want to modify).

Suppose \ExternalObject::something() can throw exceptions \AlphaException or \BetaException.

I use \ExternalObject::something(), but I don't particularly care about the distinction between the various exceptions OR I want to throw my own \MyCustomException, for whatever reason.

So:

try {
    \ExternalObject::something()
} catch (\AlphaException|\BetaException $e) {
    throw new \MyCustomException(sprintf('Thrown know exception `%s` with message: `%s`', $e::class, $e->getMessage()));
} catch (\Exception) {
    throw new \MyCustomException(sprintf('Thrown unknown exception `%s` with message: `%s`', $e::class, $e->getMessage()));
}

(I haven't checked the code for accuracy, but that's the gist of it)