Code optimization leads to unexpected values when using quantized types

[lucifer1004]

Describe the bug

Code optimization leads to unexpected values when using quantized types.

To Reproduce

import taichi as ti

ti.init(arch=ti.cpu, print_ir=True, offline_cache=False)

i4 = ti.types.quant.int(4)
f = ti.field(dtype=i4)
v = ti.BitpackedFields(max_num_bits=32)
v.place(f)
ti.root.dense(ti.i, (4,)).place(v)

@ti.kernel
def fn():
    for i in f:
        f[i] = 100 * i
        print(f[i])

fn()

Log/Screenshots

[Taichi] version 1.5.0, llvm 15.0.4, commit 7b885c28, linux, python 3.10.6
[Taichi] Starting on arch=x64
...
kernel {
$0 = offloaded range_for(0, 4) grid_dim=0 block_dim=4 
body {
  <i32> $1 = loop $0 index 0
  <i32> $2 = const 100
  <i32> $3 = mul $1 $2
  <*gen> $4 = get root [S0root][root]
  <i32> $5 = const 0
  <*gen> $6 = [S0root][root]::lookup($4, $5) activate = false
  <*gen> $7 = get child [S0root->S1dense] $6
  <*gen> $8 = [S1dense][dense]::lookup($7, $1) activate = false
  <*bs(0: qi4@0)> $9 = get child [S1dense->S2bit_struct<bs(0: qi4@0)>] $8
  <*gen> $10 = [S2bit_struct<bs(0: qi4@0)>][bit_struct]::lookup($9, $5) activate = false
  $11 : atomic bit_struct_store $10, ch_ids=[0], values=[$3]
  print $3, "\n"
}
}
0
100
200
300

Additional comments

As the log shows, print(f[i]) is optimized to print(100 * i); however, f[i] is a 4-bit integer here, so the actual value of f[i] is wrapped and does not equal to 100 * i.

I think this can lead to some bugs that cannot be easily discovered in practice, and there should be a way to handle this.