ユーザー定義の checked 演算子

checked キーワードの配置

または、 checked キーワードを、 operator キーワードの直前の場所に移動することもできます。

public static T checked operator ++(T x) {...}
public static T checked operator --(T x) {...}
public static T checked operator -(T x) {...}
public static T checked operator +(T lhs, T rhs) {...}
public static T checked operator -(T lhs, T rhs) {...}
public static T checked operator *(T lhs, T rhs) {...}
public static T checked operator /(T lhs, T rhs) {...}
public static explicit checked operator U(T x) {...}

public static T checked I1.operator ++(T x) {...}
public static T checked I1.operator --(T x) {...}
public static T checked I1.operator -(T x) {...}
public static T checked I1.operator +(T lhs, T rhs) {...}
public static T checked I1.operator -(T lhs, T rhs) {...}
public static T checked I1.operator *(T lhs, T rhs) {...}
public static T checked I1.operator /(T lhs, T rhs) {...}
public static explicit checked I1.operator U(T x) {...}

または、演算子修飾子のセットに移動することもできます。

operator_modifier
    : 'public'
    | 'static'
    | 'extern'
    | 'checked'
    | operator_modifier_unsafe
    ;

public static checked T operator ++(T x) {...}
public static checked T operator --(T x) {...}
public static checked T operator -(T x) {...}
public static checked T operator +(T lhs, T rhs) {...}
public static checked T operator -(T lhs, T rhs) {...}
public static checked T operator *(T lhs, T rhs) {...}
public static checked T operator /(T lhs, T rhs) {...}
public static checked explicit operator U(T x) {...}

public static checked T I1.operator ++(T x) {...}
public static checked T I1.operator --(T x) {...}
public static checked T I1.operator -(T x) {...}
public static checked T I1.operator +(T lhs, T rhs) {...}
public static checked T I1.operator -(T lhs, T rhs) {...}
public static checked T I1.operator *(T lhs, T rhs) {...}
public static checked T I1.operator /(T lhs, T rhs) {...}
public static checked explicit I1.operator U(T x) {...}

unchecked キーワード

checked キーワードと同じ位置にあるキーワードuncheckedサポートするための提案があり、次の意味が考えられます。

• 演算子の規則的な性質を明示的に反映する、または
• おそらく、 unchecked コンテキストで使用されるはずの演算子の個別のフレーバーを指定します。 この言語では、 op_Addition、 op_CheckedAddition、および op_UncheckedAddition をサポートして、破壊的変更の数を制限できます。 これにより、ほとんどのコードでは必要ない可能性が高い複雑さのレイヤーが追加されます。

ECMA-335 の演算子名

また、演算子名は、末尾に Checked を使用して、op_UnaryNegationChecked、op_AdditionChecked、op_SubtractionChecked、op_MultiplyChecked、op_DivisionCheckedにすることができます。 ただし、演算子ワードで名前を終了するパターンが既に確立されているようです。 たとえば、op_RightShiftUnsigned演算子ではなく、op_UnsignedRightShift演算子があります。

Checked operators は、 unchecked コンテキストでは適用できません

コンパイラは、メンバー検索を実行して、 unchecked コンテキスト内で候補のユーザー定義演算子を検索するときに、 checked operatorsを無視できます。 checked operatorのみを定義するメタデータが検出された場合は、コンパイル エラーが発生します。

public class MyClass
{
    public static void Add(Int128 lhs, Int128 rhs)
    {
        // Resolves to `op_CheckedMultiply`
        Int128 r5 = checked(lhs * rhs);

        // Error: Operator '*' cannot be applied to operands of type 'Int128' and 'Int128'
        Int128 r5 = unchecked(lhs * rhs);
    }
}

public struct Int128
{
    public static Int128 operator checked *(Int128 lhs, Int128 rhs);
}

checked コンテキストでのより複雑な演算子の参照とオーバーロードの解決規則

コンパイラは、メンバー参照を実行して、 checked コンテキスト内で候補のユーザー定義演算子を検索する場合、 Checkedで終わる適用可能な演算子も考慮します。 つまり、コンパイラがバイナリ加算演算子の適用可能な関数メンバーを見つけようとしていた場合は、 op_Addition と op_AdditionCheckedの両方を検索します。 該当する関数メンバーのみが checked operatorの場合は、そのメンバーが使用されます。 regular operatorとchecked operatorの両方が存在し、同じように適用できる場合は、checked operatorをお勧めします。 regular operatorとchecked operatorの両方が存在するが、regular operatorが完全に一致しているのにchecked operatorが存在しない場合、コンパイラはregular operatorを優先します。

public class MyClass
{
    public static void Add(Int128 lhs, Int128 rhs)
    {
        // Resolves to `op_CheckedAddition`
        Int128 r1 = checked(lhs + rhs);

        // Resolves to `op_Addition`
        Int128 r2 = unchecked(lhs + rhs);

        // Resolve to `op_Subtraction`
        Int128 r3 = checked(lhs - rhs);

        // Resolve to `op_Subtraction`
        Int128 r4 = unchecked(lhs - rhs);
    }

    public static void Multiply(Int128 lhs, byte rhs)
    {
        // Resolves to `op_Multiply` even though `op_CheckedMultiply` is also applicable
        Int128 r4 = checked(lhs * rhs);
    }
}

public struct Int128
{
    public static Int128 operator checked +(Int128 lhs, Int128 rhs);
    public static Int128 operator +(Int128 lhs, Int128 rhs);

    public static Int128 operator -(Int128 lhs, Int128 rhs);

    public static Int128 operator checked *(Int128 lhs, int rhs);
    public static Int128 operator *(Int128 lhs, byte rhs);
}

さらに、候補のユーザー定義演算子のセットを構築する別の方法

単項演算子のオーバーロードの解決

regular operatorが評価コンテキストunchecked一致すると仮定すると、checked operatorは評価コンテキストchecked一致し、checked形式 (たとえば、+) を持たない演算子はどちらのコンテキストにも一致します。§12.4.4 - 単項演算子オーバーロード解決の最初の行頭文字。

• 操作operator op(x)のXによって提供される候補ユーザー定義演算子のセットは、§12.4.6 - Candidate ユーザー定義演算子の規則を使用して決定されます。

は、次の 2 つの箇条書きに置き換えられます。

• 現在のチェック/オフコンテキストを照合operator op(x)操作のXによって提供される候補ユーザー定義演算子のセットは、Candidate ユーザー定義演算子のルールを使用して決定されます。
• 候補のユーザー定義演算子のセットが空でない場合、これは演算の候補演算子のセットになります。 それ以外の場合、操作の X によって提供される候補のユーザー定義演算子のセット operator op(x)、逆のチェック/オフのコンテキストと一致 するかどうかは、 §12.4.6 - Candidate ユーザー定義演算子の規則を使用して決定されます。

二項演算子オーバーロードの解決

regular operatorが評価コンテキストunchecked一致すると仮定すると、checked operatorは評価コンテキストchecked一致し、checked形式 (たとえば、%) を持たない演算子はどちらのコンテキストにも一致します。§12.4.5 の最初の行頭文字 - 二項演算子オーバーロードの解決:

• 演算 X の Y および operator op(x,y) によって提供される候補ユーザー定義演算子のセットが決定されます。 セットは、 X によって提供される候補演算子と、 Yによって提供される候補演算子の和集合で構成され、それぞれが §12.4.6 - Candidate ユーザー定義演算子の規則を使用して決定されます。 X と Y が同じ型の場合、または X と Y が共通の基本型から派生している場合、共有候補演算子は結合セット内に 1 回だけ出現します。

は、次の 2 つの箇条書きに置き換えられます。

• 現在のチェック/オフのコンテキストと一致operator op(x,y)、操作のXとYによって提供される候補ユーザー定義演算子のセットが決定されます。 セットは、 X によって提供される候補演算子と、 Yによって提供される候補演算子の和集合で構成され、それぞれが §12.4.6 - Candidate ユーザー定義演算子の規則を使用して決定されます。 X と Y が同じ型の場合、または X と Y が共通の基本型から派生している場合、共有候補演算子は結合セット内に 1 回だけ出現します。
• 候補のユーザー定義演算子のセットが空でない場合、これは演算の候補演算子のセットになります。 それ以外の場合は、Xによって指定された候補のユーザー定義演算子のセットと、操作のYoperator op(x,y)、逆のチェック/オフのコンテキストと一致することが決定されます。 セットは、 X によって提供される候補演算子と、 Yによって提供される候補演算子の和集合で構成され、それぞれが §12.4.6 - Candidate ユーザー定義演算子の規則を使用して決定されます。 X と Y が同じ型の場合、または X と Y が共通の基本型から派生している場合、共有候補演算子は結合セット内に 1 回だけ出現します。

例 #1:

public class MyClass
{
    public static void Add(Int128 lhs, Int128 rhs)
    {
        // Resolves to `op_CheckedAddition`
        Int128 r1 = checked(lhs + rhs);

        // Resolves to `op_Addition`
        Int128 r2 = unchecked(lhs + rhs);

        // Resolve to `op_Subtraction`
        Int128 r3 = checked(lhs - rhs);

        // Resolve to `op_Subtraction`
        Int128 r4 = unchecked(lhs - rhs);

        // Resolves to `op_CheckedMultiply`
        Int128 r5 = checked(lhs * rhs);

        // Resolves to `op_CheckedMultiply`
        Int128 r5 = unchecked(lhs * rhs);
    }

    public static void Divide(Int128 lhs, byte rhs)
    {
        // Resolves to `op_CheckedDivision`
        Int128 r4 = checked(lhs / rhs);
    }
}

public struct Int128
{
    public static Int128 operator checked +(Int128 lhs, Int128 rhs);
    public static Int128 operator +(Int128 lhs, Int128 rhs);

    public static Int128 operator -(Int128 lhs, Int128 rhs);

    public static Int128 operator checked *(Int128 lhs, Int128 rhs);

    public static Int128 operator checked /(Int128 lhs, int rhs);
    public static Int128 operator /(Int128 lhs, byte rhs);
}

例 #2:

class C
{
    static void Add(C2 x, C3 y)
    {
        object o;
        
        // C1.op_CheckedAddition
        o = checked(x + y);
        
        // C2.op_Addition
        o = unchecked(x + y);
    }
}

class C1
{
    public static C1 operator checked + (C1 x, C3 y) => new C3();
}

class C2 : C1
{
    public static C2 operator + (C2 x, C1 y) => new C2();
}

class C3 : C1
{
}

#3 の例:

class C
{
    static void Add(C2 x, C3 y)
    {
        object o;
        
        // C2.op_CheckedAddition
        o = checked(x + y);
        
        // C1.op_Addition
        o = unchecked(x + y);
    }
}

class C1
{
    public static C1 operator + (C1 x, C3 y) => new C3();
}

class C2 : C1
{
    public static C2 operator checked + (C2 x, C1 y) => new C2();
}

class C3 : C1
{
}

例 4:

class C
{
    static void Add(C2 x, byte y)
    {
        object o;
        
        // C1.op_CheckedAddition
        o = checked(x + y);
        
        // C2.op_Addition
        o = unchecked(x + y);
    }

    static void Add2(C2 x, int y)
    {
        object o;
        
        // C2.op_Addition
        o = checked(x + y);
        
        // C2.op_Addition
        o = unchecked(x + y);
    }
}

class C1
{
    public static C1 operator checked + (C1 x, byte y) => new C1();
}

class C2 : C1
{
    public static C2 operator + (C2 x, int y) => new C2();
}

例 5:

class C
{
    static void Add(C2 x, byte y)
    {
        object o;
        
        // C2.op_CheckedAddition
        o = checked(x + y);
        
        // C1.op_Addition
        o = unchecked(x + y);
    }

    static void Add2(C2 x, int y)
    {
        object o;
        
        // C1.op_Addition
        o = checked(x + y);
        
        // C1.op_Addition
        o = unchecked(x + y);
    }
}

class C1
{
    public static C1 operator + (C1 x, int y) => new C1();
}

class C2 : C1
{
    public static C2 operator checked + (C2 x, byte y) => new C2();
}

ユーザー定義の明示的な変換の処理

regular operatorが評価コンテキストunchecked一致し、checked operatorが評価コンテキストchecked一致すると仮定すると、§10.5.3 ユーザー定義変換の評価の 3 番目の行頭文字は次のようになります。

• 適用可能なユーザー定義およびリフトされた変換演算子のセット U を検索します。 このセットは、D 内のクラスまたは構造体によって宣言されたユーザー定義およびリフトされた暗黙的または明示的な変換演算子で構成され、S を包含する、またはそれに包含される型から、T を包含する、またはそれに包含される型に変換します。 If U が空である場合、その変換は未定義であり、コンパイル時エラーが発生します。

は、次の箇条書きに置き換えられます。

• 現在のチェック/オフのコンテキスト (U0) と一致する、適用可能なユーザー定義およびリフトされた明示的な変換演算子のセットを検索します。 このセットは、現在のチェック/オフのコンテキストに一致するD内のクラスまたは構造体によって宣言されたユーザー定義およびリフトされた明示的な変換演算子で構成され、Sを包含または包含する型からTを包含または包含する型に変換します。
• オン/オフの逆のコンテキストと一致する、適用可能なユーザー定義およびリフトされた明示的な変換演算子のセットを検索U1。 U0が空でない場合、U1は空です。 それ以外の場合、このセットは、逆のチェック/オフのコンテキストに一致するDのクラスまたは構造体によって宣言されたユーザー定義およびリフトされた明示的な変換演算子で構成され、Sを包含または包含する型から、Tを包含または包含する型に変換します。
• 適用可能なユーザー定義およびリフトされた変換演算子のセット U を検索します。 このセットは、 U0、 U1、および D 内のクラスまたは構造体によって宣言されたユーザー定義およびリフトされた暗黙的な変換演算子で構成されます。この演算子は、 S を包含または包含する型から、 Tを包含または包含する型に変換します。 If U が空である場合、その変換は未定義であり、コンパイル時エラーが発生します。

さらに、候補のユーザー定義演算子のセットを構築するもう 1 つの方法

単項演算子のオーバーロードの解決

セクション §12.4.4 の最初の行頭文字は、次のように調整されます (追加は太字です)。

• 操作operator op(x)のXによって提供される候補ユーザー定義演算子のセットは、後述の「ユーザー定義演算子候補」セクションのルールを使用して決定されます。 チェックされたフォームに少なくとも 1 つの演算子がセットに含まれている場合、通常の形式のすべての演算子がセットから削除されます。

セクション §12.8.20 は、単項演算子のオーバーロード解決に対するチェック/オフコンテキストの効果を反映するように調整されます。

二項演算子オーバーロードの解決

セクション §12.4.5 の最初の行頭文字は、次のように調整されます (追加は太字です)。

• 演算 X の Y および operator op(x,y) によって提供される候補ユーザー定義演算子のセットが決定されます。 セットは、 X によって提供される候補演算子と、 Yによって提供される候補演算子の和集合で構成されます。各演算子は、以下の「ユーザー定義演算子候補」セクションの規則を使用して決定されます。 X と Y が同じ型の場合、または X と Y が共通の基本型から派生している場合、共有候補演算子は結合セット内に 1 回だけ出現します。 チェックされたフォームに少なくとも 1 つの演算子がセットに含まれている場合、通常の形式のすべての演算子がセットから削除されます。

Checked 演算子と unchecked 演算子 §12.8.20 セクションは、チェック/オフのコンテキストが二項演算子のオーバーロード解決に与える影響を反映するように調整されます。

ユーザー定義演算子候補

§12.4.6 - ユーザー定義演算子候補セクションは、次のように調整されます (追加は太字です)。

型Tと操作operator op(A)opがオーバーロード可能な演算子であり、Aが引数リストである場合、operator op(A)に対してTによって提供される候補ユーザー定義演算子のセットは次のように決定されます。

• T0 型を決定します。 Tが null 許容型の場合、T0は基になる型です。それ以外の場合、T0はTと等しくなります。
• checked評価コンテキスト内のチェック済みおよび標準形式のすべてのoperator op宣言について、T0およびそのような演算子のすべてのリフトされた形式のunchecked評価コンテキスト内の通常の形式でのみ、引数リストAに対して少なくとも 1 つの演算子 (§12.6.4.2) が適用できる場合、候補演算子のセットは、T0のすべての該当する演算子で構成されます。
• それ以外の場合、 T0 が object場合、候補の演算子のセットは空になります。
• それ以外の場合、 T0 によって提供される候補演算子のセットは、 T0の直接基底クラスによって提供される候補演算子のセット、または T0 が型パラメーターの場合は T0 の有効な基底クラスです。

同様のフィルター処理が適用され、インターフェイス https://github.com/dotnet/csharplang/blob/main/meetings/2017/LDM-2017-06-27.md#shadowing-within-interfacesの候補演算子のセットが決定されます。

§12.8.20 セクションは、単項演算子と二項演算子のオーバーロード解決に対するチェック/オフコンテキストの影響を反映するように調整されます。

例 #1:

public class MyClass
{
    public static void Add(Int128 lhs, Int128 rhs)
    {
        // Resolves to `op_CheckedAddition`
        Int128 r1 = checked(lhs + rhs);

        // Resolves to `op_Addition`
        Int128 r2 = unchecked(lhs + rhs);

        // Resolve to `op_Subtraction`
        Int128 r3 = checked(lhs - rhs);

        // Resolve to `op_Subtraction`
        Int128 r4 = unchecked(lhs - rhs);

        // Resolves to `op_CheckedMultiply`
        Int128 r5 = checked(lhs * rhs);

        // Error: Operator '*' cannot be applied to operands of type 'Int128' and 'Int128'
        Int128 r5 = unchecked(lhs * rhs);
    }

    public static void Divide(Int128 lhs, byte rhs)
    {
        // Resolves to `op_CheckedDivision`
        Int128 r4 = checked(lhs / rhs);
    }
}

public struct Int128
{
    public static Int128 operator checked +(Int128 lhs, Int128 rhs);
    public static Int128 operator +(Int128 lhs, Int128 rhs);

    public static Int128 operator -(Int128 lhs, Int128 rhs);

    public static Int128 operator checked *(Int128 lhs, Int128 rhs);

    public static Int128 operator checked /(Int128 lhs, int rhs);
    public static Int128 operator /(Int128 lhs, byte rhs);
}

例 #2:

class C
{
    static void Add(C2 x, C3 y)
    {
        object o;
        
        // C1.op_CheckedAddition
        o = checked(x + y);
        
        // C2.op_Addition
        o = unchecked(x + y);
    }
}

class C1
{
    public static C1 operator checked + (C1 x, C3 y) => new C3();
}

class C2 : C1
{
    public static C2 operator + (C2 x, C1 y) => new C2();
}

class C3 : C1
{
}

#3 の例:

class C
{
    static void Add(C2 x, C3 y)
    {
        object o;
        
        // C2.op_CheckedAddition
        o = checked(x + y);
        
        // C1.op_Addition
        o = unchecked(x + y);
    }
}

class C1
{
    public static C1 operator + (C1 x, C3 y) => new C3();
}

class C2 : C1
{
    public static C2 operator checked + (C2 x, C1 y) => new C2();
}

class C3 : C1
{
}

例 4:

class C
{
    static void Add(C2 x, byte y)
    {
        object o;
        
        // C2.op_Addition
        o = checked(x + y);
        
        // C2.op_Addition
        o = unchecked(x + y);
    }

    static void Add2(C2 x, int y)
    {
        object o;
        
        // C2.op_Addition
        o = checked(x + y);
        
        // C2.op_Addition
        o = unchecked(x + y);
    }
}

class C1
{
    public static C1 operator checked + (C1 x, byte y) => new C1();
}

class C2 : C1
{
    public static C2 operator + (C2 x, int y) => new C2();
}

例 5:

class C
{
    static void Add(C2 x, byte y)
    {
        object o;
        
        // C2.op_CheckedAddition
        o = checked(x + y);
        
        // C1.op_Addition
        o = unchecked(x + y);
    }

    static void Add2(C2 x, int y)
    {
        object o;
        
        // C1.op_Addition
        o = checked(x + y);
        
        // C1.op_Addition
        o = unchecked(x + y);
    }
}

class C1
{
    public static C1 operator + (C1 x, int y) => new C1();
}

class C2 : C1
{
    public static C2 operator checked + (C2 x, byte y) => new C2();
}

ユーザー定義の明示的な変換の処理

§10.5.5 の 3 番目の行頭文字:

• 適用可能なユーザー定義およびリフトされた変換演算子のセット U を検索します。 このセットは、D 内のクラスまたは構造体によって宣言されたユーザー定義およびリフトされた暗黙的または明示的な変換演算子で構成され、S を包含する、またはそれに包含される型から、T を包含する、またはそれに包含される型に変換します。 If U が空である場合、その変換は未定義であり、コンパイル時エラーが発生します。

は、次の箇条書きに置き換えられます。

• 適用可能なユーザー定義およびリフトされた明示的な変換演算子のセット ( U0) を検索します。 このセットは、Dのクラスまたは構造体によって宣言されたユーザー定義およびリフトされた明示的な変換演算子で構成され、checked評価コンテキスト内のチェックフォームと標準フォームでのみ、unchecked評価コンテキスト内の通常の形式で、Sを包含または包含する型から、Tを包含または包含する型に変換します。
• U0チェック フォームに少なくとも 1 つの演算子が含まれている場合、通常の形式のすべての演算子がセットから削除されます。
• 適用可能なユーザー定義およびリフトされた変換演算子のセット U を検索します。 このセットは、 U0の演算子と、 D 内のクラスまたは構造体によって宣言されたユーザー定義およびリフトされた暗黙的な変換演算子で構成されます。この演算子は、 S を包含または包含する型から、 Tを包含または包含する型に変換します。 If U が空である場合、その変換は未定義であり、コンパイル時エラーが発生します。

Checked 演算子と unchecked 演算子 §12.8.20 セクションは、チェック/オフのコンテキストがユーザー定義の明示的な変換の処理に与える影響を反映するように調整されます。

内のチェックされたコンテキストとチェックされていないコンテキスト checked operator

コンパイラは、 checked operator の既定のコンテキストをチェック済みとして扱う場合があります。 開発者は、アルゴリズムの一部がchecked contextに参加してはならない場合は、uncheckedを明示的に使用する必要があります。 ただし、 checked/unchecked トークンを演算子の修飾子として許可し始め、本文内でコンテキストを設定し始めると、これは将来うまく機能しない可能性があります。 修飾子とキーワードは互いに矛盾する可能性があります。 また、 regular operator に対して同じ (既定のコンテキストをオフに扱う) ことはできなくなります。これは破壊的変更になるためです。