feat: add runtime TypeSchema and TypeChecker for dynamic type conversion

Add C++ runtime equivalents of the Python TypeSchema class:
- TypeSchema: data class describing FFI types via recursive {origin, args}
  structure, with JSON parsing and human-readable Repr()
- TypeChecker: pre-compiled converter that resolves type schemas to
  efficient enum dispatch at construction time, providing TryCast
  (with coercion), Cast (throwing), and CheckStrict (exact match)

Supports all FFI types: POD (int/float/bool/None), String, Bytes,
DataType, Device, Object hierarchy, Optional, Array, List, Map,
Variant, Tuple, and Callable. Container conversion uses fast-path
(zero-copy when elements match) and slow-path (element-by-element
conversion) following the same pattern as compile-time TypeTraits.

Author: junrushao

CMakeLists.txt

@@ -85,6 +85,7 @@ set(_tvm_ffi_extra_objs_sources
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ffi/extra/library_module_dynamic_lib.cc"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ffi/extra/env_context.cc"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/ffi/extra/env_c_api.cc"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/ffi/extra/type_checker.cc"
 )
 if (TVM_FFI_USE_EXTRA_CXX_API)
   list(APPEND _tvm_ffi_objs_sources ${_tvm_ffi_extra_objs_sources})

include/tvm/ffi/extra/type_checker.h

@@ -0,0 +1,177 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/*!
+ * \file tvm/ffi/extra/type_checker.h
+ * \brief Runtime type schema and type checker/converter.
+ *
+ * TypeSchema is a runtime data class describing an FFI type via a recursive
+ * {origin, args} structure (the C++ counterpart of the Python TypeSchema).
+ *
+ * TypeChecker is a pre-compiled converter built from a TypeSchema.  It
+ * provides efficient runtime type checking and conversion — the dynamic
+ * equivalent of the compile-time `AnyView::cast<T>()` / `TypeTraits<T>`.
+ */
+#ifndef TVM_FFI_EXTRA_TYPE_CHECKER_H_
+#define TVM_FFI_EXTRA_TYPE_CHECKER_H_
+
+#include <tvm/ffi/any.h>
+#include <tvm/ffi/extra/base.h>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace tvm {
+namespace ffi {
+
+/*!
+ * \brief Runtime type schema describing an FFI type.
+ *
+ * Mirrors the Python `TypeSchema` class.  The schema is expressed as a
+ * recursive structure with an `origin` type name and optional `args`
+ * (type arguments for generic/container types).
+ *
+ * Examples of JSON representations parsed by this class:
+ * - `{"type":"int"}`
+ * - `{"type":"Optional","args":[{"type":"ffi.String"}]}`
+ * - `{"type":"ffi.Array","args":[{"type":"int"}]}`
+ * - `{"type":"ffi.Map","args":[{"type":"ffi.String"},{"type":"int"}]}`
+ */
+struct TypeSchema {
+  /*! \brief The origin type name (e.g. "int", "ffi.Array", "Optional"). */
+  std::string origin;
+  /*! \brief Recursive type arguments (e.g. element type for Array). */
+  std::vector<TypeSchema> args;
+
+  /*!
+   * \brief Construct a TypeSchema from a parsed JSON value.
+   * \param obj A json::Object (Map<Any,Any>) with key "type" and optional "args".
+   * \return The constructed TypeSchema.
+   */
+  TVM_FFI_EXTRA_CXX_API static TypeSchema FromJSON(const Any& obj);
+
+  /*!
+   * \brief Construct a TypeSchema from a JSON string.
+   * \param json_str The JSON string to parse.
+   * \return The constructed TypeSchema.
+   */
+  TVM_FFI_EXTRA_CXX_API static TypeSchema FromJSONStr(const String& json_str);
+
+  /*!
+   * \brief Render a human-readable representation.
+   *
+   * Uses Python-style typing syntax:
+   * - Unions: `"T1 | T2"`
+   * - Optional: `"T | None"`
+   * - Callables: `"Callable[[arg1, ...], ret]"`
+   * - Containers: `"origin[arg1, ...]"`
+   *
+   * \return A human-readable string.
+   */
+  TVM_FFI_EXTRA_CXX_API std::string Repr() const;
+};
+
+/*!
+ * \brief Pre-compiled type checker/converter built from a TypeSchema.
+ *
+ * On construction, the checker resolves the schema's origin string to an
+ * efficient internal enum and pre-resolves any object type keys to runtime
+ * type indices.  This makes subsequent TryCast / CheckStrict calls fast
+ * (no string comparisons on the hot path).
+ *
+ * The conversion semantics match the compile-time `TypeTraits<T>` system:
+ * - `CheckStrict` ↔ `TypeTraits<T>::CheckAnyStrict`
+ * - `TryCast` ↔ `TypeTraits<T>::TryCastFromAnyView`
+ */
+class TypeChecker {
+ public:
+  /*!
+   * \brief Construct a TypeChecker from a TypeSchema.
+   * \param schema The type schema to compile.
+   */
+  TVM_FFI_EXTRA_CXX_API explicit TypeChecker(TypeSchema schema);
+
+  /*!
+   * \brief Try to convert src to the target type.
+   *
+   * May apply type coercion (e.g. int→float, List→Array with element
+   * conversion).  Returns std::nullopt if conversion is not possible.
+   *
+   * \param src The input value.
+   * \return The converted value, or std::nullopt.
+   */
+  TVM_FFI_EXTRA_CXX_API std::optional<Any> TryCast(AnyView src) const;
+
+  /*!
+   * \brief Convert src to the target type, or throw TypeError.
+   * \param src The input value.
+   * \return The converted value.
+   */
+  TVM_FFI_EXTRA_CXX_API Any Cast(AnyView src) const;
+
+  /*!
+   * \brief Check if src strictly matches the target type (no conversion).
+   *
+   * For containers this recursively checks all elements.
+   *
+   * \param src The input value.
+   * \return True if the value exactly matches the expected type.
+   */
+  TVM_FFI_EXTRA_CXX_API bool CheckStrict(AnyView src) const;
+
+  /*! \return The underlying TypeSchema. */
+  const TypeSchema& schema() const { return schema_; }
+
+ private:
+  /*! \brief Dispatch tag for efficient runtime type checking. */
+  enum class Kind : uint8_t {
+    kAny,
+    kNone,
+    kInt,
+    kBool,
+    kFloat,
+    kStr,
+    kBytes,
+    kDataType,
+    kDevice,
+    kOpaquePtr,
+    kDLTensorPtr,
+    kObject,
+    kOptional,
+    kArray,
+    kList,
+    kMap,
+    kVariant,
+    kTuple,
+    kCallable,
+  };
+
+  /*! \brief Resolve a TypeSchema into Kind + type index. */
+  static Kind ResolveKind(const std::string& origin, int32_t* resolved_type_index);
+
+  Kind kind_;
+  int32_t resolved_type_index_{-1};
+  TypeSchema schema_;
+  std::vector<TypeChecker> args_;
+};
+
+}  // namespace ffi
+}  // namespace tvm
+
+#endif  // TVM_FFI_EXTRA_TYPE_CHECKER_H_