[Static abstract?] Constants in interfaces

[Perksey]

This is a significantly reduced scope variant of #6748

The proposal is to have constants in interfaces (similar to static abstract) such that generic parameters can be used in constant expressions (like attribute arguments). This enables the ValueArray use case that motivated @hez2010's constant generics MVP without creating a massive amount of work or committing to too many changes in the type system for a niche use case.

public interface X
{
     const int Y;
}
public class XImpl : X
{
    public const int Y = 3;
}
public class XAdder<T, U> : X where T: X where Y: X
{
    public const int Y = T.Y + U.Y;
}

Perhaps the above example shows how even this could be... umm... "well-used" by the community, but this feels like a minor addition and minor commitment at the language-level and runtime-level compared to constant generics while achieving most of the same effect.

[HaloFour]

I'm not sure how this would work. Constants aren't really members, let alone virtual members. The call site is expected to be replaced by the compiler during compilation. This changes that concept drastically.

[Perksey]

If the problem was already solved I wouldn't be opening this issue.

[HaloFour]

I'm only suggesting that it's not simple, and it effectively changes the meaning of constants in the .NET ecosystem. Why wouldn't existing mechanisms, like declaring an abstract static get-only property, be sufficient?

[Perksey]

These cannot be used in constant expressions thereby preventing their use in attribute arguments ergo preventing the ValueArray use case for which constant generics (a far more wider-reaching and expensive proposal) was originally proposed. This will still need some metadata definition, as attribute arguments currently must be encoded subject to strict rules, but even still will be less damaging than const generics given that it’d be a niche solution for a niche problem.

[HaloFour]

Being used as an attribute argument would require that the value of the constant be known at compile time so that the compiler can replace the reference to the constant with the literal value. I don't see how that works if the constant itself can be expressed as an expression.

[Perksey]

Yeah, it'll still need some metadata definition as attribute arguments currently must be encoded subject to strict rules. I guess it comes down to the fact that the JIT sees each instantiation of a type as a separate type, but the language does not.

[colejohnson66]

What’s wrong with static abstract getters? The JIT will inline it for you.

[Perksey]

Can't be used as attribute arguments, the motivating use case. This can't either without some metadata changes.

[Joe4evr]

@Perksey Do you happen to own the attribute that you want to use this with? If so, you can make a generic attribute constrained to your interface and read the properties from the type parameter.

public interface IMyAttributeValues
{
    static abstract int X { get; }
    static abstract int Y { get; }
}
public sealed class MyAttribute<TValues> : Attribute
    where TValues : IMyAttributeValues
{
    public int Sum => TValues.X + TValues.Y;
}

[Perksey]

Unfortunately not, it's InlineArrayAttribute :/