Consider adding ConfigureAwaitOptions polyfill

[paulomorgado]

Consider adding source-compatible polyfills for ConfigureAwaitOptions.

Possible implementation:

#if !NET8_0_OR_GREATER
/// <summary>Options to control behavior when awaiting.</summary>
internal static class ConfigureAwaitOptions
{
    /// <summary>No options specified.</summary>
    /// <remarks>
    /// <see cref="Task.ConfigureAwait(ConfigureAwaitOptions)"/> with a <see cref="None"/> argument behaves
    /// identically to using <see cref="Task.ConfigureAwait(bool)"/> with a <see langword="false"/> argument.
    /// </remarks>
    public const bool None = false;

    /// <summary>
    /// Attempt to marshal the continuation back to the original <see cref="SynchronizationContext"/> or
    /// <see cref="TaskScheduler"/> present on the originating thread at the time of the await.
    /// </summary>
    /// <remarks>
    /// If there is no such context/scheduler, or if this option is not specified, the thread on
    /// which the continuation is invoked is unspecified and left up to the determination of the system.
    /// <see cref="Task.ConfigureAwait(ConfigureAwaitOptions)"/> with a <see cref="ContinueOnCapturedContext"/> argument
    /// behaves identically to using <see cref="Task.ConfigureAwait(bool)"/> with a <see langword="true"/> argument.
    /// </remarks>
    public const bool ContinueOnCapturedContext = true;
}
#endif

The other members are not safe to assume to have equivalents before .NET 8.0.

Ther's the possibility that user could use this for ValueTask.ConfigureAwait(bool) and ValueTask<T>.ConfigureAwait(bool), and that would not compile above .NET 8.0.

[SimonCropp]

Thanks for the suggestion, but I don't think this is a good fit for Polyfill.

A few problems:

1. The real ConfigureAwaitOptions is a [Flags] enum (None=0, ContinueOnCapturedContext=1, SuppressThrowing=2, ForceYielding=4). The proposed static class with const bool fields has a completely different shape — it breaks flags combinations (a | b), equality/switch on enum values, reflection, and any method signature that takes a ConfigureAwaitOptions parameter.
2. There's no way to add Task.ConfigureAwait(ConfigureAwaitOptions) on older TFMs. The proposal only "works" because the bool constant accidentally binds to the existing ConfigureAwait(bool) overload — so it's not really polyfilling the API, just aliasing false/true.
3. As you noted, code using this against ValueTask would compile on old TFMs and break on net8.0+. A polyfill that compiles differently depending on the target framework is exactly what this package exists to prevent.
4. SuppressThrowing and ForceYielding can't be polyfilled in any meaningful way, so consumers would only ever get None/ContinueOnCapturedContext — and those are already spelled ConfigureAwait(false) / ConfigureAwait(true) without needing anything from this package.

or am i missing something?

[paulomorgado]

No, you are not missing anything.

I'm wondering if we can fully implement this.

extension(Task task)
{
    public new ConfiguredTaskAwaitable<TResult> ConfigureAwait(ConfigureAwaitOptions options)
    {
        if ((options & ~(ConfigureAwaitOptions.ContinueOnCapturedContext |
                         ConfigureAwaitOptions.ForceYielding)) != 0)
        {
            ThrowForInvalidOptions(options);
        }

        return task.ConfigureAwait((options & ConfigureAwaitOptions.ContinueOnCapturedContext) != 0);

        static void ThrowForInvalidOptions(ConfigureAwaitOptions options) =>
            throw ((options & ConfigureAwaitOptions.SuppressThrowing) == 0 ?
                new ArgumentOutOfRangeException(nameof(options)) :
                new ArgumentOutOfRangeException(nameof(options), SR.TaskT_ConfigureAwait_InvalidOptions));
    }

    public Task ConfigureAwait(ConfigureAwaitOptions options)
    {
        var t = task;

        if ((options & ConfigureAwaitOptions.ForceYielding) != 0)
        {
            t = ForceYieldingAsync(t);
            static async Task ForceYieldingAsync(Task t)
            {
               await Task.Yield();
               await t;
            }
        }

        if ((options & ConfigureAwaitOptions.SuppressThrowing) != 0)
        {
            t = SuppressThrowingAsync(t);
            static async Task SuppressThrowingAsync(Task t)
            {
                try
                {
                    await t;
                }
                catch
                {
                    // ignore exception
                }
            }
        }

        return t.ConfigureAwait((options & ConfigureAwaitOptions.ContinueOnCapturedContext) != 0);
    }
}