Why is `flags &= (ushort)~Mask;` problematic when `Mask` is `const`?

The following code throws a compiler error CS0221: Constant value '-2' cannot be converted to a 'ushort' (use 'unchecked' syntax to override)

private ushort _fooFlags = 0;
public void SetFoo1Flag(bool foo)
{
    const ushort Foo1Mask = 0x0001;
    if (foo)
    {
        _fooFlags |= Foo1Mask;
    }
    else
    {
        _fooFlags &= (ushort)~Foo1Mask; // CS0221 error
    }
}

As the hint suggests, using unchecked fixes this issue.

private ushort _fooFlags = 0;
public void SetFoo1Flag(bool foo)
{
    const ushort Foo1Mask = 0x0001;
    if (foo)
    {
        _fooFlags |= Foo1Mask;
    }
    else
    {
        unchecked
        {
            _fooFlags &= (ushort)~Foo1Mask;
        }
    }
}

I'm primarily a C coder, so I tried variations to see how these (basic) integer operations behave.

Removing const works fine..

public void SetFoo2Flag(bool foo)
{
    ushort Foo2Mask = 0x0001;
    if (foo)
    {
        _fooFlags |= Foo2Mask;
    }
    else
    {
        _fooFlags &= (ushort)~Foo2Mask;
    }
}

..as well as replacing const with readonly.

private readonly ushort Foo3Mask= 0x0004;
public void SetFoo3Flag(bool foo)
{
    if (foo)
    {
        _fooFlags |= Foo3Mask;
    }
    else
    {
        _fooFlags &= (ushort)~Foo3Mask;
    }
}

I'm using an explicit cast, so I'd expect (ushort)~Foo1Mask to become a ushort, regardless of what happens with ~Foo1Mask.

What makes const so different, that it requires special treatment, while the other two (in my view) similar variations work as I have expected?

PS: I know in this example I could've used an enum and [Flags].

The ~ operator is supported for the following types: "int, uint, long, and ulong" as per the documentation. There's an implicit conversion from ushort to all of those, but int is the "smallest" of those types, so it "wins" the fight and becomes the type of ~anyUshortExpression.

An operation can also be performed at compile time when the expression involves entirely literals, constants, or other expressions that can be resolved at compile time. This means that ~Foo1Mask will be treated identically to the compiler as if you'd have written -2. Which is why you see that in the compiler error you get.

As far as why you only see it when you use a constant, if you don't, then at compile time it has no idea that the int that you're trying to cast to a ushort won't fit inside of a ushort. It can't know that until runtime when it actually tries to execute the cast (at which point it will throw in a checked context or wrap around in an unchecked context). So it just takes your word for it at compile time, even in a checked context, since it has no other choice.