Update auto-generated bindings to LDK 0.0.118

Support trait impls on enums

Previously we'd only generate correct code for trait impls on
structs, but there's no reason for that restriction. Here we also
implement it on enums.

Correct manual conversion for `ChainHash`

Drop `#[no_mangle]` from `*_write_void` to make cbindgen not export

cbindgen recently switched to exporting all `#[no_mangle]` and
`extern "C"` functions. Our `*_write_void` methods are
internal-only but we'd marked them `#[no_mangle]`, which resulted
in them spuriously appearing in `lightning.h`.

Merge pull request #113 from TheBlueMatt/main

Update args on supertraits of supertraits when cloning trait impls

Update auto-generated bindings

Update args on supertraits of supertraits when cloning trait impls

When cloning implementations of traits from in-crate structs, we
forgot to update the arguments for supertraits of supertraits,
causing methods on that trait to be called against the previous
struct, not the cloned one.

This was ultimately identified downstream in the Java bindings,
fixes https://github.com/lightningdevkit/ldk-garbagecollected/issues/138

Drop unused parameter from `get_module_type_resolver`

Merge pull request #112 from TheBlueMatt/main

Upgrade to 0.0.117

Avoid dependencies of build-deps on MacOS by pinning cc

Sadly we have to hack around cargo to make this work with
`-Zbuild-std`.

Pin memchr so that no-std builds work

Update CI and Cargo.toml references to 0.0.117-bindings

Update auto-generated bindings

Include argument info docs on all-pub struct constructors

Fixes https://github.com/lightningdevkit/ldk-garbagecollected/issues/129

Update C/C++ demo bindings and ldk-net to LDK 0.0.117

Update hardcoded and manually-defined types for LDK 0.0.117

Drop `#[no_mangle]`/`extern` flag for internal-only method

This prevents new `cbindgen` from generating bindings for things we
don't actually want to export.

Drop `empty_val_check_suffix_from_path` for Signature as its unused

Handle type references which refer to a module defined in scope

eg
```
mod module;
fn a() -> module::Type { todo!() }
```

Print fewer types in call generics, leaning on rustc to pick types

Picking types is hard, its easier to make rustc do it.

Use the resolved type name in generic strings, not the original

This makes some generics less readable, but some more, and reduces
generic type pollution. Some cases are a loss, eg
`Option_PaymentHashZ` gets converted to `Option_ThirtyTwoBytesZ`
(which less less readable but fewer total types as a result), but
we ultimately need this because we now have `schnorr::Signature`
and `ecdsa::Signature` so we can't rely on just using `Signature`
and having it be unique :(.

Handle `Deref<Self::Type>` bounds as `Self::Type`'s trait bound

Accept `DerefMut` bounds on generics as if they were `Deref`

Support `f64` as a primitive type

impl `DerefMut` for all traits

This is sometimes required in LDK now, and there's no real reason
not to implement it.

Allow `Sized` bounds

There was no reason to only allow `Sized`, rustc will let us know
if something is wrong.

Include `String` in the default import, since we use it now

Merge pull request #110 from TheBlueMatt/main

LDK 0.0.116

Update auto-generated bindings to LDK 0.0.116

Update lightning-c-bindings Cargo.toml & CI to point to 0.0.116

Update C/C++ demo apps for new upstream API

Update hard-coded types and add some new manual bitcoin types

Include a `struct` before trait return fields

EIther `struct Type` or `Type` work fine because of our type
declarations, but cbindgen uses `struct Type` everywhere so its
easiest if we match it, especially for downstream code.

Allow generation of manual types in reference options

The limiting of supported types in `write_template_generics` isn't
super useful as its only called once per type - later uses of the
same type with the reference flag set or wiped doesn't change
anything. Still, it is relied on somewhat, so we can't drop it
entirely.

Now that we've moved more of the `[u8; 32]` newtypes to option
wrappers, failing for non-primitive references spuriously breaks.
Instead, we just allow it for manually-mapped types and let the
compiler complain if we do something invalid.

Handle all traits in type resolution, including no-export ones

In the previous commit, we set up handling of no-export traits with
only a single implementor. In order to utilize that, we need such
traits to participate in type resolution, which we add support for
here.

Handle no-export traits which are only implemented once as the implementor

If we have a trait marked no-export, and there's a single
implementor, we can just pretend its always the implementor. This
makes sense in LDK, for example, for the `APeerManager` trait,
which is implemented for all `PeerManager`s, but doesn't make sense
in bindings.

Support Unit struct types

Allow `?Sized` bounds in some cases

Drop special handling for more Option types and all-0 array handling

Correct `use` resolution for submodule use statements

Otherwise we fail to resolve a `use` that starts with a submodule
of the current module.

Drop `#[must_use]` that rustc complains is ignored

Merge pull request #111 from TheBlueMatt/2023-07-0.0.115-aliasing-fix

[0.0.115] Fix strict-aliasing violation on traits holding inner fields

Update auto-generated bindings with aliasing fix.

Pin quote and proc-macro2 in CI to meet MSRV

Fix strict-aliasing violation on traits holding inner fields

When we map a trait method which returns a reference to a struct,
we map it by storing said struct in the trait implementation
struct. Then, we create a setter method which ensures the new field
is set. Sadly, because the original Rust trait method may take a
non-mutable reference to self, we have to update the field without
a mutable reference to the trait implementation struct.

Previously we did this by simply unsafe-casting a pointer to
mutable, which violates the aliasing rules in Rust. In a recent
rustc (at least on macOS), this broke.

Here, we convert the stored struct to wrap it in an `UnsafeCell`,
which fixes the issue.

Merge pull request #108 from TheBlueMatt/main

Skip address sanitizer builds on OSX

Skip address sanitizer builds on OSX

...cause it appears broken on newer macOS and I'm skeptical its
detecting real leaks.

Merge pull request #107 from TheBlueMatt/main

Support Building OSX binaries on Linux

Update the set of OSX runners since github removed 10.15

Build OSX releases on Linux if `MACOS_SDK` is set

Make `clang-lto-link-osx` work on Linux (by forcing bash)

Merge pull request #106 from TheBlueMatt/main

Make `BitEndianScalar` clonable

Update auto-generated bindings

Make `BitEndianScalar` clonable

Merge pull request #105 from arik-so/2023-05-115-debugging

Add debugging lines to demo.cpp

Add debugging lines to demo.cpp

Merge pull request #103 from TheBlueMatt/main

Update to LDK 0.0.115

Update CI+Cargo.toml bindings branch to 0.0.115

Update auto-generated bindings for LDK 0.0.115

Update C++ demo application to LDK 0.0.115

Ensure an option always unwraps to a non-reference type

Handle Option<Vec<_>> with a much cleaner option converter

Handle use of `#[doc]` in the original source

Replace type resolution assertions with failures

Type resolution now supports failing, but some assertions are still
left over from when it didn't. Replace some of those which now fail
on LDK 0.0.115.

Update hard-coded type definitions

Fix documentation on generated _hash methods for std::hash::Hash

Support the new no-exported tag that is more human readable

Merge pull request #102 from TheBlueMatt/main

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

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