Treat pointers as nullable values

[IS4Code]

Situation

At the moment, nullable types in the language are reference types (class constraint) and Nullable<T>. With such types, you get the following:

• Null-coalescing operator ??, to pick a fallback value if the operand is null.
• Null-conditional operators ?., ?[], and ?.Invoke() (sic), allowing early exit from an expression in case of a null operand.
• Diagnostics when using nullable values in problematic situations without checking for null first (automatically for Nullable<T>, #nullable enable(warnings) for NRTs).

However, for pointers, despite them being "nullable" (having a null value), none of this is possible:

int* a = ..., b = ...;

int x = *(a ?? b); // error
int? y = a?[0]; // error

There is no ?-> operator, and extensions are not allowed for pointers (why?) so ?. is not applicable either:

DateTime* ptr = ...;
int? day = ptr?->Day; // invalid syntax
int? day = (ptr?.Get() ?? default)?.Day; // nope

unsafe static class PointerExtensions
{
    static T Get<T>(this T* ptr) where T : unmanaged // cannot do this T*
    {
        return *ptr;
    }
}

You can null-conditionally call delegates, but not delegate*:

delegate*<void> b = &M;
b?(); // invalid
b?.Invoke(); // nope

static void M() { }

unsafe static class PointerExtensions
{
    static void Invoke(this delegate*<void> ptr) // cannot do this delegate*
    {
        ptr();
    }
}

Lastly, even with just #nullable enable warnings, you get warnings for obviously null object references, but not for pointers:

#nullable enable warnings
object a = null;
Console.WriteLine(a.ToString()); // dereference of a possibly null reference

int* b = null;
Console.WriteLine(b->ToString()); // exact same situation, but no warning

Nullability attributes on pointers are ignored:

string M([AllowNull] object arg)
{
    return arg.ToString(); // warning
}

string M([AllowNull] int* arg)
{
    return arg->ToString(); // no warning
}

Proposal

Even though pointers are considered "reference types" internally (at least by ECMA-335) and have a null value, they are not "nullable" as considered by C#. My proposal is therefore:

• Allow ?? and ?[] for pointers.
• Consider permitting new syntax in the form ?-> or ?(), or allow extension methods for pointers together with ?..
• Acknowledge pointers during null-state analysis (when the mode is at least warnings). In such situations, treat pointers as reference types as if #nullable enable warnings was used (no type annotations or new syntax for "nullable pointers"), and extend attributes such as AllowNull or NotNullIfNotNull to pointers.

Examples

Operators

int* a = ...
return a == null ? null : *a;
// could be rewritten into
return a?[0];

Attributes

[return: MaybeNull, NotNullIfNotNull(nameof(arr))]
public static T* ToPointer<T>(this T[]? arr, out GCHandle handle) where T : unmanaged
{
    if(arr == null)
    {
        handle = default;
        return null;
    }
    handle = GCHandle.Alloc(arr, GCHandleType.Pinned);
    return (T*)handle.AddrOfPinnedObject();
}