Track state separately in NullableWalker for nested and containing methods

src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs

@@ -389,7 +389,7 @@ private BoundLambda SuppressIfNeeded(BoundLambda lambda)
         public bool HasExplicitlyTypedParameterList { get { return Data.HasExplicitlyTypedParameterList; } }
         public int ParameterCount { get { return Data.ParameterCount; } }
         public TypeWithAnnotations InferReturnType(ConversionsBase conversions, NamedTypeSymbol delegateType, ref HashSet<DiagnosticInfo> useSiteDiagnostics)
-            => BindForReturnTypeInference(delegateType).GetInferredReturnType(conversions, _nullableState?.Clone(), ref useSiteDiagnostics);
+            => BindForReturnTypeInference(delegateType).GetInferredReturnType(conversions, _nullableState, ref useSiteDiagnostics);
 
         public RefKind RefKind(int index) { return Data.RefKind(index); }
         public void GenerateAnonymousFunctionConversionError(DiagnosticBag diagnostics, TypeSymbol targetType) { Data.GenerateAnonymousFunctionConversionError(diagnostics, targetType); }

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

@@ -1634,6 +1634,14 @@ void updatePendingBranchState(ref TLocalState stateToUpdate, ref TLocalState sta
 
         protected Optional<TLocalState> NonMonotonicState;
 
+        /// <summary>
+        /// Join state from other try block, potentially in a nested method.
+        /// </summary>
+        protected virtual void JoinTryBlockState(ref TLocalState self, ref TLocalState other)
+        {
+            Join(ref self, ref other);
+        }
+
         private void VisitTryBlockWithAnyTransferFunction(BoundStatement tryBlock, BoundTryStatement node, ref TLocalState tryState)
         {
             if (_nonMonotonicTransfer)
@@ -1646,7 +1654,7 @@ private void VisitTryBlockWithAnyTransferFunction(BoundStatement tryBlock, Bound
                 if (oldTryState.HasValue)
                 {
                     var oldTryStateValue = oldTryState.Value;
-                    Join(ref oldTryStateValue, ref tempTryStateValue);
+                    JoinTryBlockState(ref oldTryStateValue, ref tempTryStateValue);
                     oldTryState = oldTryStateValue;
                 }
 
@@ -1675,7 +1683,7 @@ private void VisitCatchBlockWithAnyTransferFunction(BoundCatchBlock catchBlock,
                 if (oldTryState.HasValue)
                 {
                     var oldTryStateValue = oldTryState.Value;
-                    Join(ref oldTryStateValue, ref tempTryStateValue);
+                    JoinTryBlockState(ref oldTryStateValue, ref tempTryStateValue);
                     oldTryState = oldTryStateValue;
                 }
 
@@ -1720,7 +1728,7 @@ private void VisitFinallyBlockWithAnyTransferFunction(BoundStatement finallyBloc
                 if (oldTryState.HasValue)
                 {
                     var oldTryStateValue = oldTryState.Value;
-                    Join(ref oldTryStateValue, ref tempTryStateValue);
+                    JoinTryBlockState(ref oldTryStateValue, ref tempTryStateValue);
                     oldTryState = oldTryStateValue;
                 }
 

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

@@ -40,7 +40,7 @@ public AbstractLocalFunctionState(TLocalState stateFromBottom, TLocalState state
             public bool Visited = false;
         }
 
-        protected abstract TLocalFunctionState CreateLocalFunctionState();
+        protected abstract TLocalFunctionState CreateLocalFunctionState(LocalFunctionSymbol symbol);
 
         private SmallDictionary<LocalFunctionSymbol, TLocalFunctionState>? _localFuncVarUsages = null;
 
@@ -50,7 +50,7 @@ protected TLocalFunctionState GetOrCreateLocalFuncUsages(LocalFunctionSymbol loc
 
             if (!_localFuncVarUsages.TryGetValue(localFunc, out TLocalFunctionState? usages))
             {
-                usages = CreateLocalFunctionState();
+                usages = CreateLocalFunctionState(localFunc);
                 _localFuncVarUsages[localFunc] = usages;
             }
             return usages;

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

@@ -73,7 +73,7 @@ public LocalFunctionState(LocalState unreachableState)
             { }
         }
 
-        protected override LocalFunctionState CreateLocalFunctionState() => new LocalFunctionState(UnreachableState());
+        protected override LocalFunctionState CreateLocalFunctionState(LocalFunctionSymbol symbol) => new LocalFunctionState(UnreachableState());
 
         protected override bool Meet(ref LocalState self, ref LocalState other)
         {

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

@@ -23,7 +23,10 @@ public LocalFunctionState(LocalState stateFromBottom, LocalState stateFromTop)
             { }
         }
 
-        protected override LocalFunctionState CreateLocalFunctionState()
+        protected override LocalFunctionState CreateLocalFunctionState(LocalFunctionSymbol symbol)
+            => CreateLocalFunctionState();
+
+        private LocalFunctionState CreateLocalFunctionState()
             => new LocalFunctionState(
                 // The bottom state should assume all variables, even new ones, are assigned
                 new LocalState(BitVector.AllSet(nextVariableSlot), normalizeToBottom: true),

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

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -87,7 +85,7 @@ public bool Equals(VariableIdentifier other)
                 return Symbol.Equals(other.Symbol, TypeCompareKind.AllIgnoreOptions);
             }
 
-            public override bool Equals(object obj)
+            public override bool Equals(object? obj)
             {
                 throw ExceptionUtilities.Unreachable;
             }

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

@@ -19,6 +19,7 @@
 #define REFERENCE_STATE
 #endif
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -38,6 +39,29 @@ internal partial class DefiniteAssignmentPass : LocalDataFlowPass<
         DefiniteAssignmentPass.LocalState,
         DefiniteAssignmentPass.LocalFunctionState>
     {
+        /// <summary>
+        /// A mapping from local variables to the index of their slot in a flow analysis local state.
+        /// </summary>
+        private readonly PooledDictionary<VariableIdentifier, int> _variableSlot = PooledDictionary<VariableIdentifier, int>.GetInstance();
+
+        /// <summary>
+        /// A mapping from the local variable slot to the symbol for the local variable itself.  This
+        /// is used in the implementation of region analysis (support for extract method) to compute
+        /// the set of variables "always assigned" in a region of code.
+        ///
+        /// The first slot, slot 0, is reserved for indicating reachability, so the first tracked variable will
+        /// be given slot 1. When referring to VariableIdentifier.ContainingSlot, slot 0 indicates
+        /// that the variable in VariableIdentifier.Symbol is a root, i.e. not nested within another
+        /// tracked variable. Slots &lt; 0 are illegal.
+        /// </summary>
+        protected VariableIdentifier[] variableBySlot = new VariableIdentifier[1];
+
+        /// <summary>
+        /// Variable slots are allocated to local variables sequentially and never reused.  This is
+        /// the index of the next slot number to use.
+        /// </summary>
+        protected int nextVariableSlot = 1;
+
         /// <summary>
         /// Some variables that should be considered initially assigned.  Used for region analysis.
         /// </summary>
@@ -192,6 +216,7 @@ internal DefiniteAssignmentPass(
 
         protected override void Free()
         {
+            _variableSlot.Free();
             _usedVariables.Free();
             _readParameters?.Free();
             _usedLocalFunctions.Free();
@@ -204,6 +229,52 @@ protected override void Free()
             base.Free();
         }
 
+        protected override bool TryGetVariable(VariableIdentifier identifier, out int slot)
+        {
+            return _variableSlot.TryGetValue(identifier, out slot);
+        }
+
+        protected override int AddVariable(VariableIdentifier identifier)
+        {
+            int slot = nextVariableSlot++;
+            _variableSlot.Add(identifier, slot);
+            if (slot >= variableBySlot.Length)
+            {
+                Array.Resize(ref this.variableBySlot, slot * 2);
+            }
+
+            variableBySlot[slot] = identifier;
+            return slot;
+        }
+
+        protected Symbol GetNonMemberSymbol(int slot)
+        {
+            VariableIdentifier variableId = variableBySlot[slot];
+            while (variableId.ContainingSlot > 0)
+            {
+                Debug.Assert(variableId.Symbol.Kind == SymbolKind.Field || variableId.Symbol.Kind == SymbolKind.Property || variableId.Symbol.Kind == SymbolKind.Event,
+                    "inconsistent property symbol owner");
+                variableId = variableBySlot[variableId.ContainingSlot];
+            }
+            return variableId.Symbol;
+        }
+
+        private int RootSlot(int slot)
+        {
+            while (true)
+            {
+                int containingSlot = variableBySlot[slot].ContainingSlot;
+                if (containingSlot == 0)
+                {
+                    return slot;
+                }
+                else
+                {
+                    slot = containingSlot;
+                }
+            }
+        }
+
 #if DEBUG
         protected override void VisitRvalue(BoundExpression node, bool isKnownToBeAnLvalue = false)
         {

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

@@ -7,7 +7,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -27,31 +26,6 @@ internal interface ILocalDataFlowState : ILocalState
             bool NormalizeToBottom { get; }
         }
 
-        /// <summary>
-        /// A mapping from local variables to the index of their slot in a flow analysis local state.
-        /// </summary>
-        protected PooledDictionary<VariableIdentifier, int> _variableSlot = PooledDictionary<VariableIdentifier, int>.GetInstance();
-
-        /// <summary>
-        /// A mapping from the local variable slot to the symbol for the local variable itself.  This
-        /// is used in the implementation of region analysis (support for extract method) to compute
-        /// the set of variables "always assigned" in a region of code.
-        ///
-        /// The first slot, slot 0, is reserved for indicating reachability, so the first tracked variable will
-        /// be given slot 1. When referring to <see cref="VariableIdentifier.ContainingSlot"/>, slot 0 indicates
-        /// that the variable in <see cref="VariableIdentifier.Symbol"/> is a root, i.e. not nested within another
-        /// tracked variable. Slots &lt; 0 are illegal.
-        /// </summary>
-        protected VariableIdentifier[] variableBySlot = new VariableIdentifier[1];
-
-        /// <summary>
-        /// Variable slots are allocated to local variables sequentially and never reused.  This is
-        /// the index of the next slot number to use.
-        /// </summary>
-        protected int nextVariableSlot = 1;
-
-        private readonly int _maxSlotDepth;
-
         /// <summary>
         /// A cache for remember which structs are empty.
         /// </summary>
@@ -62,12 +36,10 @@ protected LocalDataFlowPass(
             Symbol? member,
             BoundNode node,
             EmptyStructTypeCache emptyStructs,
-            bool trackUnassignments,
-            int maxSlotDepth = 0)
+            bool trackUnassignments)
             : base(compilation, member, node, nonMonotonicTransferFunction: trackUnassignments)
         {
             Debug.Assert(emptyStructs != null);
-            _maxSlotDepth = maxSlotDepth;
             _emptyStructTypeCache = emptyStructs;
         }
 
@@ -85,11 +57,9 @@ protected LocalDataFlowPass(
             _emptyStructTypeCache = emptyStructs;
         }
 
-        protected override void Free()
-        {
-            _variableSlot.Free();
-            base.Free();
-        }
+        protected abstract bool TryGetVariable(VariableIdentifier identifier, out int slot);
+
+        protected abstract int AddVariable(VariableIdentifier identifier);
 
         /// <summary>
         /// Locals are given slots when their declarations are encountered.  We only need give slots
@@ -107,7 +77,7 @@ protected int VariableSlot(Symbol symbol, int containingSlot = 0)
             containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, forceContainingSlotsToExist: false);
 
             int slot;
-            return (_variableSlot.TryGetValue(new VariableIdentifier(symbol, containingSlot), out slot)) ? slot : -1;
+            return TryGetVariable(new VariableIdentifier(symbol, containingSlot), out slot) ? slot : -1;
         }
 
         protected virtual bool IsEmptyStructType(TypeSymbol type)
@@ -137,7 +107,7 @@ protected virtual int GetOrCreateSlot(Symbol symbol, int containingSlot = 0, boo
             int slot;
 
             // Since analysis may proceed in multiple passes, it is possible the slot is already assigned.
-            if (!_variableSlot.TryGetValue(identifier, out slot))
+            if (!TryGetVariable(identifier, out slot))
             {
                 if (!createIfMissing)
                 {
@@ -150,19 +120,7 @@ protected virtual int GetOrCreateSlot(Symbol symbol, int containingSlot = 0, boo
                     return -1;
                 }
 
-                if (_maxSlotDepth > 0 && GetSlotDepth(containingSlot) >= _maxSlotDepth)
-                {
-                    return -1;
-                }
-
-                slot = nextVariableSlot++;
-                _variableSlot.Add(identifier, slot);
-                if (slot >= variableBySlot.Length)
-                {
-                    Array.Resize(ref this.variableBySlot, slot * 2);
-                }
-
-                variableBySlot[slot] = identifier;
+                slot = AddVariable(identifier);
             }
 
             if (IsConditionalState)
@@ -178,17 +136,6 @@ protected virtual int GetOrCreateSlot(Symbol symbol, int containingSlot = 0, boo
             return slot;
         }
 
-        private int GetSlotDepth(int slot)
-        {
-            int depth = 0;
-            while (slot > 0)
-            {
-                depth++;
-                slot = variableBySlot[slot].ContainingSlot;
-            }
-            return depth;
-        }
-
         /// <summary>
         /// Sets the starting state for any newly declared variables in the LocalDataFlowPass.
         /// </summary>
@@ -227,7 +174,7 @@ private int DescendThroughTupleRestFields(ref Symbol symbol, int containingSlot,
                     }
                     else
                     {
-                        if (!_variableSlot.TryGetValue(new VariableIdentifier(restField, containingSlot), out containingSlot))
+                        if (!TryGetVariable(new VariableIdentifier(restField, containingSlot), out containingSlot))
                         {
                             return -1;
                         }
@@ -242,18 +189,6 @@ private int DescendThroughTupleRestFields(ref Symbol symbol, int containingSlot,
 
         protected abstract bool TryGetReceiverAndMember(BoundExpression expr, out BoundExpression? receiver, [NotNullWhen(true)] out Symbol? member);
 
-        protected Symbol GetNonMemberSymbol(int slot)
-        {
-            VariableIdentifier variableId = variableBySlot[slot];
-            while (variableId.ContainingSlot > 0)
-            {
-                Debug.Assert(variableId.Symbol.Kind == SymbolKind.Field || variableId.Symbol.Kind == SymbolKind.Property || variableId.Symbol.Kind == SymbolKind.Event,
-                    "inconsistent property symbol owner");
-                variableId = variableBySlot[variableId.ContainingSlot];
-            }
-            return variableId.Symbol;
-        }
-
         /// <summary>
         /// Return the slot for a variable, or -1 if it is not tracked (because, for example, it is an empty struct).
         /// </summary>
@@ -310,22 +245,6 @@ 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;
-                }
-            }
-        }
-
         protected static bool HasInitializer(Symbol field) => field switch
         {
             SourceMemberFieldSymbol f => f.HasInitializer,