Use WeakReference<PythonType> instead of WeakReference

Author: slozier

Src/IronPython/Runtime/Types/PythonType.cs

@@ -39,7 +39,7 @@ public partial class PythonType : IPythonMembersList, IDynamicMetaObjectProvider
         private PythonTypeAttributes _attrs;                // attributes of the type
         private int _flags;                                 // CPython-like flags on the type
         private int _version = GetNextVersion();            // version of the type
-        private List<WeakReference> _subtypes;              // all of the subtypes of the PythonType
+        private List<WeakReference<PythonType>> _subtypes;  // all of the subtypes of the PythonType
         private PythonContext _pythonContext;               // the context the type was created from, or null for system types.
         private bool? _objectNew, _objectInit;              // true if the type doesn't override __new__ / __init__ from object.
         internal Dictionary<CachedGetKey, FastGetBase> _cachedGets; // cached gets on user defined type instances
@@ -76,7 +76,6 @@ public partial class PythonType : IPythonMembersList, IDynamicMetaObjectProvider
         [MultiRuntimeAware]
         private static int MasterVersion = 1;
         private static readonly CommonDictionaryStorage _pythonTypes = new CommonDictionaryStorage();
-        private static readonly WeakReference[] _emptyWeakRef = Array.Empty<WeakReference>();
         private static readonly object _subtypesLock = new object();
         internal static readonly Func<string, Exception, Exception> DefaultMakeException = (message, innerException) => new Exception(message, innerException);
         internal static readonly Func<string, Exception> DefaultMakeExceptionNoInnerException = (message) => new Exception(message);
@@ -680,17 +679,15 @@ public void __setattr__(CodeContext/*!*/ context, string name, object value) {
 
         public PythonList __subclasses__(CodeContext/*!*/ context) {
             PythonList ret = new PythonList();
-            IList<WeakReference> subtypes = SubTypes;
+            var subtypes = SubTypes;
 
             if (subtypes != null) {
                 PythonContext pc = context.LanguageContext;
 
-                foreach (WeakReference wr in subtypes) {
-                    if (wr.IsAlive) {
-                        PythonType pt = (PythonType)wr.Target;
-
+                foreach (var wr in subtypes) {
+                    if (wr.TryGetTarget(out PythonType pt)) {
                         if (pt.PythonContext == null || pt.PythonContext == pc) {
-                            ret.AddNoLock(wr.Target);
+                            ret.AddNoLock(pt);
                         }
                     }
                 }
@@ -1270,8 +1267,8 @@ internal void AddSlot(string name, PythonTypeSlot slot) {
         private void ClearObjectNewInSubclasses(PythonType pt) {
             lock (_subtypesLock) {
                 if (pt._subtypes != null) {
-                    foreach (WeakReference wr in pt._subtypes) {
-                        if (wr.Target is PythonType type) {
+                    foreach (var wr in pt._subtypes) {
+                        if (wr.TryGetTarget(out PythonType type)) {
                             type._objectNew = null;
 
                             ClearObjectNewInSubclasses(type);
@@ -1284,8 +1281,8 @@ private void ClearObjectNewInSubclasses(PythonType pt) {
         private void ClearObjectInitInSubclasses(PythonType pt) {
             lock (_subtypesLock) {
                 if (pt._subtypes != null) {
-                    foreach (WeakReference wr in pt._subtypes) {
-                        if (wr.Target is PythonType type) {
+                    foreach (var wr in pt._subtypes) {
+                        if (wr.TryGetTarget(out PythonType type)) {
                             type._objectInit = null;
 
                             ClearObjectInitInSubclasses(type);
@@ -2465,9 +2462,9 @@ private void EnsureInstanceCtor() {
         #region Private implementation details
 
         private void UpdateVersion() {
-            foreach (WeakReference wr in SubTypes) {
-                if (wr.IsAlive) {
-                    ((PythonType)wr.Target).UpdateVersion();
+            foreach (var wr in SubTypes) {
+                if (wr.TryGetTarget(out PythonType pt)) {
+                    pt.UpdateVersion();
                 }
             }
 
@@ -2497,31 +2494,32 @@ private void EnsureDict() {
                     null);
             }
         }
-      
+
         /// <summary>
         /// Internal helper function to add a subtype
         /// </summary>
         private void AddSubType(PythonType subtype) {
             if (_subtypes == null) {
-                Interlocked.CompareExchange<List<WeakReference>>(ref _subtypes, new List<WeakReference>(), null);
+                Interlocked.CompareExchange(ref _subtypes, new List<WeakReference<PythonType>>(), null);
             }
 
             lock (_subtypesLock) {
-                _subtypes.Add(new WeakReference(subtype));
+                _subtypes.Add(new WeakReference<PythonType>(subtype));
             }
         }
 
         private void RemoveSubType(PythonType subtype) {
-            int i = 0;
-            if (_subtypes != null) {
-                lock (_subtypesLock) {
-                    while (i < _subtypes.Count) {
-                        if (!_subtypes[i].IsAlive || _subtypes[i].Target == subtype) {
-                            _subtypes.RemoveAt(i);
-                            continue;
-                        }
-                        i++;
+            if (_subtypes is null) return;
+
+            lock (_subtypesLock) {
+                int i = 0;
+                while (i < _subtypes.Count) {
+                    var wr = _subtypes[i];
+                    if (!wr.TryGetTarget(out PythonType target) || target == subtype) {
+                        _subtypes.RemoveAt(i);
+                        continue;
                     }
+                    i++;
                 }
             }
         }
@@ -2530,9 +2528,9 @@ private void RemoveSubType(PythonType subtype) {
         /// Gets a list of weak references to all the subtypes of this class.  May return null
         /// if there are no subtypes of the class.
         /// </summary>
-        private IList<WeakReference> SubTypes {
+        private IList<WeakReference<PythonType>> SubTypes {
             get {
-                if (_subtypes == null) return _emptyWeakRef;
+                if (_subtypes == null) return Array.Empty<WeakReference<PythonType>>();
 
                 lock (_subtypesLock) {
                     return _subtypes.ToArray();