Вывод типа для нежизнеспособных шаблонов функций

В его ответ в этот вопрос и раздел комментариев, Йоханнес Шауб говорит, что есть «ошибка совпадения» при попытке сделать вывод типа шаблона для шаблона функции, который требует больше аргументов, чем было передано:

template<class T>
void foo(T, int);

foo(42); // the template specialization foo<int>(int, int) is not viable

В контексте другого вопроса важно то, успешно ли выполняется вывод типа для шаблона функции (и происходит ли подстановка):

template<class T>
struct has_no_nested_type {};

// I think you need some specialization for which the following class template
// `non_immediate_context` can be instantiated, otherwise the program is
// ill-formed, NDR
template<>
struct has_no_nested_type<double>
{ using type = double; };

// make the error appear NOT in the immediate context
template<class T>
struct non_immediate_context
{
using type = typename has_no_nested_type<T>::type;
};template<class T>
typename non_immediate_context<T>::type
foo(T, int) { return {}; }

template<class T>
bool foo(T) { return {}; }int main()
{
foo(42);      // well-formed? clang++3.5 and g++4.8.2 accept it
foo<int>(42); // well-formed? clang++3.5 accepts it, but not g++4.8.2
}

При создании первого шаблона функции foo за T == int, замена производит недопустимый тип не в непосредственном контексте foo, Это приводит к серьезной ошибке (вот что связанный вопрос около.)

Однако при сдаче foo вывести его шаблон-аргумент, g ++ и clang ++ соглашаются, что создание экземпляров не происходит. Как Йоханнес Шауб объясняет, это потому, что есть «ошибка совпадения».

Вопрос: Что такое «ошибка соответствия», и где и как она указана в Стандарте?

Альтернативный вопрос: почему есть разница между foo(42) а также foo<int>(42) для g ++?

---

Что я нашел / попробовал до сих пор:

[over.match.funcs] / 7 и [temp.over] описывают особенности разрешения перегрузки для шаблонов функций. Последние, кажется, требуют замены параметров шаблона для foo,

Интересно, что [over.match.funcs] / 7 запускает процесс, описанный в [temp.over] до проверка жизнеспособности шаблона функции (специализация).
Точно так же вычитание типа не учитывает, скажем, аргументы функции по умолчанию (кроме того, что делает их не выводимым контекстом). Насколько я могу судить, это не касается жизнеспособности.

Другим, возможно, важным аспектом является способ определения типа вывода. Он действует на параметры одной функции, но я не вижу, где проводится различие между типами параметров, которые содержат / зависят от параметров шаблона (например, T const&) и те, которые не (как int).

Тем не менее, g ++ делает различие между явным указанием параметра шаблона (серьезная ошибка) и разрешением их вывода (ошибка вывода / SFINAE). Зачем?