Penasaran null-coalescing perilaku tersirat kustom operator konversi

Catatan: ini tampaknya telah diperbaiki di Roslyn

Pertanyaan ini muncul ketika menulis jawaban saya untuk yang ini , yang berbicara tentang asosiatifitas operator penggabungan nol .

Sama seperti pengingat, ide dari operator null-coalescing adalah ekspresi dari form

x ?? y

pertama mengevaluasi x, lalu:

• Jika nilai xnol, ydievaluasi dan itu adalah hasil akhir dari ekspresi
• Jika nilai xnon-null, yyang tidak dievaluasi, dan nilai xadalah hasil akhir dari ekspresi, setelah konversi ke jenis kompilasi-waktu yjika diperlukan

Sekarang biasanya tidak perlu konversi, atau itu hanya dari jenis nullable ke non-nullable - biasanya jenisnya sama, atau hanya dari (katakanlah) int?ke int. Namun, Anda dapat membuat operator konversi tersirat Anda sendiri, dan itu digunakan jika perlu.

Untuk kasus sederhana x ?? y, saya belum melihat perilaku aneh. Namun, dengan (x ?? y) ?? zsaya melihat beberapa perilaku membingungkan.

Berikut ini adalah program pengujian singkat tapi lengkap - hasilnya ada di komentar:

using System;

public struct A
{
    public static implicit operator B(A input)
    {
        Console.WriteLine("A to B");
        return new B();
    }

    public static implicit operator C(A input)
    {
        Console.WriteLine("A to C");
        return new C();
    }
}

public struct B
{
    public static implicit operator C(B input)
    {
        Console.WriteLine("B to C");
        return new C();
    }
}

public struct C {}

class Test
{
    static void Main()
    {
        A? x = new A();
        B? y = new B();
        C? z = new C();
        C zNotNull = new C();

        Console.WriteLine("First case");
        // This prints
        // A to B
        // A to B
        // B to C
        C? first = (x ?? y) ?? z;

        Console.WriteLine("Second case");
        // This prints
        // A to B
        // B to C
        var tmp = x ?? y;
        C? second = tmp ?? z;

        Console.WriteLine("Third case");
        // This prints
        // A to B
        // B to C
        C? third = (x ?? y) ?? zNotNull;
    }
}

Jadi kami memiliki tiga tipe nilai khusus A,, Bdan C, dengan konversi dari A ke B, A ke C, dan B ke C.

Saya dapat memahami kasus kedua dan ketiga ... tetapi mengapa ada konversi tambahan A ke B dalam kasus pertama? Khususnya, saya benar - benar berharap kasus pertama dan kedua menjadi hal yang sama - setelah itu, hanya mengekstraksi ekspresi menjadi variabel lokal.

Adakah yang tahu apa yang terjadi? Saya sangat ragu untuk menangis "bug" ketika datang ke kompiler C #, tapi saya bingung apa yang terjadi ...

EDIT: Oke, ini contoh buruk tentang apa yang terjadi, berkat jawaban konfigurator, yang memberi saya alasan lebih lanjut untuk menganggapnya sebagai bug. Sunting: Sampel bahkan tidak perlu dua operator penggabungan nol sekarang ...

using System;

public struct A
{
    public static implicit operator int(A input)
    {
        Console.WriteLine("A to int");
        return 10;
    }
}

class Test
{
    static A? Foo()
    {
        Console.WriteLine("Foo() called");
        return new A();
    }

    static void Main()
    {
        int? y = 10;

        int? result = Foo() ?? y;
    }
}

Output dari ini adalah:

Foo() called
Foo() called
A to int

Fakta bahwa Foo()dipanggil dua kali di sini sangat mengejutkan bagi saya - saya tidak dapat melihat alasan mengapa ekspresi dievaluasi dua kali.

Terima kasih kepada semua orang yang berkontribusi dalam menganalisis masalah ini. Ini jelas merupakan bug penyusun. Tampaknya hanya terjadi ketika ada konversi terangkat yang melibatkan dua jenis nullable di sisi kiri operator penggabungan.

Saya belum mengidentifikasi di mana tepatnya ada yang salah, tetapi pada beberapa titik selama fase kompilasi "nullable menurunkan" - setelah analisis awal tetapi sebelum pembuatan kode - kami mengurangi ekspresi

result = Foo() ?? y;

dari contoh di atas hingga yang setara dengan moral:

A? temp = Foo();
result = temp.HasValue ? 
    new int?(A.op_implicit(Foo().Value)) : 
    y;

Jelas itu tidak benar; penurunan yang benar adalah

result = temp.HasValue ? 
    new int?(A.op_implicit(temp.Value)) : 
    y;

Tebakan terbaik saya berdasarkan analisis saya sejauh ini adalah bahwa pengoptimal nullable keluar dari jalur di sini. Kami memiliki pengoptimal yang dapat dibatalkan yang mencari situasi di mana kami tahu bahwa ekspresi tertentu dari jenis yang tidak dapat dibatalkan tidak mungkin nol. Pertimbangkan analisis naif berikut: pertama-tama kita mungkin mengatakan itu

result = Foo() ?? y;

sama dengan

A? temp = Foo();
result = temp.HasValue ? 
    (int?) temp : 
    y;

dan kemudian kita bisa mengatakan itu

conversionResult = (int?) temp 

sama dengan

A? temp2 = temp;
conversionResult = temp2.HasValue ? 
    new int?(op_Implicit(temp2.Value)) : 
    (int?) null

Tetapi pengoptimal dapat melangkah dan berkata "tunggu dulu, kami sudah memeriksa bahwa temp bukan nol; tidak perlu memeriksanya untuk null untuk yang kedua kalinya hanya karena kami memanggil operator konversi yang diangkat". Kami ingin mereka mengoptimalkannya menjadi adil

new int?(op_Implicit(temp2.Value)) 

Dugaan saya adalah bahwa kita berada di suatu tempat yang menyembunyikan fakta bahwa bentuk yang dioptimalkan (int?)Foo()adalah new int?(op_implicit(Foo().Value))tetapi itu sebenarnya bukan bentuk yang dioptimalkan yang kita inginkan; kami ingin bentuk yang dioptimalkan dari Foo () - diganti-dengan-sementara-dan-kemudian dikonversi.

Banyak bug di kompiler C # adalah hasil dari keputusan caching yang buruk. Sebuah kata bijak: setiap kali Anda menyimpan fakta untuk digunakan nanti, Anda berpotensi menciptakan inkonsistensi jika sesuatu yang relevan berubah . Dalam hal ini hal yang relevan yang telah berubah pasca analisis awal adalah bahwa panggilan ke Foo () harus selalu direalisasikan sebagai pengambilan sementara.

Kami melakukan banyak reorganisasi dari pass penulisan ulang nullable di C # 3.0. Bug mereproduksi dalam C # 3.0 dan 4.0 tetapi tidak dalam C # 2.0, yang berarti bahwa bug itu mungkin buruk saya. Maaf!

Saya akan memasukkan bug ke dalam basis data dan kami akan melihat apakah kami dapat memperbaikinya untuk versi bahasa yang akan datang. Sekali lagi terima kasih untuk analisis Anda; itu sangat membantu!

PEMBARUAN: Saya menulis ulang pengoptimal yang dapat dibatalkan dari awal untuk Roslyn; sekarang melakukan pekerjaan yang lebih baik dan menghindari kesalahan aneh semacam ini. Untuk beberapa pemikiran tentang cara kerja pengoptimal di Roslyn, lihat seri artikel saya yang dimulai di sini: https://ericlippert.com/2012/12/20/nullable-micro-optimizations-part-one/

Ini pasti bug.

public class Program {
    static A? X() {
        Console.WriteLine("X()");
        return new A();
    }
    static B? Y() {
        Console.WriteLine("Y()");
        return new B();
    }
    static C? Z() {
        Console.WriteLine("Z()");
        return new C();
    }

    public static void Main() {
        C? test = (X() ?? Y()) ?? Z();
    }
}

Kode ini akan menampilkan:

X()
X()
A to B (0)
X()
X()
A to B (0)
B to C (0)

Itu membuat saya berpikir bahwa bagian pertama dari setiap ??ekspresi penggabungan dievaluasi dua kali. Kode ini membuktikannya:

B? test= (X() ?? Y());

output:

X()
X()
A to B (0)

Ini tampaknya terjadi hanya ketika ekspresi membutuhkan konversi antara dua jenis nullable; Saya telah mencoba berbagai permutasi dengan salah satu sisi menjadi string, dan tidak ada satupun yang menyebabkan perilaku ini.

Jika Anda melihat pada kode yang dibuat untuk case yang dikelompokkan Kiri itu benar-benar melakukan sesuatu seperti ini ( csc /optimize-):

C? first;
A? atemp = a;
B? btemp = (atemp.HasValue ? new B?(a.Value) : b);
if (btemp.HasValue)
{
    first = new C?((atemp.HasValue ? new B?(a.Value) : b).Value);
}

Menemukan lain, jika Anda menggunakannya first akan menghasilkan jalan pintas jika keduanya adan badalah null dan kembali c. Namun jika aatau btidak nol itu mengevaluasi kembali asebagai bagian dari konversi implisit untuk Bsebelum mengembalikan yang aatau btidak nol.

Dari Spesifikasi C # 4.0, §6.1.4:

• Jika konversi yang dapat dibatalkan adalah dari S?ke T?:
  • Jika nilai sumber adalah null( HasValueproperti adalah false), hasilnya adalah nullnilai tipe T?.
  • Jika tidak, konversi dievaluasi sebagai unwrapping dari S?ke S, diikuti oleh konversi yang mendasari dari Ske T, diikuti oleh pembungkus (§4.1.10) dari Tke T?.

Ini tampaknya menjelaskan kombinasi pembungkusan-pembungkus kedua.

Kompiler C # 2008 dan 2010 menghasilkan kode yang sangat mirip, namun ini terlihat seperti regresi dari kompiler C # 2005 (8.00.50727.4927) yang menghasilkan kode berikut untuk yang di atas:

A? a = x;
B? b = a.HasValue ? new B?(a.GetValueOrDefault()) : y;
C? first = b.HasValue ? new C?(b.GetValueOrDefault()) : z;

Aku ingin tahu apakah ini bukan karena sihir tambahan yang diberikan pada sistem inferensi tipe?

Sebenarnya, saya akan menyebutnya bug sekarang, dengan contoh yang lebih jelas. Ini masih berlaku, tetapi evaluasi ganda jelas tidak baik.

Tampaknya seolah-olah A ?? Bdiimplementasikan sebagai A.HasValue ? A : B. Dalam hal ini, ada banyak casting juga (mengikuti casting reguler untuk ?:operator ternary ). Tetapi jika Anda mengabaikan semua itu, maka ini masuk akal berdasarkan cara penerapannya:

1. A ?? B meluas ke A.HasValue ? A : B
2. Aadalah milik kita x ?? y. Luaskan kex.HasValue : x ? y
3. ganti semua kemunculan A -> (x.HasValue : x ? y).HasValue ? (x.HasValue : x ? y) : B

Di sini Anda dapat melihat bahwa x.HasValuedicentang dua kali, dan jika x ?? ymembutuhkan casting, xakan dicasting dua kali.

Saya meletakkannya hanya sebagai artefak tentang bagaimana ??diimplementasikan, daripada bug kompiler. Take-Away: Jangan membuat operator casting implisit dengan efek samping.

Tampaknya menjadi kompiler bug yang berputar di sekitar bagaimana ??diterapkan. Take-away: jangan bersarang ekspresi penggabungan dengan efek samping.

Saya bukan ahli C # sama sekali seperti yang Anda lihat dari riwayat pertanyaan saya, tetapi, saya mencoba ini dan saya pikir ini adalah bug .... tetapi sebagai pemula, saya harus mengatakan bahwa saya tidak mengerti semuanya berjalan di sini jadi saya akan menghapus jawaban saya jika saya jauh.

Saya sampai pada bugkesimpulan ini dengan membuat versi berbeda dari program Anda yang berhubungan dengan skenario yang sama, tetapi tidak terlalu rumit.

Saya menggunakan tiga properti integer nol dengan backing store. Saya mengatur masing-masing ke 4 dan kemudian menjalankanint? something2 = (A ?? B) ?? C;

( Kode lengkap di sini )

Ini hanya membaca A dan tidak ada yang lain.

Pernyataan ini bagi saya sepertinya bagi saya seharusnya:

1. Mulai dalam tanda kurung, lihat A, kembalikan A dan selesaikan jika A tidak nol.
2. Jika A adalah nol, evaluasi B, selesaikan jika B bukan nol
3. Jika A dan B adalah nol, evaluasi C.

Jadi, karena A bukan nol, itu hanya melihat A dan selesai.

Dalam contoh Anda, meletakkan breakpoint pada Kasus Pertama menunjukkan bahwa x, y dan z semuanya tidak nol dan oleh karena itu, saya berharap mereka diperlakukan sama seperti contoh saya yang kurang kompleks .... tapi saya takut saya terlalu banyak seorang pemula C # dan telah melewatkan inti pertanyaan ini sepenuhnya!