Arrays of nullable references

[jnm2]

It looks as though string?[] is not allowed by the current grammar, or any X?[] when X is a class_type, interface_type, delegate_type, 'dynamic', or type_parameter:

csharpstandard/standard/types.md

Lines 56 to 68 in 286b10a

	array_type
	: non_array_type rank_specifier+
	;
	non_array_type
	: value_type
	| class_type
	| interface_type
	| delegate_type
	| 'dynamic'
	| type_parameter
	| pointer_type // unsafe code support
	;

This extends the problem beyond arrays of nullable arrays, to arrays of nullable references of any kind.

[Nigel-Ecma]

Exactly, the addition of nullable references types excluded any use with arrays.

This is the starting point for all the various investigations on nullable & arrays that have been undertaken/are in progress.

I’ll close this as “Known, work in progress”

[jskeet]

Reopening, as it's known but needs to be fixed :)

[jskeet]

I've been looking at this fresh. I think at the minimum (and this may not be enough) for any array type (e.g. string[]?, string?[], string[]?[,]) we need to know:

• The nullability of the type itself
• The rank of the type
• The element type

I've done some experimentation to come up with rules for all of those summarised below.

#pragma warning disable CS0219

string d0a = Create<string>(); // Non-nullable, rank 0 (not an array type)
string? d0b = Create<string?>(); // Nullable, rank 0 (not an array type)

string[] d1a = Create<string[]>();   // Non nullable, rank 1, element type is string
string u1a = d1a[0];
string[]? d1b = Create<string[]?>();  // Nullable, rank 1, element type is string
string u1b = d1b![0];
string?[] d1c = Create<string?[]>();  // Non-nullable, rank 1, element type is string?
string? u1c = d1c[0];
string?[]? d1d = Create<string?[]?>(); // Nullable, rank 1, element type is string?
string? u1d = d1d![0];

string[][,] d2a = Create<string[][,]>(); // Non-nullable, rank 1, element type is string[,]
string[,] u2a = d2a[0];
string[][,]? d2b = Create<string[][,]?>(); // Nullable, rank 1, element type is string[,]
string[,] u2b = d2b![0]; // d2b may be null
string[]?[,] d2c = Create<string[]?[,]>(); // Non-nullable, rank 2, element type is string[]?
string[]? u2c = d2c[0, 1];
string[]?[,]? d2d = Create<string[]?[,]?>(); // Nullable, rank 2, element type is string[]?
string[]? u2d = d2d![0, 1];
string?[][,] d2e = Create<string?[][,]>(); // Non-nullable, rank 1, element type is string?[,]
string?[,] u2e = d2e[0];
string?[][,]? d2f = Create<string?[][,]?>(); // Nullable, rank 1, element type is string?[,]
string?[,]? u2f = d2f![0];
string?[]?[,] d2g = Create<string?[]?[,]>(); // Non-nullable, rank 2, element type is string?[]?
string?[]? u2g = d2g[0, 1];
string?[]?[,]? d2h = Create<string?[]?[,]?>(); // Nullable, rank 2, element type is string?[]?
string?[]? u2h = d2h![0, 1];

string[][,][,,] d3a = Create<string[][,][,,]>(); // Non-nullable, rank 1, element type is string[,][,,]
string[,][,,] u3a = d3a[0];
string[][,][,,]? d3b = Create<string[][,][,,]?>(); // Nullable, rank 1, element type is string[,][,,]
string[,][,,] u3b = d3b![0];
string[][,]?[,,] d3c = Create<string[][,]?[,,]>(); // Non-nullable, rank 3, element type is string[][,]?
string[][,]? u3c = d3c[0, 1, 2];
string[][,]?[,,]? d3d = Create<string[][,]?[,,]?>(); // Nullable, rank 3, element type is string[][,]?
string[][,]? u3d = d3d![0, 1, 2];
string[]?[,][,,] d3e = Create<string[]?[,][,,]>(); // Non-nullable, rank 2, element type is string[]?[,,]
string[]?[,,] u3e = d3e[0, 1];
string[]?[,][,,]? d3f = Create<string[]?[,][,,]?>(); // Non-nullable, rank 2, element type is string[]?[,,]
string[]?[,,] u3f = d3f![0, 1];
string[]?[,]?[,,] d3g = Create<string[]?[,]?[,,]>(); // Non-nullable, rank 3, element type is string[]?[,]?
string[]?[,]? u3g = d3g[0, 1, 2];
string[]?[,]?[,,]? d3h = Create<string[]?[,]?[,,]?>(); // Nullable, rank 3, element type is string[]?[,]?
string[]?[,]? u3h = d3h![0, 1, 2];
string?[][,][,,] d3i = Create<string?[][,][,,]>(); // Non-nullable rank 1, element type is string?[,][,,]
string?[,][,,] u3i = d3i[0];
string?[][,][,,]? d3j = Create<string?[][,][,,]?>(); // Nullable rank 1, element type is string?[,][,,]
string?[,][,,] u3j = d3j![0];
string?[][,]?[,,] d3k = Create<string?[][,]?[,,]>(); // Non-nullable, rank 3, element type is string?[][,]?
string?[][,]? u3k = d3k[0, 1, 2];
string?[][,]?[,,]? d3l = Create<string?[][,]?[,,]?>(); // Nullable,  rank 3, element type is string?[][,]?
string?[][,]? u3l = d3l![0, 1, 2];
string?[]?[,][,,] d3m = Create<string?[]?[,][,,]>(); // Non-nullable, rank 2, element type is string?[]?[,,]
string?[]?[,,] u3m = d3m[0, 1];
string?[]?[,][,,]? d3n = Create<string?[]?[,][,,]?>(); // Nullable, rank 2, element type is string?[]?[,,]
string?[]?[,,] u3n = d3n![0, 1];
string?[]?[,]?[,,] d3o = Create<string?[]?[,]?[,,]>(); // Non-nullable, rank 3, element type is string?[]?[,]?
string?[]?[,]? u3o = d3o[0, 1, 2];
string?[]?[,]?[,,]? d3p = Create<string?[]?[,]?[,,]?>();
string?[]?[,]? u3p = d3p![0, 1, 2];

// Candidate rules:
// - Whether the array variable itself is nullable is just "does the type end with a question mark"
// - Remove any question mark from the end
// - Find the right-most question mark, if any.
//   - Identify the rank-specifier following the right-most question-mark, or the first rank-specifier otherwise.
//   - The rank of the array type is the rank of that rank-specifier.
//   - The element of the array type is the type having removed that rank-specifier.


string[][,][,,]?[,,,][,,,,] test1 = Create<string[][,][,,]?[,,,][,,,,]>();
string[][,][,,]?[,,,,] utest1 = test1[0, 1, 2, 3];

string[]?[,][,,]?[,,,][,,,,] test2 = Create<string[]?[,][,,]?[,,,][,,,,]>();
string[]?[,][,,]?[,,,,] utest2 = test2[0, 1, 2, 3];

T Create<T>() => default!;

[jnm2]

Thanks for slogging through all that with us! It all looks correct to me.

(The original array type syntax rank order is the one and only thing in C# that I'd wave a magic wand and remove if I could. Don't even look at typeof(string[][,]).FullName 😆)

[jskeet]

After discussion, I'm reassigning this to myself to come up with an alternative PR.