¿Está bien definir una función swap() totalmente general?

El problema es la implementación de libstdc++de unique_ptr. Esto es de su rama 4.9.2:

Https://gcc.gnu.org/onlinedocs/gcc-4.9.2/libstdc++/api/a01298_source.html#l00339

  338       void
  339       reset(pointer __p = pointer()) noexcept
  340       {
  341     using std::swap;
  342     swap(std::get<0>(_M_t), __p);
  343     if (__p != pointer())
  344       get_deleter()(__p);
  345       }

Como puede ver, hay una llamada swap no calificada. Ahora veamos la implementación de libcxx (libc++):

Https://git.io/vKzhF

_LIBCPP_INLINE_VISIBILITY void reset(pointer __p = pointer()) _NOEXCEPT
{
    pointer __tmp = __ptr_.first();
    __ptr_.first() = __p;
    if (__tmp)
        __ptr_.second()(__tmp);
}

_LIBCPP_INLINE_VISIBILITY void swap(unique_ptr& __u) _NOEXCEPT
    {__ptr_.swap(__u.__ptr_);}

No llaman swap dentro de reset ni usan una llamada swap no calificada.

Dyp's answer proporciona un desglose bastante sólido sobre por qué libstdc++ se está conformando, pero también por qué su código se romperá cada vez que swap sea requerido para ser llamado por la biblioteca estándar. Para citar TemplateRex:

No debería tener ninguna razón para definir tal plantilla general swap en un espacio de nombres muy específico que contiene solo tipos específicos. Sólo define una sobrecarga no-plantilla swap para foo::bar. Dejar el intercambio general a std::swap, y solo proporcionan sobrecargas específicas. fuente

Como ejemplo, esto no compilará:

std::vector<foo::bar> v;
std::vector<foo::bar>().swap(v);

Si estás apuntando a una plataforma con una antigua biblioteca estándar/GCC (como CentOS), te recomendaría usar Boost en lugar de reinventar la rueda para evitar errores como este.

Esta técnica se puede utilizar para evitar foo::swap() ser encontrado por ADL:

namespace foo
{
    namespace adl_barrier
    {
        template <typename T>
        void swap(T& a, T& b)
        {
            T tmp = std::move(a);
            a = std::move(b);
            b = std::move(tmp);
        }
    }

    using namespace adl_barrier;
}

Así es como Boost.La gama es independiente begin()/end() las funciones están definidas. Probé algo similar antes de hacer la pregunta, pero lo hice using adl_barrier::swap; en su lugar, lo cual no funciona.

En cuanto a si el fragmento de código en la pregunta debería funcionar tal cual, no estoy seguro. Una complicación que puedo ver es que unique_ptr puede tener tipos personalizados pointer del Deleter, que deben intercambiarse con el idioma habitual using std::swap; swap(a, b);. Que el modismo está claramente roto para foo::bar* en la pregunta.