instr: allow to coerce int to FormatValue for backward compatibility

Author: MatthieuDartiailh

src/bytecode/instr.py

@@ -985,13 +985,18 @@ def _check_arg(self, name: str, opcode: int, arg: InstrArg) -> None:
 
         elif opcode in BINARY_OPS:
             if not isinstance(arg, BinaryOp):
-                try:
-                    arg = BinaryOp(arg)
-                except Exception as e:
-                    raise TypeError(
-                        "operation %s argument type must be "
-                        "coercible to BinaryOp, got %s" % (name, type(arg).__name__)
-                    ) from e
+                if isinstance(arg, int):
+                    try:
+                        arg = BinaryOp(arg)
+                    except Exception as e:
+                        raise TypeError(
+                            "operation %s argument type must be "
+                            "coercible to BinaryOp, got %s" % (name, type(arg).__name__)
+                        ) from e
+                raise TypeError(
+                    "operation %s argument type must be "
+                    "BinaryOp, got %s" % (name, type(arg).__name__)
+                )
 
         # We do not enforce constant immortality since which constants are
         # immortal may differ between recompilation and execution.
@@ -1048,10 +1053,19 @@ def _check_arg(self, name: str, opcode: int, arg: InstrArg) -> None:
                         "got %s (value=%s)" % (name, type(arg).__name__, str(arg))
                     )
             elif not isinstance(arg, FormatValue):
-                raise TypeError(
-                    "operation %s argument must be a FormatValue] "
-                    "got %s (value=%s)" % (name, type(arg).__name__, str(arg))
-                )
+                if isinstance(arg, int):
+                    try:
+                        arg = FormatValue(arg)
+                    except Exception as e:
+                        raise TypeError(
+                            "operation %s argument must be a FormatValue] "
+                            "got %s (value=%s)" % (name, type(arg).__name__, str(arg))
+                        ) from e
+                else:
+                    raise TypeError(
+                        "operation %s argument must be a FormatValue] "
+                        "got %s (value=%s)" % (name, type(arg).__name__, str(arg))
+                    )
 
         elif opcode_has_argument(opcode):
             _check_arg_int(arg, name)

tests/test_bytecode.py

@@ -380,6 +380,7 @@ def func(a):
                     if PY314
                     else Instr("LOAD_FAST", "a", lineno=2),
                     Instr("CONVERT_VALUE", FormatValue.REPR, lineno=2),
+                    Instr("FORMAT_SIMPLE", lineno=2),
                     Instr("RETURN_VALUE", lineno=2),
                 ]
                 if PY313

tests/test_instr.py

@@ -195,20 +195,15 @@ def test_invalid_arg(self):
             self.assertRaises(ValueError, Instr, "LOAD_SMALL_INT", 256)
 
         for name in (opcode.opname[op] for op in FORMAT_VALUE_OPS):
-            if name == "CONVERT_VALUE":
-                Instr(name, FormatValue.STR)
-                self.assertRaises(TypeError, Instr, name, FormatValue.STR.value)
-                Instr(name, FormatValue.STR)
-                self.assertRaises(TypeError, Instr, name, FormatValue.STR.value)
-            elif name == "BUILD_INTERPOLATION":
+            if name in BITFLAG_OPCODES:
                 Instr(name, (True, FormatValue.STR))
                 Instr(name, (False, FormatValue.STR))
                 self.assertRaises(TypeError, Instr, name, True, FormatValue.STR)
                 self.assertRaises(TypeError, Instr, name, False, FormatValue.STR)
             else:
-                raise ValueError(
-                    f"expected CONVERT_VALUE or BUILD_INTERPOLATION but got {name=}"
-                )
+                Instr(name, FormatValue.STR)
+                Instr(name, FormatValue.STR.value)
+                self.assertRaises(TypeError, Instr, name, "STR")
 
         # EXTENDED_ARG
         self.assertRaises(ValueError, Instr, "EXTENDED_ARG", 0)