[REFACTOR][IR][FFI] Bump tvm-ffi (+ SEqHashDef migration) and phase out tvm/ir/repr.h

include/tvm/ir/expr.h

@@ -24,11 +24,11 @@
 #ifndef TVM_IR_EXPR_H_
 #define TVM_IR_EXPR_H_
 
+#include <tvm/ffi/extra/dataclass.h>
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/ffi/string.h>
 #include <tvm/ir/cast.h>
 #include <tvm/ir/cow.h>
-#include <tvm/ir/repr.h>
 #include <tvm/ir/source_map.h>
 #include <tvm/ir/type.h>
 #include <tvm/script/printer/config.h>

include/tvm/relax/exec_builder.h

@@ -23,12 +23,12 @@
 #ifndef TVM_RELAX_EXEC_BUILDER_H_
 #define TVM_RELAX_EXEC_BUILDER_H_
 
+#include <tvm/ffi/extra/dataclass.h>
 #include <tvm/ffi/extra/structural_equal.h>
 #include <tvm/ffi/extra/structural_hash.h>
 #include <tvm/ffi/function.h>
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/ir/expr.h>
-#include <tvm/ir/repr.h>
 #include <tvm/runtime/vm/bytecode.h>
 #include <tvm/runtime/vm/executable.h>
 

include/tvm/relax/expr.h

@@ -574,7 +574,8 @@ class BindingNode : public ffi::Object {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<BindingNode>()
         .def_ro("span", &BindingNode::span, refl::AttachFieldFlag::SEqHashIgnore())
-        .def_ro("var", &BindingNode::var, refl::AttachFieldFlag::SEqHashDef());
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("var", &BindingNode::var, refl::AttachFieldFlag::SEqHashDefRecursive());
   }
 
   static constexpr TVMFFISEqHashKind _type_s_eq_hash_kind = kTVMFFISEqHashKindTreeNode;
@@ -616,7 +617,9 @@ class MatchCastNode : public BindingNode {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<MatchCastNode>()
         .def_ro("value", &MatchCastNode::value)
-        .def_ro("struct_info", &MatchCastNode::struct_info, refl::AttachFieldFlag::SEqHashDef());
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("struct_info", &MatchCastNode::struct_info,
+                refl::AttachFieldFlag::SEqHashDefRecursive());
   }
   TVM_FFI_DECLARE_OBJECT_INFO_FINAL("relax.expr.MatchCast", MatchCastNode, BindingNode);
 };
@@ -822,7 +825,7 @@ class FunctionNode : public BaseFuncNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<FunctionNode>()
-        .def_ro("params", &FunctionNode::params, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("params", &FunctionNode::params, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("body", &FunctionNode::body)
         .def_ro("ret_struct_info", &FunctionNode::ret_struct_info)
         .def_ro("is_pure", &FunctionNode::is_pure);

include/tvm/relax/struct_info.h

@@ -294,7 +294,7 @@ class FuncStructInfoNode : public StructInfoNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<FuncStructInfoNode>()
-        .def_ro("params", &FuncStructInfoNode::params, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("params", &FuncStructInfoNode::params, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("ret", &FuncStructInfoNode::ret)
         .def_ro("derive_func", &FuncStructInfoNode::derive_func)
         .def_ro("purity", &FuncStructInfoNode::purity);

include/tvm/tirx/buffer.h

@@ -126,13 +126,18 @@ class BufferNode : public ffi::Object {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<BufferNode>()
-        .def_ro("data", &BufferNode::data, refl::AttachFieldFlag::SEqHashDef())
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("data", &BufferNode::data, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("dtype", &BufferNode::dtype)
-        .def_ro("shape", &BufferNode::shape, refl::AttachFieldFlag::SEqHashDef())
-        .def_ro("strides", &BufferNode::strides, refl::AttachFieldFlag::SEqHashDef())
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("shape", &BufferNode::shape, refl::AttachFieldFlag::SEqHashDefRecursive())
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("strides", &BufferNode::strides, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("axis_separators", &BufferNode::axis_separators,
-                refl::AttachFieldFlag::SEqHashDef())
-        .def_ro("elem_offset", &BufferNode::elem_offset, refl::AttachFieldFlag::SEqHashDef())
+                refl::AttachFieldFlag::SEqHashDefRecursive())
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("elem_offset", &BufferNode::elem_offset,
+                refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("name", &BufferNode::name, refl::AttachFieldFlag::SEqHashIgnore())
         .def_ro("data_alignment", &BufferNode::data_alignment)
         .def_ro("offset_factor", &BufferNode::offset_factor)

include/tvm/tirx/exec_scope.h

@@ -126,7 +126,7 @@ class ScopeIdDefNode : public ffi::Object {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<ScopeIdDefNode>()
-        .def_ro("def_ids", &ScopeIdDefNode::def_ids, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("def_ids", &ScopeIdDefNode::def_ids, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("extents", &ScopeIdDefNode::extents)
         .def_ro("scope", &ScopeIdDefNode::scope)
         .def_ro("preferred_extents", &ScopeIdDefNode::preferred_extents);

include/tvm/tirx/expr.h

@@ -698,7 +698,8 @@ class LetNode : public PrimExprNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<LetNode>()
-        .def_ro("var", &LetNode::var, refl::AttachFieldFlag::SEqHashDef())
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("var", &LetNode::var, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("value", &LetNode::value)
         .def_ro("body", &LetNode::body);
   }
@@ -823,8 +824,8 @@ class CommReducerNode : public ffi::Object {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<CommReducerNode>()
-        .def_ro("lhs", &CommReducerNode::lhs, refl::AttachFieldFlag::SEqHashDef())
-        .def_ro("rhs", &CommReducerNode::rhs, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("lhs", &CommReducerNode::lhs, refl::AttachFieldFlag::SEqHashDefRecursive())
+        .def_ro("rhs", &CommReducerNode::rhs, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("result", &CommReducerNode::result)
         .def_ro("identity_element", &CommReducerNode::identity_element)
         .def_ro("span", &CommReducerNode::span, refl::AttachFieldFlag::SEqHashIgnore());

include/tvm/tirx/function.h

@@ -105,7 +105,7 @@ class PrimFuncNode : public BaseFuncNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<PrimFuncNode>()
-        .def_ro("params", &PrimFuncNode::params, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("params", &PrimFuncNode::params, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("ret_type", &PrimFuncNode::ret_type)
         .def_ro("buffer_map", &PrimFuncNode::buffer_map)
         .def_ro("body", &PrimFuncNode::body);

include/tvm/tirx/index_map.h

@@ -156,7 +156,7 @@ class IndexMapNode : public ffi::Object {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<IndexMapNode>()
         .def_ro("initial_indices", &IndexMapNode::initial_indices,
-                refl::AttachFieldFlag::SEqHashDef())
+                refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("final_indices", &IndexMapNode::final_indices)
         .def_ro("inverse_index_map", &IndexMapNode::inverse_index_map,
                 refl::AttachFieldFlag::SEqHashIgnore());

include/tvm/tirx/predicate.h

@@ -45,7 +45,7 @@ class PredicateNode : public ffi::Object {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<PredicateNode>()
-        .def_ro("vars", &PredicateNode::vars, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("vars", &PredicateNode::vars, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("pred", &PredicateNode::pred);
   }
 

include/tvm/tirx/stmt.h

@@ -86,7 +86,8 @@ class BindNode : public StmtNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<BindNode>()
-        .def_ro("var", &BindNode::var, refl::AttachFieldFlag::SEqHashDef())
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("var", &BindNode::var, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("value", &BindNode::value);
   }
   TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tirx.Bind", BindNode, StmtNode);
@@ -273,7 +274,8 @@ class AllocBufferNode : public StmtNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<AllocBufferNode>()
-        .def_ro("buffer", &AllocBufferNode::buffer, refl::AttachFieldFlag::SEqHashDef())
+        // TODO(tqchen): use SEqHashDefNonRecursive after the next pypi tvm-ffi release
+        .def_ro("buffer", &AllocBufferNode::buffer, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("annotations", &AllocBufferNode::annotations);
   }
   TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tirx.AllocBuffer", AllocBufferNode, StmtNode);
@@ -619,7 +621,7 @@ class ForNode : public StmtNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<ForNode>()
-        .def_ro("loop_var", &ForNode::loop_var, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("loop_var", &ForNode::loop_var, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("min", &ForNode::min)
         .def_ro("extent", &ForNode::extent)
         .def_ro("kind", &ForNode::kind)
@@ -879,7 +881,7 @@ class SBlockNode : public StmtNode {
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<SBlockNode>()
-        .def_ro("iter_vars", &SBlockNode::iter_vars, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("iter_vars", &SBlockNode::iter_vars, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("reads", &SBlockNode::reads)
         .def_ro("writes", &SBlockNode::writes)
         .def_ro("name_hint", &SBlockNode::name_hint, refl::AttachFieldFlag::SEqHashIgnore())

include/tvm/tirx/var.h

@@ -279,7 +279,7 @@ class IterVarNode : public PrimExprConvertibleNode {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<IterVarNode>()
         .def_ro("dom", &IterVarNode::dom)
-        .def_ro("var", &IterVarNode::var, refl::AttachFieldFlag::SEqHashDef())
+        .def_ro("var", &IterVarNode::var, refl::AttachFieldFlag::SEqHashDefRecursive())
         .def_ro("iter_type", &IterVarNode::iter_type)
         .def_ro("thread_tag", &IterVarNode::thread_tag);
   }

python/tvm/ir/attrs.py

@@ -79,6 +79,16 @@ def __getitem__(self, item):
 class DictAttrs(Attrs):
     """Dictionary attributes."""
 
+    @property
+    def __dict__(self):
+        """Return the underlying key-value map as a Python dict.
+
+        Defined explicitly so that tvm_ffi's _add_class_attrs skips registering
+        the C++ reflection field named '__dict__' (Python forbids adding a class
+        attribute named '__dict__' via setattr on extension-type subclasses).
+        """
+        return dict(self._dict())
+
     def _dict(self):
         """Get internal dict"""
         return _ffi_api.DictAttrsGetDict(self)

src/ir/repr.cc → src/ir/access_path_repr.cc

@@ -18,30 +18,27 @@
  */
 
 /*!
- * \file ir/repr.cc
- * \brief Implements Dump helpers and FFI registration for ffi-repr-based printing.
+ * \file ir/access_path_repr.cc
+ * \brief FFI registration for ffi-repr-based printing.
  *
- * The legacy ReprPrinter has been replaced by ffi::ReprPrint.  This file:
- *  - Implements the Dump() debug helpers (they call ffi::ReprPrint).
+ * This file:
  *  - Registers node.AsRepr (for backward Python compatibility) via ffi::ReprPrint.
- *  - Registers __ffi_repr__ hooks for ffi::reflection::AccessPath and AccessStep.
+ *  - Registers __ffi_repr__ hooks for ffi::reflection::AccessPath and AccessStep
+ *    so that ffi.ReprPrint formats them as concise "<root>.field[idx]" strings.
+ *
+ * Note: tvm::Dump() has been removed (zero in-tree callers). Use
+ * tvm::ffi::ReprPrint(any) directly from gdb instead.
  */
 #include <tvm/ffi/cast.h>
 #include <tvm/ffi/extra/dataclass.h>
 #include <tvm/ffi/function.h>
 #include <tvm/ffi/reflection/access_path.h>
 #include <tvm/ffi/reflection/registry.h>
-#include <tvm/ir/repr.h>
-#include <tvm/runtime/device_api.h>
 
 #include <sstream>
 
 namespace tvm {
 
-void Dump(const ffi::ObjectRef& n) { std::cerr << ffi::ReprPrint(ffi::Any(n)) << "\n"; }
-
-void Dump(const ffi::Object* n) { Dump(ffi::GetRef<ffi::ObjectRef>(n)); }
-
 TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   // node.AsRepr: backward-compatible Python entry point.

src/ir/instrument.cc

@@ -21,10 +21,10 @@
  * \file src/ir/instrument.cc
  * \brief Infrastructure for instrumentation.
  */
+#include <tvm/ffi/extra/dataclass.h>
 #include <tvm/ffi/function.h>
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/ir/instrument.h>
-#include <tvm/ir/repr.h>
 #include <tvm/ir/transform.h>
 #include <tvm/runtime/logging.h>
 

src/ir/transform.cc

@@ -21,11 +21,11 @@
  * \file src/ir/transform.cc
  * \brief Infrastructure for transformation passes.
  */
+#include <tvm/ffi/extra/dataclass.h>
 #include <tvm/ffi/extra/structural_hash.h>
 #include <tvm/ffi/function.h>
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/ffi/rvalue_ref.h>
-#include <tvm/ir/repr.h>
 #include <tvm/ir/transform.h>
 #include <tvm/relax/expr.h>
 #include <tvm/runtime/device_api.h>

src/relax/ir/dataflow_pattern.cc

@@ -24,7 +24,6 @@
 
 #include <tvm/ffi/extra/dataclass.h>
 #include <tvm/ffi/reflection/registry.h>
-#include <tvm/ir/repr.h>
 #include <tvm/relax/dataflow_pattern.h>
 #include <tvm/relax/dataflow_pattern_functor.h>
 

src/relax/ir/transform.cc

@@ -22,10 +22,10 @@
  * \brief Relax specific transformation passes.
  */
 #include <tvm/ffi/cast.h>
+#include <tvm/ffi/extra/dataclass.h>
 #include <tvm/ffi/function.h>
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/ffi/rvalue_ref.h>
-#include <tvm/ir/repr.h>
 #include <tvm/relax/analysis.h>
 #include <tvm/relax/expr_functor.h>
 #include <tvm/relax/struct_info_functor.h>

src/script/printer/script_printer.cc

@@ -21,7 +21,6 @@
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/ir/cast.h>
 #include <tvm/ir/expr.h>
-#include <tvm/ir/repr.h>
 #include <tvm/script/printer/config.h>
 
 #include <algorithm>

src/tirx/ir/transform.cc

@@ -21,10 +21,10 @@
  * \file tirx/ir/transform.cc
  * \brief TIR specific transformation passes.
  */
+#include <tvm/ffi/extra/dataclass.h>
 #include <tvm/ffi/function.h>
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/ffi/rvalue_ref.h>
-#include <tvm/ir/repr.h>
 #include <tvm/tirx/transform.h>
 
 namespace tvm {