template<typename ItemType>
inline
std::vector<ItemType>& push_back_helper( std::vector<ItemType> &v, const ItemType &elem )
{
    v.push_back(elem);
    return v;
}

inline
std::vector<int> makeVec( int i )
{
    return push_back_helper( std::vector<int>(), i );
}

int main()
{
    auto v = makeVec( 3 );
}

push_back_helper(std::vector<ItemType>&& v, const ItemType& elem)
                                      ^^

σ>push_back_helper(std::vector<ItemType>&& v, const ItemType& elem)
σ>                                      ^^
σ>

template<typename ItemType>
inline
std::vector<ItemType>&& push_back_helper( std::vector<ItemType> &&v, const ItemType &elem )
{
    v.push_back(elem);
    return std::move(v);
}

template <class T>
struct VectorInit : public std::vector<T>
 {
  template <class Func>
  VectorInit(Func func) { func((std::vector<T> &)*this); } 
 };

M>>template<typename ItemType>
M>>inline
M>>std::vector<ItemType>& push_back_helper( std::vector<ItemType> &v, const ItemType &elem )
M>>{
M>>    v.push_back(elem);
M>>    return v;
M>>}

M>>inline
M>>std::vector<int> makeVec( int i )
M>>{
M>>    return push_back_helper( std::vector<int>(), i );
M>>}

M>>int main()
M>>{
M>>    auto v = makeVec( 3 );
M>>}
M>>

template<typename ItemType>
inline std::vector<ItemType>& push_back_helper( std::vector<ItemType>&& v, const ItemType &elem )
{
    v.push_back(elem);
    return v;
}

inline
std::vector<int> makeVec( int i )
{
   return push_back_helper( std::vector<int>(), i );
}

M>>>template<typename ItemType>
M>>>inline
M>>>std::vector<ItemType>& push_back_helper( std::vector<ItemType> &v, const ItemType &elem )
M>>>{
M>>>    v.push_back(elem);
M>>>    return v;
M>>>}

M>>>inline
M>>>std::vector<int> makeVec( int i )
M>>>{
M>>>    return push_back_helper( std::vector<int>(), i );
M>>>}

M>>>int main()
M>>>{
M>>>    auto v = makeVec( 3 );
M>>>}
M>>>

inline
std::vector<int> makeVec( int i )
{
   std::vector<int> r;
   return push_back_helper(r, i );
}

BFE>template<typename ItemType>
BFE>inline std::vector<ItemType>& push_back_helper( std::vector<ItemType>&& v, const ItemType &elem )
BFE>{
BFE>    v.push_back(elem);
BFE>    return v;
BFE>}
BFE>

BFE>inline
BFE>std::vector<int> makeVec( int i )
BFE>{
BFE>   return push_back_helper( std::vector<int>(), i );
BFE>}
BFE>

auto&& v = push_back_helper( std::vector<int>(), i );

Ш>template<typename ItemType>
Ш>inline
Ш>std::vector<ItemType>&& push_back_helper( std::vector<ItemType> &&v, const ItemType &elem )
Ш>{
Ш>    v.push_back(elem);
Ш>    return std::move(v);
Ш>}
Ш>

template<typename ContainerT typename ItemT>
ContainerT push_back_helper(ContainerT&& v, ItemT&& item)
{
    v.push_back(std::forward<ItemT>(item));
    return std::forward<ContainerT>(v);
}

R>auto&& v = push_back_helper( std::vector<int>(), i );
R>

template<typename T>
T& test( T&&t)
{
    return t;
}

struct IntWrapper {
  IntWrapper(int x): x(x) {}
  ~IntWrapper() { x = 1; }
  int getX() { return x; }
  int x;
};

int main()
{
  auto&& i = test(IntWrapper(0));
  return i.getX();
}

; Function Attrs: noinline nounwind optnone uwtable
define linkonce_odr dso_local dereferenceable(32) %struct.IntWrapper* @"??$test@UIntWrapper@@@@YAAEAUIntWrapper@@$$QEAU0@@Z"(%struct.IntWrapper* dereferenceable(32) %0) #1 comdat {
  %2 = alloca %struct.IntWrapper*, align 8
  store %struct.IntWrapper* %0, %struct.IntWrapper** %2, align 8
  %3 = load %struct.IntWrapper*, %struct.IntWrapper** %2, align 8
  ret %struct.IntWrapper* %3
}

f(g())

tmp=g();
f(tmp);

using Int = int;
Int i = 42;
...
i.~Int();

  type& v = getrvalue();
  call(getrvalue(), ...);

 (6.9) — A temporary object bound to a reference parameter in a function call (7.6.1.2) persists until the
completion of the full-expression containing the call.

O>  type& v = getrvalue();
O>  call(getrvalue(), ...);
O>

Temporary objects are destroyed as the last step in evaluating the full-expression

 (6.9) — A temporary object bound to a reference parameter in a function call (7.6.1.2) persists until the
O>completion of the full-expression containing the call.

O>>  type& v = getrvalue();
O>>  call(getrvalue(), ...);
O>>

The word const was never present in this section. The rule has always been (from as long as I can remember) that a temporary used to initialize a reference has its lifetime extended to match that of the reference, regardless of the type of the reference.

 (6.9) — A temporary object bound to a reference parameter in a function call (7.6.1.2) persists until the
O>>completion of the full-expression containing the call.

BFE>Зачем нужна эта сентенция, если утверждение процитированное выше —

#include <iostream>

static int count__ = 0;

struct class_type {
    class_type() {
       ++count__;
    }
    
    class_type(class_type const& ) { ++count__; }
    ~class_type() { --count__; }
    
    void foo(class_type const&, class_type, class_type&) {
         std::cout << "objects: " << count__ << std::endl;
    }
};

int main()
{
    {
        class_type& c0 = class_type();
        c0.foo(class_type(), class_type(), class_type());
        {
            class_type& c1=class_type();
            c1.foo(class_type(), class_type(), class_type());
        }
        c0.foo(class_type(), class_type(), class_type());
    }
    std::cout << "objects: " << count__ << std::endl;
}

O>>>  type& v = getrvalue();
O>>>  call(getrvalue(), ...);
O>>>

  type& v = getrvalue();   // (1)
  call(getrvalue(), ...);  // (2)
  // вот тут у MS обект созданный в (1) продолжает жить, а объект созданный в (2) уже разрушен.

inline
std::vector<int> makeVec( int i )
{
  std::vector<int> ret;

  ret.push_back(i);

  return ret;
}

inline
std::vector<int> makeVec( int i )
{
    return push_back_helper( std::vector<int>(), i );
}

struct Vect
 {
  int val = 0 ;

  Vect() {}

  Vect(const Vect &obj) : val(obj.val) { Printf(Con,"copy\n"); }

  Vect(const Vect &&obj) : val(obj.val) { Printf(Con,"move\n"); }

  void push_back(int v) { val=v; }
 };

inline
Vect & push_back_helper( Vect &&v, int elem )
{
    v.push_back(elem);

    return v;
}

inline
Vect makeVec1( int i )
{
    Vect ret;

    ret.push_back(i);

    return ret;
}

inline
Vect makeVec2( int i )
{
    return push_back_helper(Vect(),i);
}

struct VectorInit : public Vect
 {
  template <class Func>
  VectorInit(Func func) { func((Vect &)*this); }
 };

/* Main() */

void Main()
 {
  {
   auto v = makeVec1( 3 );

   Printf(Con,"#;\n",v.val);
  }
  {
   auto v = makeVec2( 3 );

   Printf(Con,"#;\n",v.val);
  }
  {
   VectorInit v( [] (Vect &v) { v.push_back(3); } );

   Printf(Con,"#;\n",v.val);
  }
 }

3
copy
3
3