compile-time checked #[ts(optional)]

[NyxCode]

Builds on top of #366.

• Get's rid of all string/path manipulation in the macro
  • As a consequence, it's impossible to break this with type aliases in all cases.
• Produces a compile-time error when #[ts(optional)] is used on a non-Option field. The error is not great yet - it's probably possible to improve this though.

    #[ts(optional = nullable)]
    d: i32,

error[E0308]: mismatched types
  --> ts-rs/tests/integration/optional_field.rs:94:10
   |
94 | #[derive(TS)]
   |          ^^
   |          |
   |          expected `PhantomData<Option<_>>`, found `PhantomData<i32>`
   |          expected due to this
   |
   = note: expected struct `PhantomData<std::option::Option<_>>`
              found struct `PhantomData<i32>`

[NyxCode]

This is achieved (technically semver-breaking) by adding an associated type, OptionInnerType to the TS trait. This type is set to Self for all types, except for Option<T>, where it is set to T.

With that, the behaviour of #[ts(optional)] never errors by itself. The mechanism to produce an error if it's used on a non-Option field is completely separate.

This is done by emitting this code:

use std::marker::PhantomData;
let actual: PhantomData<#ty> = PhantomData;
let must: PhantomData<Option<_>> = actual;

If #ty is not an Option, that code fails to compile, and produces the error as seen above.

[NyxCode]

Alternative way to provoke a compile-time error:

fn a<T>(_: std::option::Option<T>) {}
fn b(x: #ty) { a(x) }

[NyxCode]

Notably, what unfortunately does not work is something like this:

let true = <#ty as TS>::IS_OPTION;

[NyxCode]

I massively improved the error. For

#[derive(TS)]
#[ts(export, export_to = "optional_field/", optional)]
struct OptionalStruct {
    #[ts(optional = nullable)]
    d: i32,
}

we now get

error[E0277]: `#[ts(optional)]` can only be used on fields of type `Option`
   --> ts-rs/tests/integration/optional_field.rs:104:5
    |
104 |     #[ts(optional = nullable)]
    |     ^
    |
    = help: the trait `IsOption` is not implemented for `i32`
    = note: `#[ts(optional)]` was used on a field of type i32, which is not permitted
    = help: the trait `IsOption` is implemented for `std::option::Option<T>`

There is a weird note attached to the error though, which I don't know how to get rid of:

note: required by a bound in `<OptionalStruct as TS>::inline::check_that_field_is_option`
   --> ts-rs/tests/integration/optional_field.rs:94:10
    |
94  | #[derive(TS)]
    |          ^^ required by this bound in `check_that_field_is_option`
...
104 |     #[ts(optional = nullable)]
    |     - required by a bound in this function
    = note: this error originates in the derive macro `TS` (in Nightly builds, run with -Z macro-backtrace for more info)

I think that's what rust-lang/rust#51992 will be for.

[gustavo-shigueo]

Dude, this is awesome! You fixed all the issues we had with Option in the first place. I love that you got the compiler to check #[ts(optional)] with a great error message

[gustavo-shigueo]

There is a weird note attached to the error though, which I don't know how to get rid of:

note: required by a bound in `<OptionalStruct as TS>::inline::check_that_field_is_option`
   --> ts-rs/tests/integration/optional_field.rs:94:10
    |
94  | #[derive(TS)]
    |          ^^ required by this bound in `check_that_field_is_option`
...
104 |     #[ts(optional = nullable)]
    |     - required by a bound in this function
    = note: this error originates in the derive macro `TS` (in Nightly builds, run with -Z macro-backtrace for more info)

With how good the error message is overall, I don't think this is a problem