A New Way of Passing References: Allowing Use of References Without Direct Modification

[YT-GameMaker]

I recently encountered two issues that seem to point to the same language feature requirement.

struct S
{
    static S s_shared;
    public static ref S Shared => ref s_shared;
}

In this example, s_shared is returned by reference to allow external access to its members for modification of its state. However, this also allows external modification of s_shared directly like this S.Shared = default, which is not what I want.

interface I { }
struct S : I { }
class C : I { }

static class Extensions
{
    static void Func<T>(this ref T t) where T : struct, I => InternalFunc(ref t);
    static void Func<T>(this T t) where T : class, I => InternalFunc(ref t);
    static void InternalFunc<T>(ref T t) where T : I { ... }
}

In this example, I want to add some extension methods for types that implement a specific interface. However, I don't know whether the types implementing the interface are value types or reference types, so I have to implement them separately for each case, even though the final invocation calls the same internal implementation.

In both examples, I only want to use references and do not want to directly modify the referenced variables. However, since ref allows modification of the referenced variables, it poses a security risk in the first example, and the second example cannot merge extension methods applicable to value types with those applicable to reference types.

If there is a way to pass references that signifies you can only use this reference without modifying it, both of these issues can be resolved. The specific syntax can be discussed; here, I'm using using ref temporarily to explain some details.

using ref T Func<T>(using ref T p)
{
    p = default;     // Disallowed
    p.ChangeSelf();  // Allowed
    T a = p;         // Allowed
    ref T b = ref p; // Disallowed
    using ref T c = using ref p; // Allowed
    return c;
}

using ref in the syntax ensures that the referenced variable will not be directly modified. At runtime, if T is a value type, using ref T p is equivalent to ref T p; if T is a reference type, using ref T p is equivalent to T p. With such syntax, we can update the two examples mentioned at the beginning:

struct S
{
    static S s_shared;
    public static using ref S Shared => using ref s_shared;
}

static class Extensions
{
    // Applicable to both value types and reference types
    static void Func<T>(this using ref T t) where T : I { ... }
}

With using ref, when passing references, we should use using ref whenever possible, unless we genuinely intend to modify the referenced variable. This can make our code more adaptable because ref can be converted to using ref, but the reverse is not possible.

[huoyaoyuan]

It should be theoretically achievable by a custom attribute with analyzer.

What's the benefit of having this built in with the language? Note that static struct fields are allocated on the heap.

[YT-GameMaker]

In the first example, it allows us to avoid writing some meaningless wrapper methods, and this also applies to non-static members. In the second example, it can simplify the implementation of extension methods for interfaces (which is quite common).
Actually, what I am doing is creating random number generators suitable for different needs—some are classes, some are structs, but they all implement the same interface. Then, I've written many extension methods for this interface, such as generating random points in space, generating normally distributed random numbers, shuffling algorithms, and so on.

[huoyaoyuan]

Actually, what I am doing is creating random number generators suitable for different needs—some are classes, some are structs, but they all implement the same interface.

Do note that there is a solution to directly wrap a struct into a class. Static instances of structs are meaningless - they will always be boxed.

[YT-GameMaker]

Yes, static members are just for convenience; sometimes, they also need to hold instances.

[huoyaoyuan]

Side note: don't start with syntax when proposing features, as different people may interpret them differently. Even fancyref looks clearer to me than using ref.

[YT-GameMaker]

Renamed.

[Tinister]

Would this work any differently to how ref readonly works now?

struct S
{
    public int Number;

    static S s_shared = new S { Number = 7 };
    public static ref readonly S Shared => ref s_shared;
}

void Main()
{
    S.Shared.Number = 6;
    // CS8332 Cannot assign to a member of property 'Shared' or use it as the right hand side of a ref assignment because it is a readonly variable
}

[huoyaoyuan]

ref readonly doesn't support mutation of the struct in any way. This proposal allows mutation via struct methods.

[timcassell]

Another case that this would solve: #4345.

using (var tempList = new PoolBackedList<int>(0))
{
    FillList(ref tempList); // Error, cannot pass using variable by reference.
}

P.S. Syntax may not be important at this point, but I think const ref is better than using ref.