Ability to create implicit conversions to int

[remyvanlis]

Hi there,

in the binder the TokenType for int is 'keyword', which in the Binder's switch case will be replaced with Int32. It seems that the CodeAnalyzor is unaware of this and simply states that the struct Int32 is not equal to Keyword - but Keyword will become Int32 in a later stage - that seems weird to me.

Currently, it's impossible to do something like this for implicit enum conversion:

public enum MyEnum
{
    Value1,
    Value2
}
    
int foo = MyEnum.Value1;

If the code analyzor would allow the compiler to continue if Int32 were equal to the integer keyword, developers would be allowed to implicitly assign enums to integers with something like this partial struct on Int32:

public partial struct Int32
{
    public static implicit operator Int32(MyEnum mt) => (Int32)mt;
}

I think this would be a fun feature that developers would enjoy. In many codebases there are a TON of:

int a = (int) MyEnum.value1;
int b = (int) MyEnum.value2;
int c = (int) MyEnum.value3;
int d = (int) MyEnum.value4;

while the int conversion could be skipped if the analyzor just knew that the IntegerKeyword would actually become the struct Int32.

[HaloFour]

I think this might come for free with extension operators, assuming they cover conversion operators:

public static class EnumIntExtensions {
    extension(T) where T : System.Enum, struct {
        public static implicit operator int(T e) {
            return (int) e;
        }
    }
}

Note that not all enums are backed in a 32-bit int, though, so this could fail with some enum types. You really shouldn't be treating enums like raw numbers, which is why C# doesn't allow an implicit conversation.

[remyvanlis]

You're conflating two things. You could have written int foo = MyEnum.Value1; and you would be similarly blocked from writing Int32 bar = MyEnum.Value2;. int and Int32 are entirely exchangeable semantically (as long as Int32 actually binds to System.Int32.

What's going on here is simply that we (for legacy historical reasons) allow the constant zero value to be assignable between enum and int. That's true regardless of whether you write it as int (the builtin lang keyword) or as Int32 (the well known framework type that it maps to).

This is actually false; if that is in fact the intended behavior, it's actually even more concerning that this doesn't work:

Feel free to try this yourself.

[remyvanlis]

Noting that binds to System.Int32 here doesn’t mean any type defined in that namespace with that name.

It specifically means the version defined in the same assembly that defined System.Object and which has no dependencies. Said assembly is frequently referred to as “corelib”

What you’ve done in your example is to define a custom user-defined System.Int32 struct which exists in your own assembly and which is distinct from the system defined one that is aliased to the int keyword — your defined implicit conversion also won’t work, it recurses infinitely on itself and will either never return or stack overflow (depending on compiler optimizations)

That claim is also false; it is a partial struct, meaning we keep the entire struct for Int32 and simply append it with the implicit operator for MyEnum:

That is why int baz = foo * 3; is still completely functional - it is still the sytem.Int32, it's just appended on.

[CyrusNajmabadi]

Feel free to try this yourself.

You are defining your own int32 type, which has no relation to the one provided by the system.

[CyrusNajmabadi]

You are not reading or understanding the responses from several of the designers here.

Your own System.Int32 type is not special. It has no relationship to the actual built-in System.Int32 type (see tanner's comment).

int maps exactly to that type. Always.

--

Aside from that, there are rules for how enums behave (including with the special constant zero value).

Please read the rules in the language here. You keep ignoring the critical information people are taking time to get you to understand.

[remyvanlis]

You are not reading or understanding the responses from several of the designers here.

Your own System.Int32 type is not special. It has no relationship to the actual built-in System.Int32 type (see tanner's comment).

int maps exactly to that type. Always.

--

Aside from that, there are rules for how enums behave (including with the special constant zero value).

Please read the rules in the language here. You keep ignoring the critical information people are taking time to get you to understand.

Ahh I see now. So it is in reality impossible to modify built-in types - Rider just "thinks" that it is working. In that case this is entirely my bad and I apologise for misunderstanding!

In that case that's all clear.

[CyrusNajmabadi]

Cheers!