Как ADL влияет на этот фрагмент кода C++?

В этом случае обычный поиск имени находит N2::foo, а N1::foo находит ADL, они оба добавляются в набор перегрузки, затем выполняется разрешение перегрузки и призыв неоднозначный.

Кстати: без using N2::foo; в main() ::foo будет найдено обычным поиском имени, а N1::foo также будет найдено ADL; в результате вызов все еще неоднозначен.

Обновлено:

Итак, вопрос здесь в том, почему ::foo не может вызываться foo(N1::S{}); в функции main?

Поскольку при использовании using N2::foo; имя N2::foo вводится в функцию main. При вызове foo имя N2::foo будет найдено в области видимости main, затем поиск имени остановится, дальнейшая область видимости (глобальное пространство имен) не будет проверяться, поэтому ::foo вообще не будет найдено и добавлено в набор перегрузки. В результате в обоих случаях вызывается N2::foo.

поиск имени проверяет области действия, как описано ниже, пока не найдет хотя бы одно объявление любого вида, после чего поиск останавливается и дальнейшие области не проверяются.

Кстати: если вы поместите using N2::foo; в глобальное пространство имен перед main, foo(N1::S{}); вызовет ::foo. И N2::foo, и ::foo находятся при поиске по имени, а ::foo выигрывает в разрешении перегрузки.

ПРЯМОЙ ЭФИР

Во-первых, у вас есть обычный поиск, который ищет из внутренних областей во внешние области и останавливается при первом совпадении, скрывая перегрузку из более поздних областей. Затем, когда активируется ADL, он добавит в поиск дополнительные связанные объекты и пространства имен.

Таким образом, в вашем случае поиск ADL ничего не добавляет к набору перегрузки.

#include <iostream>

namespace N1 {
  struct S {};
  /*
  void foo(S s) {
    std::cout << "called N1::foo, specific one." << '\n';
  }
  */
}
namespace N2 { 
  template<typename T>
  void foo(T) {
    std::cout << "called N2::foo, generic one." << '\n';
  }
}
void foo(N1::S s) {
  std::cout << "called foo." << '\n';
}
int main() {
  using N2::foo;
  foo(N1::S{}); // ordinary lookup finds N2 in main scope and stops.
                // adl lookup add N1 ns to the additionnal ns set but finds nothing
                // overload set = N2::foo by ordinary lookup
}

Теперь, если я раскомментирую вашу версию S1, она победит! Это то, что ты получаешь:

#include <iostream>

namespace N1 {
  struct S {};
  void foo(S s) {
    std::cout << "called N1::foo, specific one." << '\n';
  }
}
namespace N2 { 
  template<typename T>
  void foo(T) {
    std::cout << "called N2::foo, generic one." << '\n';
  }
}
void foo(N1::S s) {
  std::cout << "called foo." << '\n';
}
int main() {
  using N2::foo;
  foo(N1::S{}); // ordinary lookup finds N2 in main scope and stops
                // adl lookup add N1 ns to the additionnal ns set and finds N1::foo
                // overload set = N2::foo by ordinary lookup, N1::foo by ADL, N1::foo wins
}

Вы получаете то же самое с свопом. В данном случае используется Foo::swap, поскольку он находится в пространстве имен N1:

#include <iostream>

namespace N1 {
    struct Foo {

    };
    void swap(Foo& , Foo&) {
        std::cout << "swap Foo" << std::endl;
    }
}

namespace N2 {

struct S {
    N1::Foo f;
};

void swap(S& l,S& r) {
    using std::swap; // overload set is std::swap by ordinary lookup
    swap(l.f, r.f); // and Foo::swap by ADL, Foo::swap wins
}
}

int main() {
    N2::S s1,s2;
    swap(s1,s2);
}

Но если вы переместите специфичный для Foo своп в глобальный ns, то будет вызван std::swap:

#include <iostream>

namespace N1 {
    struct Foo {

    };
}

void swap(N1::Foo& , N1::Foo&) {
    std::cout << "swap Foo" << std::endl;
}

namespace N2 {

struct S {
    N1::Foo f;
};

void swap(S& l,S& r) {
    using std::swap; // overload set is std::swap by ordinary lookup
    swap(l.f, r.f); // because ADL does not add the global ns to the
                    // ns to be searched for
}
}

int main() {
    N2::S s1,s2;
    swap(s1,s2);
}