class TOnlyMovable {
public:
    TOnlyMovable() = default;
    TOnlyMovable(TOnlyMovable&&) {}
};

void foo(TOnlyMovable&& object) {
    TOnlyMovable m(object);
}


int main() {
    foo( TOnlyMovable() );
    return 0;
}

void foo(TOnlyMovable&& object) {
    TOnlyMovable m(std::move(object));
}

void foo(TOnlyMovable&& object) {
NI>>    TOnlyMovable m(std::move(object));
NI>>}

TOnlyMovable m(std::move(object))

TOnlyMovable m(object)

void foo(TOnlyMovable&& object) {
NI>>>    TOnlyMovable m(std::move(object));
NI>>>}

Even if the variable's type is rvalue reference, the expression consisting of its name is an lvalue expression

void foo(int&) { std::cout << "ref"; }

void foo(int&&) { std::cout << "rref"; }

int main() 
{
    int&& t = 1;
    foo(t);
    foo(1);
    return 0;
}

void foo(TOnlyMovable&& object) {
    TOnlyMovable m(std::move(object));
}

Named rvalue references are lvalues. Unnamed rvalue references are rvalues. This is important to understand why the std::move call is necessary in: foo&& r = foo(); foo f = std::move(r);

In general, the effect of this rule is that named rvalue references are treated as lvalues and unnamed rvalue
references to objects are treated as xvalues; rvalue references to functions are treated as lvalues whether
named or not.

void foo(TOnlyMovable&& object) {
NI>>    TOnlyMovable m(std::move(object));
NI>>}

An identifier is an id-expression provided it has been suitably declared (Clause 7). [ Note: for operator-function-ids, see 13.5; for conversion-function-ids, see 12.3.2; for literal-operator-ids, see 13.5.8; for templateids, see 14.2. A class-name or decltype-specifier prefixed by ~ denotes a destructor; see 12.4. Within the definition of a non-static member function, an identifier that names a non-static member is transformed to a class member access expression (9.3.1). —end note ] The type of the expression is the type of the identifier. The result is the entity denoted by the identifier. The result is an lvalue if the entity is a function, variable, or data member and a prvalue otherwise.

If an expression initially has the type “reference to T” (8.3.2, 8.5.3), the type is adjusted to T prior to any further analysis. The expression designates the object or function denoted by the reference, and the expression is an lvalue or an xvalue, depending on the expression.

If the postfix-expression designates a destructor (12.4), the type of the function call expression is void; otherwise, the type of the function call expression is the return type of the statically chosen function (i.e., ignoring the virtual keyword), even if the type of the function actually called is different. This return type shall be an object type, a reference type or cv void.

A function call is an lvalue if the result type is an lvalue reference type or an rvalue reference to function type, an xvalue if the result type is an rvalue reference to object type, and a prvalue otherwise.