Fix C++ demo bindings build due to function signature mismatch

Merge pull request #101 from TheBlueMatt/main

Update to use `find_route_with_id` to match upstream changes

Update to use `find_route_with_id` to match upstream changes

Merge pull request #100 from TheBlueMatt/main

LDK 0.0.114

Workaround github actions brokenness

Update `rust-lightning` branch to 0.0.114-bindings

Update auto-generated bindings

Note that cross-language LTO requires lld in addition to clang

Print something for custom messages in C++ demo

Fix connection race in C++ demo

Update C/C++ Demos to latest upstream API

Add `lightning-background-processor`'s new std feature

Support new rust-bitcoin type mappings for various hashes

Ignore discriminants on enum variants

While this loses the value information, its better than failing to
generate bindings at all.

Support tuples containing array elements

Add type for 8 u16s (which is used for the scoring data)

Support non-u8 (primitive) arrays

Support supertraits-of-supertraits

If we have a supertrait that requires an in-crate supertrait, we
handle that here by writing the required impls. We don't support
a supertrait-of-a-supertrait-of-a-supertrait.

Fix typo in path resolution leading to a "crate name" of a full path

Support passing `Option<&OpaqueStruct>` to C

Luckily the solution is trivial - just treat the conversion for the
inner pointer as `ptr_for_ref`, because we ultimately want a
pointer on the inside, not on the outside.

Merge pull request #98 from TheBlueMatt/main

Fix OSX building by not redirecting to `/dev/null`

Fix OSX building by not redirecting to `/dev/null`

Somehow this results in a broken pipe error...cause macOS is trash.

Merge pull request #97 from TheBlueMatt/main

Fix LTO compilation with latest ld.lld on OSX

Stop timing C++ demo bindings run cause OSX is, as usual, garbage

Update CI references to OSX clang 15.0.3

Fix LTO compilation with latest ld.lld on OSX

Merge pull request #96 from TheBlueMatt/main

0.0.113 Bindings

Update CI and Cargo.toml references to 0.0.113

Set the C target to wasm32-wasi rather than wasm32

We need at least a partial C stdlib anyway, so there's no real
difference going ahead and linking wasm32-wasi on the C side vs
only on the Rust side. This fixes compilation on Debian testing
with OS packages installed.

Update C/C++ demo bindings to latest upstream API

Update auto-generated bindings to 0.0.113

Support new upstream manually-mapped types

Add support for witnesses via a manual mapping

Support u128 values

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.