why CS8121?

[nczsl]

For the same statement, if you use switch to express that it is OK, but if you use switch statement, you will recived an error cs8121

[CyrusNajmabadi]

Can you please provide a copy of your code and a copy of the diagnostic message you're getting?

[nczsl]

using System;

abstract public class Expr
{
    public struct Chain
    {
        public string value;
        public Chain(string value)
        {
            this.value = value;
        }

        static public Chain None = nameof(None);
        static public Chain Add = "+";

        static public implicit operator Chain(string value) => new Chain(value);
        static public implicit operator string(Chain con) => con.value;
    }

    public Expr.Chain OperType { get; set; }

    public Expr(Expr.Chain type)
    {
    }
}

public class Constant : Expr
{
    public Constant(double value = 0d) : base(Expr.Chain.None)
    {
    }

    static public implicit operator Constant(double value) => new Constant(value);
}

public class Symbol : Expr
{
    public Symbol(Expr.Chain type) : base(type)
    {
    }

    public void Compile()
    {
        switch (this.OperType)
        {
            case Chain i when i == Chain.Add: break;
        }
    }
}

[CyrusNajmabadi]

Thanks. I trimmed down your repro to something more manageable. I'm fairly certain this has to do with back-compat and the fact that you have an implicit string conversion here: static public implicit operator string(Chain con).

Because switch-statements can switch on strings, i think it's defaulting to that behavior, causing this issue. Tagging @jcouv @gafter to confirm if this is expected or not.

[bbarry]

public struct Chain
{
    public string value;
    public Chain(string v) => value = v;

    static public Chain Add = new Chain("+");

    static public implicit operator string(Chain con) => con.value;
}

public class Test
{
    public void Foo(Chain value)
    {
        switch (value)
        {
            case Chain i when i == Chain.Add: break;
        }
    }
}

It is a little bit of an unexpected experience. I very strongly dislike implicit conversion operators to an external type though and would never write this code to find that error so perhaps the surprising nature of it to me is just my aversion to the area?

[gafter]

From https://github.com/dotnet/csharplang/blob/master/spec/statements.md#the-switch-statement

The governing type of a switch statement is established by the switch expression.

• If the type of the switch expression is sbyte, byte, short, ushort, int, uint, long, ulong, bool, char, string, or an enum_type, or if it is the nullable type corresponding to one of these types, then that is the governing type of the switch statement.
• Otherwise, exactly one user-defined implicit conversion (User-defined conversions) must exist from the type of the switch expression to one of the following possible governing types: sbyte, byte, short, ushort, int, uint, long, ulong, char, string, or, a nullable type corresponding to one of those types.
• Otherwise, if no such implicit conversion exists, or if more than one such implicit conversion exists, a compile-time error occurs.

When we added pattern-matching we changed the "compile-time error occurs" to being permitted. That's pretty much always what we like to do when adding language features: take conditions that used to be errors and giving them new meaning. But your code falls into the second bullet, which establishes the governing type to be the result of the conversion.