Use the resolved name, not original ident, for Vec naming

This will be useful in the next commit when we rename `u5` to `U5`

Ignore async functions as mapping them would be substantial work

Allow enums with lifetime-only generics

Use `Clone::clone(a)` rather than `a.clone` to avoid deref recursion

Some initial support for `pub(.*) use` aliasing in type resolution

Make rustc stop complaining about unused `Box::from_raw`s

Merge pull request #94 from TheBlueMatt/main

Update for 0.0.112

Update Cargo.toml and CI references to 0.0.112

Update auto-generated bindings

Update C/C++ demos for latest upstream API

Map `io::ErrorKind` the same as `io::Error`, we only use the kind

Handle path types that start with `crate::`

Handle multiple `impl`s of the same trait in the same file

This should be easy, but we end up with redundant `use` statements.
Thus, we instead track which use statements we want and put them at
the end when generating new files

(Partially) support supertraits with generic bounds

If we extend a supertrait where the supertrait is generic, we will
ultimately need to genericize the supertrait into a derived object.
This doesn't implement that part, but it does implement the
subtrait-writing code to make it compatible with such a future.

Support trait methods that return enums in the C++ sed script

Merge pull request #93 from TheBlueMatt/main

Expose the `rapid-gossip-sync` crate for no-std builds

Update auto-generated bindings for backport of RGS-no-std support

Expose the `rapid-gossip-sync` crate for no-std builds

Merge pull request #92 from TheBlueMatt/main

Add a convinience constructor for the new BigEndianScalar

Update auto-generated bindings

Add a convinience constructor for the new BigEndianScalar

Merge pull request #91 from TheBlueMatt/main

0.0.111

Update auto-generated bindings

Update C++ bindings demo to latest upstream API

Add Scalar and SharedSecret type mappings for new secp256k1 types

Update bindings branch to 0.0.111 and update rust-bitcoin and secp

Allow liftime bounds on generic bounds

While liftime bounds require bindings users to ensure liftime
requirements are met, they're important for allowing us to export
lock wrappers. Thus, we relax the simple-bounds assertions checks
here.

Don't use a turbofish when all parameters are lifetimes.

For some reason rustc doesn't like this, and its easy, so whatever.

Use trait, not impl, definition for X_as_Trait functions

When we map a trait impl block, we historically didn't know how to
resolve the types in the trait context, so we just used the impl
context definitions and assumed the types were the same. Sadly, if
we have an associated type that is bounded by a trait, we need to
use the trait bound to figure out what to write for the X_as_Trait
method declarations.

Since we now have the ability to generate full trait-context type
resolvers, we do so here.

Support mapping `Readable` `impl`s outside of the `lightning` crate

In order to map `Readable` `impl` blocks in crates other than the
`lightning` main crate we simply have to update the type references
to include crate name, which we do here.

Prefer `Option_` mappings for more types over transparent mappings

In general, the explicit `Option_` mappings are easier for
downstream bindings to match against, and clearer for users anyway.
Sadly, originally we were trying to avoid them where possible, so
some types default to transparent mappings. Here we swap the
default, at least for manually-mapped types, with a few explicit
exceptions (that probably should be changed as well).

Merge pull request #89 from TheBlueMatt/main

Don't force targeting sandybridge on all platforms

Don't force targeting sandybridge on all platforms

This should fix building on macOS when using upstream clang.

Merge pull request #88 from TheBlueMatt/main

Try clone'ing the field before skipping exporting a field getter

Update auto-generated bindings

Try clone'ing the field before skipping exporting a field getter

Merge pull request #87 from TheBlueMatt/main

LDK 0.0.110

Update auto-generated bindings to LDK 0.0.110

Update lightning-c-bindings Cargo and CI to reference 0.0.110

Update C/C++ demos to latest upstream API

Merge pull request #84 from TheBlueMatt/main

0.0.109 Support

Update lightning-c-bindings Cargo.toml and CI to 0.0.109

Update auto-generated C bindings for 0.0.109

Update demo.cpp to 0.0.109 API

Support `&[[u8; N]]` passed to Rust.

Support `Option<Tuple>` with elements in the tuple

Merge pull request #83 from TheBlueMatt/main

Update `deterministic-build-wrappers` to include a rapid-gossip-sync match

Update `deterministic-build-wrappers` to include a rapid-gossip-sync match

Merge pull request #82 from TheBlueMatt/main

0.0.108.1

Update auto-generated bindings to match latest 0.0.108-bindings

Update demo.cpp to match updated 0.0.108-bindings API

Merge pull request #81 from TheBlueMatt/main

0.0.108 Bindings Updates

Fix cbindgen install to be MSRV-compatible with older hashbrown

Update auto-generated bindings

Update C/C++ demos to latest upstream API

Update lightning-c-bindings Cargo.toml and CI to 0.0.108-bindings

Add rapid gossip sync crate to generation in `std` mode.

Add locally defined crates as "dependencies" without `extern crate`

We later use the `dependency` set when doing type resolution to
decide if `::asdf::T` means `current_crate::asdf::T` or `asdf::T`,
which will resolve incorrectly if we don't ensure all possible
crates are in the `dependencies` list.

Support `Option<Trait>` (and `Option<&Trait>`, implemented the same)

Use new `Type`-based resolution to decide if a container is transparent

We also assert that we were able to resolve paths inside containers
as we shouldn't be deciding if a container is transparent without
all the context.

Use new `Type`-based generic resolution in `write_rust_path`

This gives us better generic resolution, but because we determine
whether to include a `crate::` prefix or not based on generic
resolution it means we have to pipe through the "type is a generic that
was resolved" flag from `write_rust_type`. We also take this opporunity
to do better decision making for the `crate::` prefix entirely, which
is important for enums that contain trait instances.

Pass `with_ref_lifetime` through to rust-type-printing from C-path printing

If we get to `write_c_path_intern` with `c_ty` unset, we delegate to
`write_rust_path`, however it would lose the `with_ref_lifetime`
flag, causing us to miss `'static` when printing references in
generic arguments. Here we simply pipe it through.

Check whether the fields of an enum are clonable before implementing clone

Do a second initial-walk pass to apply clonable flags to aliases

This enables the clonable flags for `*Features`.

Move code to map aliased types into a virtual impl block into a helper

This will allow us to create virtual impl blocks during the early
code passes before we go to do the full conversion pass.

Generate mutable references in `default_generics` when relevant

As we move towards resolving generics via the new `Type`-based
interface instead of the string-based one, we need to ensure we
retain the mutability flag when resolving references, which we do
here.

Move overly-specific check to an assertion where its relevant

Do not make `Deref<T>` generic params always a `&T` for traits.

We never expect traits to be passed by reference, so when using
the new-style generic resolution, we shouldn't force all `Deref`s
to `&T`, at least if the `T` is a trait.

Print field documentation even for unnamed enum variant fields

Add a note in output documentation for fields with refs to opaques

Because we (probably shouldn't, but do) map "opaque" structs with
an `is_owned` field instead of having a dedicated reference type,
fields which are a `Deref<Struct>` are simply mapped as
`OpaqueMappedStruct`. This is confusing for downstream `lightning.h`
consumers as they cannot differentiate between a field that expects
to own a `Struct` and one which expects to own a reference to it.

This is worked around here by adding documentation which can be
matched on, though ultimately structs should move towards full
ownership.

Set `ptr_for_ref` correctly when writing conversions for enum fields

Correctly set the `ptr_for_ref` arg on `write_c_type` calls in enum printing

This avoids adding references to opaque structs in enum fields,
where we should, of course, map them as owned opaque structs.

It does generate some difficult-to-parse-by-downstream-bindings
code, which is addressed in a later commit by adding documentation.

Note that it also relies on the types being mapped differently
being opaque as it now needs logic to map a reference to a
non-reference with `is_owned` unset.

Correctly define the `native` type alias for enums with generic params

Correctly generate `impl` blocks for traits with generics

Support `T: Deref...where` in underlying structs from type aliases

Handle trait methods with a default implementation

This does not currently expose the default implementation to users
who wish to avoid manually implementing the method.

Include the `where` clause from a "real" type when mapping type aliases

ie if we have a
```
struct A<T: Deref> where T::Target: Trait {}
pub type B<T> = A<T>;
```

this includes the `where` clause so that we end up calling
`writeln_opaque` for `struct B<T: Deref> where T::Target: Trait {}`
instead of `struct B<T: Deref> {}`.

Add where-clause generic params to `default_generics` map

This moves yet more generic resolution to being able to rely on the
`default_generics` map for full-`Type` resolution rather than
string-based name resolution.

Make panics in macros more debug-able by giving them a unique print

Support `use ...::self` imports

Previously we'd supported `use self:...` but this adds support for
using some path that ends with `self`.

Support arrays inside Option types

Previously we'd supported arrays in options only if the real type
was something which we'd aliased to an array, so its not a big
stretch to support Options containing arrays explicitly.

Add more manually-generated types to the on-startup clonable list

Update c_types `IOError` type to support `no-std` via `core2`

Add C type for bitcoin::util::address::WitnessVersion

Update `lightning-c-bindings` to new `bitcoin`/`secp256k1`

including new error types for `secp256k1::Error`

Update type mappings for bitcoin 0.28.1

Merge pull request #77 from jurvis/main

Use GNU sed if available on macOS

Check if GNU sed is available on macOS

Check if is_gnu_sed is true

Merge pull request #75 from TheBlueMatt/main

Fix M1 build

Add a warning before we run a ton of sed's

Skip building x86_64 release binaries on M1 Macs

Explicitly specify a target when calling local clang

This should fix using upstream x86_64 clang on an M1 Mac via Rosetta

Don't use -mcpu=native on aarch64-macos

Merge pull request #74 from TheBlueMatt/main

[ldk-net] Correct pollfds array offset after reads

[ldk-net] Correct pollfds array offset after reads

Previously, we were copying the pollfds array at an offset of one
into the handler thread's stack. However, when it was changed to
copying at a 0 offset (adding the pipe read fd at the end instead
of beginning), the disable-read handling code was not updated.

This leads to an assertion failure at runtime if LDK decides we
need to stop reading due to the outbound buffer of a peer being
full.

Merge pull request #73 from TheBlueMatt/main

Handle impl blocks outside of the mod of the being-implemented object

Drop now-unused code from c-bindings-gen

Update auto-generated bindings

Handle impl blocks exist outside of the mod of the being-implemented object

This allows us to implement the feature bit accessor functions.

Use full paths in impl block handling instead of assuming in-file idents

In the next commit we'll want to handle impl blocks in one module
for an object that is defined in a different model. This violates
several existing assumptions in the impl block handling code,
namely that we're implementing for an object declared in the
current module. This relaxes that assumption in a few places.