Nullability: conversion behavior

Author: jnm2

standard/types.md

@@ -859,6 +859,8 @@ A compiler is not required to perform any static analysis nor is it required to
 
 **The remainder of this subclause is conditionally normative.**
 
+#### 8.9.5.1 Flow analysis
+
 A compiler that generates diagnostic warnings conforms to these rules.
 
 Every expression has one of three ***null state***s:
@@ -1042,4 +1044,78 @@ A compiler may use any expression that dereferences a variable, property, or eve
 >
 > *end example*
 
+#### 8.9.5.2 Type conversions
+
+For the purpose of determining whether a conversion is *permitted*, a compiler must consider every nullable-annotated type to be equivalent to its unannotated version. The compiler may however issue warnings if the annotations of the types are not compatible.
+
+(examples: `List<string>` to `IEnumerable<object?>`, or `List<string?>?` to `IEnumerable<object>`, ...)
+
+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 ([§1.7.6](arrays.md#176-array-covariance)) in determining whether to issue a warning for type conversions. 
+(Do we need to list each type here? E.g. tuple types...)
+
+> <!-- Example: {template:"code-in-class-lib", name:"NullVariance"} -->
+> ```csharp
+> #nullable enable
+> public class C
+> {
+>     public void M1(IEnumerable<string> p)
+>     {
+>         IEnumerable<string?> v1 = p; // No warning
+>     }
+>
+>     public void M2(IEnumerable<string?> p)
+>     {
+>         IEnumerable<string> v1 = p; // Warning
+>         IEnumerable<string> v2 = p!; // No warning
+>     }
+>
+>     public void M3(Action<string?> p)
+>     {
+>         Action<string> v1 = p; // No warning
+>     }
+>
+>     public void M4(Action<string> p)
+>     {
+>         Action<string?> v1 = p; // Warning
+>         Action<string?> v2 = p!; // No warning
+>     }
+>
+>     public void M5(string[] p)
+>     {
+>         string?[] v1 = p; // No warning
+>     }
+>
+>     public void M6(string?[] p)
+>     {
+>         string[] v1 = p; // Warning
+>         string[] v2 = p!; // No warning
+>     }
+> }
+> ```
+>
+> *end example*
+
+Types that are invariant likewise may produce a warning when the conversion differs only in the nullability of type arguments.
+
+> <!-- Example: {template:"code-in-class-lib", name:"NullInvariance"} -->
+> ```csharp
+> #nullable enable
+> public class C
+> {
+>     public void M1(List<string> p)
+>     {
+>         List<string?> v1 = p; // Warning
+>         List<string?> v1 = p!; // No Warning
+>     }
+>
+>     public void M2(List<string?> p)
+>     {
+>         List<string> v1 = p; // Warning
+>         List<string> v1 = p!; // No Warning
+>     }
+> }
+> ```
+>
+> *end example*
+
 ***End of conditionally normative text***