Serious bugs with lifted/nullable conversions from int, allowing conversion from decimal

I think this question will bring me instant fame here on Stack Overflow. Suppose you have the following type: ``` // represents a decimal number with at most two decimal places after the period struct NumberFixedPoint2 { decimal number; // an integer has no fractional part; can convert to this type public static implicit operator NumberFixedPoint2(int integer) { return new NumberFixedPoint2 { number = integer }; } // this type is a decimal number; can convert to System.Decimal public static implicit operator decimal(NumberFixedPoint2 nfp2) { return nfp2.number; } /* will add more nice members later */ } ``` It has been written such that only safe conversions that don't lose precision are allowed. However, when I try this code: ``` static void Main() { decimal bad = 2.718281828m; NumberFixedPoint2 badNfp2 = (NumberFixedPoint2)bad; Console.WriteLine(badNfp2); } ``` I am surprised this compiles and, when run, writes out `2`. The conversion from `int` (of value `2`) to `NumberFixedPoint2` is important here. (An overload of `WriteLine` that takes in a `System.Decimal` is preferred, in case anyone wonders.) Why on Earth is the conversion from `decimal` to `NumberFixedPoint2` allowed? (By the way, in the above code, if `NumberFixedPoint2` is changed from a struct to a class, nothing changes.) Do you know if the C# Language Specification says that an implicit conversion from `int` to a custom type "implies" the existence of a "direct" explicit conversion from `decimal` to that custom type? It becomes much worse. Try this code instead: ``` static void Main() { decimal? moreBad = 7.3890560989m; NumberFixedPoint2? moreBadNfp2 = (NumberFixedPoint2?)moreBad; Console.WriteLine(moreBadNfp2.Value); } ``` As you see, we have (lifted) `Nullable<>` conversions here. But oh yes, that does compile. When compiled in x86 "platform", this code writes out an unpredictable numeric value. Which one varies from time to time. As an example, on one occasion I got `2289956`. Now, that's one serious bug! When compiled for the x64 platform, the above code crashes the application with a `System.InvalidProgramException` with message Common Language Runtime detected an invalid program. According to the documentation of the `InvalidProgramException` class: Generally this indicates a bug in the compiler that generated the program. Does anyone (like Eric Lippert, or someone who has worked with lifted conversions in the C# compiler) know the cause of these bugs? Like, what is a sufficient condition that we don't run into them in our code? Because the type `NumberFixedPoint2` is actually something that we have in real code (managing other people's money and stuff).