C++ 为什么可以'；GCC使用正确的类型解析此声明

在我从事的一个项目中编写代码时，我发现了一些非常奇怪的事情：

namespace detail {

    struct tuplelike_tag { };
    struct arraylike_tag { };

    template<typename>
    struct call_with_traits;

    template<typename... Ts>
    struct call_with_traits<std::tuple<Ts...>> {
        using tag = tuplelike_tag;

        enum { size = sizeof...(Ts) };
    };

    template<typename T, std::size_t Sz>
    struct call_with_traits<std::array<T, Sz>> {
        using tag = arraylike_tag;

        enum { size = Sz };
    };

    template<typename T, std::size_t Sz>
    struct call_with_traits<T[Sz]> {
        using tag = arraylike_tag;

        enum { size = Sz };
    };

    template<typename F, typename T, int... Is>
    auto call_with(F && f, T && tup, indices<Is...>, tuplelike_tag) -> ResultOf<Unqualified<F>> {
        return (std::forward<F>(f))(std::get<Is>(std::forward<T>(tup))...);
    }

    template<typename F, typename A, int... Is>
    auto call_with(F && f, A && arr, indices<Is...>, arraylike_tag) -> ResultOf<Unqualified<F>> {
        return (std::forward<F>(f))(std::forward<A>(arr)[Is]...);
    }
}

template<typename F, typename Cont>
inline auto call_with(F && f, Cont && cont) -> ResultOf<Unqualified<F>> {
    using unqualified = Unqualified<Cont>;
    using traits  = typename detail::call_with_traits<unqualified>;
    using tag     = typename detail::call_with_traits<unqualified>::tag;
    using no_tag  = typename traits::tag;   // this is what it's all about
    return detail::call_with(std::forward<F>(f), std::forward<Cont>(cont), build_indices<traits::size>(), tag());
}

名称空间详细信息{
结构tuplelike_标记{}；
结构arraylike_标记{}；
模板
结构调用具有_特征的_；
模板
结构调用带有_特征的{
使用tag=tuplelike_标记；
枚举{size=sizeof…（Ts）}；
};
模板
结构调用带有_特征的{
使用tag=arraylike_标记；
枚举{size=Sz}；
};
模板
结构调用带有_特征的{
使用tag=arraylike_标记；
枚举{size=Sz}；
};
模板
使用（F&&F，T&&tup，index，tuplelike_标记）自动调用\>ResultOf{
返回（std:：forward（f））（std:：get（std:：forward（tup））…）；
}
模板
使用（F&&F，A&&arr，索引，arraylike_标记）->ResultOf自动调用_{
return（std:：forward（f））（std:：forward，包括来自GCC的相关错误消息。
这似乎是g++4.7.2中的一个错误。下面是一个简单的示例：

template<typename> struct A { using tag = int; };

template<typename T>
inline void f() {
  using AT = A<T>;
  typename A<T>::tag x; // no error
  typename   AT::tag y; // error
}

int main(int argc, char ** argv) {
  f<int>();

  return 0;
}

模板结构A{using tag=int；}；
模板
内联void f（）{
使用AT=A；
typename A:：tag x；//无错误
typename AT:：tag y；//错误
}
int main（int argc，字符**argv）{
f（）；
返回0；
}

如果使用
typedef
而不是
使用
声明，或者使用
a
而不是
a
，则不会出现错误，我会说这是一个bug。在GCC 4.8.0和Clang 3.2上编译良好，我已经建议这样做，但感谢您的验证。现在，我将使用FQN引用它o所讨论的类型，因为我的机器上只安装了GCC 4.7.2。
template<typename> struct A { using tag = int; };

template<typename T>
inline void f() {
  using AT = A<T>;
  typename A<T>::tag x; // no error
  typename   AT::tag y; // error
}

int main(int argc, char ** argv) {
  f<int>();

  return 0;
}