diff --git a/standard/arrays.md b/standard/arrays.md index ccfcfe278..9bfde42ad 100644 --- a/standard/arrays.md +++ b/standard/arrays.md @@ -50,6 +50,38 @@ At run-time, a value of an array type can be `null` or a reference to an instanc > *Note*: Following the rules of [§17.6](arrays.md#176-array-covariance), the value may also be a reference to a covariant array type. *end note* +### §arrays-of-nullable-arrays Arrays of nullable arrays + +The nullable annotation `?` may be placed on an array type, as in `T[R]?`. Such an annotated array type may be used as the element type of another array type, as in `T[R]?[R₂]`. + +`T[R₁][R₂]?[R₃][R₄]` is not a single *array_type* with four ranks. Rather, it is two *array_type*s, each of which has two ranks. The outer *array_type* has ranks `[R₃][R₄]`, read left to right, and its element type is `T[R₁][R₂]?`. The element type is another *array_type* with a nullable annotation, and this inner *array_type* has ranks `[R₁][R₂]`, read left to right. This is the sole exception to the general rule that the meaning of a program remains the same when nullable reference types annotations are removed. + +Every reference type which contains nullable annotations has a corresponding unannotated type with no semantic difference (§8.9.1). The corresponding unannotated type for an array of nullable arrays is a single array type which recursively collects all the ranks of all the nested *array_type*s. + +The unannotated array type of an array of nullable arrays cannot be found by simply removing the nullable annotations `?` from the grammar and reparsing. This is because array ranks are read left to right while nested *array_type* productions are read outside-in, with outer array type ranks to the right, inner array type ranks to the left. Thus, the type `T[R₁][R₂]?[R₃][R₄]` has an unannotated array type of `T[R₃][R₄][R₁][R₂]`. + +To obtain the unannotated array type of an array of nullable arrays, the following steps are followed: + +1. Take the ranks on the outermost array type in order from left to right. (From `T[R₁][R₂]?[R₃][R₄]`, take `[R₃]` and then `[R₄]`.) +2. Move to the array type inside the nullable element type and take its ranks in order from left to right. (From `T[R₁][R₂]`, take `[R₁]` and then `[R₂]`.) +3. Repeat in this fashion until the element type is no longer a nullable array type. (`T`) +4. Take this remaining element type and place on it all the collected ranks in order from first to last to obtain the unannotated array type. (On `T`, place `[R₃]`, then `[R₄]`, then `[R₁]`, then `[R₂]`, obtaining the final result of `T[R₃][R₄][R₁][R₂]`.) + +> *Example*: +> +> The following table demonstrates the effect on the unannotated array type caused by breaking up array types by inserting nullable annotations: +> +> | Annotated | Unannotated | +> |----------------------------------|-------------------------------------------| +> | `T?[][,][,,]` | `T[][,][,,]` (not intervening, no change) | +> | `T[][,][,,]?` | `T[][,][,,]` (not intervening, no change) | +> | `T[]?[,]?[,,]` | `T[,,][,][]` | +> | `T[]?[,][,,]` | `T[,][,,][]` | +> | `T[][,]?[,,]` | `T[,,][][,]` | +> | `T[][,]?[,,][,,,]?[,,,,][,,,,,]` | `T[,,,,][,,,,,][,,][,,,][][,]` | +> +> *end example* + ### 17.2.2 The System.Array type The type `System.Array` is the abstract base type of all array types. An implicit reference conversion ([§10.2.8](conversions.md#1028-implicit-reference-conversions)) exists from any array type to `System.Array` and to any interface type implemented by `System.Array`. An explicit reference conversion ([§10.3.5](conversions.md#1035-explicit-reference-conversions)) exists from `System.Array` and any interface type implemented by `System.Array` to any array type. `System.Array` is not itself an *array_type*. Rather, it is a *class_type* from which all *array_type*s are derived. diff --git a/standard/types.md b/standard/types.md index 31ccd4773..91981382c 100644 --- a/standard/types.md +++ b/standard/types.md @@ -54,17 +54,22 @@ interface_type ; array_type - : non_array_type rank_specifier+ + : array_type nullable_type_annotation rank_specifier+ + | non_array_type rank_specifier+ ; non_array_type - : value_type + : non_array_non_nullable_type nullable_type_annotation? + | pointer_type // unsafe code support + ; + +non_array_non_nullable_type + : non_nullable_value_type | class_type | interface_type | delegate_type | 'dynamic' | type_parameter - | pointer_type // unsafe code support ; rank_specifier @@ -732,7 +737,7 @@ There are two forms of nullability for reference types: > *Note:* The types `R` and `R?` are represented by the same underlying type, `R`. A variable of that underlying type can either contain a reference to an object or be the value `null`, which indicates “no reference.” *end note* -The syntactic distinction between a *nullable reference type* and its corresponding *non-nullable reference type* enables a compiler to generate diagnostics. A compiler must allow the *nullable_type_annotation* as defined in [§8.2.1](types.md#821-general). The diagnostics must be limited to warnings. Neither the presence or absence of nullable annotations, nor the state of the nullable context can change the compile time or runtime behavior of a program except for changes in any diagnostic messages generated at compile time. +The syntactic distinction between a *nullable reference type* and its corresponding *non-nullable reference type* enables a compiler to generate diagnostics. A compiler must allow the *nullable_type_annotation* as defined in [§8.2.1](types.md#821-general). The diagnostics must be limited to warnings. Neither the presence or absence of nullable annotations, nor the state of the nullable context can change the compile time or runtime behavior of a program except for changes in any diagnostic messages generated at compile time, with one exception: arrays of nullable arrays are not parsed as a single *array_type*, but rather as multiple nested *array_type*s. The corresponding *non-nullable reference type* of an array of nullable arrays is not the single array type that would be parsed if the nullable annotations were removed; see §arrays-of-nullable-arrays. ### 8.9.2 Non-nullable reference types @@ -1098,6 +1103,8 @@ A compiler may issue a warning when nullability annotations differ between two t A compiler may follow rules for interface variance ([§18.2.3.3](interfaces.md#18233-variance-conversion)), delegate variance ([§20.4](delegates.md#204-delegate-compatibility)), and array covariance ([§17.6](arrays.md#176-array-covariance)) in determining whether to issue a warning for type conversions. +(See §arrays-of-nullable-arrays for the specification of the corresponding non-nullable array type used in `M7` and `M8`.) + > > ```csharp > #nullable enable @@ -1135,6 +1142,17 @@ A compiler may follow rules for interface variance ([§18.2.3.3](interfaces.md#1 > string[] v1 = p; // Warning > string[] v2 = p!; // No warning > } +> +> public void M7(string[][,] p) +> { +> string[,]?[] v1 = p; // No warning +> } +> +> public void M6(string[]?[,] p) +> { +> string[,][] v1 = p; // Warning +> string[,][] v2 = p!; // No warning +> } > } > ``` >