Print ref conversion in `write_(from|to)_c_conversion_to_ref_prefix`

Not idea why this was not true originally, but clearly when writing
a *reference* conversion, we should be doing so as a *reference*.

Use native types when converting for for single-impl traits

Now that we properly handle single-impl traits as Rust types (i.e.
in generic parameters), we have to handle "converting" single-impl
traits. Here we implement this, diverging from the impl of the
underlying impl'd trait by keeping the existing type as-passed and
only ref'ing it if required.

Handle writing Rust types for single-impl traits

Single-impl traits which are marked no-export (like
`AChannelManager` in LDK) are mapped as the singular implementing
type, rather than a full-blown trait.

Here we handle this case when writing Rust objects (generally used
in writing generic bounds).

Ensure we use the in-crate type for traits returning references

impl `Send`/`Sync`/`Deref`/deref method for opaque wrapper structs

This adds a "same item but as a reference/non-`is_owned`" helper
method for our opaque wrapper structs, as well as implements
`Deref` on them to the native type. Finally, it implements `Send`
and `Sync` on them by blindly assuming it is implemented on the
underlying struct.

Add a `*Ref` struct for traits and `Deref` to it rather than `Self`

Because LDK often takes `Deref<Target=Trait>` as type parameters,
we'd implemented `Deref { type Target=Self; .. }` for the traits
defined in the bindings crate. This worked well, but because Rust
auto-`Deref`s, it can lead to spurious compilation failures due to
infinite recursion trying to deref.

In the past we've worked around this by coming up with alternative
compilation strategies when faced with `Deref` recursion, but we
don't strictly need to.

Instead, here, we introduce duplicates of all our `Trait` structs
which become the `Deref` `Target`. This way, we can `Deref` into
the `Trait` and maintain LDK compatibility, without having any
infinite `Deref` recursion issues.

One complication is traits which contain associated types to define
`Deref`s to another associated type, e.g.

trait A {
    type B;
    type C: Deref<Target = Self::B>;
}

In this case, `B` needs to be the `TraitRef` and `C` needs to be
the `Trait`. We add code specifically to detect this case.

Support serialization impls defined in a diff module from the type

Allow functions being mapped to be `const`

Handle printing generic bounds on a trait impl better

Stop relying on `impl Deref { type Target = Self; ...`

... this has a tendency to cause `reached the recursion limit while
auto-dereferencing` errors, and even a dumb struct copy suffices to
avoid it.

Merge pull request #126 from TheBlueMatt/main

0.0.123.1

Update autogenerated bindings to latest LDK 0.0.123-bindings

Handle `Vec`s resolved as `alloc::vec::Vec`

Up until now we'd always relied on `Vec`s being imported through a
prelude, but LDK sometimes forgets to keep doing that. Thus, here
we move to also accepting `alloc::vec::Vec` by mapping it to `Vec`
during name resolution.

impl `Display` properly even if its written as `core::fmt::Display`

Merge pull request #124 from TheBlueMatt/main

Update to LDK 0.0.123

Pin compiler_builtins to 0.1.109 when building std

See https://github.com/rust-lang/compiler-builtins/issues/610

Update C/C++ demo to latest LDK API

Update auto-generated bindings to LDK 0.0.123

Update CI/Cargo.toml to point to LDK 0.0.123's bindings branch

Update hard-coded type definitions

Expose a `BigEndianScalar_clone` method

Support clone for `ThreeBytes`

Add a `TweakedPubKey` to mirror `bitcoin::key::TweakedPublicKey`

Write out real generics when calling trait methods

This avoids issues where a trait has a generic which can't be
resolved.

Correct separator writing in generic writing

Handle `-> ()` as an fn return value

Handle `self: [&*] Self` as argument rather than just `[*&]self`

Merge pull request #123 from TheBlueMatt/main

Update CI/Cargo.toml references to 0.0.122

Update CI/Cargo.toml references to 0.0.122

Merge pull request #122 from TheBlueMatt/main

Disable asan checks which are hitting an asan regression

Disable asan checks which are hitting an asan regression

Merge pull request #121 from TheBlueMatt/main

Fix cargo cache wiping for new registry and for empty caches

Fix cargo cache wiping for new registry and for empty caches

Merge pull request #119 from arik-so/arik/2024/01/skip-tests-option

Create an option to skip tests

Run cargo commands when skipping tests.

Move test-skipping effect to be prior to sanity-
checking and running the gcc app.

Merge pull request #120 from TheBlueMatt/main

Enable X-Lang LTO for extra builds/windows builds

Create an option to skip tests.

Enable X-lang LTO for Windows x86-64 builds (or any extra build)

Optimize for sandy when building extra x86-64 builds

Merge pull request #118 from TheBlueMatt/main

Stop using designated initializer for array in C++ demo

Stop using designated initializer for array in C++ demo

This seems to be no issue on recent-ish compilers, but my Android
compiler seems to complain about it.

Merge pull request #117 from TheBlueMatt/main

Update to 0.0.121

Drop stale pins in CI due to rustc bump

Bump CI to Debian bookworm due to new LDK MSRV

Update CI and Cargo.toml branch names to LDK 0.0.121

Update auto-generated bindings to LDK 0.0.121

Update C/C++ demo tests with latest 0.0.121 API changes

Add support for resolving 33-byte arrays, though its unused

Ignore `Debug` bounds on generics which may be redundant

Use resolved-type matching rather than as-written in trait exposing

Expose accessors for `TxIn` and `TxOut`

The fields themselves are already public, so there's not a lot of
value for C users for these, but it avoids having to have this
logic written out by hand in the Java bindings, which is nice.

Update rust-bitcoin wrappers to latest rust-bitcoin/secp

Ignore `Send` and `Sync` bounds when resolving generics

Add support for implementing traits with a `Debug` requirement

Support passing lifetime'd enums to C

While this is generally unsafe, we have to do something for
`CandidateRouteHop`, which is passed to the scorer. Because its
incredibly performance-sensitive, forcing the bindings users to
take a performance hit just to make the scoring interface marginally
safer seems like a bad trade-off.

Merge pull request #116 from TheBlueMatt/main

Support Building on Fedora

Test bindings on Fedora in addition to Debian

Stop passing -mcpu on x86-64

This is actually not supported, but we did it anyway because Debian
accepted it. Instead, we should rely on -march and -mtune

Properly parse Fedora's clang version string

Merge pull request #115 from TheBlueMatt/main

Fix race in peer connection in C++ demo app

Add simple wrapper to call clang with a windows target

This enables building for Windows with the existing
LDK_C_BINDINGS_EXTRA_TARGETS and LDK_C_BINDINGS_EXTRA_TARGETS_CCS
environment variables.

Fix race in peer connection in C++ demo app

When we disconnect then immediately reconnect from one peer we may
still get the second connection through before the disconnection is
handled on the other end, causing connection failures. We fix this
here by disconnecting on both ends before reconnecting.

Merge pull request #114 from TheBlueMatt/main

0.0.118

Update Cargo.toml and CI references to LDK 0.0.118

Update C/C++ demo to LDK 0.0.118 API

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.