Track state separately in NullableWalker for nested and containing methods

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

@@ -53,7 +53,7 @@ private List<Symbol> Analyze(ref bool badRegion)
  {
  foreach (var i in _endOfRegionState.Assigned.TrueBits())
  {
- if (i >= variableBySlot.Length)
+ if (i >= variableBySlot.Count)
  {
  continue;
  }

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

@@ -52,9 +52,9 @@ internal partial class DefiniteAssignmentPass : LocalDataFlowPass<
  /// 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.
+ /// tracked variable. Slots less than 0 are illegal.
  /// </summary>
- protected VariableIdentifier[] variableBySlot = new VariableIdentifier[1];
+ protected readonly ArrayBuilder<VariableIdentifier> variableBySlot = ArrayBuilder<VariableIdentifier>.GetInstance(1, default);
 
  /// <summary>
  /// Variable slots are allocated to local variables sequentially and never reused. This is
@@ -216,6 +216,7 @@ internal DefiniteAssignmentPass(
 
  protected override void Free()
  {
+ variableBySlot.Free();
  _variableSlot.Free();
  _usedVariables.Free();
  _readParameters?.Free();
@@ -238,11 +239,10 @@ protected override int AddVariable(VariableIdentifier identifier)
  {
  int slot = nextVariableSlot++;
  _variableSlot.Add(identifier, slot);
- if (slot >= variableBySlot.Length)
+ while (slot >= variableBySlot.Count)
  {
- Array.Resize(ref this.variableBySlot, slot * 2);
+ variableBySlot.Add(default);
  }
-
  variableBySlot[slot] = identifier;
  return slot;
  }

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

@@ -90,7 +90,7 @@ private void ProcessState(HashSet<Symbol> definitelyAssigned, LocalState state1,
  {
  foreach (var slot in state1.Assigned.TrueBits())
  {
- if (slot < variableBySlot.Length &&
+ if (slot < variableBySlot.Count &&
  state2opt?.IsAssigned(slot) != false &&
  variableBySlot[slot].Symbol is { } symbol &&
  symbol.Kind != SymbolKind.Field)

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.Variables.cs

@@ -78,16 +78,14 @@ private sealed class NextId
  private readonly PooledDictionary<Symbol, TypeWithAnnotations> _variableTypes = SpecializedSymbolCollections.GetPooledSymbolDictionaryInstance<Symbol, TypeWithAnnotations>();
 
  /// <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.
+ /// A mapping from the local variable slot to the symbol for the local variable itself.
  ///
  /// 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.
+ /// tracked variable. Slots less than 0 are illegal.
  /// </summary>
- private readonly ArrayBuilder<VariableIdentifier> _variableBySlot;
+ private readonly ArrayBuilder<VariableIdentifier> _variableBySlot = ArrayBuilder<VariableIdentifier>.GetInstance(1, default);
 
  internal static Variables Create(Symbol? symbol)
  {
@@ -130,15 +128,13 @@ private void Populate(VariablesSnapshot snapshot)
 
  private Variables(NextId nextId, int id, Variables? container, Symbol? symbol)
  {
- Debug.Assert(container is null || container.Id < nextId.Value);
+ Debug.Assert(container is null || container.Id < id);
  Debug.Assert(id < nextId.Value);
  _nextId = nextId;
  // PROTOTYPE: Handle > 64K nested methods (distinct ids). See NullableStateTooManyNestedFunctions().
  Id = id;
  Container = container;
  Symbol = symbol;
- _variableBySlot = ArrayBuilder<VariableIdentifier>.GetInstance();
- _variableBySlot.Add(default); // slot 0 reserved for reachability
  }
 
  internal void Free()

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

@@ -2603,16 +2603,15 @@ private void VisitStatementsWithLocalFunctions(BoundBlock block)
  var state = TopState();
  var startingState = localFunctionState.StartingState;
  startingState.ForEach(
- static (slot, arg) =>
+ (slot, variables) =>
  {
- var (variables, state, localFunc, startingState) = arg;
  var symbol = variables[variables.RootSlot(slot)].Symbol;
  if (Symbol.IsCaptured(symbol, localFunc))
  {
  state[slot] = startingState[slot];
  }
  },
- (_variables, state, localFunc, startingState));
+ _variables);
  localFunctionState.Visited = true;
 
  AnalyzeLocalFunctionOrLambda(
@@ -2681,25 +2680,6 @@ private void AnalyzeLocalFunctionOrLambda(
  ImmutableArray<PendingBranch> pendingReturns = RemoveReturns();
  RestorePending(oldPending);
 
- var location = lambdaOrFunctionSymbol.Locations.FirstOrNone();
- LeaveParameters(lambdaOrFunctionSymbol.Parameters, lambdaOrFunction.Syntax, location);
-
- // Intersect the state of all branches out of the local function
- var stateAtReturn = this.State;
- foreach (PendingBranch pending in pendingReturns)
- {
- this.State = pending.State;
- BoundNode branch = pending.Branch;
-
- // Pass the local function identifier as a location if the branch
- // is null or compiler generated.
- LeaveParameters(lambdaOrFunctionSymbol.Parameters,
- branch?.Syntax,
- branch?.WasCompilerGenerated == false ? null : location);
-
- Join(ref stateAtReturn, ref this.State);
- }
-
  _snapshotBuilderOpt?.ExitWalker(this.SaveSharedState(), previousSlot);
  _variables = _variables.Container!;
  this.State = oldState;
@@ -9603,32 +9583,42 @@ internal LocalStateSnapshot(int id, LocalStateSnapshot? container, BitVector sta
  }
 
  [DebuggerDisplay("{GetDebuggerDisplay(), nq}")]
- internal sealed class LocalState : ILocalDataFlowState // PROTOTYPE: Pool instances.
+ internal struct LocalState : ILocalDataFlowState
  {
+ private sealed class Boxed
+ {
+ internal LocalState Value;
+
+ internal Boxed(LocalState value)
+ {
+ Value = value;
+ }
+ }
+
  internal readonly int Id;
- internal LocalState? Container;
+ private readonly Boxed? _container;
 
  // The representation of a state is a bit vector with two bits per slot:
  // (false, false) => NotNull, (false, true) => MaybeNull, (true, true) => MaybeDefault.
  // Slot 0 is used to represent whether the state is reachable (true) or not.
  private BitVector _state;
 
- private LocalState(int id, LocalState? container, BitVector state)
+ private LocalState(int id, Boxed? container, BitVector state)
  {
  Id = id;
- Container = container;
+ _container = container;
  _state = state;
  }
 
  internal static LocalState Create(LocalStateSnapshot snapshot)
  {
- var container = snapshot.Container is null ? null : Create(snapshot.Container);
+ var container = snapshot.Container is null ? null : new Boxed(Create(snapshot.Container));
  return new LocalState(snapshot.Id, container, snapshot.State.Clone());
  }
 
  internal LocalStateSnapshot CreateSnapshot()
  {
- return new LocalStateSnapshot(Id, Container?.CreateSnapshot(), _state.Clone());
+ return new LocalStateSnapshot(Id, _container?.Value.CreateSnapshot(), _state.Clone());
  }
 
  public bool Reachable => _state[0];
@@ -9649,15 +9639,15 @@ private static LocalState CreateReachableOrUnreachableState(Variables variables,
  {
  var container = variables.Container is null ?
  null :
- CreateReachableOrUnreachableState(variables.Container, reachable);
+ new Boxed(CreateReachableOrUnreachableState(variables.Container, reachable));
  int capacity = reachable ? variables.Count : 1;
  return new LocalState(variables.Id, container, CreateBitVector(capacity, reachable));
  }
 
  public LocalState CreateNestedFunction(Variables variables)
  {
  Debug.Assert(Id == variables.Container!.Id);
- return new LocalState(variables.Id, container: this, CreateBitVector(capacity: variables.Count, reachable: true));
+ return new LocalState(variables.Id, container: new Boxed(this), CreateBitVector(capacity: variables.Count, reachable: true));
  }
 
  private static BitVector CreateBitVector(int capacity, bool reachable)
@@ -9691,7 +9681,7 @@ private bool HasVariable(int id, int index)
  {
  if (Id > id)
  {
- return Container!.HasValue(id, index);
+ return _container!.Value.HasValue(id, index);
  }
  else
  {
@@ -9714,7 +9704,7 @@ private bool HasValue(int id, int index)
  if (Id != id)
  {
  Debug.Assert(Id > id);
- return Container!.HasValue(id, index);
+ return _container!.Value.HasValue(id, index);
  }
  else
  {
@@ -9731,7 +9721,7 @@ public void Normalize(NullableWalker walker, Variables variables)
  }
  else
  {
- Container?.Normalize(walker, variables.Container!);
+ _container?.Value.Normalize(walker, variables.Container!);
  int start = Capacity;
  EnsureCapacity(variables.Count);
  Populate(walker, start);
@@ -9740,7 +9730,7 @@ public void Normalize(NullableWalker walker, Variables variables)
 
  public void PopulateAll(NullableWalker walker)
  {
- Container?.PopulateAll(walker);
+ _container?.Value.PopulateAll(walker);
  Populate(walker, start: 1);
  }
 
@@ -9773,7 +9763,7 @@ private NullableFlowState GetValue(int id, int index)
  if (Id != id)
  {
  Debug.Assert(Id > id);
- return Container!.GetValue(id, index);
+ return _container!.Value.GetValue(id, index);
  }
  else
  {
@@ -9798,7 +9788,7 @@ private void SetValue(int id, int index, NullableFlowState value)
  if (Id != id)
  {
  Debug.Assert(Id > id);
- Container!.SetValue(id, index, value);
+ _container!.Value.SetValue(id, index, value);
  }
  else
  {
@@ -9812,7 +9802,7 @@ private void SetValue(int id, int index, NullableFlowState value)
 
  internal void ForEach<TArg>(Action<int, TArg> action, TArg arg)
  {
- Container?.ForEach(action, arg);
+ _container?.Value.ForEach(action, arg);
  for (int index = 1; index < Capacity; index++)
  {
  action(Variables.ConstructSlot(Id, index), arg);
@@ -9824,7 +9814,7 @@ internal LocalState GetStateForVariables(int id)
  var state = this;
  while (state.Id != id)
  {
- state = state.Container!;
+ state = state._container!.Value;
  }
  return state;
  }
@@ -9835,15 +9825,15 @@ internal LocalState GetStateForVariables(int id)
  /// <returns></returns>
  public LocalState Clone()
  {
- var container = Container?.Clone();
+ var container = _container is null ? null : new Boxed(_container.Value.Clone());
  return new LocalState(Id, container, _state.Clone());
  }
 
  public bool Join(in LocalState other)
  {
  Debug.Assert(Id == other.Id);
  bool result = false;
- if (Container is { } && Container.Join(in other.Container!))
+ if (_container is { } && _container.Value.Join(in other._container!.Value))
  {
  result = true;
  }
@@ -9858,7 +9848,7 @@ public bool Meet(in LocalState other)
  {
  Debug.Assert(Id == other.Id);
  bool result = false;
- if (Container is { } && Container.Meet(in other.Container!))
+ if (_container is { } && _container.Value.Meet(in other._container!.Value))
  {
  result = true;
  }
@@ -9896,7 +9886,7 @@ internal string Dump(Variables variables)
 
  private void Dump(StringBuilder builder, Variables variables)
  {
- Container?.Dump(builder, variables.Container!);
+ _container?.Value.Dump(builder, variables.Container!);
 
  for (int index = 1; index < Capacity; index++)
  {