Use of [RequiresUnreferencedCode] annotated methods by generated code

[xecrets]

Hi!

When I update ReactiveUI to 22.1.1 the build starts generate a lot of warnings because the ReactiveCommand.Create...(...) methods have been annotated with the [RequiresUnreferencedCode] attribute. A warning might look like this:

...Error IL2026 : Using member 'ReactiveUI.ReactiveCommand.Create(Action, IObservable<Boolean>, IScheduler)' which has 'RequiresUnreferencedCodeAttribute' can break functionality when trimming application code. The method uses reflection and will not work in AOT environments.

This is of course alarming. In my specific case I don't need AOT compatibility, but I do need trimming.

Nothing has actually changed in ReactiveUI, the methods have apparently always been a risk, but now they are annotated to inform the caller of the situation.

So now I'm migrating to ReactiveUI.SourceGenerators and I was thinking that using the [ReactiveCommand] attributes would address this issue.

But, when I use the [ReactiveCommand] attribute to generate code, it appears that the source generator generates codes similar to the following, slightly abbreviated:

#pragma warning disable
...
        private ReactiveUI.ReactiveCommand<global::System.Action<global::System.IDisposable>, global::System.Reactive.Unit>? _activateCommand;

        [global::System.CodeDom.Compiler.GeneratedCode("ReactiveUI.SourceGenerators.ReactiveCommandGenerator", "2.4.0.0")]
        [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        public ReactiveUI.ReactiveCommand<global::System.Action<global::System.IDisposable>, global::System.Reactive.Unit> ActivateCommand { get => _activateCommand ??= ReactiveUI.ReactiveCommand.CreateFromTask<global::System.Action<global::System.IDisposable>, global::System.Reactive.Unit>(Activate); }
...
#pragma warning restore

The generated code does pretty much the same that my original code was doing, it calls ReactiveCommand.CreateFromTask... which is now annotated with [RequiresUnreferencedCode].

There's no warning though, since the whole generated code block is fenced by #pragma warning disable. Notably, other generated code from ReactiveUI.SourceGenerators disable some specific warnings, but here it's everything.

So, finally, to my question:

Can I really trust that the code generator intentionally silences all warnings, because it knows that the use of the ReactiveCommand.Create... methods are AOT and trimmer safe in the context where the code is generated?

I have also been struggling to understand just under what circumstances ReactiveCommand.Create... is safe to use, and when it's not. I have been trimming my app all the time, and have been using ReactiveCommand.Create... very much without any issues, but ignoring (or not having annotations to generate) trimming warnings works until it doesn't and I'd like to be very sure that it will work!

[glennawatson]

In terms of ReactiveCommand it's likely a false positive.

We went too and added those warnings when we got those warnings. RxApp though uses some reflection where the schedulers are by default in the past have been placed. We now have the RxSchedulers class which has no reflection so therefore doesn't have those warnings.

I just need to probably this weekend go through and use that class instead, and see how many of these AOT warnings we can remove.

ReactiveCommand itself doesn't use any reflection directly

[xecrets]

Thanks for the response, ok, so one more todo ;-) - Move from RxApp.MainThreadScheduler to RxSchedulers.MainTreadScheduler, but that seems fairly benign.

We went too and added those warnings when we got those warnings

This I don't quite get... Did you add warnings upstream? What I saw was the opposite, a disabling of all warnings in the generated code.

ReactiveCommand itself doesn't use any reflection directly

So why are the ReactiveCommand.Create..(...) methods annotated with [RequiresUnreferencedCode]?

They are already using RxSchedulers.MainThreadScheduler it seems.

Or was someone just overly ambitious when all those attributes were added to ReactiveUI.ReactiveCommand.Create...(...)?

Or is the Splat dependency involved again?

To be honest, I'm mostly annoyed that Splat is pulled in. I don't need it. I don't want it. I would have expected logging to be something that you'd register via an implementation of an interface only if you want it and you could choose what implementation to use according to preference, or none. To have everything pull it in, and thus effectively cause the whole code base to be polluted with [RequiresUnreferencedCode] doesn't seem right to me. But maybe it's more complicated than I think? It often turns out to be...

So there is no current way to implement IReactiveCommand without AOT/trimming warnings except to roll my own, or suppress the warnings?

[glennawatson]

Not presently no way to disable them. It's a weekend job to convert it over.

Big thing splat is used for is a lightweight DI registration system for the plugin for the binding engine. Eventually we want to swap to source generators using the work we prototyped over on the reactive marbles project for all the binding and remove reflection there also.

[xecrets]

Not presently no way to disable them. It's a weekend job to convert it over.

Ok, thanks. As you said, they are very likely false positives, and can probably safely be ignored. If I use the ReactiveUI.SourceGenerators [ReactiveCommand] attribute I get suppressed warnings, cleaner code and hopefully it gets even better with time.

Big thing splat is used for is a lightweight DI registration system for the plugin for the binding engine.

Right, I thought I saw some reference to logging also, but anyway.