Improve nullable analysis of local functions

This design tries to meld better analysis of nullable reference types in
local functions with performance. To keep the common case one pass,
local functions are analyzed using the starting state that is an
intersection of all the states before its usages (calls, delegate
conversions, etc), but the results of variables made nullable or
non-nullable inside the local function do not propagate to the callers.

Author: agocke

src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs

@@ -200,6 +200,7 @@ protected AbstractFlowPass(
             this.Diagnostics = DiagnosticBag.GetInstance();
             this.compilation = compilation;
             _symbol = symbol;
+            CurrentSymbol = symbol;
             this.methodMainNode = node;
             this.firstInRegion = firstInRegion;
             this.lastInRegion = lastInRegion;
@@ -1167,11 +1168,10 @@ public override BoundNode VisitCall(BoundCall node)
             return null;
         }
 
-        private void VisitLocalFunctionUse(LocalFunctionSymbol symbol, SyntaxNode syntax, bool isCall)
+        protected void VisitLocalFunctionUse(LocalFunctionSymbol symbol, SyntaxNode syntax, bool isCall)
         {
             var localFuncState = GetOrCreateLocalFuncUsages(symbol);
             VisitLocalFunctionUse(symbol, localFuncState, syntax, isCall);
-            localFuncState.Visited = true;
         }
 
         protected virtual void VisitLocalFunctionUse(
@@ -1185,6 +1185,7 @@ protected virtual void VisitLocalFunctionUse(
                 Join(ref State, ref localFunctionState.StateFromBottom);
                 Meet(ref State, ref localFunctionState.StateFromTop);
             }
+            localFunctionState.Visited = true;
         }
 
         private void VisitReceiverBeforeCall(BoundExpression receiverOpt, MethodSymbol method)

src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.LocalFunctions.cs

@@ -77,22 +77,6 @@ private void CheckIfAssignedDuringLocalFunctionReplay(Symbol symbol, SyntaxNode
             }
         }
 
-        private int RootSlot(int slot)
-        {
-            while (true)
-            {
-                var varInfo = variableBySlot[slot];
-                if (varInfo.ContainingSlot == 0)
-                {
-                    return slot;
-                }
-                else
-                {
-                    slot = varInfo.ContainingSlot;
-                }
-            }
-        }
-
         private void RecordReadInLocalFunction(int slot)
         {
             var localFunc = GetNearestLocalFunctionOpt(CurrentSymbol);

src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs

@@ -132,7 +132,6 @@ internal DefiniteAssignmentPass(
         {
             this.initiallyAssignedVariables = null;
             _sourceAssembly = ((object)member == null) ? null : (SourceAssemblySymbol)member.ContainingAssembly;
-            this.CurrentSymbol = member;
             _unassignedVariableAddressOfSyntaxes = unassignedVariableAddressOfSyntaxes;
             _requireOutParamsAssigned = requireOutParamsAssigned;
             _trackClassFields = trackClassFields;

src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs

@@ -286,5 +286,21 @@ protected int MakeMemberSlot(BoundExpression receiverOpt, Symbol member)
             }
             return GetOrCreateSlot(member, containingSlot);
         }
+
+        protected int RootSlot(int slot)
+        {
+            while (true)
+            {
+                ref var varInfo = ref variableBySlot[slot];
+                if (varInfo.ContainingSlot == 0)
+                {
+                    return slot;
+                }
+                else
+                {
+                    slot = varInfo.ContainingSlot;
+                }
+            }
+        }
     }
 }