[model] Add StackTraceMap and StackTraceSet

This adds debug helpers that collect stack traces for updates to
Map and Set.

Change-Id: I79ca28055fe1fa5fa073776f21c6e380af4af9f6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/429400
Reviewed-by: Chloe Stefantsova <[email protected]>
Commit-Queue: Johnni Winther <[email protected]>

Author: johnniwinther

pkg/_fe_analyzer_shared/lib/src/debug_helpers/stack_trace.dart

@@ -64,7 +64,7 @@ class StackTraceValue<T> {
 ///
 class StackTraceList<T> with ListMixin<T> implements List<T> {
   List<T> _list;
-  List<(String, Object?, StackTrace)> _stackTraces = [];
+  final List<(String, Object?, StackTrace)> _stackTraces = [];
 
   StackTraceList(this._list) {
     _stackTraces.add(('init', _list, StackTrace.current));
@@ -119,3 +119,138 @@ class StackTraceList<T> with ListMixin<T> implements List<T> {
     return _list.remove(element);
   }
 }
+
+/// Debug helper that tracks updates to a set.
+///
+/// Use this in debugging to record stack traces for when a set is updated.
+/// For instance to track the list `bars` change
+///
+///     class Foo {
+///       Set<Bar> bars;
+///       Foo(this.bars);
+///     }
+///
+/// to
+///
+///     class Foo {
+///       StackTraceSet<Bar> _bars;
+///       Foo(Set<Bar> bars) : _bars = StackTraceList(bars);
+///       Set<Bar> get bars => _bars;
+///       void set bars(Set<Bar> value) {
+///         _bars.value = value;
+///       }
+///     }
+///
+class StackTraceSet<T> with SetMixin<T> implements Set<T> {
+  Set<T> _set;
+  final List<(String, Object?, StackTrace)> _stackTraces = [];
+
+  StackTraceSet(this._set) {
+    _stackTraces.add(('init', _set, StackTrace.current));
+  }
+
+  Set<T> get value => _set;
+
+  void set value(Set<T> v) {
+    _stackTraces.add(('value', v, StackTrace.current));
+    _set = v;
+  }
+
+  @override
+  bool add(T element) {
+    _stackTraces.add(('add', element, StackTrace.current));
+    return _set.add(element);
+  }
+
+  @override
+  void addAll(Iterable<T> iterable) {
+    _stackTraces.add(('addAll', iterable.toList(), StackTrace.current));
+    _set.addAll(iterable);
+  }
+
+  @override
+  int get length => _set.length;
+
+  @override
+  void clear() {
+    _stackTraces.add(('clear', null, StackTrace.current));
+    _set.clear();
+  }
+
+  @override
+  bool remove(Object? element) {
+    _stackTraces.add(('remove', element, StackTrace.current));
+    return _set.remove(element);
+  }
+
+  @override
+  bool contains(Object? element) => _set.contains(element);
+
+  @override
+  Iterator<T> get iterator => _set.iterator;
+
+  @override
+  T? lookup(Object? element) => _set.lookup(element);
+
+  @override
+  Set<T> toSet() => _set.toSet();
+}
+
+/// Debug helper that tracks updates to a map.
+///
+/// Use this in debugging to record stack traces for when a map is updated.
+/// For instance to track the map `bars` change
+///
+///     class Foo {
+///       Map<Bar, Baz> bars;
+///       Foo(this.bars);
+///     }
+///
+/// to
+///
+///     class Foo {
+///       StackTrace<Bar, Baz> _bars;
+///       Foo(Map<Bar, Baz> bars) : _bars = StackTraceMap(bars);
+///       Map<Bar, Baz> get bars => _bars;
+///       void set bars(Map<Bar, Baz> value) {
+///         _bars.value = value;
+///       }
+///     }
+///
+class StackTraceMap<K, V> with MapBase<K, V> implements Map<K, V> {
+  Map<K, V> _map;
+  List<(String, Object?, StackTrace)> _stackTraces = [];
+
+  StackTraceMap(this._map);
+
+  Map<K, V> get value => _map;
+
+  void set value(Map<K, V> v) {
+    _stackTraces.add(('value', v, StackTrace.current));
+    _map = value;
+  }
+
+  @override
+  V? operator [](Object? key) => _map[key];
+
+  @override
+  void operator []=(K key, V value) {
+    _stackTraces.add(('[]=', (key, value), StackTrace.current));
+    _map[key] = value;
+  }
+
+  @override
+  void clear() {
+    _stackTraces.add(('clear', null, StackTrace.current));
+    _map.clear();
+  }
+
+  @override
+  Iterable<K> get keys => _map.keys;
+
+  @override
+  V? remove(Object? key) {
+    _stackTraces.add(('remove', key, StackTrace.current));
+    return _map.remove(key);
+  }
+}