[REFACTOR][IR] Unify PrimExpr with Expr typed view

[tqchen]

Summary

• Make PrimExpr a typed C++ view over Expr values whose ExprNode::ty is PrimType, instead of using a separate runtime node class as the proof of primitive-ness.
• Use the shared ir::Call node for Relax, TIRX, and primitive-valued calls, while keeping primitive-only APIs explicit at their semantic boundaries.
• Keep Python on the general Expr surface for primitive-typed values so isinstance behavior does not imply a nominal primitive-expression subclass.

Design Rationale

The main advantage of this change is that common expression nodes such as Call can be unified without specializing each one to PrimType. A single ir::Call can represent a Relax tensor call, a Relax scalar call, or a primitive-valued intrinsic call; the result type stored in ExprNode::ty determines whether that particular value can be viewed as PrimExpr.

This keeps the IR node hierarchy focused on expression structure rather than result-type categories. Nodes that are intrinsically primitive, such as integer and floating-point literals or TIRX primitive operators, still have strongly typed C++ APIs and data structures. General nodes whose result type may vary, such as Call, remain general Expr nodes and are narrowed to PrimExpr only where primitive-only semantics are required.

The PR also keeps the compatibility surface practical: C++ primitive-only APIs continue to accept PrimExpr, Python exposes a compatibility predicate for checking the primitive typed category, and visitors/printers use one natural Call path rather than duplicating Relax and primitive call handling. Missing expression types are represented explicitly with Type::Missing() so constructors can leave type inference to later analysis without relying on nullable Type values.

[gemini-code-assist]

Code Review

This pull request refactors the TVM IR and Relax type systems by unifying primitive expressions under the base Expr class with a PrimType annotation, replacing the separate PrimExpr class. It also introduces Type::Missing() as a sentinel for unpopulated type information. The review feedback highlights a potential compiler crash in src/relax/op/op.cc when DeriveCallRetType returns Type::Missing(), and suggests several code simplifications, such as using ffi::downcast in C++ and utilizing the is_prim_expr helper in Python instead of manual type checks.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[tqchen]

Follow-up for the latest review batch is pushed in 27aef69ffc31cfbbf2c7efb6072a1f7dfc9c1a44.

• Added the missing Type::Missing() guard before TIRVarsInType in call_tir output inference, with a regression test for an uninferrable output shape.
• Replaced the local unsafe object construction in TypedExpr::ty() with the public checked path: Type::as<ExpectedType::ContainerType>() plus ffi::GetRef<ExpectedType>(). This checkout does not provide a free-function ffi::downcast.
• Kept the explicit Python Expr plus PrimType checks in the reviewed construction/dispatch paths so those local boundaries continue to spell out the typed-category condition; tvm.ir.is_prim_expr remains the compatibility predicate elsewhere.