More fixes for type identities.

It turns out that we were walking into arbitrary python objects. Our compiler doesn't,
in fact, do that.  For instance if you have

    class C:
        def __init__(self, x):
            self.x = x

    c = C(10)

    @entrypoint
    def f():
        return c.x

the compiler knows that 'x' might change and will not inline the constant. Unfortunately, our
identityHasher was walking in and including the '10' in the value of the hash, which can lead to
serious instability.

Author: braxtonmckee

typed_python/CompilerVisibleObjectVisitor.hpp

@@ -703,20 +703,19 @@ class CompilerVisibleObjectVisitor {
             return;
         }
 
-        // we do want to visit the internals of arbitrary objects, because
-        // the compiler will attempt to do so as well.
-        if (PyObject_HasAttrString(obj.pyobj(), "__dict__")) {
-            PyObjectStealer dict(PyObject_GetAttrString(obj.pyobj(), "__dict__"));
-
-            if (dict) {
-                hashVisit(ShaHash(12));
-
-                instanceVisit((PyObject*)obj.pyobj()->ob_type);
-                visitDict(dict, true);
-                return;
-            }
+        if (obj.pyobj()->ob_type == &PyClassMethodDescr_Type
+            || obj.pyobj()->ob_type == &PyMethodDescr_Type) {
+            // the compiler looks at the type and the name of a given method descriptor
+            instanceVisit(PyDescr_TYPE(obj.pyobj()));
+            instanceVisit(PyDescr_NAME(obj.pyobj()));
+            return;
         }
 
+        // we don't visit the internals of arbitrary objects - by default, the compiler
+        // won't do this because they are mutable.
+
+        // we do visit the type, since the compiler may infer something about the type
+        // of the instance and we assume that type objects are stable.
         instanceVisit((PyObject*)obj.pyobj()->ob_type);
     }
 

typed_python/MutuallyRecursiveTypeGroup.cpp

@@ -978,11 +978,8 @@ ShaHash MutuallyRecursiveTypeGroup::computePyObjectShaHashConstant(PyObject* h)
     }
 
     if (h->ob_type == &PyProperty_Type
-        || h->ob_type == &PyProperty_Type
-        || h->ob_type == &PyClassMethodDescr_Type
         || h->ob_type == &PyGetSetDescr_Type
         || h->ob_type == &PyMemberDescr_Type
-        || h->ob_type == &PyMethodDescr_Type
         || h->ob_type == &PyWrapperDescr_Type
         || h->ob_type == &PyDictProxy_Type
         || h->ob_type == &_PyMethodWrapper_Type
@@ -1032,11 +1029,8 @@ bool MutuallyRecursiveTypeGroup::isSimpleConstant(PyObject* h) {
         || h == (PyObject*)&PyFunction_Type
         || PyFloat_Check(h)
         || h->ob_type == &PyProperty_Type
-        || h->ob_type == &PyProperty_Type
-        || h->ob_type == &PyClassMethodDescr_Type
         || h->ob_type == &PyGetSetDescr_Type
         || h->ob_type == &PyMemberDescr_Type
-        || h->ob_type == &PyMethodDescr_Type
         || h->ob_type == &PyWrapperDescr_Type
         || h->ob_type == &PyDictProxy_Type
         || h->ob_type == &_PyMethodWrapper_Type

typed_python/TypeOrPyobj.hpp

@@ -47,6 +47,16 @@ class TypeOrPyobj {
         incref(mPyObj);
     }
 
+    TypeOrPyobj(PyTypeObject* o) :
+        mType(nullptr),
+        mPyObj((PyObject*)o)
+    {
+        if (!mPyObj) {
+            throw std::runtime_error("Can't construct a TypeOrPyobj with a null PyObject");
+        }
+        incref(mPyObj);
+    }
+
     ~TypeOrPyobj() {
         if (mPyObj) {
             decref(mPyObj);
@@ -162,4 +172,4 @@ namespace std {
             return hash<void*>()((void*)k.pyobj());
         }
     };
-}
+}

typed_python/type_identity_test.py

@@ -12,17 +12,18 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-from typed_python.test_util import evaluateExprInFreshProcess
+import threading
 import pytest
+
+import typed_python
+from typed_python.test_util import evaluateExprInFreshProcess
 from typed_python import (
     UInt64, UInt32,
     ListOf, TupleOf, Tuple, NamedTuple, Dict, OneOf, Forward, identityHash,
     Entrypoint, Class, Member, Final, TypeFunction, SerializationContext,
     Function, NotCompiled
 )
 
-import typed_python
-
 from typed_python.hash import Hash
 
 from typed_python._types import (
@@ -112,6 +113,33 @@ def g(x: int):
         raise Exception("hash instability found")
 
 
+moduleLevelThreadLocal = threading.local()
+
+
+@NotCompiled
+def functionAccessingModuleLevelThreadLocal():
+    return hasattr(moduleLevelThreadLocal, "anything")
+
+
+def test_identity_of_function_accessing_thread_local():
+    print(typesAndObjectsVisibleToCompilerFrom(type(functionAccessingModuleLevelThreadLocal)))
+
+    identityHash(functionAccessingModuleLevelThreadLocal)
+    moduleLevelThreadLocal.anything = True
+    identityHash(functionAccessingModuleLevelThreadLocal)
+
+    hashInstability = checkForHashInstability()
+
+    if hashInstability is not None:
+        print(hashInstability)
+        raise Exception("hash instability found")
+
+
+def test_identity_of_method_descriptors():
+    assert identityHash(ListOf(int).append) != identityHash(ListOf(float).append)
+    assert identityHash(ListOf(int).append) != identityHash(ListOf(int).extend)
+
+
 def test_class_and_held_class_in_group():
     class C(Class):
         pass