Fix nullability on var locals

dotnet · May 26, 2021 · 12c2f04 · 12c2f04
1 parent ccef3a7
commit 12c2f04
Show file tree

Hide file tree

Showing 2 changed files with 43 additions and 20 deletions.
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeWithState.cs b/src/Compilers/CSharp/Portable/Symbols/TypeWithState.cs
@@ -87,7 +87,7 @@ public TypeWithAnnotations ToTypeWithAnnotations(CSharpCompilation compilation,
             if (Type?.IsTypeParameterDisallowingAnnotationInCSharp8() == true)
             {
                 var type = TypeWithAnnotations.Create(Type, NullableAnnotation.NotAnnotated);
-                return State == NullableFlowState.MaybeDefault ? type.SetIsAnnotated(compilation) : type;
+                return (State == NullableFlowState.MaybeDefault || asAnnotatedType) ? type.SetIsAnnotated(compilation) : type;
             }
             NullableAnnotation annotation = asAnnotatedType ?
                 (Type?.IsValueType == true ? NullableAnnotation.NotAnnotated : NullableAnnotation.Annotated) :

diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -5112,9 +5112,10 @@ void M<T>(T t)
             var declaration = syntaxTree.GetRoot().DescendantNodes().OfType<VariableDeclaratorSyntax>().Single();
             var model = comp.GetSemanticModel(syntaxTree);
             var local = (ILocalSymbol)model.GetDeclaredSymbol(declaration);
-            Assert.Equal(CodeAnalysis.NullableAnnotation.NotAnnotated, local.NullableAnnotation);
-            Assert.Equal(CodeAnalysis.NullableAnnotation.NotAnnotated, local.Type.NullableAnnotation);
-            Assert.Equal("T", local.Type.ToTestDisplayString(includeNonNullable: true));
+            Assert.Equal("T? t2", local.ToTestDisplayString());
+            Assert.Equal(CodeAnalysis.NullableAnnotation.Annotated, local.NullableAnnotation);
+            Assert.Equal(CodeAnalysis.NullableAnnotation.Annotated, local.Type.NullableAnnotation);
+            Assert.Equal("T?", local.Type.ToTestDisplayString(includeNonNullable: true));
         }
 
         [Fact]
@@ -142889,30 +142890,18 @@ static T F5<T, U>(U x5) where U : T?
 }";
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (7,14): warning CS8600: Converting null literal or possible null value to non-nullable type.
-                //         y1 = default(T);
-                Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "default(T)").WithLocation(7, 14),
                 // (8,16): warning CS8603: Possible null reference return.
                 //         return y1; // 1
                 Diagnostic(ErrorCode.WRN_NullReferenceReturn, "y1").WithLocation(8, 16),
                 // (14,16): warning CS8603: Possible null reference return.
                 //         return y2; // 2
                 Diagnostic(ErrorCode.WRN_NullReferenceReturn, "y2").WithLocation(14, 16),
-                // (19,14): warning CS8600: Converting null literal or possible null value to non-nullable type.
-                //         y3 = default(T);
-                Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "default(T)").WithLocation(19, 14),
                 // (20,16): warning CS8603: Possible null reference return.
                 //         return y3; // 3
                 Diagnostic(ErrorCode.WRN_NullReferenceReturn, "y3").WithLocation(20, 16),
-                // (25,14): warning CS8600: Converting null literal or possible null value to non-nullable type.
-                //         y4 = default(T);
-                Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "default(T)").WithLocation(25, 14),
                 // (26,16): warning CS8603: Possible null reference return.
                 //         return y4; // 4
                 Diagnostic(ErrorCode.WRN_NullReferenceReturn, "y4").WithLocation(26, 16),
-                // (31,14): warning CS8600: Converting null literal or possible null value to non-nullable type.
-                //         y5 = default(U);
-                Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "default(U)").WithLocation(31, 14),
                 // (32,16): warning CS8603: Possible null reference return.
                 //         return y5; // 5
                 Diagnostic(ErrorCode.WRN_NullReferenceReturn, "y5").WithLocation(32, 16));
@@ -142922,11 +142911,11 @@ static T F5<T, U>(U x5) where U : T?
             var locals = tree.GetRoot().DescendantNodes().OfType<VariableDeclaratorSyntax>().ToArray();
             Assert.Equal(5, locals.Length);
             // https://github.com/dotnet/roslyn/issues/46236: Locals should be treated as annotated.
-            VerifyVariableAnnotation(model, locals[0], "T y1", NullableAnnotation.NotAnnotated);
+            VerifyVariableAnnotation(model, locals[0], "T? y1", NullableAnnotation.Annotated);
             VerifyVariableAnnotation(model, locals[1], "T? y2", NullableAnnotation.Annotated);
-            VerifyVariableAnnotation(model, locals[2], "T y3", NullableAnnotation.NotAnnotated);
-            VerifyVariableAnnotation(model, locals[3], "T y4", NullableAnnotation.NotAnnotated);
-            VerifyVariableAnnotation(model, locals[4], "U y5", NullableAnnotation.NotAnnotated);
+            VerifyVariableAnnotation(model, locals[2], "T? y3", NullableAnnotation.Annotated);
+            VerifyVariableAnnotation(model, locals[3], "T? y4", NullableAnnotation.Annotated);
+            VerifyVariableAnnotation(model, locals[4], "U? y5", NullableAnnotation.Annotated);
         }
 
         private static void VerifyVariableAnnotation(SemanticModel model, VariableDeclaratorSyntax syntax, string expectedDisplay, NullableAnnotation expectedAnnotation)
@@ -146785,5 +146774,39 @@ public void M(Container<string?> x)
                 Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "y").WithLocation(13, 13)
                 );
         }
+
+        [Theory, WorkItem(52925, "https://github.com/dotnet/roslyn/issues/52925")]
+        [InlineData("")]
+        [InlineData(" where T : notnull")]
+        [InlineData(" where T : class")]
+        [InlineData(" where T : class?")]
+        public void VarDeclarationWithGenericType(string constraint)
+        {
+            var src = $@"
+#nullable enable
+
+class C<T> {constraint}
+{{
+    void M(T initial, System.Func<T, T?> selector)
+    {{
+        for (var current = initial; current != null; current = selector(current))
+        {{
+        }}
+
+        var current2 = initial;
+        current2 = default;
+
+        for (T? current3 = initial; current3 != null; current3 = selector(current3))
+        {{
+        }}
+
+        T? current4 = initial;
+        current4 = default;
+    }}
+}}
+";
+            var comp = CreateCompilation(src);
+            comp.VerifyDiagnostics();
+        }
     }
 }