Explain the internal working of Truffle's AST specialization?

Every Truffle AST node starts life in an uninitialized/generic state - it doesn't yet know the concrete types of its operands.

flowchart LR
  A[Uninitialized node] --> B{First execution}
  B --> C[Observe operand types]
  C --> D[Rewrite node to specialized variant]
  D --> E{Types stay stable?}
  E -->|Yes| F[Stay specialized, compile efficiently]
  E -->|No| G[Rewrite again or fall back to generic]

1. On its first execution, the node inspects the actual runtime types of its inputs (e.g. two ints for an addition node).
2. It then rewrites itself in place in the AST to a specialized version (e.g. IntAddNode) that assumes those types and skips generic type-checking overhead.
3. If a later execution sees different types (e.g. a double instead of an int), the node rewrites itself again to a more general specialization, or ultimately to a fully generic fallback if types are too unstable.

This self-modifying-tree approach means the interpreter itself gets progressively faster the more it runs, and it gives the Graal compiler a stable, type-specialized shape to partially evaluate into efficient machine code, rather than having to speculate across all possible types every time.