It seems we also should give that restriction to lambda-expression

[]()->A&{
  /*....*/
};

In this example, the return type is a reference type. Anyway, I think we could uniformly restrict the return type to be an object type in this bullet. Since the return type of a coroutine is always an object type as per [coroutine.traits.primary#1]. In both the function that is non-coroutine and a lambda-expression, they all should be restricted for their return type.

If the expression in a return ([stmt.return]) or co_­return ([stmt.return.coroutine]) statement is a (possibly parenthesized) id-expression that names an implicitly movable entity declared in the body or parameter-declaration-clause of the innermost enclosing function or lambda-expression whose return type shall be (possibly cv-qualified) class type.

If the first overload resolution fails or was not performed

It seems the overload resolution always performs even though the candidate set is empty.

The first overload resolution is not performed if we don't have an implicitly movable entity to start with.

According to the whole rule, it is based on we do have an implicitly movable entity. Since it says as if the expression or operand were an rvalue. Since we have such a expression or operand, the overload resolution definitely performs.

No.

p1 talks about copy/move elision, which is totally different.

p3 talks about trying a move under certain circumstances; p3 starts with the definition of implicitly movable entity. Then, it says "In the following situations, a move is considered before attempting a copy". If e.g. the "return" is returning a global variable, this is not one of those situations, and we never try a move. We always try a copy, though.

Reworded to cover both functions and lambda-expressions.

If we phrase it as the following, it seems more clear

if the expression or operand is an implicitly movable entity, overload resolution to select the constructor for the copy or the return_­value overload to call is first performed as if the expression or operand were an rvalue. Otherwise, or if the overload resolution fails, overload resolution is performed again, considering the expression or operand as an lvalue.