Handling of template members

[vitaut]

Currently there is an inconsistency in handling class and non-class members of class templates. Consider the following example:

/** A class */
template <typename T>
class C {
 public:
  /** An inner class. */
  class D {};

  /** A method. */
  void f();
};

Inner class is passed as class C::D to the domain directive while function is passed as void C<T>::f(). Note that C has template arguments in the case of member function, but not in the case of the class.

While it doesn't change rendering, it affects how the domain targets are generated and, in particular, it means that in some cases cross references are not generated as in the following example:

/** A class */
template <typename T>
class C {
 public:
  /** An inner class. */
  class D {};

  /** A method. */
  void f(D);  // reference to D will not be generated
};

Therefore, we should either strip template arguments in the case of functions (making void C::f() in the above example) or add them in the case of classes (making class C<T>::D). I tend to prefer the first option because technically a template argument is just placeholder and not part of a signature until you instantiate a template.

@michaeljones do you have any ideas or comments about this?

[michaeljones]

Great catch! I don't have any strong ideas on this one. I guess the template parameters are unnecessary from an identification stand point. You can't have two difference classes with the same name and different template parameters to tell them apart so dropping it seems to be a simplifying step with any downsides. I agree with you!

[vitaut]

OK, I'll try implementing removal of template parameters then.

[vitaut]

Reopening as the same should be done for data members as well.

[vitaut]

Fixed in c9d73f6 for all members.