Явные функции преобразования, прямая инициализация и конструкторы преобразования

Нестандартный черновик n3376 имеет в качестве примера (12.3.2: 2) использование функции явного преобразования в определяемый пользователем тип:

class Y { };
struct Z {
explicit operator Y() const;
};
void h(Z z) {
Y y1(z); // OK: direct-initialization
}

Согласно 12.3.2: 2, явная функция преобразования:рассматривается только как пользовательское преобразование для прямой инициализации«; однако, это могло бы позволить:

struct Y { Y(int); };
struct Z {
explicit operator int() const;
};
void h(Z z) {
Y y1(z); // direct-initialization
}

который, кажется, вступает в противоречие с целью стандарта, и действительно отклоняется gcc-4.7.1:

source.cpp: In function 'void h(Z)':
source.cpp:4:9: error: no matching function for call to 'Y::Y(Z&)'
source.cpp:4:9: note: candidates are:
source.cpp:1:12: note: Y::Y(int)
source.cpp:1:12: note:   no known conversion for argument 1 from 'Z' to 'int'
source.cpp:1:8: note: constexpr Y::Y(const Y&)
source.cpp:1:8: note:   no known conversion for argument 1 from 'Z' to 'const Y&'
source.cpp:1:8: note: constexpr Y::Y(Y&&)
source.cpp:1:8: note:   no known conversion for argument 1 from 'Z' to 'Y&&'

Правильно ли gcc отклонить преобразование из Z в Y с помощью intили стандарт действительно разрешает такое использование?

Я рассмотрел контекст упомянутого прямая инициализация; согласно определению прямой инициализации для типа класса в 8.5: 16, конструктор вызывается с выражением инициализатора в качестве аргументов, которые поэтому преобразуются в тип параметра с помощью неявной последовательности преобразования (13.3.3.1). Поскольку последовательность неявного преобразования является неявным преобразованием (4: 3) и, таким образом, моделирует инициализацию копирования (8.5: 14), а не прямую инициализацию, язык в 12.3.2: 2 должен ссылаться на выражение в целом.

Также обратите внимание, что это не является нарушением 12.3: 4 (несколько пользовательских преобразований); тот же компилятор доволен тем же кодом с explicit удалены (как Clang и Comeau):

struct Y { Y(int); };
struct Z { operator int(); };
void h(Z z) {
Y y1(z); // direct-initialization
}

Я думаю, что Джесси Гуд определил различие между operator Y а также operator int случаи в 13.3.1.4:1, но есть третий случай, который меня все еще касается:

struct X {};
struct Y { Y(const X &); };
struct Z {
explicit operator X() const;
};
void h(Z z) {
Y y1(z); // direct-initialization via class-type X
}

Инициализация временного X быть связанным с единственным const X & параметр конструктора Y продолжается в контексте прямой инициализации в соответствии с 13.3.1.4:1, с T как X а также S как Z, Я думаю, что этот пункт неверен и должен читать:

13.3.1.4 Инициализация копии класса с помощью пользовательского преобразования [over.match.copy]

1 — […] При инициализации временной привязки к первому параметру
конструктора, который принимает ссылку на возможно резюме-квалифицированный T в качестве первого аргумента, вызывается с одним аргументом в контексте прямой инициализации объекта типа «cv2 T«, явные функции преобразования также рассматриваются. […]

Во избежание путаницы, я думаю, что 12.3.2: 2 также следует изменить:

12.3.2 Функции преобразования [class.conv.fct]

2 — Функция преобразования может быть явной (7.1.2), и в этом случае она рассматривается только как пользовательское преобразование для прямой инициализации (8.5) в определенных контекстах (13.3.1.4, 13.3.1.5, 13.3.1.6). […]

Любые комментарии по поводу выше?