Recognize attributes on ref/out parameter, misc fixes

Julien Couvreur · Julien Couvreur · commit 575bdf41830e · 2019-05-30T12:09:16.000-07:00
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -2900,6 +2900,32 @@ private static TypeWithAnnotations ApplyLValueAnnotations(TypeWithAnnotations de
             return declaredType;
         }
 
+        private static TypeWithAnnotations ApplyRValueAnnotations(TypeWithAnnotations declaredType, FlowAnalysisAnnotations flowAnalysisAnnotations)
+        {
+            if ((flowAnalysisAnnotations & FlowAnalysisAnnotations.NotNull) == FlowAnalysisAnnotations.NotNull)
+            {
+                var typeSymbol = declaredType.Type;
+                if (declaredType.NullableAnnotation.IsNotAnnotated() || (typeSymbol.IsValueType && !typeSymbol.IsNullableType()))
+                {
+                    return declaredType;
+                }
+
+                return TypeWithAnnotations.Create(typeSymbol, NullableAnnotation.NotAnnotated, declaredType.CustomModifiers);
+            }
+            else if ((flowAnalysisAnnotations & FlowAnalysisAnnotations.MaybeNull) == FlowAnalysisAnnotations.MaybeNull)
+            {
+                var typeSymbol = declaredType.Type;
+                if (!declaredType.NullableAnnotation.IsNotAnnotated() || (typeSymbol.IsValueType && typeSymbol.IsNullableType()))
+                {
+                    return declaredType;
+                }
+
+                return TypeWithAnnotations.Create(typeSymbol, NullableAnnotation.Annotated, declaredType.CustomModifiers);
+            }
+
+            return declaredType;
+        }
+
         // https://github.com/dotnet/roslyn/issues/29863 Record in the node whether type
         // arguments were implicit, to allow for cases where the syntax is not an
         // invocation (such as a synthesized call from a query interpretation).
@@ -3268,12 +3294,12 @@ private void VisitArgumentConversion(
                             else
                             {
                                 // types match, but state would let a null in
-                                ReportNullableAssignmentIfNecessary(argumentNoConversion, parameterType, resultType, useLegacyWarnings: false);
+                                ReportNullableAssignmentIfNecessary(argumentNoConversion, ApplyLValueAnnotations(parameterType, parameterAnnotations), resultType, useLegacyWarnings: false);
                             }
                         }
 
                         // Check assignment from a fictional value from the parameter to the argument.
-                        var parameterWithState = parameterType.ToTypeWithState();
+                        var parameterWithState = TypeWithState.Create(parameterType, parameterAnnotations);
                         if (argumentNoConversion.IsSuppressed)
                         {
                             parameterWithState = parameterWithState.WithNotNullState();
@@ -3289,13 +3315,15 @@ private void VisitArgumentConversion(
                     break;
                 case RefKind.Out:
                     {
-                        var parameterWithState = parameterType.ToTypeWithState();
+                        var lValueType = result.LValueType;
+                        var parameterWithAnnotations = ApplyRValueAnnotations(parameterType, parameterAnnotations);
+                        var parameterWithState = TypeWithState.Create(parameterWithAnnotations, parameterAnnotations);
                         if (argumentNoConversion is BoundLocal local && local.DeclarationKind == BoundLocalDeclarationKind.WithInferredType)
                         {
-                            _variableTypes[local.LocalSymbol] = parameterType;
+                            _variableTypes[local.LocalSymbol] = parameterWithAnnotations;
+                            lValueType = parameterWithAnnotations;
                         }
 
-                        var lValueType = result.LValueType;
                         // Check assignment from a fictional value from the parameter to the argument.
                         var parameterValue = new BoundParameter(argumentNoConversion.Syntax, parameter);
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeWithState.cs b/src/Compilers/CSharp/Portable/Symbols/TypeWithState.cs
@@ -40,11 +40,11 @@ public static TypeWithState Create(TypeWithAnnotations typeWithAnnotations, Flow
             NullableFlowState state;
             if (type.CanContainNull())
             {
-                if ((annotations & FlowAnalysisAnnotations.MaybeNull) != 0)
+                if ((annotations & FlowAnalysisAnnotations.MaybeNull) == FlowAnalysisAnnotations.MaybeNull)
                 {
                     state = NullableFlowState.MaybeNull;
                 }
-                else if ((annotations & FlowAnalysisAnnotations.NotNull) != 0)
+                else if ((annotations & FlowAnalysisAnnotations.NotNull) == FlowAnalysisAnnotations.NotNull)
                 {
                     state = NullableFlowState.NotNull;
                 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs

Original file line number	Diff line number	Diff line change
`@@ -40,11 +40,11 @@ public static TypeWithState Create(TypeWithAnnotations typeWithAnnotations, Flow`
`40`	`40`	`NullableFlowState state;`
`41`	`41`	`if (type.CanContainNull())`
`42`	`42`	`{`
`43`		`- if ((annotations & FlowAnalysisAnnotations.MaybeNull) != 0)`
	`43`	`+ if ((annotations & FlowAnalysisAnnotations.MaybeNull) == FlowAnalysisAnnotations.MaybeNull)`
`44`	`44`	`{`
`45`	`45`	`state = NullableFlowState.MaybeNull;`
`46`	`46`	`}`
`47`		`- else if ((annotations & FlowAnalysisAnnotations.NotNull) != 0)`
	`47`	`+ else if ((annotations & FlowAnalysisAnnotations.NotNull) == FlowAnalysisAnnotations.NotNull)`
`48`	`48`	`{`
`49`	`49`	`state = NullableFlowState.NotNull;`
`50`	`50`	`}`