Why is double implicitly converted to int in a cast operator?

This is strange behaviour that I haven't noticed before. I expected not to be able to cast from a double but instead the double value is implicitly converted to an int and I silently lose the fractional portion. Can I really not convert from ints without also converting from doubles?

readonly struct TestDecimal {
   public decimal Value { get; }

   TestDecimal(decimal value) => 
      Value = value;

   public static explicit operator TestDecimal(int x) => new(x);
}

...

// these assertions fail, but really this shouldn't even compile
[TestMethod]
public void Test_CastFromDouble() {
   var value = (TestDecimal)12.34; // shouldn't compile
   Assert.AreEqual(12.34m, value.Value); // assertion failed, actual value: 12.0m
}

[TestMethod]
public void Test_CastFromDecimal() {
   var value = (TestDecimal)12.34m; // shouldn't compile
   Assert.AreEqual(12.34m, value.Value); // assertion failed, actual value: 12.0m
}

This is because standard conversions can occur as part of a user-defined conversion. Before your user-defined conversion, there can be a standard conversion converting the expression's type to the type your conversion operator expects. There can also be another standard conversion converting the return value of your conversion operator to whatever type is expected in that context.

§10.5.3 Evaluation of user-defined conversions

> Once a most-specific user-defined conversion operator has been
> identified, the actual execution of the user-defined conversion
> involves up to three steps:
>
> - First, if required, performing a standard conversion from the source expression to the operand type of the user-defined or lifted
> conversion operator.
> - Next, invoking the user-defined or lifted conversion operator to perform the conversion.
> - Finally, if required, performing a standard conversion from the result type of the user-defined conversion operator to the target
> type.

This section then goes on to define terms such as most-encompassing type, which are then used in §10.5.5 to describe how exactly these conversions are resolved.

Most importantly for your case, the standard explicit conversions include "double to int" and "decimal to int". This enables you to call your conversion operator with double/decimal as arguments. See the language spec sections:

§10.4.3:

> The standard explicit conversions are all standard implicit
> conversions plus the subset of the explicit conversions for which an
> opposite standard implicit conversion exists.

Both "double to int" and "decimal to int" are "explicit conversions for which an opposite standard implicit conversion exists".

§10.3.2 Explicit numeric conversions:

> - ...
> - From double to sbyte, byte, short, ushort, int, uint, long, ulong, char, float, or double.
> - From decimal to sbyte, byte, short, ushort, int, uint, long, ulong, char, float, or double.
> - ...

§10.4.2

> The following implicit conversions are classified as standard implicit
> conversions:
>
> - ...
> - Implicit numeric conversions (§10.2.3)

§10.2.3:

> The implicit numeric conversions are:
>
> - ...
> - From int to long, float, double, or decimal.
> - ...