Allow primary constructors to reference class/record/struct constants

[CodeSetting]

I like the brevity of the new primary constructor syntax. However, I do notice a likely oversight. Currently, it is impossible to reference constants defined within the associated class/record/struct. This can lead to some repetitive (and unclear) code.

Consider the following:

namespace TestNamespace
{
	public class TestClass(int value = 123)
	{
		public const int DefaultValue = 123;

		public int Value { get; } = value;
	}
}

In this instance, it would be better if the DefaultValue constant could be referenced in the primary constructor, as follows:

namespace TestNamespace
{
	public class TestClass(int value = DefaultValue)
	{
		public const int DefaultValue = 123;

		public int Value { get; } = value;
	}
}

I propose that all constants, that are defined in a class/record/struct, should also be accessible to its primary constructors.

[sharpchen]

const is static, so you can do this

namespace TestNamespace
{
	public class TestClass(int value = TestClass.DefaultValue)
	{
		private const int DefaultValue = 123;

		public int Value { get; } = value;
	}
}

[CodeSetting]

@sharpchen Thank you for the workaround. I should have considered it. In retrospect, it is obvious.

That said, it does seem unnecessarily verbose. I would still prefer it if the constants were in scope for the primary constructor. So, I'll leave my suggestion open for now.

[sharpchen]

That would bring ambiguity when we use using static

// NS.Shared.cs
namespace NS;

static class Shared
{
    internal const int DefaultAge = 10;
}

using static NS.Shared;

class Person(string name, int age = DefaultAge) // Currently it should target to Shared.DefaultAge
{
    public const int DefaultAge = 18;
    public int Age { get; } = age;
    public string Name { get; } = name;
}

[sharpchen]

That reminds me that you can just using static Person; in file to get the feature you want. If there's no conflicts from other usings.

// This is valid code
using static Person;
class Person(string name, int age = DefaultAge)
{
    public const int DefaultAge = 18;
    public int Age { get; } = age;
    public string Name { get; } = name;
}

[CodeSetting]

This is an interesting argument. However, I would propose that this ambiguity should be resolved in the same way as it is within a traditional constructor.

In short, it is my opinion, that a primary constructor should have the same scoping rules as a traditional constructor. To me, it doesn't make sense that it has different rules.