Learn from comparisons to non-constant, non-null values

RikkiGibson · RikkiGibson · commit e8567ea66ca7 · 2019-05-24T15:05:56.000-07:00
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -2043,11 +2043,11 @@ protected override void AfterLeftChildHasBeenVisited(BoundBinaryOperator binary)
 
             // learn from non-null constant
             BoundExpression operandComparedToNonNull = null;
-            if (isNonNullConstant(binary.Left))
+            if (leftType.IsNotNull && rightType.MayBeNull && binary.Right.ConstantValue?.IsNull != true)
             {
                 operandComparedToNonNull = binary.Right;
             }
-            else if (isNonNullConstant(binary.Right))
+            else if (leftType.MayBeNull && binary.Left.ConstantValue?.IsNull != true && rightType.IsNotNull)
             {
                 operandComparedToNonNull = binary.Left;
             }
@@ -2249,6 +2249,12 @@ private void LearnFromNonNullTest(int slot, ref LocalState state)
 
         private int LearnFromNullTest(BoundExpression expression, ref LocalState state)
         {
+            // nothing to learn about a constant
+            if (expression.ConstantValue != null)
+            {
+                return -1;
+            }
+
             var expressionWithoutConversion = RemoveConversion(expression, includeExplicitConversions: true).expression;
             var slot = MakeSlot(expressionWithoutConversion);
             return LearnFromNullTest(slot, expressionWithoutConversion.Type, ref state);
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -21867,18 +21867,15 @@ void M(Delegate d, string? s)
     {
         if (s != string.Empty) s.ToString(); // warn
         d.BeginInvoke(s, null, null);
-        s.ToString(); // warn 2
+        s.ToString();
     }
 }
 ", NotNullAttributeDefinition }, options: WithNonNullTypesTrue());
 
             c.VerifyDiagnostics(
                 // (8,32): warning CS8602: Dereference of a possibly null reference.
                 //         if (s != string.Empty) s.ToString(); // warn
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s").WithLocation(8, 32),
-                // (10,9): warning CS8602: Dereference of a possibly null reference.
-                //         s.ToString(); // warn 2
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s").WithLocation(10, 9)
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s").WithLocation(8, 32)
                 );
         }
 
@@ -95651,6 +95648,29 @@ public Box(T value) { }
                 Diagnostic(ErrorCode.ERR_BadBinaryOps, "x == null").WithArguments("==", "T", "<null>").WithLocation(53, 13));
         }
 
+        [Fact, WorkItem(34942, "https://github.com/dotnet/roslyn/issues/34942")]
+        public void ConditionalExpression_InferredNullability()
+        {
+            var source =
+@"#nullable enable
+using System;
+
+public class Program
+{
+    static void Main()
+    {
+        string? value = ""42"";
+        int count = 84;
+        if (value?.Length == count)
+        {
+            Console.WriteLine(value.Length);
+        }
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics();
+        }
+
         [Fact, WorkItem(35075, "https://github.com/dotnet/roslyn/issues/35075")]
         public void ConditionalExpression_TypeParameterConstrainedToNullableValueType()
         {

Original file line number	Diff line number	Diff line change
`@@ -2043,11 +2043,11 @@ protected override void AfterLeftChildHasBeenVisited(BoundBinaryOperator binary)`
`2043`	`2043`
`2044`	`2044`	`// learn from non-null constant`
`2045`	`2045`	`BoundExpression operandComparedToNonNull = null;`
`2046`		`- if (isNonNullConstant(binary.Left))`
	`2046`	`+ if (leftType.IsNotNull && rightType.MayBeNull && binary.Right.ConstantValue?.IsNull != true)`
`2047`	`2047`	`{`
`2048`	`2048`	`operandComparedToNonNull = binary.Right;`
`2049`	`2049`	`}`
`2050`		`- else if (isNonNullConstant(binary.Right))`
	`2050`	`+ else if (leftType.MayBeNull && binary.Left.ConstantValue?.IsNull != true && rightType.IsNotNull)`
`2051`	`2051`	`{`
`2052`	`2052`	`operandComparedToNonNull = binary.Left;`
`2053`	`2053`	`}`
`@@ -2249,6 +2249,12 @@ private void LearnFromNonNullTest(int slot, ref LocalState state)`
`2249`	`2249`
`2250`	`2250`	`private int LearnFromNullTest(BoundExpression expression, ref LocalState state)`
`2251`	`2251`	`{`
	`2252`	`+ // nothing to learn about a constant`
	`2253`	`+ if (expression.ConstantValue != null)`
	`2254`	`+ {`
	`2255`	`+ return -1;`
	`2256`	`+ }`
	`2257`	`+`
`2252`	`2258`	`var expressionWithoutConversion = RemoveConversion(expression, includeExplicitConversions: true).expression;`
`2253`	`2259`	`var slot = MakeSlot(expressionWithoutConversion);`
`2254`	`2260`	`return LearnFromNullTest(slot, expressionWithoutConversion.Type, ref state);`