Fix QPY serialization.

We need to reject types with const=True in QPY until it supports them.

For now, I've also made the Index and shift operator constructors
lift their RHS to the same const-ness as the target to make it
less likely that existing users of expr run into issues when
serializing to older QPY versions.

Author: kevinhartman

qiskit/circuit/classical/expr/constructors.py

@@ -543,7 +543,7 @@ def _shift_like(
         left = _coerce_lossless(left, type) if type is not None else left
     else:
         left = lift(left, type)
-    right = lift(right)
+    right = lift(right, try_const=left.type.const)
     if left.type.kind != types.Uint or right.type.kind != types.Uint:
         raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
     return Binary(
@@ -616,7 +616,8 @@ def index(target: typing.Any, index: typing.Any, /) -> Expr:
             >>> expr.index(ClassicalRegister(8, "a"), 3)
             Index(Var(ClassicalRegister(8, "a"), Uint(8, const=False)), Value(3, Uint(2, const=True)), Bool(const=False))
     """
-    target, index = lift(target), lift(index)
+    target = lift(target)
+    index = lift(index, try_const=target.type.const)
     if target.type.kind is not types.Uint or index.type.kind is not types.Uint:
         raise TypeError(f"invalid types for indexing: '{target.type}' and '{index.type}'")
     return Index(target, index, types.Bool(const=target.type.const and index.type.const))

qiskit/qpy/binary_io/value.py

@@ -367,9 +367,10 @@ def _write_expr(
 
 
 def _write_expr_type(file_obj, type_: types.Type):
-    if type_.kind is types.Bool:
+    # Currently, QPY doesn't support const types
+    if type_.kind is types.Bool and not type_.const:
         file_obj.write(type_keys.ExprType.BOOL)
-    elif type_.kind is types.Uint:
+    elif type_.kind is types.Uint and not type_.const:
         file_obj.write(type_keys.ExprType.UINT)
         file_obj.write(
             struct.pack(formats.EXPR_TYPE_UINT_PACK, *formats.EXPR_TYPE_UINT(type_.width))

test/python/circuit/classical/test_expr_constructors.py

@@ -529,9 +529,7 @@ def test_index_explicit(self):
 
         self.assertEqual(
             expr.index(cr, 3),
-            expr.Index(
-                expr.Var(cr, types.Uint(4)), expr.Value(3, types.Uint(2, const=True)), types.Bool()
-            ),
+            expr.Index(expr.Var(cr, types.Uint(4)), expr.Value(3, types.Uint(2)), types.Bool()),
         )
         self.assertEqual(
             expr.index(a, cr),
@@ -557,23 +555,29 @@ def test_shift_explicit(self, function, opcode):
             expr.Binary(
                 opcode,
                 expr.Var(cr, types.Uint(8)),
-                expr.Value(5, types.Uint(3, const=True)),
+                expr.Value(5, types.Uint(3)),
                 types.Uint(8),
             ),
         )
         self.assertEqual(
             function(a, cr),
             expr.Binary(opcode, a, expr.Var(cr, types.Uint(8)), types.Uint(4)),
         )
-        # TODO: as it is, the LHS of a shift expression always becomes exactly the explicit
-        #  type passed to `shift_*`. The RHS is inferred with lift, and stays const if it's
-        #  const. Is this the best behavior?
+        self.assertEqual(
+            function(3, 5),
+            expr.Binary(
+                opcode,
+                expr.Value(3, types.Uint(2, const=True)),
+                expr.Value(5, types.Uint(3, const=True)),
+                types.Uint(2, const=True),
+            ),
+        )
         self.assertEqual(
             function(3, 5, types.Uint(8)),
             expr.Binary(
                 opcode,
                 expr.Value(3, types.Uint(8)),
-                expr.Value(5, types.Uint(3, const=True)),
+                expr.Value(5, types.Uint(3)),
                 types.Uint(8),
             ),
         )