[Proposal]: Simplify Enum Value Access

[huoshan12345]

Summary

Allow enum values to be referenced without requiring the enum type's prefix (e.g., SomeValue instead of SomeEnum.SomeValue) in contexts where the type is already implied or inferred.

Motivation

Currently, enum values must always be prefixed by their enum type, even when the type is clear from the context. This results in verbose, redundant code and reduces readability.

Current Example:

public void SetState(SomeEnum state)
{
    if (state == SomeEnum.SomeValue)
    {
    }
}

Proposed Usage:

public void SetState(SomeEnum state)
{
    if (state == SomeValue)
    {
    }
}

This change would make code cleaner and improve developer productivity, especially in enum-heavy scenarios.

Proposed Solution

Enable context-sensitive access to enum values, where the type can be inferred from the current scope (e.g., method parameters, variables, or properties).
This feature could be limited to specific scopes, avoiding conflicts and preserving clarity.

Why Not Static Imports?

Static imports (using static SomeEnum;) are often suggested as a solution but are not ideal because:

• They introduce global scope pollution, exposing all enum values across the file.
• They fail in cases of name conflicts, where two enums have members with the same name. For example:

using static SomeEnum;
using static AnotherEnum;

public enum SomeEnum
{
    SomeValue,
}

public enum AnotherEnum
{
    SomeValue,
}

public static void SetState(SomeEnum state)
{
    // Error: 'SomeValue' is ambiguous between 'SomeEnum' and 'AnotherEnum'
    if (state == SomeValue)
    {
    }
}

These issues make static imports unsuitable for simplifying enum usage in a safe and scalable way.

Benefits

• Improved Readability: Reduces redundant type qualifiers, making code cleaner and easier to read.
• Productivity: Minimizes boilerplate and typing overhead.
• Scalability: Works well in large codebases with multiple enums.

[CyrusNajmabadi]

Dupe of #2926

[huoshan12345]

Thanks for quick reply. I saw the original issue is converted to a discussion.
May I ask is it still under consideration, like it might be included in TypeUnions?

[CyrusNajmabadi]

May I ask is it still under consideration

Yes. The discussion tracks that. Thanks