The Mystery of "Broken" Two-Phase Template Instantiation in Microsoft Visual C++

Problem Statement:

Users commonly express concerns that Microsoft Visual C++ (MSVC) struggles with correctly implementing two-phase template instantiation. What specific aspects of the mechanism fail to operate as expected?

Background:

Two-phase template instantiation involves an initial syntax check that MSVC reportedly performs. However, doubts arise regarding whether this check verifies whether names utilized within templates are appropriately declared.

Explanation:

Indeed, MSVC's initial syntax check is limited in scope. It fails to check for the presence of declared names, leading to compilation issues when names lack proper declarations.

To illustrate this, consider the following example:

int foo(void*);

template<typename T> struct S {
  S() { int i = foo(0); }
};

void foo(int);

int main() {
  S<int> s;
}

A standard-compliant compiler would resolve the foo(0) call during the first phase and bind it to foo(void*). However, MSVC postpones this process to the second phase, incorrectly binding foo(0) to foo(int) and resulting in an error.

Moreover, MSVC's implementation of the second phase deviates from the language specification in two ways:

1. It extends the non-ADL lookup with declarations accumulated during the second phase.
2. It incorrectly resolves dependent expressions, such as bar(t) in the code below, to declarations that are only visible during the second phase.

namespace N {
  struct S {};
}

void bar(void *) {}

template <typename T> void foo(T *t) {
  bar(t);
}

void bar(N::S *s) {}

int main() {
  N::S s;
  foo(&s);
}

In both cases, MSVC's behavior contravenes the specified separation between the first and second phases of template instantiation. This incorrect implementation persists in Visual Studio 2015.