| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
This gives us more debug information in the emitted graphviz dot files.
|
|
|
|
|
|
typedef struct {} name
Fixes #427
It looks like clang is doing the hard work of getting the right name from the typedef, but it falls back to arbitrary pretty-printed descriptions if it can't find a typedef. I couldn't find an API to check whether the name comes from a typedef, so I just filter out non-ident-like spellings.
|
|
Graphviz implementation
This will solve #484 . Right now it's really basic and I will change some of things in future commits like docs and other things.
r? @fitzgen
|
|
|
|
|
|
|
|
Update clang-sys.
Fixes https://github.com/servo/rust-bindgen/issues/439
r? @fitzgen
|
|
|
|
|
|
|
|
Fixes https://github.com/servo/rust-bindgen/issues/439
|
|
C++ allows ignoring template parameters, while Rust does not. Usually we can
blindly stick a `PhantomData<T>` inside a generic Rust struct to make up for
this. That doesn't work for templated type aliases, however:
```C++
template <typename T>
using Fml = int;
```
If we generate the naive Rust code for this alias, we get:
```ignore
pub type Fml<T> = ::std::os::raw::int;
```
And this is rejected by `rustc` due to the unused type parameter.
(Aside: in these simple cases, `libclang` will often just give us the
aliased type directly, and we will never even know we were dealing with
aliases, let alone templated aliases. It's the more convoluted scenarios
where we get to have some fun...)
For such problematic template aliases, we could generate a tuple whose
second member is a `PhantomData<T>`. Or, if we wanted to go the extra mile,
we could even generate some smarter wrapper that implements `Deref`,
`DerefMut`, `From`, `Into`, `AsRef`, and `AsMut` to the actually aliased
type. However, this is still lackluster:
1. Even with a billion conversion-trait implementations, using the generated
bindings is rather un-ergonomic.
2. With either of these solutions, we need to keep track of which aliases
we've transformed like this in order to generate correct uses of the
wrapped type.
Given that we have to properly track which template parameters ended up used
for (2), we might as well leverage that information to make ergonomic
bindings that don't contain any unused type parameters at all, and
completely avoid the pain of (1).
Determining which template parameters are actually used is a trickier
problem than it might seem at a glance. On the one hand, trivial uses are
easy to detect:
```C++
template <typename T>
class Foo {
T trivial_use_of_t;
};
```
It gets harder when determining if one template parameter is used depends on
determining if another template parameter is used. In this example, whether
`U` is used depends on whether `T` is used.
```C++
template <typename T>
class DoesntUseT {
int x;
};
template <typename U>
class Fml {
DoesntUseT<U> lololol;
};
```
We can express the set of used template parameters as a constraint solving
problem (where the set of template parameters used by a given IR item is the
union of its sub-item's used template parameters) and iterate to a
fixed-point.
We use the "monotone framework" for this fix-point analysis where our
lattice is the powerset of the template parameters that appear in the input
C++ header, our join function is set union, and we use the
`ir::traversal::Trace` trait to implement the work-list optimization so we
don't have to revisit every node in the graph when for every iteration
towards the fix-point.
For a deeper introduction to the general form of this kind of analysis, see
[Static Program Analysis by Anders Møller and Michael I. Schwartzbach][spa].
[spa]: https://cs.au.dk/~amoeller/spa/spa.pdf
|
|
|
|
Use the constness of the inner type when converting array function args.
Fixes https://github.com/servo/rust-bindgen/issues/509
I'm actually surprised we had no tests for this.
|
|
arguments.
Fixes https://github.com/servo/rust-bindgen/issues/509
I'm actually surprised we had no tests for this.
Signed-off-by: Emilio Cobos Álvarez <emilio@crisal.io>
|
|
|
|
This makes the IR traversal infrastructure generic. It makes it so we can use
the same traversal code for whitelisting traversals and asserting no dangling
item references. Therefore the queue of items to visit is generic (whitelisting
uses DFS, while asserting against dangling uses BFS), the storage for the seen
set (whitelisting uses a simple set, asserting against dangling uses a map from
item to the item from which it was discovered).
It also introduces the concept of different kinds of edges in the IR graph, and
the ability to choose which edges to follow. This means we can simplify
non-transitive whitelisting to a simple function that always returns "no do not
follow this edge". It plays an important part for future analysis of which
template declaration type parameters are used or not.
|
|
And its `collect_types` method to `trace`.
|
|
|
|
Also moves it out to its own ir::traversal module, and moves ItemSet to the
ir::item module.
|
|
Don't mangle name in partial specification (with Cargo.lock update)
|
|
|
|
|
|
|
|
Fixes: https://github.com/servo/rust-bindgen/issues/482
|
|
Rename llvm_stable feature and remove references from docs.
Fixes: https://github.com/servo/rust-bindgen/issues/409
|
|
|
|
|
|
Template instantiation
I very much suspect this needs a rebase, but I haven't done it yet.
This is the majority of #446, although it doesn't have the name generation for anonymous named types patches yet (that will be a different PR).
|
|
ir: Remove unused call to clang_Cursor_isAnonymous.
Fixes #496
|
|
Clang 3.5 support
Fixes #496
|
|
Fixes #496
|
|
|
|
|
|
|
|
This commit renames `build_template_wrapper` to `instantiate_template` because
that is what it is really doing. Additionally, it completely reworks its
logic. Sometimes clang gives us rather sorry ASTs for template
instantiations (particularly when they involve incomplete template declarations)
and we need to manually reconstruct the template argument nesting.
|
|
This commit create the PartialType type to represent types that we are in the
middle of parsing and their cursor where we found them. Additionally, it fixes a
long standing FIXME to make `currently_parsed_types` private. Finally, it
implements `TemplateDeclaration` for `PartialType` so that we can get
information about a partially parsed template declaration type's template
parameters.
|
|
The TemplateDeclaration trait aggregates information about template
declarations (separate from instantiations and specializations) and their
template parameters into a single source of truth.
|
|
|
|
|
|
The `CanonicalTypeDeclaration` type exists as proof-by-construction that its
cursor is the canonical declaration for its type. If you have a
`CanonicalTypeDeclaration` instance, you know for sure that the type and cursor
match up in a canonical declaration relationship, and it simply cannot be
otherwise.
|
|
This commit adds collect_children, has_children, and has_at_least_num_children
methods to Cursor.
|
