; 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