Stack overflow in ir::item::Item::is_constified_enum_module
#2102
Comments
|
I slightly further reduced this: template <typename> class B{};
template <typename c> class C {
public:
using U = B<c>;
};
class A : C<A> {
U u;
};There's a test case in this branch, which currently fails: master...adetaylor:bug-2102-test-case
The problem seems to be that we're generating a |
|
This case seems to work fine: struct B{};
template <typename c> class C {
public:
using U = B;
};
class A : C<A> {
U u;
};In this case, the |
|
It looks like the self-referential debug!("Avoiding recursion parsing type: {:?}", ty); |
adetaylor
added a commit
to adetaylor/rust-bindgen
that referenced
this issue
Oct 19, 2021
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 rust-lang#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 rust-lang#2102.
adetaylor
added a commit
to adetaylor/rust-bindgen
that referenced
this issue
Oct 19, 2021
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 rust-lang#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 rust-lang#2102.
lightsofapollo
pushed a commit
to lightsofapollo/rust-bindgen
that referenced
this issue
Oct 19, 2021
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 rust-lang#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 rust-lang#2102.
emilio
pushed a commit
that referenced
this issue
Oct 27, 2021
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.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Input C/C++ Header
Bindgen Invocation
Actual Results
due to stack overflow
Expected Results
Successful build.
Call stack
then many repeats ...
Thanks to @JustAPerson for reducing this test case over on google/autocxx#616.
The text was updated successfully, but these errors were encountered: