Ensure that we walk into closures of function instances bound inside of types.

This demonstrates that we need to rethink how we handle TP Instances in the
MRTG since its clearly possible for TP instances to be directly reachable
as constants in this kind of code, and we're not including that in the compiler
hash correctly right now.

Author: braxtonmckee

typed_python/CompilerVisibleObjectVisitor.hpp

@@ -523,6 +523,39 @@ class CompilerVisibleObjectVisitor {
         );
     }
 
+    template<class visitor_type>
+    static void walkInstance(
+        Type* objType,
+        instance_ptr instance,
+        const visitor_type& visitor
+    ) {
+        if (objType->isComposite()) {
+            CompositeType* compType = (CompositeType*)objType;
+            for (long k = 0; k < compType->getTypes().size(); k++) {
+                walkInstance(
+                    compType->getTypes()[k],
+                    compType->eltPtr(instance, k),
+                    visitor
+                );
+            }
+            return;
+        }
+
+        if (objType->isPyCell()) {
+            static PyCellType* pct = PyCellType::Make();
+
+            PyObject* o = pct->getPyObj(instance);
+
+            if (!PyCell_Check(o) || !PyCell_Get(o)) {
+                return;
+            }
+
+            visitor.visitTopo(PyCell_Get(o));
+            return;
+        }
+    }
+
+
     template<class visitor_type>
     static void walk(
         TypeOrPyobj obj,
@@ -576,6 +609,19 @@ class CompilerVisibleObjectVisitor {
         if (argType) {
             visitor.visitHash(ShaHash(2));
             visitor.visitTopo(argType);
+
+            if (argType->isFunction()) {
+                // visit the function's closure
+                Function* funcT = (Function*)argType;
+                instance_ptr dataPtr = ((PyInstance*)obj.pyobj())->dataPtr();
+
+                walkInstance(
+                    funcT->getClosureType(),
+                    dataPtr,
+                    visitor
+                );
+            }
+
             return;
         }
 

typed_python/FunctionType.hpp

@@ -876,7 +876,10 @@ class Function : public Type {
                     );
                 }
 
-                visitor.visitNamedTopo(nameAndGlobal.first, nameAndGlobal.second);
+                visitor.visitNamedTopo(
+                    nameAndGlobal.first,
+                    nameAndGlobal.second
+                );
             }
 
             if (mReturnType) {

typed_python/Type.hpp

@@ -197,6 +197,10 @@ class Type {
         return m_typeCategory == catPythonObjectOfType;
     }
 
+    bool isPyCell() const {
+        return m_typeCategory == catPyCell;
+    }
+
     bool isClass() const {
         return m_typeCategory == catClass;
     }

typed_python/type_identity_test.py

@@ -784,3 +784,51 @@ def makeFun(mh):
 
         fFromOtherProcess = callFunctionInFreshProcess(makeFun, ('C',))
         assert fFromOtherProcess.__globals__['__module_hash__'] == 'C'
+
+
+@TypeFunction
+def RefsAValueInEntrypointedStaticmethod(i):
+    class C:
+        @staticmethod
+        @Entrypoint
+        def f():
+            return i
+    return C
+
+
+@TypeFunction
+def RefsAValueInStaticmethod(i):
+    class C:
+        @staticmethod
+        def f():
+            return i
+    return C
+
+
+@TypeFunction
+def RefsAValueInStaticmethodOnClass(i):
+    class C(Class):
+        @staticmethod
+        def f():
+            return i
+    return C
+
+
+def test_type_function_identity_referencing_int_in_function_only():
+    assert RefsAValueInEntrypointedStaticmethod(1).f() == 1
+    assert RefsAValueInEntrypointedStaticmethod(2).f() == 2
+
+    assert (
+        identityHash(RefsAValueInStaticmethod(1))
+        != identityHash(RefsAValueInStaticmethod(2))
+    )
+
+    assert (
+        identityHash(RefsAValueInEntrypointedStaticmethod(1))
+        != identityHash(RefsAValueInEntrypointedStaticmethod(2))
+    )
+
+    assert (
+        identityHash(RefsAValueInStaticmethodOnClass(1))
+        != identityHash(RefsAValueInStaticmethodOnClass(2))
+    )