notes on type printing

[Tom Tromey <tromey at redhat dot com>]

Today I spent some time looking at a few type-printing examples that
Benjamin Kosnik sent a while back.

gdb often prints the "wrong" information for a type.  I think this
problem has two parts.  First, debuginfo often does not express all
the information we need.  Second, I think we may need to extend
'whatis' or 'ptype' to give the user more control over verbosity.

Consider a simple case:

    namespace ns {
      template<typename T>
      class k {
        T z;
      };

      typedef k<int> td;
    }

    ns::td zardoz;
    ns::k<int> maude;

'whatis' shows funny results:

    (gdb) whatis zardoz
    type = td
    (gdb) whatis maude
    type = ns::k<int>

Here, I think both types should be qualified with 'ns::'.  In the
'zardoz' case, this boils down to missing debug info.  Most of
Benjamin's tests come down to this -- g++ emitting something other
than what the user wrote.

The need for verbosity control needs a somewhat more complicated
test.  I've appended Benjamin's '2.cc' for reference.

Here, if you 'start' and then 'ptype functor_type', you will get the
weird:

(gdb) ptype functor_type
type = 
    class functor<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, int> {
  private:
    std::basic_string<char, std::char_traits<char>, std::allocator<char> > one;
    
    std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > two;
    int three;

  public:
    void operator()();
}

Now, this is all correct -- just not what the user, IMO, would expect.
For instance, there is no mention of 'vector_type' here (and none in
the debug info anywhere, to my surprise).

'whatis' also gives somewhat unfriendly results -- fully expanding
std::string and std::vector.

By default, I think, ptype and whatis should give what the source
shows -- typedefs in place, defaulted template arguments omitted, etc.
However, on occasion it is nice to see the full expansion.  So, that
is why I think some kind of verbosity control is needed.

I think it may also be handy to have a mode that omits methods from
the type.  I don't know how important this is.

All of this is contingent on g++ emitting usable info, though.
I filed a bug for this: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=37590

I can send out Benjamin's other (two) tests if anybody wants them.

Tom

#include <string>
#include <utility>
#include <vector>

// 02, more complex types
template<typename T1, typename T2, typename T3>
struct functor
{
  void
  operator()() 
  {
    std::size_t s1 = one.size();
    std::size_t s2 = two.size();
    std::size_t s3 = three;
  }

private:
  T1 one;
  T2 two;
  T3 three;
};
  
int main()
{
  typedef std::vector<std::string>			vector_type;
  typedef functor<std::string, vector_type, int>	functor_type;

  functor_type f;
  f();

  return 0;
}