Disambiguator template keyword for a template member of a template: when exactly?

Question

A question regarding template disambiguator was given here:

template disambiguator

and in the answer we can read:

ISO C++03 14.2/4

Answer 1

BaseType does depend on the type T- but so does InnerB. In effect, from the perspective of any code inside BaseType<T>, it does not depend on T.

Answer 2

They implement the C++0x specification, where Base is the current instantiation. And C++0x allows to omit template keyword in such a case. Since BaseType is a typedef for Base, when you say BaseType, that names the current instantiation too.

To quote the spec, since you seem to be interested in spec refs

A name is a member of the current instantiation if it is [...]

• A qualified-id in which the nested-name-specifier refers to the current instantiation and that, when looked up, refers to at least one member of the current instantiation or a non-dependent base class thereof.

and

A name refers to the current instantiation if it is [...]

• in the definition of a [...] nested class of a class template, [...], the injected-class-name (Clause 9) of the class template or nested class

and (the modified 14.2/4 that you quoted)

[...] or the nested-name-specifier in the qualified-id refers to a dependent type, but the name is not a member of the current instantiation (14.6.2.1), the member template name must be prefixed by the keyword template. [...]

---

Note: In C++03 your code is ill-formed because both BaseType and OtherType are dependent. The spec says:

A type is dependent if it is [...]

• a template parameter
• a qualified-id with a nested-name-specifier which contains a class-name that names a dependent type
• a template-id in which either the template name is a template parameter or any of the template arguments is a dependent type

(note that Base is equivalent to Base<T>, which is the base on which Base and BaseType::InnerA are dependent types).

Note that "explicitly depends" in your quote is a pre-standard term, and was gotten rid of fairly lately (I believe it was at December1996). It basically meant (in this context) a qualified-id in which the qualifier is dependent or a class member access (a->x / a.x) where the a was dependent. After "explicitly depends" was removed from the draft, it was still lurking around at some places, and even C++0x has still references to "explicitly depends" in a note at 14.6.2p2:

the base class name B<T>, the type name T::A, the names B<T>::i and pb->j explicitly depend on the template-parameter.

Answer 3

Because OtherType is a nested dependent name while BaseType is not a nested type to begin with.

You need to use template for nested dependent types.

The keywords here are:

• Dependent Type
• Nested Type

If a type is both, then you've to use template.

• OtherType is both dependent type (it depends on T) as well as nested type
• BaseType is only dependent type (it depends on T). Its not a nested type.