You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tvm.apache.org by tq...@apache.org on 2026/10/24 11:46:24 UTC

(tvm-tirx) branch main updated: [REFACTOR] Bump TVM FFI and use singular detail namespaces (#39)

This is an automated email from the ASF dual-hosted git repository.

tqchen pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tvm-tirx.git


The following commit(s) were added to refs/heads/main by this push:
     new 4eda5fe04 [REFACTOR] Bump TVM FFI and use singular detail namespaces (#39)
4eda5fe04 is described below

commit 4eda5fe04ba57e4d49ec93af85cb5f5e6b8bcae2
Author: Tianqi Chen <tq...@users.noreply.github.com>
AuthorDate: Sat Oct 24 07:46:18 2026 -0400

    [REFACTOR] Bump TVM FFI and use singular detail namespaces (#39)
    
    Follow the common singular `detail` convention for internal C++
    namespaces and helper names. Bump TVM FFI to
    `830f2ebac90928f1375c882601599aa4e4fd3116` and migrate TIRx namespace
    reopenings, qualified references, and the renamed `base_detail.h`
    include to remain compatible with the dependency.
---
 3rdparty/tvm-ffi                            |  2 +-
 include/tvm/ir/expr.h                       | 24 +++++------
 include/tvm/ir/expr_functor.h               |  8 ++--
 include/tvm/ir/object_functor.h             | 22 +++++-----
 include/tvm/ir/op.h                         | 26 ++++++------
 include/tvm/ir/prim/const_fold.h            | 42 +++++++++---------
 include/tvm/ir/prim/pattern_match.h         | 16 +++----
 include/tvm/ir/transform.h                  |  4 +-
 include/tvm/script/ir_builder/base.h        |  6 +--
 include/tvm/script/printer/doc_translator.h | 14 +++---
 include/tvm/target/config_schema.h          |  2 +-
 include/tvm/tirx/expr.h                     |  8 ++--
 include/tvm/tirx/stmt_functor.h             |  4 +-
 src/backend/vulkan/codegen/ir_builder.h     |  2 +-
 src/ir/expr.cc                              | 66 ++++++++++++++---------------
 src/ir/prim/expr.cc                         | 38 ++++++++---------
 src/ir/prim/int_operator.h                  |  4 +-
 src/ir/prim/math.cc                         |  2 +-
 src/ir/prim/op.cc                           | 26 ++++++------
 src/ir/prim/op_utils.h                      |  4 +-
 src/ir/prim/vector_expr.cc                  | 18 ++++----
 src/ir/seq_stmt_mutate.h                    |  2 +-
 src/ir/stmt.cc                              | 60 +++++++++++++-------------
 src/ir/type.cc                              | 18 ++++----
 src/runtime/thread_pool.cc                  |  2 +-
 src/script/ir_builder/base.cc               |  6 +--
 src/script/ir_builder/ir.cc                 |  4 +-
 src/script/printer/doc_printer.cc           |  6 +--
 src/script/printer/doc_printer.h            |  4 +-
 src/script/printer/ir/call.cc               |  8 ++--
 src/script/printer/ir/ir.cc                 | 14 +++---
 src/script/printer/ir/misc.cc               |  8 ++--
 src/script/printer/ir/prim_expr.cc          | 44 +++++++++----------
 src/script/printer/ir/prim_type.cc          | 14 +++---
 src/script/printer/ir/stmt.cc               | 18 ++++----
 src/script/printer/ir/utils.cc              |  8 ++--
 src/script/printer/ir/utils.h               |  4 +-
 src/script/printer/printer.cc               |  4 +-
 src/sym/canonical_simplify.cc               |  6 +--
 src/sym/const_fold.h                        |  4 +-
 src/sym/int_operator.h                      |  8 ++--
 src/sym/iter_affine_map.cc                  | 12 +++---
 src/target/target.cc                        |  2 +-
 src/tirx/ir/function.cc                     |  6 +--
 src/tirx/ir/layout/axis_registry.cc         |  2 +-
 src/tirx/ir/layout/compose_layout.cc        | 34 +++++++--------
 src/tirx/ir/layout/layout.cc                | 18 ++++----
 src/tirx/ir/layout/tile_canonicalize.cc     |  2 +-
 src/tirx/ir/layout/tile_core.cc             | 32 +++++++-------
 src/tirx/ir/layout/tile_internal.h          |  4 +-
 src/tirx/ir/layout/tile_tile_ops.cc         |  5 +--
 src/tirx/ir/type.cc                         |  6 +--
 src/tirx/op/math.cc                         |  2 +-
 src/tirx/script/ir_builder/ir.cc            |  4 +-
 src/tirx/script/printer/block.cc            |  6 +--
 src/tirx/script/printer/expr.cc             | 12 +++---
 src/tirx/script/printer/for_loop.cc         |  7 ++-
 src/tirx/script/printer/function.cc         |  6 +--
 src/tirx/script/printer/ir.cc               |  6 +--
 src/tirx/script/printer/stmt.cc             | 10 ++---
 src/tirx/script/printer/tensor.cc           | 14 +++---
 tests/cpp/runtime/backend_workspace_test.cc |  4 +-
 62 files changed, 381 insertions(+), 393 deletions(-)

diff --git a/3rdparty/tvm-ffi b/3rdparty/tvm-ffi
index 8fd93039f..830f2ebac 160000
--- a/3rdparty/tvm-ffi
+++ b/3rdparty/tvm-ffi
@@ -1 +1 @@
-Subproject commit 8fd93039ff332d6262d1f6a47f626b6f91a84080
+Subproject commit 830f2ebac90928f1375c882601599aa4e4fd3116
diff --git a/include/tvm/ir/expr.h b/include/tvm/ir/expr.h
index fd6be0e5b..8474b5893 100644
--- a/include/tvm/ir/expr.h
+++ b/include/tvm/ir/expr.h
@@ -217,13 +217,13 @@ class IntExpr : public PrimExpr {
   static constexpr bool _type_container_is_exact = false;
 };
 
-namespace ffi::details {
+namespace ffi::detail {
 // Array members require storage availability before the expression traits below are complete.
 template <>
 inline constexpr bool storage_enabled_v<Expr> = true;
 template <>
 inline constexpr bool storage_enabled_v<PrimExpr> = true;
-}  // namespace ffi::details
+}  // namespace ffi::detail
 
 /*! \brief Base node for literal constants. */
 class ConstantObj : public ExprObj {
@@ -1029,19 +1029,19 @@ struct TypeTraits<TypedExpr<ExpectedType>>
     : public ObjectRefTypeTraitsBase<TypedExpr<ExpectedType>> {
   TVM_FFI_INLINE static bool CheckAnyStrict(const TVMFFIAny* src) {
     if (src->type_index < TypeIndex::kTVMFFIStaticObjectBegin ||
-        !details::IsObjectInstance<ExprObj>(src->type_index)) {
+        !detail::IsObjectInstance<ExprObj>(src->type_index)) {
       return false;
     }
     // Non-owning: this only reads `ty`, and the owning form's incref/decref pair costs two
     // atomics per check on a path every typed field assignment takes.
-    const auto* expr = details::ObjectUnsafe::RawObjectPtrFromUnowned<ExprObj>(src->v_obj);
-    return details::AnyUnsafe::CheckAnyViewStrict<ExpectedType>(expr->ty);
+    const auto* expr = detail::ObjectUnsafe::RawObjectPtrFromUnowned<ExprObj>(src->v_obj);
+    return detail::AnyUnsafe::CheckAnyViewStrict<ExpectedType>(expr->ty);
   }
 
   TVM_FFI_INLINE static std::string GetMismatchTypeInfo(const TVMFFIAny* src) {
     if (src->type_index >= TypeIndex::kTVMFFIStaticObjectBegin && src->v_obj != nullptr &&
-        details::IsObjectInstance<ExprObj>(src->type_index)) {
-      const auto* expr = details::ObjectUnsafe::RawObjectPtrFromUnowned<ExprObj>(src->v_obj);
+        detail::IsObjectInstance<ExprObj>(src->type_index)) {
+      const auto* expr = detail::ObjectUnsafe::RawObjectPtrFromUnowned<ExprObj>(src->v_obj);
       if (expr->ty.defined()) {
         const auto* prim_ty = expr->ty.as<PrimTypeObj>();
         std::string ty =
@@ -1112,7 +1112,7 @@ struct TypeTraits<IntExpr> : public ObjectRefWithFallbackTraitsBase<IntExpr, int
 
   TVM_FFI_INLINE static bool CheckAnyStrict(const TVMFFIAny* src) {
     if (!Base::CheckAnyStrict(src)) return false;
-    const auto* expr = details::ObjectUnsafe::RawObjectPtrFromUnowned<ExprObj>(src->v_obj);
+    const auto* expr = detail::ObjectUnsafe::RawObjectPtrFromUnowned<ExprObj>(src->v_obj);
     const auto* ty = expr->ty.as<PrimTypeObj>();
     return ty != nullptr && ty->dtype.lanes == 1 &&
            (ty->dtype.code == kDLInt || ty->dtype.code == kDLUInt);
@@ -1148,14 +1148,14 @@ struct TypeTraits<PrimVar> : public ObjectRefTypeTraitsBase<PrimVar> {
       return false;
     }
     const auto* var = static_cast<const VarObj*>(
-        details::ObjectUnsafe::ObjectPtrFromUnowned<Object>(src->v_obj).get());
-    return details::AnyUnsafe::CheckAnyStrict<PrimType>(var->ExprObj::ty);
+        detail::ObjectUnsafe::ObjectPtrFromUnowned<Object>(src->v_obj).get());
+    return detail::AnyUnsafe::CheckAnyStrict<PrimType>(var->ExprObj::ty);
   }
 
   TVM_FFI_INLINE static std::optional<PrimVar> TryCastFromAnyView(const TVMFFIAny* src) {
     if (CheckAnyStrict(src)) {
-      return details::ObjectUnsafe::ObjectRefFromObjectPtr<PrimVar>(
-          details::ObjectUnsafe::ObjectPtrFromUnowned<VarObj>(src->v_obj));
+      return detail::ObjectUnsafe::ObjectRefFromObjectPtr<PrimVar>(
+          detail::ObjectUnsafe::ObjectPtrFromUnowned<VarObj>(src->v_obj));
     }
     return std::nullopt;
   }
diff --git a/include/tvm/ir/expr_functor.h b/include/tvm/ir/expr_functor.h
index aa2cde57d..786b25742 100644
--- a/include/tvm/ir/expr_functor.h
+++ b/include/tvm/ir/expr_functor.h
@@ -445,8 +445,8 @@ class TVM_TIRX_DLL ExprMutator : public ObjectMutator {
    */
   TVM_FFI_INLINE UnchangedOr<PrimExpr> Mutate(const PrimExpr& expr,
                                               InplaceMode inplace_mode = InplaceMode::kDisallow) {
-    return ffi::details::UnchangedOrUnsafe::MoveFromTVMFFIAny<PrimExpr>(
-        ffi::details::UnchangedOrUnsafe::MoveToTVMFFIAny(Mutate(ffi::AnyView(expr), inplace_mode)));
+    return ffi::detail::UnchangedOrUnsafe::MoveFromTVMFFIAny<PrimExpr>(
+        ffi::detail::UnchangedOrUnsafe::MoveToTVMFFIAny(Mutate(ffi::AnyView(expr), inplace_mode)));
   }
 
   /*!
@@ -459,8 +459,8 @@ class TVM_TIRX_DLL ExprMutator : public ObjectMutator {
    */
   TVM_FFI_INLINE UnchangedOr<Expr> Mutate(const Expr& expr,
                                           InplaceMode inplace_mode = InplaceMode::kDisallow) {
-    return ffi::details::UnchangedOrUnsafe::MoveFromTVMFFIAny<Expr>(
-        ffi::details::UnchangedOrUnsafe::MoveToTVMFFIAny(Mutate(ffi::AnyView(expr), inplace_mode)));
+    return ffi::detail::UnchangedOrUnsafe::MoveFromTVMFFIAny<Expr>(
+        ffi::detail::UnchangedOrUnsafe::MoveToTVMFFIAny(Mutate(ffi::AnyView(expr), inplace_mode)));
   }
 
   // A downstream class overrides any existing hook without rebuilding the table.
diff --git a/include/tvm/ir/object_functor.h b/include/tvm/ir/object_functor.h
index f356a1240..982d691fb 100644
--- a/include/tvm/ir/object_functor.h
+++ b/include/tvm/ir/object_functor.h
@@ -242,11 +242,11 @@ class TVM_TIRX_DLL ObjectVisitor : public ffi::StructuralVisitorObj {
   virtual ffi::Optional<VisitInterrupt> Visit(ffi::AnyView value) {
     if (native_vtable_->CanDispatch(value)) {
       const auto* object =
-          ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ffi::Object>(value);
+          ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ffi::Object>(value);
       try {
         return (*native_vtable_)(object, this);
       } catch (ffi::Error& error) {
-        ffi::details::UpdateVisitErrorContext(error, ffi::GetRef<ffi::ObjectRef>(object));
+        ffi::detail::UpdateVisitErrorContext(error, ffi::GetRef<ffi::ObjectRef>(object));
         throw;
       }
     }
@@ -310,7 +310,7 @@ class TVM_TIRX_DLL ObjectVisitor : public ffi::StructuralVisitorObj {
       // DefaultVisitExpected does not name the current node; DefaultMutateExpected does.
       return ffi::StructuralVisitorObj::DefaultVisitExpected(value).value();
     } catch (ffi::Error& error) {
-      ffi::details::UpdateVisitErrorContext(error, value);
+      ffi::detail::UpdateVisitErrorContext(error, value);
       throw;
     }
   }
@@ -329,7 +329,7 @@ class TVM_TIRX_DLL ObjectVisitor : public ffi::StructuralVisitorObj {
   }
   static TVMFFIAny StructuralVTableVisitImpl(ffi::StructuralVisitorObj* self,
                                              ffi::AnyView value) noexcept {
-    return ffi::details::ExpectedUnsafe::MoveToTVMFFIAny(
+    return ffi::detail::ExpectedUnsafe::MoveToTVMFFIAny(
         static_cast<ObjectVisitor*>(self)->VisitExpected(value));
   }
 
@@ -386,7 +386,7 @@ class TVM_TIRX_DLL ObjectMutator : public ffi::StructuralMapEngineBase {
       try {
         return (*native_vtable_)(object, this, inplace_mode);
       } catch (ffi::Error& error) {
-        ffi::details::UpdateVisitErrorContext(error, ffi::GetRef<ffi::ObjectRef>(object));
+        ffi::detail::UpdateVisitErrorContext(error, ffi::GetRef<ffi::ObjectRef>(object));
         throw;
       }
     }
@@ -473,8 +473,8 @@ class TVM_TIRX_DLL ObjectMutator : public ffi::StructuralMapEngineBase {
   template <typename Self, typename Node>
   static UnchangedOr<ffi::Any> DispatchNode(const ffi::Object* node, ObjectMutator* self,
                                             InplaceMode inplace_mode) {
-    return ffi::details::UnchangedOrUnsafe::MoveFromTVMFFIAny<ffi::Any>(
-        ffi::details::UnchangedOrUnsafe::MoveToTVMFFIAny(
+    return ffi::detail::UnchangedOrUnsafe::MoveFromTVMFFIAny<ffi::Any>(
+        ffi::detail::UnchangedOrUnsafe::MoveToTVMFFIAny(
             static_cast<Self*>(self)->Mutate_(static_cast<const Node*>(node), inplace_mode)));
   }
 
@@ -497,22 +497,22 @@ class TVM_TIRX_DLL ObjectMutator : public ffi::StructuralMapEngineBase {
   }
   static TVMFFIAny StructuralVTableMutateImpl(ffi::StructuralMutatorObj* self,
                                               ffi::AnyView value) noexcept {
-    return ffi::details::ExpectedUnsafe::MoveToTVMFFIAny(
+    return ffi::detail::ExpectedUnsafe::MoveToTVMFFIAny(
         static_cast<ObjectMutator*>(self)->MutateExpected(value, InplaceMode::kDisallow));
   }
   static TVMFFIAny StructuralVTableMaybeInplaceMutateImpl(ffi::StructuralMutatorObj* self,
                                                           ffi::AnyView value) noexcept {
-    return ffi::details::ExpectedUnsafe::MoveToTVMFFIAny(
+    return ffi::detail::ExpectedUnsafe::MoveToTVMFFIAny(
         static_cast<ObjectMutator*>(self)->MutateExpected(value, InplaceMode::kAllow));
   }
   static TVMFFIAny StructuralVTableVarRemapGetImpl(ffi::StructuralMutatorObj* self,
                                                    ffi::AnyView key) noexcept {
-    return ffi::details::ExpectedUnsafe::MoveToTVMFFIAny(
+    return ffi::detail::ExpectedUnsafe::MoveToTVMFFIAny(
         static_cast<ObjectMutator*>(self)->VarRemapGetImpl(key));
   }
   static TVMFFIAny StructuralVTableVarRemapSetImpl(ffi::StructuralMutatorObj* self,
                                                    ffi::AnyView key, ffi::AnyView value) noexcept {
-    return ffi::details::ExpectedUnsafe::MoveToTVMFFIAny(
+    return ffi::detail::ExpectedUnsafe::MoveToTVMFFIAny(
         static_cast<ObjectMutator*>(self)->VarRemapSetImpl(key, value));
   }
 
diff --git a/include/tvm/ir/op.h b/include/tvm/ir/op.h
index c34d0dd61..edf5992a7 100644
--- a/include/tvm/ir/op.h
+++ b/include/tvm/ir/op.h
@@ -187,9 +187,7 @@ class Op : public Expr {
       }
       using View = ffi::reflection::NativeFunctionView<void(const CallObj*)>;
       // set_validator stores only an owning NativeFunction with this signature.
-      ffi::details::AnyUnsafe::CopyFromAnyViewAfterCheck<View>(validator)
-          .CallExpected(call)
-          .value();
+      ffi::detail::AnyUnsafe::CopyFromAnyViewAfterCheck<View>(validator).CallExpected(call).value();
     }
   }
   TVM_FFI_DEFINE_OBJECT_REF_METHODS_NOTNULLABLE(Op, Expr, OpObj);
@@ -243,7 +241,7 @@ struct ValidateState {
   size_t ty_args_index = 0;
 };
 
-namespace details {
+namespace detail {
 
 template <typename T>
 inline bool ReportTypeMismatch(ffi::Expected<void>* out, const ValidateState* state, bool type_arg,
@@ -265,7 +263,7 @@ inline bool ReportTypeMismatch(ffi::Expected<void>* out, const ValidateState* st
   return false;
 }
 
-}  // namespace details
+}  // namespace detail
 
 /*! \brief One value argument of type T, for example `sig::arg<PrimExpr>("index")`
  * for a required primitive index expression. */
@@ -293,8 +291,8 @@ struct arg : SignatureTrait {
     if constexpr (!std::is_same_v<T, Expr>) {
       ffi::AnyView value(state->call->args.GetArrayObj()->begin()[state->args_index]);
       if (TVM_FFI_PREDICT_FALSE(value == nullptr ||
-                                !ffi::details::AnyUnsafe::CheckAnyViewStrict<T>(value))) {
-        return details::ReportTypeMismatch<T>(out, state, false, state->args_index, value);
+                                !ffi::detail::AnyUnsafe::CheckAnyViewStrict<T>(value))) {
+        return detail::ReportTypeMismatch<T>(out, state, false, state->args_index, value);
       }
     }
     ++state->args_index;
@@ -330,8 +328,8 @@ struct var_args : SignatureTrait {
       for (; state->args_index != state->call->args.size(); ++state->args_index) {
         ffi::AnyView value(values[state->args_index]);
         if (TVM_FFI_PREDICT_FALSE(value == nullptr ||
-                                  !ffi::details::AnyUnsafe::CheckAnyViewStrict<T>(value))) {
-          return details::ReportTypeMismatch<T>(out, state, false, state->args_index, value);
+                                  !ffi::detail::AnyUnsafe::CheckAnyViewStrict<T>(value))) {
+          return detail::ReportTypeMismatch<T>(out, state, false, state->args_index, value);
         }
       }
     } else {
@@ -367,8 +365,8 @@ struct ty_arg : SignatureTrait {
     if constexpr (!std::is_same_v<T, Type>) {
       ffi::AnyView value(state->call->ty_args.GetArrayObj()->begin()[state->ty_args_index]);
       if (TVM_FFI_PREDICT_FALSE(value == nullptr ||
-                                !ffi::details::AnyUnsafe::CheckAnyViewStrict<T>(value))) {
-        return details::ReportTypeMismatch<T>(out, state, true, state->ty_args_index, value);
+                                !ffi::detail::AnyUnsafe::CheckAnyViewStrict<T>(value))) {
+        return detail::ReportTypeMismatch<T>(out, state, true, state->ty_args_index, value);
       }
     }
     ++state->ty_args_index;
@@ -404,8 +402,8 @@ struct var_ty_args : SignatureTrait {
       for (; state->ty_args_index != state->call->ty_args.size(); ++state->ty_args_index) {
         ffi::AnyView value(values[state->ty_args_index]);
         if (TVM_FFI_PREDICT_FALSE(value == nullptr ||
-                                  !ffi::details::AnyUnsafe::CheckAnyViewStrict<T>(value))) {
-          return details::ReportTypeMismatch<T>(out, state, true, state->ty_args_index, value);
+                                  !ffi::detail::AnyUnsafe::CheckAnyViewStrict<T>(value))) {
+          return detail::ReportTypeMismatch<T>(out, state, true, state->ty_args_index, value);
         }
       }
     } else {
@@ -438,7 +436,7 @@ struct call_attrs : SignatureTrait {
   static bool Validate(ValidateState* state, ffi::Expected<void>* out) {
     ffi::AnyView attrs(state->call->attrs);
     if (TVM_FFI_PREDICT_FALSE(!state->call->attrs.has_value() ||
-                              !ffi::details::AnyUnsafe::CheckAnyViewStrict<const T*>(attrs))) {
+                              !ffi::detail::AnyUnsafe::CheckAnyViewStrict<const T*>(attrs))) {
       TVMFFIAny raw = attrs.CopyToTVMFFIAny();
       std::string actual = state->call->attrs.has_value()
                                ? "`" + ffi::TypeTraits<const T*>::GetMismatchTypeInfo(&raw) + "`"
diff --git a/include/tvm/ir/prim/const_fold.h b/include/tvm/ir/prim/const_fold.h
index 6be3adb21..030652cc1 100644
--- a/include/tvm/ir/prim/const_fold.h
+++ b/include/tvm/ir/prim/const_fold.h
@@ -60,7 +60,7 @@ inline ffi::Optional<PrimExpr> TryConstFold(PrimExpr a, PrimExpr b);
 template <typename Op>
 inline ffi::Optional<PrimExpr> TryConstFold(PrimExpr a);
 
-namespace details {
+namespace detail {
 
 /*!
  * \brief Check whether type is used to represent index.
@@ -121,7 +121,7 @@ inline bool IsInFloat32Range(double value) {
                                    value <= std::numeric_limits<float>::max());
 }
 
-}  // namespace details
+}  // namespace detail
 
 #define TVM_PRIM_CONST_PROPAGATION(BODY)       \
   using tvm::FloatImmObj;                      \
@@ -131,11 +131,11 @@ inline bool IsInFloat32Range(double value) {
   const FloatImmObj* fb = b.as<FloatImmObj>(); \
   BODY;
 
-#define TVM_PRIM_INDEX_CONST_PROPAGATION(BODY)                                                  \
-  const IntImmObj* pa = a.as<IntImmObj>();                                                      \
-  const IntImmObj* pb = b.as<IntImmObj>();                                                      \
-  if (::tvm::prim::details::IsIndexTypedExpr(a) && ::tvm::prim::details::IsIndexTypedExpr(b)) { \
-    BODY;                                                                                       \
+#define TVM_PRIM_INDEX_CONST_PROPAGATION(BODY)                                                \
+  const IntImmObj* pa = a.as<IntImmObj>();                                                    \
+  const IntImmObj* pb = b.as<IntImmObj>();                                                    \
+  if (::tvm::prim::detail::IsIndexTypedExpr(a) && ::tvm::prim::detail::IsIndexTypedExpr(b)) { \
+    BODY;                                                                                     \
   }
 
 // specialization of constant folders.
@@ -145,7 +145,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Add>(PrimExpr a, PrimExpr b) {
     PrimType result_ty = a.ty();
     if (pa && pb) {
       ffi::BigInt res = pa->value + pb->value;
-      if (!details::IsRepresentable(res, result_ty)) return std::nullopt;
+      if (!detail::IsRepresentable(res, result_ty)) return std::nullopt;
       return IntImm(result_ty, std::move(res));
     }
     if (pa && pa->value == 0) return b;
@@ -155,7 +155,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Add>(PrimExpr a, PrimExpr b) {
         float lhs = static_cast<float>(fa->value);
         float rhs = static_cast<float>(fb->value);
         // Check before rounding can turn a finite overflow into infinity.
-        if (!details::IsInFloat32Range(static_cast<double>(lhs) + rhs)) return std::nullopt;
+        if (!detail::IsInFloat32Range(static_cast<double>(lhs) + rhs)) return std::nullopt;
         return FloatImm(result_ty, static_cast<float>(lhs + rhs));
       } else if (result_ty.bits() == 64) {
         return FloatImm(result_ty, fa->value + fb->value);
@@ -173,7 +173,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Sub>(PrimExpr a, PrimExpr b) {
     PrimType result_ty = a.ty();
     if (pa && pb) {
       ffi::BigInt res = pa->value - pb->value;
-      if (!details::IsRepresentable(res, result_ty)) return std::nullopt;
+      if (!detail::IsRepresentable(res, result_ty)) return std::nullopt;
       return IntImm(result_ty, std::move(res));
     }
     if (pb && pb->value == 0) return a;
@@ -182,7 +182,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Sub>(PrimExpr a, PrimExpr b) {
         float lhs = static_cast<float>(fa->value);
         float rhs = static_cast<float>(fb->value);
         // Check before rounding can turn a finite overflow into infinity.
-        if (!details::IsInFloat32Range(static_cast<double>(lhs) - rhs)) return std::nullopt;
+        if (!detail::IsInFloat32Range(static_cast<double>(lhs) - rhs)) return std::nullopt;
         return FloatImm(result_ty, static_cast<float>(lhs - rhs));
       } else if (result_ty.bits() == 64) {
         return FloatImm(result_ty, fa->value - fb->value);
@@ -199,7 +199,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Mul>(PrimExpr a, PrimExpr b) {
     PrimType result_ty = a.ty();
     if (pa && pb) {
       ffi::BigInt res = pa->value * pb->value;
-      if (!details::IsRepresentable(res, result_ty)) return std::nullopt;
+      if (!detail::IsRepresentable(res, result_ty)) return std::nullopt;
       return IntImm(result_ty, std::move(res));
     }
     if (pa) {
@@ -215,7 +215,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Mul>(PrimExpr a, PrimExpr b) {
         float lhs = static_cast<float>(fa->value);
         float rhs = static_cast<float>(fb->value);
         // Check before rounding can turn a finite overflow into infinity.
-        if (!details::IsInFloat32Range(static_cast<double>(lhs) * rhs)) return std::nullopt;
+        if (!detail::IsInFloat32Range(static_cast<double>(lhs) * rhs)) return std::nullopt;
         return FloatImm(result_ty, static_cast<float>(lhs * rhs));
       } else if (result_ty.bits() == 64) {
         return FloatImm(result_ty, fa->value * fb->value);
@@ -242,7 +242,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Div>(PrimExpr a, PrimExpr b) {
       // NOTE: this will assumes truc div.
       TVM_FFI_ICHECK_NE(pb->value, 0) << "Divide by zero";
       ffi::BigInt res = pa->value / pb->value;
-      if (!details::IsRepresentable(res, result_ty)) return std::nullopt;
+      if (!detail::IsRepresentable(res, result_ty)) return std::nullopt;
       return IntImm(result_ty, std::move(res));
     }
     if (pa) {
@@ -258,7 +258,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Div>(PrimExpr a, PrimExpr b) {
         float lhs = static_cast<float>(fa->value);
         float rhs = static_cast<float>(fb->value);
         // Check before rounding can turn a finite overflow into infinity.
-        if (!details::IsInFloat32Range(static_cast<double>(lhs) / rhs)) return std::nullopt;
+        if (!detail::IsInFloat32Range(static_cast<double>(lhs) / rhs)) return std::nullopt;
         return FloatImm(result_ty, static_cast<float>(lhs / rhs));
       } else if (result_ty.bits() == 64) {
         return FloatImm(result_ty, fa->value / fb->value);
@@ -280,7 +280,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Mod>(PrimExpr a, PrimExpr b) {
     if (pa && pb) {
       TVM_FFI_ICHECK_NE(pb->value, 0) << "Divide by zero";
       ffi::BigInt res = pa->value % pb->value;
-      if (!details::IsRepresentable(res, result_ty)) return std::nullopt;
+      if (!detail::IsRepresentable(res, result_ty)) return std::nullopt;
       return IntImm(result_ty, std::move(res));
     }
     if (pa) {
@@ -295,7 +295,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::Mod>(PrimExpr a, PrimExpr b) {
   if (pa && pb && a.ty().bits() >= 64) {
     TVM_FFI_ICHECK_NE(pb->value, 0) << "Divide by zero";
     ffi::BigInt res = pa->value % pb->value;
-    if (!details::IsRepresentable(res, a.ty())) return std::nullopt;
+    if (!detail::IsRepresentable(res, a.ty())) return std::nullopt;
     return IntImm(a.ty(), std::move(res));
   }
   return std::nullopt;
@@ -308,7 +308,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::FloorDiv>(PrimExpr a, PrimExpr
     if (pa && pb) {
       TVM_FFI_ICHECK_NE(pb->value, 0) << "Divide by zero";
       ffi::BigInt res = ffi::floordiv(pa->value, pb->value);
-      if (!details::IsRepresentable(res, result_ty)) return std::nullopt;
+      if (!detail::IsRepresentable(res, result_ty)) return std::nullopt;
       return IntImm(result_ty, std::move(res));
     }
     if (pa) {
@@ -322,7 +322,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::FloorDiv>(PrimExpr a, PrimExpr
       if (result_ty.bits() == 32) {
         float lhs = static_cast<float>(fa->value);
         float rhs = static_cast<float>(fb->value);
-        if (!details::IsInFloat32Range(static_cast<double>(lhs) / rhs)) return std::nullopt;
+        if (!detail::IsInFloat32Range(static_cast<double>(lhs) / rhs)) return std::nullopt;
         float quotient = lhs / rhs;
         return FloatImm(result_ty, std::floor(quotient));
       } else if (result_ty.bits() == 64) {
@@ -347,7 +347,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::FloorMod>(PrimExpr a, PrimExpr
     if (pa && pb) {
       TVM_FFI_ICHECK_NE(pb->value, 0) << "Divide by zero";
       ffi::BigInt res = ffi::floormod(pa->value, pb->value);
-      if (!details::IsRepresentable(res, result_ty)) return std::nullopt;
+      if (!detail::IsRepresentable(res, result_ty)) return std::nullopt;
       return IntImm(result_ty, std::move(res));
     }
     if (pa) {
@@ -362,7 +362,7 @@ inline ffi::Optional<PrimExpr> TryConstFold<prim::FloorMod>(PrimExpr a, PrimExpr
   if (pa && pb && (a.ty().bits() >= 64 || a.ty().MatchesCode(DLDataTypeCode::kDLUInt))) {
     TVM_FFI_ICHECK_NE(pb->value, 0) << "Divide by zero";
     ffi::BigInt res = ffi::floormod(pa->value, pb->value);
-    if (!details::IsRepresentable(res, a.ty())) return std::nullopt;
+    if (!detail::IsRepresentable(res, a.ty())) return std::nullopt;
     return IntImm(a.ty(), std::move(res));
   }
   return std::nullopt;
diff --git a/include/tvm/ir/prim/pattern_match.h b/include/tvm/ir/prim/pattern_match.h
index 0ee7fdbcb..dafc0e6b8 100644
--- a/include/tvm/ir/prim/pattern_match.h
+++ b/include/tvm/ir/prim/pattern_match.h
@@ -550,7 +550,7 @@ inline PBroadcastExpr<TA, TLanes> broadcast(const Pattern<TA>& value,
 }
 
 // internal namespace
-namespace details {
+namespace detail {
 // implementation details for  CallExpr
 template <bool stop, std::size_t I, typename F>
 struct tuple_for_each_dispatcher {
@@ -599,7 +599,7 @@ struct PCallExprEvalArgsFunctor {
     args_.push_back(pattern.Eval());
   }
 };
-}  // namespace details
+}  // namespace detail
 
 /*!
  * \brief Pattern CallExpr expression.
@@ -614,16 +614,16 @@ class PCallExpr : public Pattern<PCallExpr<Op, TArgs...>> {
   explicit PCallExpr(const TArgs&... args) : args_(args...) {}
 
   void InitMatch_() const {
-    details::PCallExprInitMatchFunctor finit;
-    details::tuple_for_each(finit, args_);
+    detail::PCallExprInitMatchFunctor finit;
+    detail::tuple_for_each(finit, args_);
   }
 
   bool Match_(const ffi::ObjectRef& node) const {
     if (const CallObj* ptr = node.as<CallObj>()) {
       if (ptr->args.size() != sizeof...(TArgs)) return false;
       if (!ptr->op.same_as(Op::GetOp())) return false;
-      details::PCallExprMatchFunctor fmatch(ptr);
-      details::tuple_for_each(fmatch, args_);
+      detail::PCallExprMatchFunctor fmatch(ptr);
+      detail::tuple_for_each(fmatch, args_);
       return fmatch.matched_;
     } else {
       return false;
@@ -631,8 +631,8 @@ class PCallExpr : public Pattern<PCallExpr<Op, TArgs...>> {
   }
 
   PrimExpr Eval() const {
-    details::PCallExprEvalArgsFunctor feval_args;
-    details::tuple_for_each(feval_args, args_);
+    detail::PCallExprEvalArgsFunctor feval_args;
+    detail::tuple_for_each(feval_args, args_);
     return Op::Eval(feval_args.args_);
   }
 
diff --git a/include/tvm/ir/transform.h b/include/tvm/ir/transform.h
index 58500e321..8c1b7ce77 100644
--- a/include/tvm/ir/transform.h
+++ b/include/tvm/ir/transform.h
@@ -163,7 +163,7 @@ class PassContext : public ffi::ObjectRef {
           if (!opt_val.has_value()) {
             TVM_FFI_THROW(AttributeError)
                 << "Expect config " << key << " to have type " << type_key << ", but instead get "
-                << ffi::details::AnyUnsafe::GetMismatchTypeInfo<ValueType>(value);
+                << ffi::detail::AnyUnsafe::GetMismatchTypeInfo<ValueType>(value);
           }
           return *opt_val;
         }
@@ -177,7 +177,7 @@ class PassContext : public ffi::ObjectRef {
         if (!opt_val.has_value()) {
           TVM_FFI_THROW(AttributeError)
               << "Expect config " << key << " to have type " << type_str << ", but instead get "
-              << ffi::details::AnyUnsafe::GetMismatchTypeInfo<ValueType>(value);
+              << ffi::detail::AnyUnsafe::GetMismatchTypeInfo<ValueType>(value);
           TVM_FFI_UNREACHABLE();
         } else {
           return *opt_val;
diff --git a/include/tvm/script/ir_builder/base.h b/include/tvm/script/ir_builder/base.h
index 3836eda60..4af73c239 100644
--- a/include/tvm/script/ir_builder/base.h
+++ b/include/tvm/script/ir_builder/base.h
@@ -268,7 +268,7 @@ class IRBuilder : public ffi::ObjectRef {
 
 ////////////////////////////// Details //////////////////////////////
 
-namespace details {
+namespace detail {
 
 /*! \brief Language variant extensible access to an object's mutable source location. */
 class LocationAccessor {
@@ -284,11 +284,11 @@ class Namer {
   TVM_TIRX_DLL static void Name(ffi::ObjectRef node, ffi::String name);
 };
 
-}  // namespace details
+}  // namespace detail
 
 template <class TObjectRef>
 inline TObjectRef IRBuilder::Name(ffi::String name, TObjectRef obj) {
-  details::Namer::Name(obj, name);
+  detail::Namer::Name(obj, name);
   return obj.template as_or_throw<TObjectRef>();
 }
 
diff --git a/include/tvm/script/printer/doc_translator.h b/include/tvm/script/printer/doc_translator.h
index 99ab8509b..8d47efe84 100644
--- a/include/tvm/script/printer/doc_translator.h
+++ b/include/tvm/script/printer/doc_translator.h
@@ -133,7 +133,7 @@ class DocTranslatorObj : public ffi::Object {
    */
   ffi::Optional<ExprDoc> Translate(ffi::AnyView value,
                                    const ffi::Optional<Var> bind_var = std::nullopt) {
-    auto result = ffi::details::ExpectedUnsafe::MoveFromTVMFFIAny<ffi::Optional<ExprDoc>>(
+    auto result = ffi::detail::ExpectedUnsafe::MoveFromTVMFFIAny<ffi::Optional<ExprDoc>>(
                       vtable_->translate(this, value,
                                          bind_var.has_value() ? bind_var.value().get() : nullptr))
                       .value();
@@ -161,7 +161,7 @@ class DocTranslatorObj : public ffi::Object {
    * \return The binding's IdDoc, with explicit definitions removed from pending entries.
    */
   IdDoc VarGetOrAllocId(const Var& var, bool explicit_def) {
-    return ffi::details::ExpectedUnsafe::MoveFromTVMFFIAny<IdDoc>(
+    return ffi::detail::ExpectedUnsafe::MoveFromTVMFFIAny<IdDoc>(
                vtable_->var_get_or_alloc_id(this, var, explicit_def))
         .value();
   }
@@ -171,7 +171,7 @@ class DocTranslatorObj : public ffi::Object {
    * \return The allocated identifier.
    */
   IdDoc AllocId(const ffi::String& hint) {
-    return ffi::details::ExpectedUnsafe::MoveFromTVMFFIAny<IdDoc>(vtable_->alloc_id(this, hint))
+    return ffi::detail::ExpectedUnsafe::MoveFromTVMFFIAny<IdDoc>(vtable_->alloc_id(this, hint))
         .value();
   }
   /*!
@@ -179,7 +179,7 @@ class DocTranslatorObj : public ffi::Object {
    * \return The live mutable dictionary of variables and their identifiers.
    */
   ffi::Dict<Var, IdDoc> GetImplicitDefs() {
-    return ffi::details::ExpectedUnsafe::MoveFromTVMFFIAny<ffi::Dict<Var, IdDoc>>(
+    return ffi::detail::ExpectedUnsafe::MoveFromTVMFFIAny<ffi::Dict<Var, IdDoc>>(
                vtable_->get_implicit_defs(this))
         .value();
   }
@@ -227,7 +227,7 @@ class DocTranslatorObj : public ffi::Object {
    * \brief Begin a lexical variable scope independent of Doc collection.
    */
   void BeginVarScope() {
-    ffi::details::ExpectedUnsafe::MoveFromTVMFFIAny<void>(vtable_->begin_var_scope(this)).value();
+    ffi::detail::ExpectedUnsafe::MoveFromTVMFFIAny<void>(vtable_->begin_var_scope(this)).value();
   }
   /*!
    * \brief End the latest naming region, retaining the root region.
@@ -236,7 +236,7 @@ class DocTranslatorObj : public ffi::Object {
    * shared by sibling functions.
    */
   void EndVarScope() {
-    ffi::details::ExpectedUnsafe::MoveFromTVMFFIAny<void>(vtable_->end_var_scope(this)).value();
+    ffi::detail::ExpectedUnsafe::MoveFromTVMFFIAny<void>(vtable_->end_var_scope(this)).value();
   }
   /*!
    * \brief Run a callback in a balanced lexical variable scope without collecting Docs.
@@ -251,7 +251,7 @@ class DocTranslatorObj : public ffi::Object {
     struct Scope {
       DocTranslatorObj* translator;
       ~Scope() {
-        ffi::details::ExpectedUnsafe::MoveFromTVMFFIAny<void>(
+        ffi::detail::ExpectedUnsafe::MoveFromTVMFFIAny<void>(
             translator->vtable_->end_var_scope(translator));
       }
     };
diff --git a/include/tvm/target/config_schema.h b/include/tvm/target/config_schema.h
index 7d9d04ef4..44d7fbbb2 100644
--- a/include/tvm/target/config_schema.h
+++ b/include/tvm/target/config_schema.h
@@ -219,7 +219,7 @@ class ConfigSchema {
       e.default_value = ffi::AnyView::CopyFromTVMFFIAny(info.default_value_or_factory);
       // Release the extra ref created by CopyToTVMFFIAny in Apply
       if (info.default_value_or_factory.type_index >= TVMFFITypeIndex::kTVMFFIStaticObjectBegin) {
-        ffi::details::ObjectUnsafe::DecRefObjectHandle(info.default_value_or_factory.v_obj);
+        ffi::detail::ObjectUnsafe::DecRefObjectHandle(info.default_value_or_factory.v_obj);
       }
     }
     return e;
diff --git a/include/tvm/tirx/expr.h b/include/tvm/tirx/expr.h
index 09f35975c..1891960a0 100644
--- a/include/tvm/tirx/expr.h
+++ b/include/tvm/tirx/expr.h
@@ -120,14 +120,14 @@ struct TypeTraits<tirx::TensorVar> : public ObjectRefTypeTraitsBase<tirx::Tensor
       return false;
     }
     const auto* var = static_cast<const tvm::VarObj*>(
-        details::ObjectUnsafe::ObjectPtrFromUnowned<Object>(src->v_obj).get());
-    return details::AnyUnsafe::CheckAnyStrict<tirx::TensorType>(var->ExprObj::ty);
+        detail::ObjectUnsafe::ObjectPtrFromUnowned<Object>(src->v_obj).get());
+    return detail::AnyUnsafe::CheckAnyStrict<tirx::TensorType>(var->ExprObj::ty);
   }
 
   TVM_FFI_INLINE static std::optional<tirx::TensorVar> TryCastFromAnyView(const TVMFFIAny* src) {
     if (CheckAnyStrict(src)) {
-      return details::ObjectUnsafe::ObjectRefFromObjectPtr<tirx::TensorVar>(
-          details::ObjectUnsafe::ObjectPtrFromUnowned<tvm::VarObj>(src->v_obj));
+      return detail::ObjectUnsafe::ObjectRefFromObjectPtr<tirx::TensorVar>(
+          detail::ObjectUnsafe::ObjectPtrFromUnowned<tvm::VarObj>(src->v_obj));
     }
     return std::nullopt;
   }
diff --git a/include/tvm/tirx/stmt_functor.h b/include/tvm/tirx/stmt_functor.h
index 20cc528bc..fdf26f476 100644
--- a/include/tvm/tirx/stmt_functor.h
+++ b/include/tvm/tirx/stmt_functor.h
@@ -233,8 +233,8 @@ class TVM_TIRX_DLL StmtExprMutator : public tvm::ExprMutator {
    */
   TVM_FFI_INLINE UnchangedOr<Stmt> Mutate(const Stmt& stmt,
                                           InplaceMode inplace_mode = InplaceMode::kDisallow) {
-    return ffi::details::UnchangedOrUnsafe::MoveFromTVMFFIAny<Stmt>(
-        ffi::details::UnchangedOrUnsafe::MoveToTVMFFIAny(Mutate(ffi::AnyView(stmt), inplace_mode)));
+    return ffi::detail::UnchangedOrUnsafe::MoveFromTVMFFIAny<Stmt>(
+        ffi::detail::UnchangedOrUnsafe::MoveToTVMFFIAny(Mutate(ffi::AnyView(stmt), inplace_mode)));
   }
 
   /*! \brief Mutate a scope body without collapsing its sequence container. */
diff --git a/src/backend/vulkan/codegen/ir_builder.h b/src/backend/vulkan/codegen/ir_builder.h
index c530ef7a0..8d2d3952c 100644
--- a/src/backend/vulkan/codegen/ir_builder.h
+++ b/src/backend/vulkan/codegen/ir_builder.h
@@ -223,7 +223,7 @@ class InstrBuilder {
   InstrBuilder& AddSeq(Args&&... args) {
     AddSeqHelper helper;
     helper.builder = this;
-    ffi::details::for_each(helper, std::forward<Args>(args)...);
+    ffi::detail::for_each(helper, std::forward<Args>(args)...);
     return *this;
   }
   /*!
diff --git a/src/ir/expr.cc b/src/ir/expr.cc
index 35b96a95b..d20ec3a22 100644
--- a/src/ir/expr.cc
+++ b/src/ir/expr.cc
@@ -44,8 +44,7 @@ namespace {
 template <typename TNode>
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> ConstantVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
-  const TNode* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value);
+  const TNode* self = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ty));
   return std::nullopt;
 }
@@ -53,7 +52,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> ConstantVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> DataTypeImmVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const DataTypeImmObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DataTypeImmObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DataTypeImmObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ty));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->value));
   return std::nullopt;
@@ -62,7 +61,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> DataTypeImmVisi
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> DataTypeImmMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const DataTypeImmObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DataTypeImmObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DataTypeImmObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty,
                                     mutator->MutateExpected(self->ty));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<DLDataType>, mapped_value,
@@ -79,7 +78,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> DataTypeImmMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> DataTypeImmMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   DataTypeImmObj* self = const_cast<DataTypeImmObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DataTypeImmObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DataTypeImmObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty,
                                     mutator->MutateExpected(self->ty, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<DLDataType>, mapped_value,
@@ -92,8 +91,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> DataTypeImmMaybeInplace
 template <typename TNode>
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ConstantMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
-  const TNode* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value);
+  const TNode* self = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty,
                                     mutator->MutateExpected(self->ty));
   if (mapped_ty.UnchangedOrSameAs(self->ty)) return ffi::Unchanged();
@@ -106,7 +104,7 @@ template <typename TNode>
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ConstantMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   TNode* self = const_cast<TNode*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty,
                                     mutator->MutateExpected(self->ty, ffi::InplaceMode::kAllow));
   if (!mapped_ty.UnchangedOrSameAs(self->ty)) {
@@ -118,7 +116,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ConstantMaybeInplaceMut
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> OpaqueExprVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const OpaqueExprObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const OpaqueExprObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const OpaqueExprObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ty));
   // Any None is Expected<Optional<VisitInterrupt>>'s successful empty value.
   return std::nullopt;
@@ -127,7 +125,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> OpaqueExprVisit
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> OpaqueExprMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const OpaqueExprObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const OpaqueExprObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const OpaqueExprObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty));
   if (mapped_ty_u.UnchangedOrSameAs(self->ty)) {
@@ -141,7 +139,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> OpaqueExprMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> OpaqueExprMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   OpaqueExprObj* self = const_cast<OpaqueExprObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const OpaqueExprObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const OpaqueExprObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty, ffi::InplaceMode::kAllow));
   if (mapped_ty_u.UnchangedOrSameAs(self->ty)) {
@@ -154,7 +152,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> OpaqueExprMaybeInplaceM
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TensorLoadVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const TensorLoadObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorLoadObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorLoadObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ty));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->source));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->indices));
@@ -164,7 +162,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TensorLoadVisit
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorLoadMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const TensorLoadObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorLoadObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorLoadObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty));
   Type result_ty = std::move(mapped_ty_u).ValueOrUnchanged(self->ty);
@@ -189,7 +187,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorLoadMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorLoadMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   TensorLoadObj* self = const_cast<TensorLoadObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorLoadObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorLoadObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty, ffi::InplaceMode::kAllow));
   Type result_ty = std::move(mapped_ty_u).ValueOrUnchanged(self->ty);
@@ -215,7 +213,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorLoadMaybeInplaceM
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TensorRegionVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const TensorRegionObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorRegionObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorRegionObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ty));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->source));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->region));
@@ -225,7 +223,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TensorRegionVis
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorRegionMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const TensorRegionObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorRegionObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorRegionObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_source_u,
@@ -246,7 +244,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorRegionMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorRegionMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   TensorRegionObj* self = const_cast<TensorRegionObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorRegionObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorRegionObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
@@ -268,7 +266,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorRegionMaybeInplac
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TupleVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const TupleObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ty));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->fields));
   return std::nullopt;
@@ -277,7 +275,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TupleVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TupleMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const TupleObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Expr>>, mapped_fields_u,
@@ -294,7 +292,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TupleMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TupleMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   TupleObj* self = const_cast<TupleObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
@@ -312,7 +310,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TupleGetItemVis
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: index
   const TupleGetItemObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleGetItemObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleGetItemObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ty));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->tuple));
   return std::nullopt;
@@ -322,7 +320,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TupleGetItemMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: index
   const TupleGetItemObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleGetItemObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleGetItemObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_tuple_u,
@@ -340,7 +338,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TupleGetItemMaybeInplac
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: index
   TupleGetItemObj* self = const_cast<TupleGetItemObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleGetItemObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleGetItemObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ty_u,
                                     mutator->MutateExpected(self->ty, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_tuple_u,
@@ -392,7 +390,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> FloatImmMaybeInplaceMut
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> RangeVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const RangeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RangeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RangeObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->begin));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->extent));
   return std::nullopt;
@@ -401,7 +399,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> RangeVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> RangeMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const RangeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RangeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RangeObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_begin_u,
                                     mutator->MutateExpected(self->begin));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_extent_u,
@@ -419,7 +417,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> RangeMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> RangeMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   RangeObj* self = const_cast<RangeObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RangeObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RangeObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_begin_u,
                                     mutator->MutateExpected(self->begin, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
@@ -440,7 +438,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> VarVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: name
   const VarObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const VarObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const VarObj>(value);
   // A PrimType carries only a dtype, so it has nothing to visit.  Broad callbacks do not see this
   // skipped field; dynamically typed Vars still descend through the Type value.
   if (!self->ty.as<PrimTypeObj>()) {
@@ -460,10 +458,10 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> VarMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: name
   const VarObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const VarObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const VarObj>(value);
   ffi::Expected<ffi::Any> remap_result = mutator->VarRemapGetExpected(value);
   TVM_FFI_S_MUTATE_MAYBE_EARLY_RETURN(remap_result);
-  if (ffi::details::ExpectedUnsafe::GetData(remap_result).type_index() !=
+  if (ffi::detail::ExpectedUnsafe::GetData(remap_result).type_index() !=
       ffi::TypeIndex::kTVMFFINone) {
     return std::move(remap_result);
   }
@@ -503,10 +501,10 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> VarMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: name
   VarObj* self = const_cast<VarObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const VarObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const VarObj>(value));
   ffi::Expected<ffi::Any> remap_result = mutator->VarRemapGetExpected(value);
   TVM_FFI_S_MUTATE_MAYBE_EARLY_RETURN(remap_result);
-  if (ffi::details::ExpectedUnsafe::GetData(remap_result).type_index() !=
+  if (ffi::detail::ExpectedUnsafe::GetData(remap_result).type_index() !=
       ffi::TypeIndex::kTVMFFINone) {
     return std::move(remap_result);
   }
@@ -565,7 +563,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> CallVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: attrs, constant metadata left untouched like the classic Expr functors.
   const CallObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(value);
   // A PrimType carries only a dtype, so it has nothing to visit.  Broad callbacks do not see this
   // skipped field; dynamically typed Call results still descend through the Type value.
   if (!self->ty.as<PrimTypeObj>()) {
@@ -589,7 +587,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> CallMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: attrs, constant metadata left untouched like the classic Expr functors.
   const CallObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(value);
   // A PrimType carries only a dtype, so it has nothing to substitute.  Broad callbacks do not see
   // this skipped field; dynamically typed Call results still descend through the Type value.
   ffi::UnchangedOr<Type> mapped_ty_u = ffi::Unchanged();
@@ -633,7 +631,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> CallMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: attrs, constant metadata left untouched like the classic Expr functors.
   CallObj* self = const_cast<CallObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(value));
   // A PrimType carries only a dtype, so it has nothing to substitute.  Broad callbacks do not see
   // this skipped field; dynamically typed Call results still descend through the Type value.
   ffi::UnchangedOr<Type> mapped_ty_u = ffi::Unchanged();
diff --git a/src/ir/prim/expr.cc b/src/ir/prim/expr.cc
index a2e643e42..3cd5603ae 100644
--- a/src/ir/prim/expr.cc
+++ b/src/ir/prim/expr.cc
@@ -52,8 +52,7 @@ template <typename TNode>
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> BinaryVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
-  const TNode* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value);
+  const TNode* self = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->a));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->b));
   return std::nullopt;
@@ -63,8 +62,7 @@ template <typename TNode>
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BinaryMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
-  const TNode* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value);
+  const TNode* self = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, a_u,
                                     mutator->MutateExpected(self->a));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, b_u,
@@ -86,7 +84,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BinaryMaybeInplaceMutat
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   TNode* self = const_cast<TNode*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TNode>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, a_u,
                                     mutator->MutateExpected(self->a, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, b_u,
@@ -103,7 +101,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> CastVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const CastObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CastObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CastObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->value));
   return std::nullopt;
 }
@@ -112,7 +110,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> CastMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const CastObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CastObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CastObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_value_u,
                                     mutator->MutateExpected(self->value));
   if (mapped_value_u.UnchangedOrSameAs(self->value)) {
@@ -127,7 +125,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> CastMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   CastObj* self = const_cast<CastObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CastObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CastObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_value_u,
                                     mutator->MutateExpected(self->value, ffi::InplaceMode::kAllow));
   if (mapped_value_u.UnchangedOrSameAs(self->value)) {
@@ -141,7 +139,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> NotVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const NotObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const NotObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const NotObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->a));
   return std::nullopt;
 }
@@ -150,7 +148,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> NotMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const NotObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const NotObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const NotObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_a_u,
                                     mutator->MutateExpected(self->a));
   if (mapped_a_u.UnchangedOrSameAs(self->a)) {
@@ -165,7 +163,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> NotMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   NotObj* self = const_cast<NotObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const NotObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const NotObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_a_u,
                                     mutator->MutateExpected(self->a, ffi::InplaceMode::kAllow));
   if (mapped_a_u.UnchangedOrSameAs(self->a)) {
@@ -179,7 +177,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> BitwiseNotVisit
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const BitwiseNotObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BitwiseNotObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BitwiseNotObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->a));
   return std::nullopt;
 }
@@ -188,7 +186,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BitwiseNotMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const BitwiseNotObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BitwiseNotObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BitwiseNotObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_a_u,
                                     mutator->MutateExpected(self->a));
   if (mapped_a_u.UnchangedOrSameAs(self->a)) {
@@ -203,7 +201,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BitwiseNotMaybeInplaceM
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   BitwiseNotObj* self = const_cast<BitwiseNotObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BitwiseNotObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BitwiseNotObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_a_u,
                                     mutator->MutateExpected(self->a, ffi::InplaceMode::kAllow));
   if (mapped_a_u.UnchangedOrSameAs(self->a)) {
@@ -217,7 +215,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> SelectVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const SelectObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SelectObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SelectObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->condition));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->true_value));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->false_value));
@@ -228,7 +226,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> SelectMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const SelectObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SelectObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SelectObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_condition_u,
                                     mutator->MutateExpected(self->condition));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_true_value_u,
@@ -254,7 +252,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> SelectMaybeInplaceMutat
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   SelectObj* self = const_cast<SelectObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SelectObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SelectObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<PrimExpr>, mapped_condition_u,
       mutator->MutateExpected(self->condition, ffi::InplaceMode::kAllow));
@@ -282,7 +280,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> LetVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const LetObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const LetObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const LetObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->WithDefRegionKind(
       kTVMFFIDefRegionKindSimple, [&]() { return visitor->VisitExpected(self->var); }));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->value));
@@ -293,7 +291,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> LetVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> LetMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const LetObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const LetObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const LetObj>(value);
   Type old_value_type = self->value->ty;
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_value_u,
                                     mutator->MutateExpected(self->value));
@@ -333,7 +331,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> LetMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> LetMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   LetObj* self = const_cast<LetObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const LetObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const LetObj>(value));
   Type old_value_type = self->value->ty;
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_value_u,
                                     mutator->MutateExpected(self->value, ffi::InplaceMode::kAllow));
diff --git a/src/ir/prim/int_operator.h b/src/ir/prim/int_operator.h
index b4f900110..ece6ac2e5 100644
--- a/src/ir/prim/int_operator.h
+++ b/src/ir/prim/int_operator.h
@@ -28,7 +28,7 @@
 
 namespace tvm {
 namespace prim {
-namespace details {
+namespace detail {
 
 /*!
  * \brief Perform trunc division of two integers.
@@ -71,7 +71,7 @@ inline int64_t floormod(int64_t x, int64_t y) {
   return is_floor_div ? rmod : rmod + y;
 }
 
-}  // namespace details
+}  // namespace detail
 }  // namespace prim
 }  // namespace tvm
 #endif  // TVM_IR_PRIM_INT_OPERATOR_H_
diff --git a/src/ir/prim/math.cc b/src/ir/prim/math.cc
index d47dec279..253c77587 100644
--- a/src/ir/prim/math.cc
+++ b/src/ir/prim/math.cc
@@ -31,7 +31,7 @@
 namespace tvm {
 namespace prim {
 
-using namespace prim::details;
+using namespace prim::detail;
 
 template <size_t N>
 static Type InferTypeReturnArgType(const CallObj* call) {
diff --git a/src/ir/prim/op.cc b/src/ir/prim/op.cc
index 8883bec5d..bf9203c92 100644
--- a/src/ir/prim/op.cc
+++ b/src/ir/prim/op.cc
@@ -28,7 +28,7 @@
 namespace tvm {
 using prim::IsConstInt;
 using prim::MakeConst;
-using namespace prim::details;
+using namespace prim::detail;
 namespace {
 TVM_FFI_INLINE const PrimTypeObj* GetPrimTypeObj(const PrimExpr& expr) {
   // Avoid PrimExpr::ty() ObjectRef materialization on binary operator hot paths.
@@ -72,7 +72,7 @@ bool IsVScaleCall(const PrimExpr& expr) {
 }
 
 }  // namespace
-namespace prim::details {
+namespace prim::detail {
 void BroadcastToMatchLanes(PrimExpr& op_a, PrimExpr& op_b) {  // NOLINT(*)
   PrimType ty_a = op_a.ty();
   PrimType ty_b = op_b.ty();
@@ -184,7 +184,7 @@ void BinaryOpMatchTypes(PrimExpr& lhs, PrimExpr& rhs, Location loc) {  // NOLINT
   }
 }
 
-}  // namespace prim::details
+}  // namespace prim::detail
 namespace prim {
 // maximum and min limits
 PrimExpr max_value(PrimType value_ty, Location loc) {
@@ -312,7 +312,7 @@ PrimExpr cast(PrimExpr value, PrimType t, Location loc) {
     if (const IntImmObj* op = value.as<IntImmObj>()) {
       if (dtype.MatchesCode(DLDataTypeCode::kDLInt, DLDataTypeCode::kDLUInt,
                             DLDataTypeCode::kDLBool)) {
-        if (details::IsRepresentable(op->value, dtype)) return IntImm(dtype, op->value, op->loc);
+        if (detail::IsRepresentable(op->value, dtype)) return IntImm(dtype, op->value, op->loc);
       } else if (dtype.MatchesElementType(DLDataTypeCode::kDLFloat, 32)) {
         if (auto small = op->value.as<int64_t>()) {
           return FloatImm(dtype, static_cast<float>(*small), op->loc);
@@ -350,12 +350,12 @@ PrimExpr cast(PrimExpr value, PrimType t, Location loc) {
         if (std::isfinite(source) &&
             (!dtype.MatchesCode(DLDataTypeCode::kDLBool) || source == 0 || source == 1)) {
           ffi::BigInt result(source);
-          if (details::IsRepresentable(result, dtype)) {
+          if (detail::IsRepresentable(result, dtype)) {
             return IntImm(dtype, std::move(result), op->loc);
           }
         }
       } else if (dtype.MatchesElementType(DLDataTypeCode::kDLFloat, 32)) {
-        if (details::IsInFloat32Range(source)) {
+        if (detail::IsInFloat32Range(source)) {
           return FloatImm(dtype, static_cast<float>(source), op->loc);
         }
       } else if (dtype.MatchesElementType(DLDataTypeCode::kDLFloat, 16) ||
@@ -403,10 +403,10 @@ PrimExpr cast(PrimExpr value, PrimType t, Location loc) {
         if (dtype.IsFixedLengthVector() && base && stride &&
             dtype.MatchesCode(DLDataTypeCode::kDLInt, DLDataTypeCode::kDLUInt)) {
           ffi::BigInt last = base->value + stride->value * (dtype.lanes() - 1);
-          if (details::IsRepresentable(base->value, elem_ty) &&
-              details::IsRepresentable(stride->value, elem_ty) &&
-              details::IsRepresentable(last, elem_ty) &&
-              details::IsRepresentable(last, ramp->base.ty())) {
+          if (detail::IsRepresentable(base->value, elem_ty) &&
+              detail::IsRepresentable(stride->value, elem_ty) &&
+              detail::IsRepresentable(last, elem_ty) &&
+              detail::IsRepresentable(last, ramp->base.ty())) {
             return prim::Ramp(cast(ramp->base, elem_ty, loc), cast(ramp->stride, elem_ty, loc),
                               ramp->lanes, loc);
           }
@@ -457,7 +457,7 @@ PrimExpr neg(PrimExpr a, Location loc) {
   const FloatImmObj* fa = a.as<FloatImmObj>();
   if (pa) {
     ffi::BigInt value = -pa->value;
-    if (prim::details::IsRepresentable(value, a.ty())) {
+    if (prim::detail::IsRepresentable(value, a.ty())) {
       return IntImm(a.ty(), std::move(value), loc);
     }
   }
@@ -707,7 +707,7 @@ PrimExpr left_shift(PrimExpr a, PrimExpr b, Location loc) {
           << result_ty;
     if (pa && pb) {
       ffi::BigInt value = pa->value << pb->value;
-      if (prim::details::IsRepresentable(value, result_ty)) {
+      if (prim::detail::IsRepresentable(value, result_ty)) {
         return IntImm(result_ty, std::move(value), loc);
       }
     }
@@ -790,7 +790,7 @@ PrimExpr prim::IntegerAbs(PrimExpr x, Location loc) {
   if (x.ty().MatchesCode(DLDataTypeCode::kDLInt)) {
     if (const IntImmObj* px = x.as<IntImmObj>()) {
       ffi::BigInt value = px->value < 0 ? -px->value : px->value;
-      if (prim::details::IsRepresentable(value, x.ty())) {
+      if (prim::detail::IsRepresentable(value, x.ty())) {
         return IntImm(x.ty(), std::move(value), px->loc);
       }
     }
diff --git a/src/ir/prim/op_utils.h b/src/ir/prim/op_utils.h
index 9ca7b992b..2913bb4b1 100644
--- a/src/ir/prim/op_utils.h
+++ b/src/ir/prim/op_utils.h
@@ -20,8 +20,8 @@
 #ifndef TVM_IR_PRIM_OP_UTILS_H_
 #define TVM_IR_PRIM_OP_UTILS_H_
 #include <tvm/ir/prim/op.h>
-namespace tvm::prim::details {
+namespace tvm::prim::detail {
 TVM_TIRX_DLL void BinaryOpMatchTypes(PrimExpr& lhs, PrimExpr& rhs, Location loc);
 
-}  // namespace tvm::prim::details
+}  // namespace tvm::prim::detail
 #endif  // TVM_IR_PRIM_OP_UTILS_H_
diff --git a/src/ir/prim/vector_expr.cc b/src/ir/prim/vector_expr.cc
index 76476caf4..180c5dacb 100644
--- a/src/ir/prim/vector_expr.cc
+++ b/src/ir/prim/vector_expr.cc
@@ -56,7 +56,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> RampVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const RampObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RampObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RampObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->base));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->stride));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->lanes));
@@ -67,7 +67,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> RampMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const RampObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RampObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RampObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_base_u,
                                     mutator->MutateExpected(self->base));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_stride_u,
@@ -90,7 +90,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> RampMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   RampObj* self = const_cast<RampObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RampObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RampObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_base_u,
                                     mutator->MutateExpected(self->base, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
@@ -113,7 +113,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> BroadcastVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const BroadcastObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BroadcastObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BroadcastObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->value));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->lanes));
   return std::nullopt;
@@ -123,7 +123,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BroadcastMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const BroadcastObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BroadcastObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BroadcastObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_value_u,
                                     mutator->MutateExpected(self->value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_lanes_u,
@@ -142,7 +142,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BroadcastMaybeInplaceMu
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   BroadcastObj* self = const_cast<BroadcastObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BroadcastObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BroadcastObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_value_u,
                                     mutator->MutateExpected(self->value, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_lanes_u,
@@ -160,7 +160,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> ShuffleVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const ShuffleObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ShuffleObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ShuffleObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->vectors));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->indices));
   return std::nullopt;
@@ -170,7 +170,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ShuffleMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   const ShuffleObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ShuffleObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ShuffleObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<PrimExpr>>, mapped_vectors_u,
                                     mutator->MutateExpected(self->vectors));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<PrimExpr>>, mapped_indices_u,
@@ -189,7 +189,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ShuffleMaybeInplaceMuta
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: PrimExpr types are always PrimType and remain unchanged in normal mutation.
   ShuffleObj* self = const_cast<ShuffleObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ShuffleObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ShuffleObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<ffi::Array<PrimExpr>>, mapped_vectors_u,
       mutator->MutateExpected(self->vectors, ffi::InplaceMode::kAllow));
diff --git a/src/ir/seq_stmt_mutate.h b/src/ir/seq_stmt_mutate.h
index 0358e725e..7f61a238c 100644
--- a/src/ir/seq_stmt_mutate.h
+++ b/src/ir/seq_stmt_mutate.h
@@ -207,7 +207,7 @@ auto MaybeInplaceMutateSeqStmtRaw(MutateElement& mutate_element, const SeqStmtOb
         }
       } else {
         results.emplace_back(
-            ffi::details::AnyUnsafe::MoveFromAnyAfterCheck<Stmt>(std::move(slots[i])));
+            ffi::detail::AnyUnsafe::MoveFromAnyAfterCheck<Stmt>(std::move(slots[i])));
       }
     }
     self->seq = ffi::Array<Stmt>(std::make_move_iterator(results.begin()),
diff --git a/src/ir/stmt.cc b/src/ir/stmt.cc
index deccacd13..76931fd10 100644
--- a/src/ir/stmt.cc
+++ b/src/ir/stmt.cc
@@ -70,7 +70,7 @@ bool IntImmValueFits(const ffi::BigInt& value, const PrimType& ty) {
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> BindVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const BindObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BindObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BindObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->WithDefRegionKind(
       kTVMFFIDefRegionKindSimple, [&]() { return visitor->VisitExpected(self->var); }));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->value));
@@ -80,7 +80,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> BindVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BindMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const BindObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BindObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BindObj>(value);
   Type old_value_type = self->value->ty;
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_value,
                                     mutator->MutateExpected(self->value));
@@ -114,7 +114,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BindMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BindMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   BindObj* self = const_cast<BindObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BindObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BindObj>(value));
   Type old_value_type = self->value->ty;
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_value,
                                     mutator->MutateExpected(self->value, ffi::InplaceMode::kAllow));
@@ -148,7 +148,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> BindMaybeInplaceMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> RegionStmtVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const RegionStmtObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RegionStmtObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RegionStmtObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->attrs));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->args));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->WithDefRegionKind(
@@ -161,7 +161,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> RegionStmtVisit
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> RegionStmtMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const RegionStmtObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RegionStmtObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RegionStmtObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<DictAttrs>, mapped_attrs,
                                     mutator->MutateExpected(self->attrs));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Expr>>, mapped_args,
@@ -196,7 +196,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> RegionStmtMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> RegionStmtMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const RegionStmtObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RegionStmtObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RegionStmtObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<DictAttrs>, mapped_attrs,
                                     mutator->MutateExpected(self->attrs, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Expr>>, mapped_args,
@@ -234,7 +234,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> AssertStmtVisit
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: error_kind and message_parts, which are constant assertion metadata.
   const AssertStmtObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const AssertStmtObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const AssertStmtObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->condition));
   return std::nullopt;
 }
@@ -243,7 +243,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> AssertStmtMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: error_kind and message_parts, which are constant assertion metadata.
   const AssertStmtObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const AssertStmtObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const AssertStmtObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_condition,
                                     mutator->MutateExpected(self->condition));
   if (mapped_condition.UnchangedOrSameAs(self->condition)) {
@@ -258,7 +258,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> AssertStmtMaybeInplaceM
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: error_kind and message_parts, which are constant assertion metadata.
   AssertStmtObj* self = const_cast<AssertStmtObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const AssertStmtObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const AssertStmtObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<PrimExpr>, mapped_condition,
       mutator->MutateExpected(self->condition, ffi::InplaceMode::kAllow));
@@ -274,7 +274,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> ForVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: kind and constant annotations; unlike SBlock annotations, these carry no expressions.
   const ForObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ForObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ForObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->WithDefRegionKind(
       kTVMFFIDefRegionKindSimple, [&]() { return visitor->VisitExpected(self->var); }));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->begin));
@@ -288,7 +288,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ForMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: kind and constant annotations; unlike SBlock annotations, these carry no expressions.
   const ForObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ForObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ForObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimVar>, mapped_var,
                                     mutator->WithDefRegionKind(kTVMFFIDefRegionKindSimple, [&]() {
                                       return mutator->MutateExpected(self->var);
@@ -319,7 +319,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ForMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: kind and constant annotations; unlike SBlock annotations, these carry no expressions.
   ForObj* self = const_cast<ForObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ForObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ForObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimVar>, mapped_var,
                                     mutator->WithDefRegionKind(kTVMFFIDefRegionKindSimple, [&]() {
                                       return mutator->MutateExpected(self->var,
@@ -349,7 +349,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ForMaybeInplaceMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> WhileVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const WhileObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const WhileObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const WhileObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->condition));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->body));
   return std::nullopt;
@@ -358,7 +358,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> WhileVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> WhileMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const WhileObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const WhileObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const WhileObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_condition,
                                     mutator->MutateExpected(self->condition));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Stmt>, mapped_body,
@@ -376,7 +376,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> WhileMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> WhileMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   WhileObj* self = const_cast<WhileObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const WhileObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const WhileObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<PrimExpr>, mapped_condition,
       mutator->MutateExpected(self->condition, ffi::InplaceMode::kAllow));
@@ -395,7 +395,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> WhileMaybeInplaceMutate
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> ReturnVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const ReturnObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ReturnObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ReturnObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->value));
   return std::nullopt;
 }
@@ -403,7 +403,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> ReturnVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ReturnMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const ReturnObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ReturnObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ReturnObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_value,
                                     mutator->MutateExpected(self->value));
   if (mapped_value.UnchangedOrSameAs(self->value)) {
@@ -417,7 +417,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ReturnMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ReturnMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   ReturnObj* self = const_cast<ReturnObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ReturnObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ReturnObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_value,
                                     mutator->MutateExpected(self->value, ffi::InplaceMode::kAllow));
   if (mapped_value.UnchangedOrSameAs(self->value)) {
@@ -460,7 +460,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> ContinueMaybeInplaceMut
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> SeqStmtVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const SeqStmtObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SeqStmtObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SeqStmtObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->seq));
   return std::nullopt;
 }
@@ -469,7 +469,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> MutateSeqStmtStructural
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value,
     ffi::InplaceMode inplace_mode) noexcept {
   const auto* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SeqStmtObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SeqStmtObj>(value);
   auto mutate = [mutator](ffi::AnyView element,
                           ffi::InplaceMode mode) -> ffi::Expected<ffi::UnchangedOr<Stmt>> {
     TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Stmt>, mapped,
@@ -491,8 +491,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> SeqStmtMaybeInplaceMuta
 
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> IfVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
-  const IfObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IfObj>(value);
+  const IfObj* self = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IfObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->condition));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->then_case));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->else_case));
@@ -501,8 +500,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> IfVisit(
 
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> IfMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
-  const IfObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IfObj>(value);
+  const IfObj* self = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IfObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_condition,
                                     mutator->MutateExpected(self->condition));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Stmt>, mapped_then_case,
@@ -530,7 +528,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> IfMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> IfMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   IfObj* self = const_cast<IfObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IfObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IfObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<PrimExpr>, mapped_condition,
       mutator->MutateExpected(self->condition, ffi::InplaceMode::kAllow));
@@ -561,7 +559,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> IfMaybeInplaceMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> EvaluateVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const EvaluateObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const EvaluateObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const EvaluateObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->value));
   return std::nullopt;
 }
@@ -569,7 +567,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> EvaluateVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> EvaluateMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const EvaluateObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const EvaluateObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const EvaluateObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_value,
                                     mutator->MutateExpected(self->value));
   if (mapped_value.UnchangedOrSameAs(self->value)) {
@@ -583,7 +581,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> EvaluateMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> EvaluateMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   EvaluateObj* self = const_cast<EvaluateObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const EvaluateObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const EvaluateObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_value,
                                     mutator->MutateExpected(self->value, ffi::InplaceMode::kAllow));
   if (mapped_value.UnchangedOrSameAs(self->value)) {
@@ -596,7 +594,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> EvaluateMaybeInplaceMut
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TensorStoreVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const TensorStoreObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorStoreObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorStoreObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->dest));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->indices));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->value));
@@ -606,7 +604,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TensorStoreVisi
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorStoreMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const TensorStoreObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorStoreObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorStoreObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_dest,
                                     mutator->MutateExpected(self->dest));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<PrimExpr>>, mapped_indices,
@@ -627,7 +625,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorStoreMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorStoreMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   TensorStoreObj* self = const_cast<TensorStoreObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorStoreObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorStoreObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Expr>, mapped_dest,
                                     mutator->MutateExpected(self->dest, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
diff --git a/src/ir/type.cc b/src/ir/type.cc
index ead22b874..069c38350 100644
--- a/src/ir/type.cc
+++ b/src/ir/type.cc
@@ -127,7 +127,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> PtrTypeVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: scope (canonical enum identity)
   const PtrTypeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PtrTypeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PtrTypeObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->element_type));
   return std::nullopt;
 }
@@ -136,7 +136,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> PtrTypeMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: scope (canonical enum identity)
   const PtrTypeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PtrTypeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PtrTypeObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_element_type_u,
                                     mutator->MutateExpected(self->element_type));
   if (mapped_element_type_u.UnchangedOrSameAs(self->element_type)) {
@@ -152,7 +152,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> PtrTypeMaybeInplaceMuta
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: scope (canonical enum identity)
   PtrTypeObj* self = const_cast<PtrTypeObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PtrTypeObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PtrTypeObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<Type>, mapped_element_type_u,
       mutator->MutateExpected(self->element_type, ffi::InplaceMode::kAllow));
@@ -165,7 +165,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> PtrTypeMaybeInplaceMuta
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> FuncTypeVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const FuncTypeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FuncTypeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FuncTypeObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->arg_types));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ret_type));
   return std::nullopt;
@@ -174,7 +174,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> FuncTypeVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> FuncTypeMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const FuncTypeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FuncTypeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FuncTypeObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Type>>, mapped_arg_types_u,
                                     mutator->MutateExpected(self->arg_types));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<Type>, mapped_ret_type_u,
@@ -194,7 +194,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> FuncTypeMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> FuncTypeMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   FuncTypeObj* self = const_cast<FuncTypeObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FuncTypeObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FuncTypeObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<ffi::Array<Type>>, mapped_arg_types_u,
       mutator->MutateExpected(self->arg_types, ffi::InplaceMode::kAllow));
@@ -213,7 +213,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> FuncTypeMaybeInplaceMut
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TupleTypeVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const TupleTypeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleTypeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleTypeObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->fields));
   return std::nullopt;
 }
@@ -221,7 +221,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TupleTypeVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TupleTypeMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const TupleTypeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleTypeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleTypeObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Type>>, mapped_fields_u,
                                     mutator->MutateExpected(self->fields));
   if (mapped_fields_u.UnchangedOrSameAs(self->fields)) {
@@ -235,7 +235,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TupleTypeMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TupleTypeMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   TupleTypeObj* self = const_cast<TupleTypeObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleTypeObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleTypeObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<ffi::Array<Type>>, mapped_fields_u,
       mutator->MutateExpected(self->fields, ffi::InplaceMode::kAllow));
diff --git a/src/runtime/thread_pool.cc b/src/runtime/thread_pool.cc
index 573603ddc..8ee52765e 100644
--- a/src/runtime/thread_pool.cc
+++ b/src/runtime/thread_pool.cc
@@ -117,7 +117,7 @@ class ParallelLauncher {
   // Signal that one job has finished.
   void SignalJobError(int task_id) {
     num_pending_.fetch_sub(1);
-    par_errors_[task_id] = tvm::ffi::details::MoveFromSafeCallRaised();
+    par_errors_[task_id] = tvm::ffi::detail::MoveFromSafeCallRaised();
     has_error_.store(true);
   }
   // Signal that one job has finished.
diff --git a/src/script/ir_builder/base.cc b/src/script/ir_builder/base.cc
index 4fbc3b4d8..1868f3e7a 100644
--- a/src/script/ir_builder/base.cc
+++ b/src/script/ir_builder/base.cc
@@ -159,7 +159,7 @@ Location IRBuilderObj::ResolveLoc(Location location) const {
 ffi::ObjectRef IRBuilderObj::AttachLoc(ffi::ObjectRef obj, Location loc) const {
   loc = ComposeLoc(ResolveLoc(), loc);
   if (!loc.as<UnknownLocObj>() && obj.defined()) {
-    if (Location* target = details::LocationAccessor::vtable()(obj)) {
+    if (Location* target = detail::LocationAccessor::vtable()(obj)) {
       *target = ComposeLoc(loc, *target);
     }
   }
@@ -201,7 +201,7 @@ bool IRBuilder::IsInScope() {
   return !stack->empty();
 }
 
-namespace details {
+namespace detail {
 
 LocationAccessor::FType& LocationAccessor::vtable() {
   static FType inst;
@@ -230,7 +230,7 @@ void Namer::Name(ffi::ObjectRef node, ffi::String name) {
   f(node, name);
 }
 
-}  // namespace details
+}  // namespace detail
 
 TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
diff --git a/src/script/ir_builder/ir.cc b/src/script/ir_builder/ir.cc
index e3a980724..b6a76f06c 100644
--- a/src/script/ir_builder/ir.cc
+++ b/src/script/ir_builder/ir.cc
@@ -34,7 +34,7 @@ namespace ir {
 
 using namespace tvm::prim;
 
-using tvm::script::ir_builder::details::Namer;
+using tvm::script::ir_builder::detail::Namer;
 
 TVM_FFI_STATIC_INIT_BLOCK() {
   Namer::vtable().SetDispatch<tvm::VarObj>(
@@ -168,7 +168,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 }
 
 TVM_FFI_STATIC_INIT_BLOCK() {
-  details::LocationAccessor::vtable().SetDispatch<tvm::StmtObj>(
+  detail::LocationAccessor::vtable().SetDispatch<tvm::StmtObj>(
       [](const ffi::ObjectRef& obj) -> Location* { return &obj.as<tvm::StmtObj>()->loc; });
 }
 
diff --git a/src/script/printer/doc_printer.cc b/src/script/printer/doc_printer.cc
index cf823f268..7f0c19eeb 100644
--- a/src/script/printer/doc_printer.cc
+++ b/src/script/printer/doc_printer.cc
@@ -1591,7 +1591,7 @@ void AttachAnnotations(const Doc& root, const ffi::Map<AccessPath, ffi::String>&
 
 }  // namespace
 
-namespace details {
+namespace detail {
 
 ffi::String RenderPythonScript(Doc doc, const PrinterConfig& cfg,
                                const ffi::Array<ffi::Any>& header,
@@ -1615,13 +1615,13 @@ ffi::String RenderPythonScript(Doc doc, const PrinterConfig& cfg,
   return RenderInvisiblePathInfo(script, underline_paths, printer.GetVisiblePaths());
 }
 
-}  // namespace details
+}  // namespace detail
 
 TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   refl::GlobalDef().def("script.printer.DocToPythonScript", [](Doc doc,
                                                                const PrinterConfig& config) {
-    return details::RenderPythonScript(std::move(doc), config, {}, config->path_to_underline, {});
+    return detail::RenderPythonScript(std::move(doc), config, {}, config->path_to_underline, {});
   });
 }
 
diff --git a/src/script/printer/doc_printer.h b/src/script/printer/doc_printer.h
index f7a5a6a34..b95d5648b 100644
--- a/src/script/printer/doc_printer.h
+++ b/src/script/printer/doc_printer.h
@@ -25,7 +25,7 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 // Render a Doc with this invocation's recovered paths and statement annotations.
 ffi::String RenderPythonScript(Doc doc, const PrinterConfig& config,
@@ -33,7 +33,7 @@ ffi::String RenderPythonScript(Doc doc, const PrinterConfig& config,
                                const ffi::Array<AccessPath>& underline_paths,
                                const ffi::Map<AccessPath, ffi::String>& annotations);
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/script/printer/ir/call.cc b/src/script/printer/ir/call.cc
index 2877d3789..31a6cdc1f 100644
--- a/src/script/printer/ir/call.cc
+++ b/src/script/printer/ir/call.cc
@@ -31,7 +31,7 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 // Semantic wrappers register their own Op hooks; ordinary calls use canonical exposure.
 
@@ -40,7 +40,7 @@ namespace {
 ffi::Optional<ExprDoc> CallDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                         const ffi::Object* destination) {
   const auto* call =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(input);
   if (auto op = call->op.as<Op>();
       op && Op::HasAttrMap(tvm::script::printer::op_attr::kDocTranslateOpCall)) {
     static const auto& overrides =
@@ -70,7 +70,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 }
 
 }  // namespace
-}  // namespace details
+}  // namespace detail
 
 ffi::Optional<ExprDoc> StandardCallDocTranslate(DocTranslatorObj* d, const CallObj* call) {
   auto maybe_op = call->op.as<Op>();
@@ -141,7 +141,7 @@ ffi::Optional<ExprDoc> StandardCallDocTranslate(DocTranslatorObj* d, const CallO
     keys.push_back("ty");
     values.push_back(d->Translate(call->ty).value());
   }
-  return details::NamedCallCallee(op->name)->Call(args, keys, values);
+  return detail::NamedCallCallee(op->name)->Call(args, keys, values);
 }
 
 }  // namespace printer
diff --git a/src/script/printer/ir/ir.cc b/src/script/printer/ir/ir.cc
index 37ca5146a..dc0b23d49 100644
--- a/src/script/printer/ir/ir.cc
+++ b/src/script/printer/ir/ir.cc
@@ -32,14 +32,14 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
 ffi::Optional<ExprDoc> IRModuleDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                             const ffi::Object* destination) {
   const auto* mod =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IRModuleObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IRModuleObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   ffi::String module_name = d->GetExtraConfig<ffi::String>("ir.module_name", "Module");
@@ -117,7 +117,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> DictAttrsDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                              const ffi::Object*) {
   const auto* attrs =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DictAttrsObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DictAttrsObj>(input);
   return d->Translate(attrs->dict).value();
 }
 
@@ -130,7 +130,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> GlobalVarDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                              const ffi::Object*) {
   const auto* var =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const GlobalVarObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const GlobalVarObj>(input);
   return GlobalReference(d, var->name_hint);
 }
 
@@ -141,7 +141,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 }
 
 ffi::Optional<ExprDoc> OpDocTranslate(DocTranslatorObj*, ffi::AnyView input, const ffi::Object*) {
-  const auto* op = ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const OpObj>(input);
+  const auto* op = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const OpObj>(input);
   return NamespaceDoc("ir")->Attr("Op")->Attr("get")->Call(
       {LiteralDoc::Str(op->name, std::nullopt)});
 }
@@ -154,7 +154,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> RangeDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                          const ffi::Object*) {
   const auto* range =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RangeObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RangeObj>(input);
   ExprDoc min = d->Translate(range->begin).value();
   ExprDoc end = d->Translate(range->begin + range->extent).value();
   return NamespaceDoc("ir")->Attr("Range")->Call({min, end});
@@ -167,7 +167,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/script/printer/ir/misc.cc b/src/script/printer/ir/misc.cc
index 6d095e39c..c4ed16125 100644
--- a/src/script/printer/ir/misc.cc
+++ b/src/script/printer/ir/misc.cc
@@ -33,14 +33,14 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
 ffi::Optional<ExprDoc> DataTypeImmDocTranslate(DocTranslatorObj*, ffi::AnyView input,
                                                const ffi::Object*) {
   const auto* imm =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DataTypeImmObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const DataTypeImmObj>(input);
   return NamespaceDoc("tirx")->Attr("dtype")->Call(
       {LiteralDoc::DataType(imm->value, std::nullopt)});
 }
@@ -118,7 +118,7 @@ namespace {
 ffi::Optional<ExprDoc> ShapeDocTranslate(DocTranslatorObj*, ffi::AnyView input,
                                          const ffi::Object*) {
   const auto* shape =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ffi::ShapeObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ffi::ShapeObj>(input);
   ffi::Array<ExprDoc> dimensions;
   for (int64_t value : ffi::GetRef<ffi::Shape>(shape)) {
     dimensions.push_back(LiteralDoc::Int(value, std::nullopt));
@@ -134,7 +134,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/script/printer/ir/prim_expr.cc b/src/script/printer/ir/prim_expr.cc
index 273d01fe9..9e2771bbe 100644
--- a/src/script/printer/ir/prim_expr.cc
+++ b/src/script/printer/ir/prim_expr.cc
@@ -31,7 +31,7 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 void EmitVarDefinition(DocTranslatorObj* d, const Var& var, ExprDoc rhs) {
   // Only this type's referenced Vars must precede its declaration.
@@ -55,7 +55,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> LambdaExprDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                               const ffi::Object*) {
   const auto* lambda =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const LambdaExprObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const LambdaExprObj>(input);
   return d->WithVarScope([&]() {
     ffi::Array<IdDoc> args;
     ffi::Array<ExprDoc> types;
@@ -99,7 +99,7 @@ namespace {
 ffi::Optional<ExprDoc> TensorRegionDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                                 const ffi::Object*) {
   const auto* region =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorRegionObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorRegionObj>(input);
   bool indexable = region->ty.as<TensorRegionTypeObj>() && !region->region.empty();
   using Slice =
       ffi::Tuple<ffi::Optional<PrimExpr>, ffi::Optional<PrimExpr>, ffi::Optional<PrimExpr>>;
@@ -178,7 +178,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> TensorLoadDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                               const ffi::Object*) {
   const auto* load =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorLoadObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorLoadObj>(input);
   return IndexDoc(d->Translate(load->source).value(), TensorIndices(d, load->indices));
 }
 
@@ -191,7 +191,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> TupleDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                          const ffi::Object*) {
   const auto* tuple =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleObj>(input);
   ffi::Array<ExprDoc> fields;
   for (const Expr& field : tuple->fields) fields.push_back(d->Translate(field).value());
   return TupleDoc(fields);
@@ -205,7 +205,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> TupleGetItemDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                                 const ffi::Object*) {
   const auto* item =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleGetItemObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleGetItemObj>(input);
   return d->Translate(item->tuple).value()[{LiteralDoc::Int(item->index, std::nullopt)}];
 }
 
@@ -219,7 +219,7 @@ template <typename T, OperationDocObj::Kind kind,
           PrimExpr (*operation)(PrimExpr, PrimExpr, Location)>
 ffi::Optional<ExprDoc> BinaryOpDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                             const ffi::Object*) {
-  const auto* node = ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const T>(input);
+  const auto* node = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const T>(input);
   ExprDoc a = d->Translate(node->a).value();
   ExprDoc b = d->Translate(node->b).value();
   // Replay operator overloads before choosing sugar. Even one constant can
@@ -273,7 +273,7 @@ ExprDoc BinaryHelperDocTranslate(DocTranslatorObj* d, const T* node, const char*
 ffi::Optional<ExprDoc> BitwiseNotDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                               const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::BitwiseNotObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::BitwiseNotObj>(input);
   return UnaryOpDocTranslate<prim::BitwiseNotObj, OperationDocObj::Kind::kInvert, tvm::bitwise_neg>(
       d, node);
 }
@@ -287,7 +287,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> NotDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                        const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::NotObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::NotObj>(input);
   return UnaryOpDocTranslate<prim::NotObj, OperationDocObj::Kind::kNot, tvm::logical_not>(d, node);
 }
 
@@ -300,7 +300,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> StringImmDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                              const ffi::Object*) {
   const auto* imm =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const StringImmObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const StringImmObj>(input);
   ExprDoc literal = LiteralDoc::Str(imm->value, std::nullopt);
   if (d->GetOrCreateExtraState<bool>("ir.explicit_value_type")) {
     return NamespaceDoc("ir")->Attr("StringImm")->Call({literal});
@@ -317,7 +317,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> CastDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                         const ffi::Object*) {
   const auto* cast =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::CastObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::CastObj>(input);
   return NamespaceDoc("tirx")->Attr("Cast")->Call(
       {LiteralDoc::DataType(cast->ty.as_or_throw<PrimType>()->dtype, std::nullopt),
        d->Translate(cast->value).value()});
@@ -332,7 +332,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> SelectDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                           const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::SelectObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::SelectObj>(input);
   return NamespaceDoc("tirx")->Attr("Select")->Call({d->Translate(node->condition).value(),
                                                      d->Translate(node->true_value).value(),
                                                      d->Translate(node->false_value).value()});
@@ -347,7 +347,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> RampDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                         const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::RampObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::RampObj>(input);
   return NamespaceDoc("tirx")->Attr("Ramp")->Call({d->Translate(node->base).value(),
                                                    d->Translate(node->stride).value(),
                                                    d->Translate(node->lanes).value()});
@@ -362,7 +362,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> BroadcastDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                              const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::BroadcastObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::BroadcastObj>(input);
   return NamespaceDoc("tirx")
       ->Attr("Broadcast")
       ->Call({d->Translate(node->value).value(), d->Translate(node->lanes).value()});
@@ -377,7 +377,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> ShuffleDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                            const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::ShuffleObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::ShuffleObj>(input);
   ExprDoc vectors = d->Translate(node->vectors).value();
   ExprDoc indices = d->Translate(node->indices).value();
   d->RecordOrigin(vectors, node->vectors);
@@ -394,7 +394,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> LetDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                        const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::LetObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::LetObj>(input);
   ExprDoc value = d->Translate(node->value).value();
   IdDoc var = VarDoc(d, node->var);
   if (auto type = node->var->ty.as<PrimType>()) {
@@ -416,7 +416,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> DivDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                        const ffi::Object* destination) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::DivObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::DivObj>(input);
   PrimType a_type = node->a.ty();
   PrimType b_type = node->b.ty();
   if (a_type.MatchesCode(DLDataTypeCode::kDLInt, DLDataTypeCode::kDLUInt) &&
@@ -509,7 +509,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> ModDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                        const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::ModObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::ModObj>(input);
   return BinaryHelperDocTranslate<prim::ModObj, tvm::truncmod>(d, node, "truncmod");
 }
 
@@ -522,7 +522,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> MinDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                        const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::MinObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::MinObj>(input);
   return BinaryHelperDocTranslate<prim::MinObj, tvm::min>(d, node, "min");
 }
 
@@ -535,7 +535,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> MaxDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                        const ffi::Object*) {
   const auto* node =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::MaxObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const prim::MaxObj>(input);
   return BinaryHelperDocTranslate<prim::MaxObj, tvm::max>(d, node, "max");
 }
 
@@ -547,7 +547,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 
 ffi::Optional<ExprDoc> VarDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                        const ffi::Object* destination) {
@@ -567,7 +567,7 @@ ffi::Optional<ExprDoc> VarDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
       rhs = NamespaceDoc("ir")->Attr("Var")->Call(
           {LiteralDoc::Str(var->name, std::nullopt), d->Translate(var->ty).value()});
     }
-    details::EmitVarDefinition(d, var, rhs);
+    detail::EmitVarDefinition(d, var, rhs);
     return std::nullopt;
   }
   return IdDoc(id->name);
diff --git a/src/script/printer/ir/prim_type.cc b/src/script/printer/ir/prim_type.cc
index c96dcf73f..141e64e32 100644
--- a/src/script/printer/ir/prim_type.cc
+++ b/src/script/printer/ir/prim_type.cc
@@ -31,7 +31,7 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
@@ -80,7 +80,7 @@ bool HasPrimTypeShorthand(const PrimType& type) {
 ffi::Optional<ExprDoc> IntImmDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                           const ffi::Object*) {
   const auto* imm =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IntImmObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IntImmObj>(input);
   DLDataType dtype = imm->ty.as_or_throw<PrimType>()->dtype;
   ExprDoc value = LiteralDoc::Int(ffi::GetRef<IntImm>(imm), std::nullopt);
   DLDataType default_dtype =
@@ -105,7 +105,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> FloatImmDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                             const ffi::Object*) {
   const auto* imm =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FloatImmObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FloatImmObj>(input);
   DLDataType dtype = imm->ty.as_or_throw<PrimType>()->dtype;
   DLDataType default_dtype =
       ffi::StringToDLDataType(d->GetExtraConfig<ffi::String>("ir.float_dtype", "void"));
@@ -133,7 +133,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> PrimTypeDocTranslate(DocTranslatorObj*, ffi::AnyView input,
                                             const ffi::Object*) {
   const auto* ty =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PrimTypeObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PrimTypeObj>(input);
   PrimType type = ffi::GetRef<PrimType>(ty);
   // Other widths and fixed or scalable vectors have no exported TIRx shorthand.
   if (HasPrimTypeShorthand(type)) {
@@ -153,7 +153,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> PtrTypeDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                            const ffi::Object*) {
   const auto* ty =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PtrTypeObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const PtrTypeObj>(input);
   return d->WithExtraStateScope<bool>("ir.explicit_value_type", true, [&]() -> ExprDoc {
     ffi::Array<ExprDoc> args{d->Translate(ty->element_type).value()};
     if (ty->scope != runtime::MemoryScope::Global()) {
@@ -185,7 +185,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> TupleTypeDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                              const ffi::Object*) {
   const auto* ty =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleTypeObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TupleTypeObj>(input);
   ExprDoc callee = NamespaceDoc("ir")->Attr("Tuple");
   ffi::Array<ExprDoc> fields;
   for (const Type& field : ty->fields) fields.push_back(d->Translate(field).value());
@@ -200,7 +200,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/script/printer/ir/stmt.cc b/src/script/printer/ir/stmt.cc
index 0e48a3bf8..6256992b4 100644
--- a/src/script/printer/ir/stmt.cc
+++ b/src/script/printer/ir/stmt.cc
@@ -25,7 +25,7 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 ffi::Array<StmtDoc> Body(const Stmt& stmt, DocTranslatorObj* d) {
   return ToStmtDocArray(d->WithDocScope([&]() { d->Translate(stmt); }));
@@ -36,7 +36,7 @@ namespace {
 ffi::Optional<ExprDoc> BindDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                         const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BindObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BindObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   d->VarGetOrAllocId(stmt->var, false);
@@ -67,7 +67,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> ReturnDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                           const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ReturnObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ReturnObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   d->Emit(ReturnDoc(d->Translate(stmt->value).value()), ffi::GetRef<ffi::ObjectRef>(stmt));
@@ -83,7 +83,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> AssertStmtDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                               const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const AssertStmtObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const AssertStmtObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   ffi::Array<ExprDoc> parts;
@@ -106,7 +106,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> WhileDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                          const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const WhileObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const WhileObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   d->Emit(WhileDoc(d->Translate(stmt->condition).value(), Body(stmt->body, d)),
@@ -122,7 +122,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> BreakDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                          const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BreakObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const BreakObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   d->Emit(BreakDoc(), ffi::GetRef<ffi::ObjectRef>(stmt));
@@ -137,7 +137,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> ContinueDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                             const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ContinueObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ContinueObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   d->Emit(ContinueDoc(), ffi::GetRef<ffi::ObjectRef>(stmt));
@@ -152,7 +152,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 ffi::Optional<ExprDoc> IfDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                       const ffi::Object* destination) {
-  const auto* stmt = ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IfObj>(input);
+  const auto* stmt = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IfObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   ExprDoc condition = d->Translate(stmt->condition).value();
@@ -169,7 +169,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 }
 
 }  // namespace
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/script/printer/ir/utils.cc b/src/script/printer/ir/utils.cc
index e627416cc..86a4620cb 100644
--- a/src/script/printer/ir/utils.cc
+++ b/src/script/printer/ir/utils.cc
@@ -30,12 +30,12 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 ffi::Optional<ExprDoc> InvokeDocHook(ffi::AnyView hook, DocTranslatorObj* d, ffi::AnyView input,
                                      const ffi::Object* destination) {
   if (hook.type_index() == ffi::TypeIndex::kTVMFFIOpaquePtr) {
-    return ffi::details::ExpectedUnsafe::MoveFromTVMFFIAny<ffi::Optional<ExprDoc>>(
+    return ffi::detail::ExpectedUnsafe::MoveFromTVMFFIAny<ffi::Optional<ExprDoc>>(
                reinterpret_cast<decltype(DocTranslatorVTable::translate)>(hook.cast<void*>())(
                    d, input, destination))
         .value();
@@ -100,7 +100,7 @@ ExprDoc CallAttrsValue(DocTranslatorObj* d, const Attrs& attrs) {
 
 // The explicit fallback retains every field, including typed attribute objects.
 
-}  // namespace details
+}  // namespace detail
 
 ExprDoc AddMetadata(DocTranslatorObj* d, ffi::Any value) {
   TVM_FFI_CHECK(value != nullptr, TypeError) << "Metadata cannot contain None";
@@ -149,7 +149,7 @@ ExprDoc RawCallDocTranslate(DocTranslatorObj* d, const CallObj* call,
   ffi::Array<ExprDoc> values;
   if (call->attrs.has_value()) {
     keys.push_back("attrs");
-    values.push_back(details::CallAttrsValue(d, call->attrs.value()));
+    values.push_back(detail::CallAttrsValue(d, call->attrs.value()));
   }
   if (!call->ty_args.empty()) {
     ffi::Array<ExprDoc> types;
diff --git a/src/script/printer/ir/utils.h b/src/script/printer/ir/utils.h
index e3bf7c1b8..b84ab607b 100644
--- a/src/script/printer/ir/utils.h
+++ b/src/script/printer/ir/utils.h
@@ -32,7 +32,7 @@ namespace tvm {
 namespace script {
 namespace printer {
 
-namespace details {
+namespace detail {
 
 ffi::Array<StmtDoc> Body(const Stmt& stmt, DocTranslatorObj* d);
 ffi::Array<Doc> TensorIndices(DocTranslatorObj* d, const ffi::Array<PrimExpr>& indices,
@@ -45,7 +45,7 @@ void EmitVarDefinition(DocTranslatorObj* d, const Var& var, ExprDoc rhs);
 ExprDoc GlobalReference(DocTranslatorObj* d, const ffi::String& name);
 ExprDoc NamedCallCallee(const ffi::String& canonical_name);
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/script/printer/printer.cc b/src/script/printer/printer.cc
index 6df8d3043..7f13bdd2e 100644
--- a/src/script/printer/printer.cc
+++ b/src/script/printer/printer.cc
@@ -426,11 +426,11 @@ ffi::String RenderScript(const ffi::ObjectRef& obj, const PrinterConfig& config)
   if (config->path_to_underline.empty() && config->obj_to_underline.empty() &&
       config->path_to_annotate.empty() && config->obj_to_annotate.empty() &&
       !config->render_invisible_path_info) {
-    return details::RenderPythonScript(doc, config, header, {}, {});
+    return detail::RenderPythonScript(doc, config, header, {}, {});
   }
   MapDocPaths paths(obj, config);
   auto [underline_paths, annotations] = paths.Map(doc, origins);
-  return details::RenderPythonScript(doc, config, header, underline_paths, annotations);
+  return detail::RenderPythonScript(doc, config, header, underline_paths, annotations);
 }
 
 }  // namespace
diff --git a/src/sym/canonical_simplify.cc b/src/sym/canonical_simplify.cc
index 5a609bd10..5fa2a5cdf 100644
--- a/src/sym/canonical_simplify.cc
+++ b/src/sym/canonical_simplify.cc
@@ -598,8 +598,8 @@ class CanonicalSimplifier::Impl : public RewriteSimplifier::Impl {
   // Bypass only this entry override; the parent checks the target and descendants stay virtual.
   TVM_FFI_INLINE UnchangedOr<PrimExpr> DirectMutate(
       const PrimExpr& value, InplaceMode inplace_mode = InplaceMode::kDisallow) {
-    return ffi::details::UnchangedOrUnsafe::MoveFromTVMFFIAny<PrimExpr>(
-        ffi::details::UnchangedOrUnsafe::MoveToTVMFFIAny(
+    return ffi::detail::UnchangedOrUnsafe::MoveFromTVMFFIAny<PrimExpr>(
+        ffi::detail::UnchangedOrUnsafe::MoveToTVMFFIAny(
             Rewriter::Mutate(ffi::AnyView(value), inplace_mode)));
   }
 
@@ -616,7 +616,7 @@ class CanonicalSimplifier::Impl : public RewriteSimplifier::Impl {
       }
       return expr;
     } catch (ffi::Error& error) {
-      ffi::details::UpdateVisitErrorContext(error, value);
+      ffi::detail::UpdateVisitErrorContext(error, value);
       throw;
     }
   }
diff --git a/src/sym/const_fold.h b/src/sym/const_fold.h
index cfe9c0ab1..fe2e9856f 100644
--- a/src/sym/const_fold.h
+++ b/src/sym/const_fold.h
@@ -32,8 +32,8 @@ namespace tvm {
 namespace sym {
 
 using prim::TryConstFold;
-using prim::details::IsIndexType;
-using prim::details::IsIndexTypedExpr;
+using prim::detail::IsIndexType;
+using prim::detail::IsIndexTypedExpr;
 
 }  // namespace sym
 }  // namespace tvm
diff --git a/src/sym/int_operator.h b/src/sym/int_operator.h
index 7e6bec980..14c3ba361 100644
--- a/src/sym/int_operator.h
+++ b/src/sym/int_operator.h
@@ -83,10 +83,10 @@ inline bool WillOverflow<prim::ModObj>(int64_t x, int64_t y, int64_t min_value,
   return y == 0;
 }
 
-using prim::details::floordiv;
-using prim::details::floormod;
-using prim::details::truncdiv;
-using prim::details::truncmod;
+using prim::detail::floordiv;
+using prim::detail::floormod;
+using prim::detail::truncdiv;
+using prim::detail::truncmod;
 
 /*!
  * \brief Take GCD of a and b.
diff --git a/src/sym/iter_affine_map.cc b/src/sym/iter_affine_map.cc
index b2940dc4b..d9a26e2fe 100644
--- a/src/sym/iter_affine_map.cc
+++ b/src/sym/iter_affine_map.cc
@@ -20,7 +20,7 @@
 /*!
  * \file src/sym/iter_affine_map.cc
  */
-#include <tvm/ffi/base_details.h>
+#include <tvm/ffi/base_detail.h>
 #include <tvm/ffi/cast.h>
 #include <tvm/ffi/expected.h>
 #include <tvm/ffi/extra/structural_visit.h>
@@ -312,8 +312,8 @@ class IterMapRewriter : public tvm::ExprMutator {
   // Bypass only this entry override; the parent checks the target and descendants stay virtual.
   TVM_FFI_INLINE UnchangedOr<PrimExpr> DirectMutate(
       const PrimExpr& value, InplaceMode inplace_mode = InplaceMode::kDisallow) {
-    return ffi::details::UnchangedOrUnsafe::MoveFromTVMFFIAny<PrimExpr>(
-        ffi::details::UnchangedOrUnsafe::MoveToTVMFFIAny(
+    return ffi::detail::UnchangedOrUnsafe::MoveFromTVMFFIAny<PrimExpr>(
+        ffi::detail::UnchangedOrUnsafe::MoveToTVMFFIAny(
             Parent::Mutate(ffi::AnyView(value), inplace_mode)));
   }
 
@@ -333,7 +333,7 @@ class IterMapRewriter : public tvm::ExprMutator {
       }
       return value;
     } catch (ffi::Error& error) {
-      ffi::details::UpdateVisitErrorContext(error, input);
+      ffi::detail::UpdateVisitErrorContext(error, input);
       throw;
     }
   }
@@ -414,8 +414,8 @@ class IterMapRewriter : public tvm::ExprMutator {
       // for now only hash on source index.
       size_t hash = value->args.size();
       for (const IterSplitExpr& arg : value->args) {
-        hash = ffi::details::StableHashCombine(hash,
-                                               std::hash<const ffi::Object*>()(arg->source.get()));
+        hash = ffi::detail::StableHashCombine(hash,
+                                              std::hash<const ffi::Object*>()(arg->source.get()));
       }
       return hash;
     }
diff --git a/src/target/target.cc b/src/target/target.cc
index b1dffa3e7..7c82dbe62 100644
--- a/src/target/target.cc
+++ b/src/target/target.cc
@@ -219,7 +219,7 @@ ffi::ObjectPtr<TargetObj> TargetInternal::FromString(
   if (ffi::Optional<Target> target =
           TargetTagRegistry::Global()->Get(tag_or_config_or_target_str)) {
     Target value = target.value();
-    return ffi::details::ObjectUnsafe::ObjectPtrFromObjectRef<TargetObj>(value);
+    return ffi::detail::ObjectUnsafe::ObjectPtrFromObjectRef<TargetObj>(value);
   }
   if (!tag_or_config_or_target_str.empty() && tag_or_config_or_target_str.data()[0] == '{') {
     return TargetInternal::FromConfigString(tag_or_config_or_target_str);
diff --git a/src/tirx/ir/function.cc b/src/tirx/ir/function.cc
index 4f20dc387..eb346a7e8 100644
--- a/src/tirx/ir/function.cc
+++ b/src/tirx/ir/function.cc
@@ -35,7 +35,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> FunctionVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: attrs (metadata), ty (derived from the function signature)
   const FunctionObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FunctionObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FunctionObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->WithDefRegionKind(
       kTVMFFIDefRegionKindPattern, [&]() { return visitor->VisitExpected(self->params); }));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->ret_type));
@@ -47,7 +47,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> FunctionMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: attrs (metadata), ty (derived from the function signature)
   const FunctionObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FunctionObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FunctionObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Var>>, mapped_params,
                                     mutator->WithDefRegionKind(kTVMFFIDefRegionKindPattern, [&]() {
                                       return mutator->MutateExpected(self->params);
@@ -78,7 +78,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> FunctionMaybeInplaceMut
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: attrs (metadata), ty (derived from the function signature)
   FunctionObj* self = const_cast<FunctionObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FunctionObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const FunctionObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Var>>, mapped_params,
                                     mutator->WithDefRegionKind(kTVMFFIDefRegionKindPattern, [&]() {
                                       return mutator->MutateExpected(self->params,
diff --git a/src/tirx/ir/layout/axis_registry.cc b/src/tirx/ir/layout/axis_registry.cc
index 0404c8642..e8e7aead8 100644
--- a/src/tirx/ir/layout/axis_registry.cc
+++ b/src/tirx/ir/layout/axis_registry.cc
@@ -32,7 +32,7 @@ namespace refl = tvm::ffi::reflection;
 /**************** Axis ****************/
 ffi::ObjectPtr<ffi::Object> CreateAxis(const std::string& name) {
   auto axis = Axis::Get(name);
-  return ffi::details::ObjectUnsafe::ObjectPtrFromObjectRef<ffi::Object>(axis);
+  return ffi::detail::ObjectUnsafe::ObjectPtrFromObjectRef<ffi::Object>(axis);
 }
 
 const ffi::EnumState& AxisEnumState() {
diff --git a/src/tirx/ir/layout/compose_layout.cc b/src/tirx/ir/layout/compose_layout.cc
index 97b4d29bf..ed712d83e 100644
--- a/src/tirx/ir/layout/compose_layout.cc
+++ b/src/tirx/ir/layout/compose_layout.cc
@@ -308,7 +308,7 @@ ComposeLayout::ComposeLayout(int per_element, int swizzle_len, int atom_len, Til
   n->swizzle_len = swizzle_len;
   n->atom_len = atom_len;
   n->swizzle_inner = swizzle_inner;
-  layout_details::CheckWellFormed(n.get());
+  layout_detail::CheckWellFormed(n.get());
   int swizzle_mask = (1 << swizzle_len) - 1;
   n->inner_mask = swizzle_mask;
   n->outer_mask = swizzle_mask << atom_len;
@@ -323,7 +323,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
   });
 }
 
-void layout_details::CheckWellFormed(const ComposeLayoutObj* layout) {
+void layout_detail::CheckWellFormed(const ComposeLayoutObj* layout) {
   TVM_FFI_CHECK(layout->per_element >= 0 && layout->swizzle_len >= 0 &&
                     layout->atom_len >= layout->swizzle_len,
                 ValueError)
@@ -332,27 +332,27 @@ void layout_details::CheckWellFormed(const ComposeLayoutObj* layout) {
   layout->tile_layout.CheckWellFormed();
 }
 
-PrimExpr layout_details::GetSize(const ComposeLayoutObj* layout,
-                                 ffi::Optional<ffi::String> axis_name) {
+PrimExpr layout_detail::GetSize(const ComposeLayoutObj* layout,
+                                ffi::Optional<ffi::String> axis_name) {
   TVM_FFI_ICHECK(!axis_name.has_value())
       << "ValueError: axis_name is not supported for compose layout";
   return layout->tile_layout.GetSize(axis_name);
 }
 
-PrimExpr layout_details::GetSpan(const ComposeLayoutObj* layout,
-                                 ffi::Optional<ffi::String> axis_name) {
+PrimExpr layout_detail::GetSpan(const ComposeLayoutObj* layout,
+                                ffi::Optional<ffi::String> axis_name) {
   TVM_FFI_ICHECK(!axis_name.has_value())
       << "ValueError: axis_name is not supported for compose layout";
   return layout->tile_layout.GetSpan(axis_name);
 }
 
-ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const ComposeLayoutObj* layout,
-                                                      ffi::Array<PrimExpr> coord) {
+ffi::Map<ffi::String, PrimExpr> layout_detail::Apply(const ComposeLayoutObj* layout,
+                                                     ffi::Array<PrimExpr> coord) {
   return ApplyStructured(layout, layout->tile_layout, std::move(coord));
 }
 
-ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const ComposeLayoutObj* layout,
-                                                      PrimExpr coord) {
+ffi::Map<ffi::String, PrimExpr> layout_detail::Apply(const ComposeLayoutObj* layout,
+                                                     PrimExpr coord) {
   auto res = layout->tile_layout.Apply(coord);
   TVM_FFI_ICHECK(res.size() == 1 && res.find("m") != res.end());
   auto m = res["m"];
@@ -371,9 +371,9 @@ ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const ComposeLayoutObj* la
       {"m", analyzer->Simplify((f(floordiv(m, base)) << layout->per_element) + floormod(m, base))}};
 }
 
-ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const ComposeLayoutObj* layout,
-                                                      const ffi::Array<PrimExpr>& coord,
-                                                      const ffi::Array<PrimExpr>& shape) {
+ffi::Map<ffi::String, PrimExpr> layout_detail::Apply(const ComposeLayoutObj* layout,
+                                                     const ffi::Array<PrimExpr>& coord,
+                                                     const ffi::Array<PrimExpr>& shape) {
   TVM_FFI_ICHECK_EQ(coord.size(), shape.size())
       << "ValueError: The size of coord and shape should be equal";
   auto grouped = TryGroup(layout->tile_layout, shape);
@@ -405,15 +405,15 @@ ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const ComposeLayoutObj* la
   return ApplyStructured(layout, grouped_tile, std::move(shard_coord));
 }
 
-Layout layout_details::Canonicalize(const ComposeLayoutObj* layout) {
+Layout layout_detail::Canonicalize(const ComposeLayoutObj* layout) {
   auto tile_normalized = layout->tile_layout.Canonicalize().as<TileLayout>().value();
   return ComposeLayout(layout->per_element, layout->swizzle_len, layout->atom_len, tile_normalized,
                        layout->swizzle_inner);
 }
 
-Layout layout_details::Tile(const ComposeLayoutObj* layout, const TileLayout& outer,
-                            const ffi::Array<PrimExpr>& outer_shape,
-                            const ffi::Array<PrimExpr>& inner_shape) {
+Layout layout_detail::Tile(const ComposeLayoutObj* layout, const TileLayout& outer,
+                           const ffi::Array<PrimExpr>& outer_shape,
+                           const ffi::Array<PrimExpr>& inner_shape) {
   // A bare swizzle (ComposeLayout with a trivial tile) carries only the swizzle
   // period, not a tile matching `inner_shape`; substitute an identity tile over
   // the inner product first, matching the former SwizzleLayoutNode::Tile.
diff --git a/src/tirx/ir/layout/layout.cc b/src/tirx/ir/layout/layout.cc
index 4a391f3c9..0c3fd7032 100644
--- a/src/tirx/ir/layout/layout.cc
+++ b/src/tirx/ir/layout/layout.cc
@@ -38,43 +38,43 @@ decltype(auto) DispatchLayout(const Layout& layout, F&& f) {
 }  // namespace
 
 void Layout::CheckWellFormed() const {
-  DispatchLayout(*this, [](const auto* node) { layout_details::CheckWellFormed(node); });
+  DispatchLayout(*this, [](const auto* node) { layout_detail::CheckWellFormed(node); });
 }
 
 PrimExpr Layout::GetSize(ffi::Optional<ffi::String> axis_name) const {
   return DispatchLayout(*this,
-                        [&](const auto* node) { return layout_details::GetSize(node, axis_name); });
+                        [&](const auto* node) { return layout_detail::GetSize(node, axis_name); });
 }
 
 PrimExpr Layout::GetSpan(ffi::Optional<ffi::String> axis_name) const {
   return DispatchLayout(*this,
-                        [&](const auto* node) { return layout_details::GetSpan(node, axis_name); });
+                        [&](const auto* node) { return layout_detail::GetSpan(node, axis_name); });
 }
 
 ffi::Map<ffi::String, PrimExpr> Layout::Apply(ffi::Array<PrimExpr> coord) const {
   return DispatchLayout(
-      *this, [&](const auto* node) { return layout_details::Apply(node, std::move(coord)); });
+      *this, [&](const auto* node) { return layout_detail::Apply(node, std::move(coord)); });
 }
 
 ffi::Map<ffi::String, PrimExpr> Layout::Apply(PrimExpr coord) const {
   return DispatchLayout(
-      *this, [&](const auto* node) { return layout_details::Apply(node, std::move(coord)); });
+      *this, [&](const auto* node) { return layout_detail::Apply(node, std::move(coord)); });
 }
 
 ffi::Map<ffi::String, PrimExpr> Layout::Apply(const ffi::Array<PrimExpr>& coord,
                                               const ffi::Array<PrimExpr>& shape) const {
-  return DispatchLayout(
-      *this, [&](const auto* node) { return layout_details::Apply(node, coord, shape); });
+  return DispatchLayout(*this,
+                        [&](const auto* node) { return layout_detail::Apply(node, coord, shape); });
 }
 
 Layout Layout::Canonicalize() const {
-  return DispatchLayout(*this, [](const auto* node) { return layout_details::Canonicalize(node); });
+  return DispatchLayout(*this, [](const auto* node) { return layout_detail::Canonicalize(node); });
 }
 
 Layout Layout::Tile(const TileLayout& outer, const ffi::Array<PrimExpr>& outer_shape,
                     const ffi::Array<PrimExpr>& inner_shape) const {
   return DispatchLayout(*this, [&](const auto* node) {
-    return layout_details::Tile(node, outer, outer_shape, inner_shape);
+    return layout_detail::Tile(node, outer, outer_shape, inner_shape);
   });
 }
 
diff --git a/src/tirx/ir/layout/tile_canonicalize.cc b/src/tirx/ir/layout/tile_canonicalize.cc
index 1f2341e29..a5560379f 100644
--- a/src/tirx/ir/layout/tile_canonicalize.cc
+++ b/src/tirx/ir/layout/tile_canonicalize.cc
@@ -119,7 +119,7 @@ TileLayout FuseAxesByScope(TileLayout layout) {
   return result;
 }
 
-Layout layout_details::Canonicalize(const TileLayoutObj* layout) {
+Layout layout_detail::Canonicalize(const TileLayoutObj* layout) {
   // 0. Remove unit iters in shard
   TileLayout res = RemoveUnitIters(ffi::GetRef<TileLayout>(layout));
   // 1. Remove zero offset
diff --git a/src/tirx/ir/layout/tile_core.cc b/src/tirx/ir/layout/tile_core.cc
index c1611ad8b..2aa72d120 100644
--- a/src/tirx/ir/layout/tile_core.cc
+++ b/src/tirx/ir/layout/tile_core.cc
@@ -38,7 +38,7 @@ namespace {
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> IterVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const IterObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IterObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IterObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->extent));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->stride));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->axis));
@@ -48,7 +48,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> IterVisit(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> IterMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const IterObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IterObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IterObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_extent,
                                     mutator->MutateExpected(self->extent));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimExpr>, mapped_stride,
@@ -69,7 +69,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> IterMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> IterMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   IterObj* self = const_cast<IterObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IterObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const IterObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
       ffi::UnchangedOr<PrimExpr>, mapped_extent,
       mutator->MutateExpected(self->extent, ffi::InplaceMode::kAllow));
@@ -91,7 +91,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> IterMaybeInplaceMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TileLayoutVisit(
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   const TileLayoutObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TileLayoutObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TileLayoutObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->shard));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->replica));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->offset));
@@ -101,7 +101,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TileLayoutVisit
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TileLayoutMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   const TileLayoutObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TileLayoutObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TileLayoutObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Iter>>, mapped_shard,
                                     mutator->MutateExpected(self->shard));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Iter>>, mapped_replica,
@@ -124,7 +124,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TileLayoutMutate(
 TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TileLayoutMaybeInplaceMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   TileLayoutObj* self = const_cast<TileLayoutObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TileLayoutObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TileLayoutObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<Iter>>, mapped_shard,
                                     mutator->MutateExpected(self->shard, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(
@@ -181,14 +181,13 @@ TVM_FFI_STATIC_INIT_BLOCK() {
   });
 }
 
-void layout_details::CheckWellFormed(const TileLayoutObj* layout) {
+void layout_detail::CheckWellFormed(const TileLayoutObj* layout) {
   const auto tile = ffi::GetRef<TileLayout>(layout);
   TVM_FFI_CHECK(tile.GetScope().has_value() || !tile.HasThreadAxis(), ValueError)
       << "A tile layout with thread axes must have a connected scope";
 }
 
-PrimExpr layout_details::GetSize(const TileLayoutObj* layout,
-                                 ffi::Optional<ffi::String> axis_name) {
+PrimExpr layout_detail::GetSize(const TileLayoutObj* layout, ffi::Optional<ffi::String> axis_name) {
   auto filter = [&](const Iter& iter, PrimExpr acc) {
     if (!axis_name.has_value() || iter->axis.name() == axis_name.value()) {
       return acc * iter->extent;
@@ -202,8 +201,7 @@ PrimExpr layout_details::GetSize(const TileLayoutObj* layout,
   return res;
 }
 
-PrimExpr layout_details::GetSpan(const TileLayoutObj* layout,
-                                 ffi::Optional<ffi::String> axis_name) {
+PrimExpr layout_detail::GetSpan(const TileLayoutObj* layout, ffi::Optional<ffi::String> axis_name) {
   sym::Analyzer analyzer;
   PrimExpr result = 1;
   auto filter = [&](const Axis& axis) { return AxisMatchesFilter(axis, axis_name); };
@@ -220,13 +218,13 @@ PrimExpr layout_details::GetSpan(const TileLayoutObj* layout,
   return analyzer->Simplify(result);
 }
 
-ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const TileLayoutObj* layout, PrimExpr coord) {
+ffi::Map<ffi::String, PrimExpr> layout_detail::Apply(const TileLayoutObj* layout, PrimExpr coord) {
   return Apply(layout, SplitCoord(coord, ffi::GetRef<TileLayout>(layout).GetShardShape()));
 }
 
-ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const TileLayoutObj* layout,
-                                                      const ffi::Array<PrimExpr>& coord,
-                                                      const ffi::Array<PrimExpr>& shape) {
+ffi::Map<ffi::String, PrimExpr> layout_detail::Apply(const TileLayoutObj* layout,
+                                                     const ffi::Array<PrimExpr>& coord,
+                                                     const ffi::Array<PrimExpr>& shape) {
   TVM_FFI_ICHECK_EQ(coord.size(), shape.size())
       << "ValueError: The size of coord and shape should be equal";
   // Group-first path: if this layout can be regrouped by ``shape`` (the input
@@ -263,8 +261,8 @@ ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const TileLayoutObj* layou
   return Apply(layout, FlattenCoord(coord, shape));
 }
 
-ffi::Map<ffi::String, PrimExpr> layout_details::Apply(const TileLayoutObj* layout,
-                                                      Array<PrimExpr> coord) {
+ffi::Map<ffi::String, PrimExpr> layout_detail::Apply(const TileLayoutObj* layout,
+                                                     Array<PrimExpr> coord) {
   sym::Analyzer analyzer;
   TVM_FFI_ICHECK_EQ(coord.size(), layout->shard.size())
       << "Coordinate size must match the number of shard axes";
diff --git a/src/tirx/ir/layout/tile_internal.h b/src/tirx/ir/layout/tile_internal.h
index f42042ea7..a067e5da6 100644
--- a/src/tirx/ir/layout/tile_internal.h
+++ b/src/tirx/ir/layout/tile_internal.h
@@ -30,7 +30,7 @@
 namespace tvm {
 namespace tirx {
 
-namespace layout_details {
+namespace layout_detail {
 
 void CheckWellFormed(const TileLayoutObj* layout);
 PrimExpr GetSize(const TileLayoutObj* layout, ffi::Optional<ffi::String> axis_name);
@@ -56,7 +56,7 @@ Layout Canonicalize(const ComposeLayoutObj* layout);
 Layout Tile(const ComposeLayoutObj* layout, const TileLayout& outer,
             const ffi::Array<PrimExpr>& outer_shape, const ffi::Array<PrimExpr>& inner_shape);
 
-}  // namespace layout_details
+}  // namespace layout_detail
 
 // Group a tile layout's shard by a logical shape, returning the grouped layout and separators.
 std::pair<TileLayout, std::vector<int64_t>> Group(TileLayout layout,
diff --git a/src/tirx/ir/layout/tile_tile_ops.cc b/src/tirx/ir/layout/tile_tile_ops.cc
index 72dc822fa..aa134c28d 100644
--- a/src/tirx/ir/layout/tile_tile_ops.cc
+++ b/src/tirx/ir/layout/tile_tile_ops.cc
@@ -122,9 +122,8 @@ TVM_FFI_STATIC_INIT_BLOCK() {
       });
 }
 
-Layout layout_details::Tile(const TileLayoutObj* layout, const TileLayout& outer_in,
-                            const Array<PrimExpr>& outer_shape,
-                            const Array<PrimExpr>& inner_shape) {
+Layout layout_detail::Tile(const TileLayoutObj* layout, const TileLayout& outer_in,
+                           const Array<PrimExpr>& outer_shape, const Array<PrimExpr>& inner_shape) {
   auto outer = outer_in.Canonicalize().as<TileLayout>().value();
   auto inner = ffi::GetRef<TileLayout>(layout).Canonicalize().as<TileLayout>().value();
 
diff --git a/src/tirx/ir/type.cc b/src/tirx/ir/type.cc
index 7f8261d27..bae5fbc14 100644
--- a/src/tirx/ir/type.cc
+++ b/src/tirx/ir/type.cc
@@ -101,7 +101,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::Optional<ffi::VisitInterrupt>> TensorTypeVisit
     ffi::StructuralVisitorObj* visitor, ffi::AnyView value) noexcept {
   // skips: scope, data_alignment
   const TensorTypeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorTypeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorTypeObj>(value);
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->dtype));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->shape));
   TVM_FFI_S_VISIT_MAYBE_EARLY_RETURN(visitor->VisitExpected(self->layout));
@@ -112,7 +112,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorTypeMutate(
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: scope, data_alignment
   const TensorTypeObj* self =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorTypeObj>(value);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorTypeObj>(value);
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimType>, mapped_dtype,
                                     mutator->MutateExpected(self->dtype));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<PrimExpr>>, mapped_shape,
@@ -134,7 +134,7 @@ TVM_FFI_INLINE ffi::Expected<ffi::UnchangedOr<ffi::Any>> TensorTypeMaybeInplaceM
     ffi::StructuralMutatorObj* mutator, ffi::AnyView value) noexcept {
   // skips: scope, data_alignment
   TensorTypeObj* self = const_cast<TensorTypeObj*>(
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorTypeObj>(value));
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorTypeObj>(value));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<PrimType>, mapped_dtype,
                                     mutator->MutateExpected(self->dtype, ffi::InplaceMode::kAllow));
   TVM_FFI_S_MUTATE_ASSIGN_OR_RETURN(ffi::UnchangedOr<ffi::Array<PrimExpr>>, mapped_shape,
diff --git a/src/tirx/op/math.cc b/src/tirx/op/math.cc
index 07b9999c6..5f03e3d43 100644
--- a/src/tirx/op/math.cc
+++ b/src/tirx/op/math.cc
@@ -30,7 +30,7 @@ namespace tvm {
 namespace tirx {
 
 using namespace prim;
-using namespace prim::details;
+using namespace prim::detail;
 
 PrimExpr logaddexp(PrimExpr a, PrimExpr b, Location loc) {
   TVM_FFI_ICHECK(a.ty().MatchesCode(DLDataTypeCode::kDLFloat)) << a;
diff --git a/src/tirx/script/ir_builder/ir.cc b/src/tirx/script/ir_builder/ir.cc
index 3b5700aee..4eeca9af6 100644
--- a/src/tirx/script/ir_builder/ir.cc
+++ b/src/tirx/script/ir_builder/ir.cc
@@ -69,7 +69,7 @@ FunctionFrame Function(bool is_private, bool persistent, bool is_declaration) {
 
 Var Arg(ffi::String name, Var var) {
   FunctionFrame frame = FindFunctionFrame("T.Arg");
-  details::Namer::Name(var, name);
+  detail::Namer::Name(var, name);
   frame->args.push_back(var);
   return var;
 }
@@ -197,7 +197,7 @@ Var Ptr(PrimType dtype, runtime::MemoryScope storage_scope = {}) {
   return tvm::Var("", type_annotation);
 }
 
-using tvm::script::ir_builder::details::Namer;
+using tvm::script::ir_builder::detail::Namer;
 
 TVM_FFI_STATIC_INIT_BLOCK() {
   Namer::vtable().SetDispatch<TensorLoadObj>(
diff --git a/src/tirx/script/printer/block.cc b/src/tirx/script/printer/block.cc
index e899d4735..2eab8b49a 100644
--- a/src/tirx/script/printer/block.cc
+++ b/src/tirx/script/printer/block.cc
@@ -29,14 +29,14 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
 ffi::Optional<ExprDoc> ThreadScopeDocTranslate(DocTranslatorObj*, ffi::AnyView input,
                                                const ffi::Object*) {
   const auto* scope =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::ThreadScopeObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::ThreadScopeObj>(input);
   return NamespaceDoc("tirx")
       ->Attr("ThreadScope")
       ->Call({LiteralDoc::Str(scope->name(), std::nullopt)});
@@ -50,7 +50,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/tirx/script/printer/expr.cc b/src/tirx/script/printer/expr.cc
index 26886a83b..5fb3457cc 100644
--- a/src/tirx/script/printer/expr.cc
+++ b/src/tirx/script/printer/expr.cc
@@ -42,14 +42,14 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
 ffi::Optional<ExprDoc> IndexMapDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                             const ffi::Object*) {
   const auto* map =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::IndexMapObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::IndexMapObj>(input);
   auto translate_lambda = [&](const tirx::IndexMapObj* node) -> ExprDoc {
     ffi::Array<IdDoc> vars;
     for (const PrimVar& var : node->initial_indices) vars.push_back(VarDoc(d, var));
@@ -77,7 +77,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> LLVMIntrinsicDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                                  const ffi::Object*) {
   const auto* call =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(input);
   if (call->attrs.has_value() || !call->ty_args.empty() || call->args.empty() ||
       !call->ty.as<PrimType>()) {
     return RawCallDocTranslate(d, call);
@@ -167,7 +167,7 @@ namespace {
 ffi::Optional<ExprDoc> TensorDataPtrDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                                  const ffi::Object*) {
   const auto* call =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(input);
   if (call->attrs.has_value() || !call->ty_args.empty() || call->args.size() != 1)
     return RawCallDocTranslate(d, call);
   return d->Translate(call->args[0]).value()->Attr("data");
@@ -178,7 +178,7 @@ ffi::Optional<ExprDoc> TensorDataPtrDocTranslate(DocTranslatorObj* d, ffi::AnyVi
 ffi::Optional<ExprDoc> PTXCallDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                            const ffi::Object*) {
   const auto* call =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const CallObj>(input);
   if (IsPTXAddressCall(call) || call->attrs.has_value() || !call->ty_args.empty() ||
       !ffi::StructuralEqual()(call->ty, PrimType::Void()))
     return RawCallDocTranslate(d, call);
@@ -215,7 +215,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 }
 
 }  // namespace
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 
diff --git a/src/tirx/script/printer/for_loop.cc b/src/tirx/script/printer/for_loop.cc
index 74c54dd3d..845fcb66b 100644
--- a/src/tirx/script/printer/for_loop.cc
+++ b/src/tirx/script/printer/for_loop.cc
@@ -32,14 +32,13 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
 ffi::Optional<ExprDoc> ForDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                        const ffi::Object* destination) {
-  const auto* loop =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ForObj>(input);
+  const auto* loop = ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const ForObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   ffi::String method;
@@ -131,7 +130,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/tirx/script/printer/function.cc b/src/tirx/script/printer/function.cc
index b5e243e83..96271e0fe 100644
--- a/src/tirx/script/printer/function.cc
+++ b/src/tirx/script/printer/function.cc
@@ -37,7 +37,7 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
@@ -155,7 +155,7 @@ void PrintFunction(DocTranslatorObj* d, const tirx::FunctionObj* func, ExprDoc d
 ffi::Optional<ExprDoc> TirxFunctionDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                                 const ffi::Object* destination) {
   const auto* func =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::FunctionObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::FunctionObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   auto construction_namespace = func->GetAttr(tvm::attr::kScriptNamespace).value_or("tirx");
@@ -172,7 +172,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/tirx/script/printer/ir.cc b/src/tirx/script/printer/ir.cc
index 1c04aaa2e..a71f1847c 100644
--- a/src/tirx/script/printer/ir.cc
+++ b/src/tirx/script/printer/ir.cc
@@ -29,14 +29,14 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
 ffi::Optional<ExprDoc> TargetDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                           const ffi::Object*) {
   const auto* target =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TargetObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TargetObj>(input);
   return NamespaceDoc("tirx")->Attr("target")->Call({d->Translate(target->ToConfig()).value()});
 }
 
@@ -48,7 +48,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/tirx/script/printer/stmt.cc b/src/tirx/script/printer/stmt.cc
index bfc7129f5..e03a01d12 100644
--- a/src/tirx/script/printer/stmt.cc
+++ b/src/tirx/script/printer/stmt.cc
@@ -37,14 +37,14 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
 ffi::Optional<ExprDoc> EvaluateDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                             const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const EvaluateObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const EvaluateObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   ExprDoc value = d->Translate(stmt->value).value();
@@ -67,7 +67,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> SeqStmtDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                            const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SeqStmtObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const SeqStmtObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   for (const Stmt& child : stmt->seq) {
@@ -85,7 +85,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> RegionStmtDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                               const ffi::Object* destination) {
   const auto* stmt =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RegionStmtObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const RegionStmtObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   TVM_FFI_CHECK(stmt->result_vars.empty(), ValueError)
@@ -127,7 +127,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/src/tirx/script/printer/tensor.cc b/src/tirx/script/printer/tensor.cc
index 94007235a..8e0478a33 100644
--- a/src/tirx/script/printer/tensor.cc
+++ b/src/tirx/script/printer/tensor.cc
@@ -34,14 +34,14 @@
 namespace tvm {
 namespace script {
 namespace printer {
-namespace details {
+namespace detail {
 
 namespace {
 
 ffi::Optional<ExprDoc> TensorTypeDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                               const ffi::Object*) {
   const auto* tensor =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::TensorTypeObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::TensorTypeObj>(input);
   // The tensor type constructor normalizes these fields.
   // Keep the explicit type constructor when that normalization would change the IR.
   if (tensor->data_alignment <= 0) {
@@ -102,7 +102,7 @@ namespace {
 ffi::Optional<ExprDoc> TensorStoreDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                                const ffi::Object* destination) {
   const auto* store =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorStoreObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const TensorStoreObj>(input);
   TVM_FFI_CHECK(destination == nullptr, TypeError)
       << "printer statement-only node cannot fulfill a destination";
   ExprDoc tensor = d->Translate(store->dest).value();
@@ -121,7 +121,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> IterDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                         const ffi::Object*) {
   const auto* iter =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::IterObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::IterObj>(input);
   ExprDoc axis = LiteralDoc::Str(iter->axis.name(), std::nullopt);
   d->RecordOrigin(axis, iter->axis);
   return NamespaceDoc("tirx")->Attr("Iter")->Call(
@@ -137,7 +137,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> TileLayoutDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                               const ffi::Object*) {
   const auto* layout =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::TileLayoutObj>(input);
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::TileLayoutObj>(input);
   auto iters = [&](const ffi::Array<tirx::Iter>& source) {
     ffi::Array<ExprDoc> docs;
     for (const tirx::Iter& iter : source) {
@@ -174,7 +174,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 ffi::Optional<ExprDoc> ComposeLayoutDocTranslate(DocTranslatorObj* d, ffi::AnyView input,
                                                  const ffi::Object*) {
   const auto* layout =
-      ffi::details::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::ComposeLayoutObj>(
+      ffi::detail::AnyUnsafe::RawObjectPtrFromAnyViewAfterCheck<const tirx::ComposeLayoutObj>(
           input);
   ffi::Array<ffi::String> keys;
   ffi::Array<ExprDoc> values;
@@ -200,7 +200,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 
 }  // namespace
 
-}  // namespace details
+}  // namespace detail
 }  // namespace printer
 }  // namespace script
 }  // namespace tvm
diff --git a/tests/cpp/runtime/backend_workspace_test.cc b/tests/cpp/runtime/backend_workspace_test.cc
index 3f6284e14..285b4c141 100644
--- a/tests/cpp/runtime/backend_workspace_test.cc
+++ b/tests/cpp/runtime/backend_workspace_test.cc
@@ -39,14 +39,14 @@ TEST(BackendWorkspace, AllocAndFreeOnCPU) {
 TEST(BackendWorkspace, AllocFailureIsReportedThroughCAPI) {
   void* ptr = TVMBackendAllocWorkspace(kUnavailableDeviceType, 0, 64, kDLFloat, 32);
   EXPECT_EQ(ptr, nullptr);
-  ffi::Error error = ffi::details::MoveFromSafeCallRaised();
+  ffi::Error error = ffi::detail::MoveFromSafeCallRaised();
   EXPECT_FALSE(error.message().empty());
 }
 
 TEST(BackendWorkspace, FreeFailureIsReportedThroughCAPI) {
   int dummy = 0;
   EXPECT_EQ(TVMBackendFreeWorkspace(kUnavailableDeviceType, 0, &dummy), -1);
-  ffi::Error error = ffi::details::MoveFromSafeCallRaised();
+  ffi::Error error = ffi::detail::MoveFromSafeCallRaised();
   EXPECT_FALSE(error.message().empty());
 }