tree 818c72154e1969c1f093fa06e00b831e87830449
parent 57853405463dd985dd49a2f14fb78bbf3595b1df
author Adrian Taylor <ade@hohum.me.uk> 1633278910 -0700
committer Emilio Cobos Álvarez <emilio@crisal.io> 1635355411 +0200

Avoid case of a self-referential type alias.

This previously produced a type alias which referred to itself,
which was clearly wrong and resulted in downstream code recursing
infinitely.

The problem case (per bug #2102) is:

  template <typename> class B{};
  template <typename c> class C {
  public:
    using U = B<c>;
  };
  class A : C<A> {
    U u;
  };

As far as I can tell, we parse clang's definition of B<A>; that leads
us to parse A; to find it has a field U which turns out to be of type
B<A>. And so we hit the line in item.rs which says:
  debug!("Avoiding recursion parsing type: {:?}", ty);
and bail out, returning the original item ID: hence, a self-
referential typedef is created.

The 'fix' in this PR creates an opaque type in this case instead,
to avoid later infinite loops. It would be preferable to avoid this
situation in the first place, but presumably that would require
us to split the parsing phase into two:
1) types
2) fields within those types.

Fixes #2102.
