Champion "Allow null coalescing operator for pointers"

[gafter]

• Proposal added
• Discussed in LDM
• Decision in LDM (and reviewed with compat council)
• Finalized (done, rejected, inactive)
• Spec'ed

See #323 for the original proposal (e.g. support p ?? q for pointer types).

See also, #328 which may take this yet further and has been prototyped by a community member at dotnet/roslyn#18526 https://github.com/lachbaer/roslyn/tree/DefaultCoalescingOperator .

See also the related proposal #398 which may make sense to consider at the same time (e.g. support p?->X and p?[e] for pointer types).

Note: if we do this feature, then ??= should also work on pointers.

[gafter]

In dotnet/roslyn#18526 (comment) @lachbaer offers an implementation of this proposal.

[Jay-Madden]

I'd like to implement this

[CyrusNajmabadi]

@jaredpar Is it ok for this community member to make a PR and submit it for review? Do we need anything happen process-wise before that can happen?

Thanks!

[jaredpar]

First I think we'd need to be a little more concrete on what we're implementing here. Basically a mini-spec. Read through the 3.5 spec on ?? and I think it could be as simple as changing:

If A is not a nullable type or a reference type, a compile-time error occurs.

To

If A is not a nullable type, a reference type or a pointer type, a compile-time error occurs.

The rest of the rules for ?? seem to just fall out after that change to allow pointers on the LHS of ??. They're already allowed on the RHS so no change needed there.

Also I agree with @gafter that at this point if we allow pointers on the LHS of ?? we should also allow it on ??=. Together this is probably not worth a feature branch though hence could be done in a PR.

Note: at this moment we're really swamped with wrapping up C# 9. Probably be a few weeks before we'll be getting around to new PRs particularly those which are feature related.

[hamarb123]

Have we considered what happens if we allow pointer types as generic arguments at some point, which would likely be a struct (e.g., Pointer<T>), meaning that int*? == Nullable<int*> would likely become legal?

[jaredpar]

Have we considered what happens if we allow pointer types as generic arguments at some point, which would likely be a struct (e.g., Pointer), meaning that int*? == Nullable<int*> would likely become legal?

In general we've thought about what would change if we allowed pointers to be generic arguments. Most recently it came up during the allow ref struct discussion. Once you're considering one anti-constraint need to make sure you're using a syntax / model that allows for other anti-constraints. Don't think we've thought about it too much for this specific issue though (but haven't really thought about this issue in a few years).

[JeremyKuhne]

@jaredpar fwiw this is another feature I would immediately use in WinForms. We do this a lot.