I've been working on improving trivial relocation proposals and I think I've found a new tool in a language we don't use

About relocation:

There are few possibilities to create move ctor:
1. trivial memcpy
2. exchange with default state
3. self reference scenario
4. do not have move ctor at all
We already have = default, which is may be deducted as 'trivially movable', but we dont have 2 scenario in standard

So i propose
struct Type {
    Type(Type&&) = swap;
    Type& operator=(Type&&) = swap;
Which will default construct Type and then adl swap all fields and bases.(or swap with right operand for operator=)
So compiler will have ability to proove +- ALL not self reference scenarios, then we can add trait
(traits checks if T has field or base class with non 'swap'/'default' move recursivelly)
This solution that will improve the old code without changes, reduce the number of boilerplate and make the code more expressive.


What if we add trait is_trivially_destructible_after_move?
You can ask - how?

It's simple, almost all types have a constexpr default constructor and destructor, even std::any.
So let the compiler create a type value, then destroy it at compilation and find out if this code had any side effects!
In this case, if 'if consteval' or 'is_constant_evaluated' is used, then both branches are checked
(if you are asking why you think type is default constructed after move - it is deductible with 'swap' or 'default' moves)