Make sure we throw an exception if we attempt to hash an MRTG more than once.

Somehow, we're seeing cases where the graph appears to be unstable and so
we get cycles in the MRTGs which is not supposed to happen. In the future,
we need to implement something else to ensure that if this happens
we can collapse the groups. But really they're supposed to be stable,
so we should try to figure out why the python object graph is not stable.

Author: braxtonmckee

typed_python/MutuallyRecursiveTypeGroup.cpp

@@ -929,34 +929,51 @@ void MutuallyRecursiveTypeGroup::computeHash() {
         return;
     }
 
-    // we are a recursive group head. We want to compute the hash
-    // of all of our constituents where, when each of them looks at
-    // other types within _our_ group, we simply hash in a placeholder
-    // for the position.
-    ShaHash wholeGroupHash;
-
-    for (auto idAndType: mIndexToObject) {
-        Type* t = idAndType.second.type();
-
-        if (t) {
-            // this actually walks the type and computes a sha-hash based on
-            // what's inside the type one layer down.
-            wholeGroupHash += t->computeIdentityHash(this);
-
-            if (t->isRecursive()) {
-                wholeGroupHash += ShaHash(t->name());
+    if (mIsCurrentlyHashing) {
+        throw std::runtime_error(
+            "Somehow we are already computing the hash of this MRTG. "
+            "This means that when we computed the group's constituents, we missed "
+            "a link between elements of this group and elements of a calling group."
+        );
+    }
+
+    try {
+        // mark that we're currently hashing.
+        mIsCurrentlyHashing = true;
+
+        // we are a recursive group head. We want to compute the hash
+        // of all of our constituents where, when each of them looks at
+        // other types within _our_ group, we simply hash in a placeholder
+        // for the position.
+        ShaHash wholeGroupHash;
+
+        for (auto idAndType: mIndexToObject) {
+            Type* t = idAndType.second.type();
+
+            if (t) {
+                // this actually walks the type and computes a sha-hash based on
+                // what's inside the type one layer down.
+                wholeGroupHash += t->computeIdentityHash(this);
+
+                if (t->isRecursive()) {
+                    wholeGroupHash += ShaHash(t->name());
+                }
+            } else {
+                wholeGroupHash += computePyObjectShaHash(idAndType.second.pyobj(), this);
             }
-        } else {
-            wholeGroupHash += computePyObjectShaHash(idAndType.second.pyobj(), this);
         }
-    }
 
-    mHash = wholeGroupHash;
+        mHash = wholeGroupHash;
+        mIsCurrentlyHashing = false;
 
-    PyEnsureGilAcquired getTheGil;
+        PyEnsureGilAcquired getTheGil;
 
-    if (mHashToGroup.find(mHash) == mHashToGroup.end()) {
-        mHashToGroup[mHash] = this;
+        if (mHashToGroup.find(mHash) == mHashToGroup.end()) {
+            mHashToGroup[mHash] = this;
+        }
+    } catch(...) {
+        mIsCurrentlyHashing = false;
+        throw;
     }
 }
 

typed_python/MutuallyRecursiveTypeGroup.hpp

@@ -23,7 +23,9 @@
 
 class MutuallyRecursiveTypeGroup {
 public:
-    MutuallyRecursiveTypeGroup() : mAnyPyObjectsIncorrectlyOrdered(false)
+    MutuallyRecursiveTypeGroup() :
+        mAnyPyObjectsIncorrectlyOrdered(false),
+        mIsCurrentlyHashing(false)
     {}
 
     MutuallyRecursiveTypeGroup(ShaHash hash);
@@ -126,6 +128,8 @@ class MutuallyRecursiveTypeGroup {
 
     void computeHash();
 
+    bool mIsCurrentlyHashing;
+
     ShaHash mHash;
 
     std::map<int32_t, TypeOrPyobj> mIndexToObject;