Suggestion for rule about function try blocks of constructors/destructors

I have a suggestion for an additional rule regarding function try blocks for constructors/destructors. As [except.handling]/14 [1] states that if control flow reaches the end of a handler of a constructor’s/destructor’s function try block, the handled exception is rethrown. To me (and I think for others it might be too) this case is surprising and therefore I suggest to always state this behavior explicitly (at least in the case mentioned), i.e. insert a throw; or return statement at the end of all handlers of constructor’s/destructor’s function try block. I'm curious whether others consider this as an issue too.

[1] http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4741.pdf

Possible rule:

E.XX: Explicitly throw at end of constructor’s/destructor’s function try block

Reason:

If controlflow reaches the end of a constructor's/destructor’s handler of a function try block the handled exception will be implicitly rethrown. The behavior is different in any other catch handler. Therefore, the desired behavior should be stated explicitly in this case.

Example, bad:

struct Resource {
    Resource() noexcept(false) try
    {
        allocationThatMightThrow();
    }
    catch (const AllocationException & e)
    {
        doSomeCleanup(e);
    }
};

Example:

struct Resource {
    Resource() noexcept(false) try
    {
        allocationThatMightThrow();
    }
    catch (const AllocationException& e)
    {
        doSomeCleanup(e);
        throw;
    }
};

Enforcement:

Flag catch handlers of a constructor’s function try block without explicit throw statement. Flag catch handlers of a destructor’s function try block without explicit return or throw statement.