depyo 1.0.2 → 1.0.3

package/lib/bytecode/python_3_13.js

@@ -66,19 +66,19 @@ const opcodes = [
     [60, new OpCode(OpCodes.CONVERT_VALUE_A, "CONVERT_VALUE", {HasArgument: true})],
     [61, new OpCode(OpCodes.COPY_A, "COPY", {HasArgument: true})],
     [62, new OpCode(OpCodes.COPY_FREE_VARS_A, "COPY_FREE_VARS", {HasArgument: true})],
-    [63, new OpCode(OpCodes.DELETE_ATTR_A, "DELETE_ATTR", {HasArgument: true})],
-    [64, new OpCode(OpCodes.DELETE_DEREF_A, "DELETE_DEREF", {HasArgument: true})],
-    [65, new OpCode(OpCodes.DELETE_FAST_A, "DELETE_FAST", {HasArgument: true})],
-    [66, new OpCode(OpCodes.DELETE_GLOBAL_A, "DELETE_GLOBAL", {HasArgument: true})],
-    [67, new OpCode(OpCodes.DELETE_NAME_A, "DELETE_NAME", {HasArgument: true})],
+    [63, new OpCode(OpCodes.DELETE_ATTR_A, "DELETE_ATTR", {HasArgument: true, HasName: true})],
+    [64, new OpCode(OpCodes.DELETE_DEREF_A, "DELETE_DEREF", {HasArgument: true, HasFree: true})],
+    [65, new OpCode(OpCodes.DELETE_FAST_A, "DELETE_FAST", {HasArgument: true, HasLocal: true})],
+    [66, new OpCode(OpCodes.DELETE_GLOBAL_A, "DELETE_GLOBAL", {HasArgument: true, HasName: true})],
+    [67, new OpCode(OpCodes.DELETE_NAME_A, "DELETE_NAME", {HasArgument: true, HasName: true})],
     [68, new OpCode(OpCodes.DICT_MERGE_A, "DICT_MERGE", {HasArgument: true})],
     [69, new OpCode(OpCodes.DICT_UPDATE_A, "DICT_UPDATE", {HasArgument: true})],
     [70, new OpCode(OpCodes.ENTER_EXECUTOR_A, "ENTER_EXECUTOR", {HasArgument: true})],
     [71, new OpCode(OpCodes.EXTENDED_ARG_A, "EXTENDED_ARG", {HasArgument: true})],
     [72, new OpCode(OpCodes.FOR_ITER_A, "FOR_ITER", {HasArgument: true})],
     [73, new OpCode(OpCodes.GET_AWAITABLE_A, "GET_AWAITABLE", {HasArgument: true})],
-    [74, new OpCode(OpCodes.IMPORT_FROM_A, "IMPORT_FROM", {HasArgument: true})],
-    [75, new OpCode(OpCodes.IMPORT_NAME_A, "IMPORT_NAME", {HasArgument: true})],
+    [74, new OpCode(OpCodes.IMPORT_FROM_A, "IMPORT_FROM", {HasArgument: true, HasName: true})],
+    [75, new OpCode(OpCodes.IMPORT_NAME_A, "IMPORT_NAME", {HasArgument: true, HasName: true})],
     [76, new OpCode(OpCodes.IS_OP_A, "IS_OP", {HasArgument: true})],
     [77, new OpCode(OpCodes.JUMP_BACKWARD_A, "JUMP_BACKWARD", {HasArgument: true})],
     [78, new OpCode(OpCodes.JUMP_BACKWARD_NO_INTERRUPT_A, "JUMP_BACKWARD_NO_INTERRUPT", {HasArgument: true})],
@@ -87,17 +87,17 @@ const opcodes = [
     [81, new OpCode(OpCodes.LIST_EXTEND_A, "LIST_EXTEND", {HasArgument: true})],
     [82, new OpCode(OpCodes.LOAD_ATTR_A, "LOAD_ATTR", {HasArgument: true, HasName: true})],
     [83, new OpCode(OpCodes.LOAD_CONST_A, "LOAD_CONST", {HasArgument: true, HasConstant: true})],
-    [84, new OpCode(OpCodes.LOAD_DEREF_A, "LOAD_DEREF", {HasArgument: true})],
+    [84, new OpCode(OpCodes.LOAD_DEREF_A, "LOAD_DEREF", {HasArgument: true, HasFree: true})],
     [85, new OpCode(OpCodes.LOAD_FAST_A, "LOAD_FAST", {HasArgument: true, HasLocal: true})],
     [86, new OpCode(OpCodes.LOAD_FAST_AND_CLEAR_A, "LOAD_FAST_AND_CLEAR", {HasArgument: true, HasLocal: true})],
     [87, new OpCode(OpCodes.LOAD_FAST_CHECK_A, "LOAD_FAST_CHECK", {HasArgument: true, HasLocal: true})],
     [88, new OpCode(OpCodes.LOAD_FAST_LOAD_FAST_A, "LOAD_FAST_LOAD_FAST", {HasArgument: true, HasLocal: true})],
-    [89, new OpCode(OpCodes.LOAD_FROM_DICT_OR_DEREF_A, "LOAD_FROM_DICT_OR_DEREF", {HasArgument: true, HasLocal: true, HasName: true})],
+    [89, new OpCode(OpCodes.LOAD_FROM_DICT_OR_DEREF_A, "LOAD_FROM_DICT_OR_DEREF", {HasArgument: true, HasFree: true})],
     [90, new OpCode(OpCodes.LOAD_FROM_DICT_OR_GLOBALS_A, "LOAD_FROM_DICT_OR_GLOBALS", {HasArgument: true, HasName: true})],
     [91, new OpCode(OpCodes.LOAD_GLOBAL_A, "LOAD_GLOBAL", {HasArgument: true, HasName: true})],
     [92, new OpCode(OpCodes.LOAD_NAME_A, "LOAD_NAME", {HasArgument: true, HasName: true})],
-    [93, new OpCode(OpCodes.LOAD_SUPER_ATTR_A, "LOAD_SUPER_ATTR", {HasArgument: true})],
-    [94, new OpCode(OpCodes.MAKE_CELL_A, "MAKE_CELL", {HasArgument: true})],
+    [93, new OpCode(OpCodes.LOAD_SUPER_ATTR_A, "LOAD_SUPER_ATTR", {HasArgument: true, HasName: true})],
+    [94, new OpCode(OpCodes.MAKE_CELL_A, "MAKE_CELL", {HasArgument: true, HasFree: true})],
     [95, new OpCode(OpCodes.MAP_ADD_A, "MAP_ADD", {HasArgument: true})],
     [96, new OpCode(OpCodes.MATCH_CLASS_A, "MATCH_CLASS", {HasArgument: true})],
     [97, new OpCode(OpCodes.POP_JUMP_IF_FALSE_A, "POP_JUMP_IF_FALSE", {HasArgument: true})],
@@ -112,7 +112,7 @@ const opcodes = [
     [106, new OpCode(OpCodes.SET_FUNCTION_ATTRIBUTE_A, "SET_FUNCTION_ATTRIBUTE", {HasArgument: true})],
     [107, new OpCode(OpCodes.SET_UPDATE_A, "SET_UPDATE", {HasArgument: true})],
     [108, new OpCode(OpCodes.STORE_ATTR_A, "STORE_ATTR", {HasArgument: true, HasName: true})],
-    [109, new OpCode(OpCodes.STORE_DEREF_A, "STORE_DEREF", {HasArgument: true})],
+    [109, new OpCode(OpCodes.STORE_DEREF_A, "STORE_DEREF", {HasArgument: true, HasFree: true})],
     [110, new OpCode(OpCodes.STORE_FAST_A, "STORE_FAST", {HasArgument: true, HasLocal: true})],
     [111, new OpCode(OpCodes.STORE_FAST_LOAD_FAST_A, "STORE_FAST_LOAD_FAST", {HasArgument: true, HasLocal: true})],
     [112, new OpCode(OpCodes.STORE_FAST_STORE_FAST_A, "STORE_FAST_STORE_FAST", {HasArgument: true, HasLocal: true})],
@@ -144,7 +144,7 @@ const opcodes = [
     [254, new OpCode(OpCodes.INSTRUMENTED_LINE_A, "INSTRUMENTED_LINE", {HasArgument: true})],
     [256, new OpCode(OpCodes.JUMP_A, "JUMP", {HasArgument: true})],
     [257, new OpCode(OpCodes.JUMP_NO_INTERRUPT_A, "JUMP_NO_INTERRUPT", {HasArgument: true})],
-    [258, new OpCode(OpCodes.LOAD_CLOSURE_A, "LOAD_CLOSURE", {HasArgument: true})],
+    [258, new OpCode(OpCodes.LOAD_CLOSURE_A, "LOAD_CLOSURE", {HasArgument: true, HasFree: true})],
     [259, new OpCode(OpCodes.LOAD_METHOD_A, "LOAD_METHOD", {HasArgument: true})],
     [260, new OpCode(OpCodes.LOAD_SUPER_METHOD_A, "LOAD_SUPER_METHOD", {HasArgument: true})],
     [261, new OpCode(OpCodes.LOAD_ZERO_SUPER_ATTR_A, "LOAD_ZERO_SUPER_ATTR", {HasArgument: true})],

package/lib/bytecode/python_3_14.js

@@ -64,19 +64,19 @@ const opcodes = [
     [58, new OpCode(OpCodes.CONVERT_VALUE_A, "CONVERT_VALUE", {HasArgument: true})],
     [59, new OpCode(OpCodes.COPY_A, "COPY", {HasArgument: true})],
     [60, new OpCode(OpCodes.COPY_FREE_VARS_A, "COPY_FREE_VARS", {HasArgument: true})],
-    [61, new OpCode(OpCodes.DELETE_ATTR_A, "DELETE_ATTR", {HasArgument: true})],
-    [62, new OpCode(OpCodes.DELETE_DEREF_A, "DELETE_DEREF", {HasArgument: true})],
-    [63, new OpCode(OpCodes.DELETE_FAST_A, "DELETE_FAST", {HasArgument: true})],
-    [64, new OpCode(OpCodes.DELETE_GLOBAL_A, "DELETE_GLOBAL", {HasArgument: true})],
-    [65, new OpCode(OpCodes.DELETE_NAME_A, "DELETE_NAME", {HasArgument: true})],
+    [61, new OpCode(OpCodes.DELETE_ATTR_A, "DELETE_ATTR", {HasArgument: true, HasName: true})],
+    [62, new OpCode(OpCodes.DELETE_DEREF_A, "DELETE_DEREF", {HasArgument: true, HasFree: true})],
+    [63, new OpCode(OpCodes.DELETE_FAST_A, "DELETE_FAST", {HasArgument: true, HasLocal: true})],
+    [64, new OpCode(OpCodes.DELETE_GLOBAL_A, "DELETE_GLOBAL", {HasArgument: true, HasName: true})],
+    [65, new OpCode(OpCodes.DELETE_NAME_A, "DELETE_NAME", {HasArgument: true, HasName: true})],
     [66, new OpCode(OpCodes.DICT_MERGE_A, "DICT_MERGE", {HasArgument: true})],
     [67, new OpCode(OpCodes.DICT_UPDATE_A, "DICT_UPDATE", {HasArgument: true})],
     [68, new OpCode(OpCodes.END_ASYNC_FOR_A, "END_ASYNC_FOR", {HasArgument: true})],
     [69, new OpCode(OpCodes.EXTENDED_ARG_A, "EXTENDED_ARG", {HasArgument: true})],
     [70, new OpCode(OpCodes.FOR_ITER_A, "FOR_ITER", {HasArgument: true})],
     [71, new OpCode(OpCodes.GET_AWAITABLE_A, "GET_AWAITABLE", {HasArgument: true})],
-    [72, new OpCode(OpCodes.IMPORT_FROM_A, "IMPORT_FROM", {HasArgument: true})],
-    [73, new OpCode(OpCodes.IMPORT_NAME_A, "IMPORT_NAME", {HasArgument: true})],
+    [72, new OpCode(OpCodes.IMPORT_FROM_A, "IMPORT_FROM", {HasArgument: true, HasName: true})],
+    [73, new OpCode(OpCodes.IMPORT_NAME_A, "IMPORT_NAME", {HasArgument: true, HasName: true})],
     [74, new OpCode(OpCodes.IS_OP_A, "IS_OP", {HasArgument: true})],
     [75, new OpCode(OpCodes.JUMP_BACKWARD_A, "JUMP_BACKWARD", {HasArgument: true})],
     [76, new OpCode(OpCodes.JUMP_BACKWARD_NO_INTERRUPT_A, "JUMP_BACKWARD_NO_INTERRUPT", {HasArgument: true})],
@@ -86,21 +86,21 @@ const opcodes = [
     [80, new OpCode(OpCodes.LOAD_ATTR_A, "LOAD_ATTR", {HasArgument: true, HasName: true})],
     [81, new OpCode(OpCodes.LOAD_COMMON_CONSTANT_A, "LOAD_COMMON_CONSTANT", {HasArgument: true})],
     [82, new OpCode(OpCodes.LOAD_CONST_A, "LOAD_CONST", {HasArgument: true, HasConstant: true})],
-    [83, new OpCode(OpCodes.LOAD_DEREF_A, "LOAD_DEREF", {HasArgument: true})],
+    [83, new OpCode(OpCodes.LOAD_DEREF_A, "LOAD_DEREF", {HasArgument: true, HasFree: true})],
     [84, new OpCode(OpCodes.LOAD_FAST_A, "LOAD_FAST", {HasArgument: true, HasLocal: true})],
     [85, new OpCode(OpCodes.LOAD_FAST_AND_CLEAR_A, "LOAD_FAST_AND_CLEAR", {HasArgument: true, HasLocal: true})],
     [86, new OpCode(OpCodes.LOAD_FAST_BORROW_A, "LOAD_FAST_BORROW", {HasArgument: true, HasLocal: true})],
     [87, new OpCode(OpCodes.LOAD_FAST_BORROW_LOAD_FAST_BORROW_A, "LOAD_FAST_BORROW_LOAD_FAST_BORROW", {HasArgument: true, HasLocal: true})],
     [88, new OpCode(OpCodes.LOAD_FAST_CHECK_A, "LOAD_FAST_CHECK", {HasArgument: true, HasLocal: true})],
     [89, new OpCode(OpCodes.LOAD_FAST_LOAD_FAST_A, "LOAD_FAST_LOAD_FAST", {HasArgument: true, HasLocal: true})],
-    [90, new OpCode(OpCodes.LOAD_FROM_DICT_OR_DEREF_A, "LOAD_FROM_DICT_OR_DEREF", {HasArgument: true, HasLocal: true, HasName: true})],
+    [90, new OpCode(OpCodes.LOAD_FROM_DICT_OR_DEREF_A, "LOAD_FROM_DICT_OR_DEREF", {HasArgument: true, HasFree: true})],
     [91, new OpCode(OpCodes.LOAD_FROM_DICT_OR_GLOBALS_A, "LOAD_FROM_DICT_OR_GLOBALS", {HasArgument: true, HasName: true})],
     [92, new OpCode(OpCodes.LOAD_GLOBAL_A, "LOAD_GLOBAL", {HasArgument: true, HasName: true})],
     [93, new OpCode(OpCodes.LOAD_NAME_A, "LOAD_NAME", {HasArgument: true, HasName: true})],
     [94, new OpCode(OpCodes.LOAD_SMALL_INT_A, "LOAD_SMALL_INT", {HasArgument: true})],
     [95, new OpCode(OpCodes.LOAD_SPECIAL_A, "LOAD_SPECIAL", {HasArgument: true})],
-    [96, new OpCode(OpCodes.LOAD_SUPER_ATTR_A, "LOAD_SUPER_ATTR", {HasArgument: true})],
-    [97, new OpCode(OpCodes.MAKE_CELL_A, "MAKE_CELL", {HasArgument: true})],
+    [96, new OpCode(OpCodes.LOAD_SUPER_ATTR_A, "LOAD_SUPER_ATTR", {HasArgument: true, HasName: true})],
+    [97, new OpCode(OpCodes.MAKE_CELL_A, "MAKE_CELL", {HasArgument: true, HasFree: true})],
     [98, new OpCode(OpCodes.MAP_ADD_A, "MAP_ADD", {HasArgument: true})],
     [99, new OpCode(OpCodes.MATCH_CLASS_A, "MATCH_CLASS", {HasArgument: true})],
     [100, new OpCode(OpCodes.POP_JUMP_IF_FALSE_A, "POP_JUMP_IF_FALSE", {HasArgument: true})],
@@ -114,7 +114,7 @@ const opcodes = [
     [108, new OpCode(OpCodes.SET_FUNCTION_ATTRIBUTE_A, "SET_FUNCTION_ATTRIBUTE", {HasArgument: true})],
     [109, new OpCode(OpCodes.SET_UPDATE_A, "SET_UPDATE", {HasArgument: true})],
     [110, new OpCode(OpCodes.STORE_ATTR_A, "STORE_ATTR", {HasArgument: true, HasName: true})],
-    [111, new OpCode(OpCodes.STORE_DEREF_A, "STORE_DEREF", {HasArgument: true})],
+    [111, new OpCode(OpCodes.STORE_DEREF_A, "STORE_DEREF", {HasArgument: true, HasFree: true})],
     [112, new OpCode(OpCodes.STORE_FAST_A, "STORE_FAST", {HasArgument: true, HasLocal: true})],
     [113, new OpCode(OpCodes.STORE_FAST_LOAD_FAST_A, "STORE_FAST_LOAD_FAST", {HasArgument: true, HasLocal: true})],
     [114, new OpCode(OpCodes.STORE_FAST_STORE_FAST_A, "STORE_FAST_STORE_FAST", {HasArgument: true, HasLocal: true})],
@@ -152,7 +152,7 @@ const opcodes = [
     [258, new OpCode(OpCodes.JUMP_IF_FALSE_A, "JUMP_IF_FALSE", {HasArgument: true})],
     [259, new OpCode(OpCodes.JUMP_IF_TRUE_A, "JUMP_IF_TRUE", {HasArgument: true})],
     [260, new OpCode(OpCodes.JUMP_NO_INTERRUPT_A, "JUMP_NO_INTERRUPT", {HasArgument: true})],
-    [261, new OpCode(OpCodes.LOAD_CLOSURE_A, "LOAD_CLOSURE", {HasArgument: true})],
+    [261, new OpCode(OpCodes.LOAD_CLOSURE_A, "LOAD_CLOSURE", {HasArgument: true, HasFree: true})],
     [262, new OpCode(OpCodes.POP_BLOCK_A, "POP_BLOCK", {HasArgument: true})],
     [263, new OpCode(OpCodes.SETUP_CLEANUP_A, "SETUP_CLEANUP", {HasArgument: true})],
     [264, new OpCode(OpCodes.SETUP_FINALLY_A, "SETUP_FINALLY", {HasArgument: true})],

package/lib/bytecode/python_3_15.js

@@ -0,0 +1,183 @@
+// Python 3.15 OpCodes
+// Generated from CPython v3.15.0a8 opcode.opmap.
+// Notable changes vs 3.14:
+//   - GET_YIELD_FROM_ITER removed
+//   - GET_ITER moved 16 -> 70 and now takes an argument
+//   - INSTRUMENTED_END_FOR/POP_ITER/END_SEND/etc. shifted down by one
+//   - TRACE_RECORD added at 255 (instrumentation only; ignore)
+//   - ENTER_EXECUTOR moved 255 -> 254
+const OpCode = require('../OpCode');
+const OpCodes = require('../OpCodes');
+
+const opcodes = [
+    [0, new OpCode(OpCodes.CACHE, "CACHE")],
+    [1, new OpCode(OpCodes.BINARY_SLICE, "BINARY_SLICE")],
+    [2, new OpCode(OpCodes.BUILD_TEMPLATE, "BUILD_TEMPLATE")],
+    [4, new OpCode(OpCodes.CALL_FUNCTION_EX, "CALL_FUNCTION_EX")],
+    [5, new OpCode(OpCodes.CHECK_EG_MATCH, "CHECK_EG_MATCH")],
+    [6, new OpCode(OpCodes.CHECK_EXC_MATCH, "CHECK_EXC_MATCH")],
+    [7, new OpCode(OpCodes.CLEANUP_THROW, "CLEANUP_THROW")],
+    [8, new OpCode(OpCodes.DELETE_SUBSCR, "DELETE_SUBSCR")],
+    [9, new OpCode(OpCodes.END_FOR, "END_FOR")],
+    [10, new OpCode(OpCodes.END_SEND, "END_SEND")],
+    [11, new OpCode(OpCodes.EXIT_INIT_CHECK, "EXIT_INIT_CHECK")],
+    [12, new OpCode(OpCodes.FORMAT_SIMPLE, "FORMAT_SIMPLE")],
+    [13, new OpCode(OpCodes.FORMAT_WITH_SPEC, "FORMAT_WITH_SPEC")],
+    [14, new OpCode(OpCodes.GET_AITER, "GET_AITER")],
+    [15, new OpCode(OpCodes.GET_ANEXT, "GET_ANEXT")],
+    [16, new OpCode(OpCodes.GET_LEN, "GET_LEN")],
+    [17, new OpCode(OpCodes.RESERVED, "RESERVED")],
+    [18, new OpCode(OpCodes.INTERPRETER_EXIT, "INTERPRETER_EXIT")],
+    [19, new OpCode(OpCodes.LOAD_BUILD_CLASS, "LOAD_BUILD_CLASS")],
+    [20, new OpCode(OpCodes.LOAD_LOCALS, "LOAD_LOCALS")],
+    [21, new OpCode(OpCodes.MAKE_FUNCTION, "MAKE_FUNCTION")],
+    [22, new OpCode(OpCodes.MATCH_KEYS, "MATCH_KEYS")],
+    [23, new OpCode(OpCodes.MATCH_MAPPING, "MATCH_MAPPING")],
+    [24, new OpCode(OpCodes.MATCH_SEQUENCE, "MATCH_SEQUENCE")],
+    [25, new OpCode(OpCodes.NOP, "NOP")],
+    [26, new OpCode(OpCodes.NOT_TAKEN, "NOT_TAKEN")],
+    [27, new OpCode(OpCodes.POP_EXCEPT, "POP_EXCEPT")],
+    [28, new OpCode(OpCodes.POP_ITER, "POP_ITER")],
+    [29, new OpCode(OpCodes.POP_TOP, "POP_TOP")],
+    [30, new OpCode(OpCodes.PUSH_EXC_INFO, "PUSH_EXC_INFO")],
+    [31, new OpCode(OpCodes.PUSH_NULL, "PUSH_NULL")],
+    [32, new OpCode(OpCodes.RETURN_GENERATOR, "RETURN_GENERATOR")],
+    [33, new OpCode(OpCodes.RETURN_VALUE, "RETURN_VALUE")],
+    [34, new OpCode(OpCodes.SETUP_ANNOTATIONS, "SETUP_ANNOTATIONS")],
+    [35, new OpCode(OpCodes.STORE_SLICE, "STORE_SLICE")],
+    [36, new OpCode(OpCodes.STORE_SUBSCR, "STORE_SUBSCR")],
+    [37, new OpCode(OpCodes.TO_BOOL, "TO_BOOL")],
+    [38, new OpCode(OpCodes.UNARY_INVERT, "UNARY_INVERT")],
+    [39, new OpCode(OpCodes.UNARY_NEGATIVE, "UNARY_NEGATIVE")],
+    [40, new OpCode(OpCodes.UNARY_NOT, "UNARY_NOT")],
+    [41, new OpCode(OpCodes.WITH_EXCEPT_START_A, "WITH_EXCEPT_START", {HasArgument: true})],
+    [42, new OpCode(OpCodes.BINARY_OP_A, "BINARY_OP", {HasArgument: true})],
+    [43, new OpCode(OpCodes.BUILD_INTERPOLATION_A, "BUILD_INTERPOLATION", {HasArgument: true})],
+    [44, new OpCode(OpCodes.BUILD_LIST_A, "BUILD_LIST", {HasArgument: true})],
+    [45, new OpCode(OpCodes.BUILD_MAP_A, "BUILD_MAP", {HasArgument: true})],
+    [46, new OpCode(OpCodes.BUILD_SET_A, "BUILD_SET", {HasArgument: true})],
+    [47, new OpCode(OpCodes.BUILD_SLICE_A, "BUILD_SLICE", {HasArgument: true})],
+    [48, new OpCode(OpCodes.BUILD_STRING_A, "BUILD_STRING", {HasArgument: true})],
+    [49, new OpCode(OpCodes.BUILD_TUPLE_A, "BUILD_TUPLE", {HasArgument: true})],
+    [50, new OpCode(OpCodes.CALL_A, "CALL", {HasArgument: true})],
+    [51, new OpCode(OpCodes.CALL_INTRINSIC_1_A, "CALL_INTRINSIC_1", {HasArgument: true})],
+    [52, new OpCode(OpCodes.CALL_INTRINSIC_2_A, "CALL_INTRINSIC_2", {HasArgument: true})],
+    [53, new OpCode(OpCodes.CALL_KW_A, "CALL_KW", {HasArgument: true})],
+    [54, new OpCode(OpCodes.COMPARE_OP_A, "COMPARE_OP", {HasArgument: true})],
+    [55, new OpCode(OpCodes.CONTAINS_OP_A, "CONTAINS_OP", {HasArgument: true})],
+    [56, new OpCode(OpCodes.CONVERT_VALUE_A, "CONVERT_VALUE", {HasArgument: true})],
+    [57, new OpCode(OpCodes.COPY_A, "COPY", {HasArgument: true})],
+    [58, new OpCode(OpCodes.COPY_FREE_VARS_A, "COPY_FREE_VARS", {HasArgument: true})],
+    [59, new OpCode(OpCodes.DELETE_ATTR_A, "DELETE_ATTR", {HasArgument: true, HasName: true})],
+    [60, new OpCode(OpCodes.DELETE_DEREF_A, "DELETE_DEREF", {HasArgument: true, HasFree: true})],
+    [61, new OpCode(OpCodes.DELETE_FAST_A, "DELETE_FAST", {HasArgument: true, HasLocal: true})],
+    [62, new OpCode(OpCodes.DELETE_GLOBAL_A, "DELETE_GLOBAL", {HasArgument: true, HasName: true})],
+    [63, new OpCode(OpCodes.DELETE_NAME_A, "DELETE_NAME", {HasArgument: true, HasName: true})],
+    [64, new OpCode(OpCodes.DICT_MERGE_A, "DICT_MERGE", {HasArgument: true})],
+    [65, new OpCode(OpCodes.DICT_UPDATE_A, "DICT_UPDATE", {HasArgument: true})],
+    [66, new OpCode(OpCodes.END_ASYNC_FOR_A, "END_ASYNC_FOR", {HasArgument: true})],
+    [67, new OpCode(OpCodes.EXTENDED_ARG_A, "EXTENDED_ARG", {HasArgument: true})],
+    [68, new OpCode(OpCodes.FOR_ITER_A, "FOR_ITER", {HasArgument: true})],
+    [69, new OpCode(OpCodes.GET_AWAITABLE_A, "GET_AWAITABLE", {HasArgument: true})],
+    [70, new OpCode(OpCodes.GET_ITER, "GET_ITER", {HasArgument: true})],
+    [71, new OpCode(OpCodes.IMPORT_FROM_A, "IMPORT_FROM", {HasArgument: true, HasName: true})],
+    [72, new OpCode(OpCodes.IMPORT_NAME_A, "IMPORT_NAME", {HasArgument: true, HasName: true})],
+    [73, new OpCode(OpCodes.IS_OP_A, "IS_OP", {HasArgument: true})],
+    [74, new OpCode(OpCodes.JUMP_BACKWARD_A, "JUMP_BACKWARD", {HasArgument: true})],
+    [75, new OpCode(OpCodes.JUMP_BACKWARD_NO_INTERRUPT_A, "JUMP_BACKWARD_NO_INTERRUPT", {HasArgument: true})],
+    [76, new OpCode(OpCodes.JUMP_FORWARD_A, "JUMP_FORWARD", {HasArgument: true})],
+    [77, new OpCode(OpCodes.LIST_APPEND_A, "LIST_APPEND", {HasArgument: true})],
+    [78, new OpCode(OpCodes.LIST_EXTEND_A, "LIST_EXTEND", {HasArgument: true})],
+    [79, new OpCode(OpCodes.LOAD_ATTR_A, "LOAD_ATTR", {HasArgument: true, HasName: true})],
+    [80, new OpCode(OpCodes.LOAD_COMMON_CONSTANT_A, "LOAD_COMMON_CONSTANT", {HasArgument: true})],
+    [81, new OpCode(OpCodes.LOAD_CONST_A, "LOAD_CONST", {HasArgument: true, HasConstant: true})],
+    [82, new OpCode(OpCodes.LOAD_DEREF_A, "LOAD_DEREF", {HasArgument: true, HasFree: true})],
+    [83, new OpCode(OpCodes.LOAD_FAST_A, "LOAD_FAST", {HasArgument: true, HasLocal: true})],
+    [84, new OpCode(OpCodes.LOAD_FAST_AND_CLEAR_A, "LOAD_FAST_AND_CLEAR", {HasArgument: true, HasLocal: true})],
+    [85, new OpCode(OpCodes.LOAD_FAST_BORROW_A, "LOAD_FAST_BORROW", {HasArgument: true, HasLocal: true})],
+    [86, new OpCode(OpCodes.LOAD_FAST_BORROW_LOAD_FAST_BORROW_A, "LOAD_FAST_BORROW_LOAD_FAST_BORROW", {HasArgument: true, HasLocal: true})],
+    [87, new OpCode(OpCodes.LOAD_FAST_CHECK_A, "LOAD_FAST_CHECK", {HasArgument: true, HasLocal: true})],
+    [88, new OpCode(OpCodes.LOAD_FAST_LOAD_FAST_A, "LOAD_FAST_LOAD_FAST", {HasArgument: true, HasLocal: true})],
+    [89, new OpCode(OpCodes.LOAD_FROM_DICT_OR_DEREF_A, "LOAD_FROM_DICT_OR_DEREF", {HasArgument: true, HasFree: true})],
+    [90, new OpCode(OpCodes.LOAD_FROM_DICT_OR_GLOBALS_A, "LOAD_FROM_DICT_OR_GLOBALS", {HasArgument: true, HasName: true})],
+    [91, new OpCode(OpCodes.LOAD_GLOBAL_A, "LOAD_GLOBAL", {HasArgument: true, HasName: true})],
+    [92, new OpCode(OpCodes.LOAD_NAME_A, "LOAD_NAME", {HasArgument: true, HasName: true})],
+    [93, new OpCode(OpCodes.LOAD_SMALL_INT_A, "LOAD_SMALL_INT", {HasArgument: true})],
+    [94, new OpCode(OpCodes.LOAD_SPECIAL_A, "LOAD_SPECIAL", {HasArgument: true})],
+    [95, new OpCode(OpCodes.LOAD_SUPER_ATTR_A, "LOAD_SUPER_ATTR", {HasArgument: true, HasName: true})],
+    [96, new OpCode(OpCodes.MAKE_CELL_A, "MAKE_CELL", {HasArgument: true, HasFree: true})],
+    [97, new OpCode(OpCodes.MAP_ADD_A, "MAP_ADD", {HasArgument: true})],
+    [98, new OpCode(OpCodes.MATCH_CLASS_A, "MATCH_CLASS", {HasArgument: true})],
+    [99, new OpCode(OpCodes.POP_JUMP_IF_FALSE_A, "POP_JUMP_IF_FALSE", {HasArgument: true})],
+    [100, new OpCode(OpCodes.POP_JUMP_IF_NONE_A, "POP_JUMP_IF_NONE", {HasArgument: true})],
+    [101, new OpCode(OpCodes.POP_JUMP_IF_NOT_NONE_A, "POP_JUMP_IF_NOT_NONE", {HasArgument: true})],
+    [102, new OpCode(OpCodes.POP_JUMP_IF_TRUE_A, "POP_JUMP_IF_TRUE", {HasArgument: true})],
+    [103, new OpCode(OpCodes.RAISE_VARARGS_A, "RAISE_VARARGS", {HasArgument: true})],
+    [104, new OpCode(OpCodes.RERAISE_A, "RERAISE", {HasArgument: true})],
+    [105, new OpCode(OpCodes.SEND_A, "SEND", {HasArgument: true})],
+    [106, new OpCode(OpCodes.SET_ADD_A, "SET_ADD", {HasArgument: true})],
+    [107, new OpCode(OpCodes.SET_FUNCTION_ATTRIBUTE_A, "SET_FUNCTION_ATTRIBUTE", {HasArgument: true})],
+    [108, new OpCode(OpCodes.SET_UPDATE_A, "SET_UPDATE", {HasArgument: true})],
+    [109, new OpCode(OpCodes.STORE_ATTR_A, "STORE_ATTR", {HasArgument: true, HasName: true})],
+    [110, new OpCode(OpCodes.STORE_DEREF_A, "STORE_DEREF", {HasArgument: true, HasFree: true})],
+    [111, new OpCode(OpCodes.STORE_FAST_A, "STORE_FAST", {HasArgument: true, HasLocal: true})],
+    [112, new OpCode(OpCodes.STORE_FAST_LOAD_FAST_A, "STORE_FAST_LOAD_FAST", {HasArgument: true, HasLocal: true})],
+    [113, new OpCode(OpCodes.STORE_FAST_STORE_FAST_A, "STORE_FAST_STORE_FAST", {HasArgument: true, HasLocal: true})],
+    [114, new OpCode(OpCodes.STORE_GLOBAL_A, "STORE_GLOBAL", {HasArgument: true, HasName: true})],
+    [115, new OpCode(OpCodes.STORE_NAME_A, "STORE_NAME", {HasArgument: true, HasName: true})],
+    [116, new OpCode(OpCodes.SWAP_A, "SWAP", {HasArgument: true})],
+    [117, new OpCode(OpCodes.UNPACK_EX_A, "UNPACK_EX", {HasArgument: true})],
+    [118, new OpCode(OpCodes.UNPACK_SEQUENCE_A, "UNPACK_SEQUENCE", {HasArgument: true})],
+    [119, new OpCode(OpCodes.YIELD_VALUE_A, "YIELD_VALUE", {HasArgument: true})],
+    [128, new OpCode(OpCodes.RESUME_A, "RESUME", {HasArgument: true})],
+    [233, new OpCode(OpCodes.INSTRUMENTED_END_FOR_A, "INSTRUMENTED_END_FOR", {HasArgument: true})],
+    [234, new OpCode(OpCodes.INSTRUMENTED_POP_ITER_A, "INSTRUMENTED_POP_ITER", {HasArgument: true})],
+    [235, new OpCode(OpCodes.INSTRUMENTED_END_SEND_A, "INSTRUMENTED_END_SEND", {HasArgument: true})],
+    [236, new OpCode(OpCodes.INSTRUMENTED_FOR_ITER_A, "INSTRUMENTED_FOR_ITER", {HasArgument: true})],
+    [237, new OpCode(OpCodes.INSTRUMENTED_INSTRUCTION_A, "INSTRUMENTED_INSTRUCTION", {HasArgument: true})],
+    [238, new OpCode(OpCodes.INSTRUMENTED_JUMP_FORWARD_A, "INSTRUMENTED_JUMP_FORWARD", {HasArgument: true})],
+    [239, new OpCode(OpCodes.INSTRUMENTED_NOT_TAKEN_A, "INSTRUMENTED_NOT_TAKEN", {HasArgument: true})],
+    [240, new OpCode(OpCodes.INSTRUMENTED_POP_JUMP_IF_TRUE_A, "INSTRUMENTED_POP_JUMP_IF_TRUE", {HasArgument: true})],
+    [241, new OpCode(OpCodes.INSTRUMENTED_POP_JUMP_IF_FALSE_A, "INSTRUMENTED_POP_JUMP_IF_FALSE", {HasArgument: true})],
+    [242, new OpCode(OpCodes.INSTRUMENTED_POP_JUMP_IF_NONE_A, "INSTRUMENTED_POP_JUMP_IF_NONE", {HasArgument: true})],
+    [243, new OpCode(OpCodes.INSTRUMENTED_POP_JUMP_IF_NOT_NONE_A, "INSTRUMENTED_POP_JUMP_IF_NOT_NONE", {HasArgument: true})],
+    [244, new OpCode(OpCodes.INSTRUMENTED_RESUME_A, "INSTRUMENTED_RESUME", {HasArgument: true})],
+    [245, new OpCode(OpCodes.INSTRUMENTED_RETURN_VALUE_A, "INSTRUMENTED_RETURN_VALUE", {HasArgument: true})],
+    [246, new OpCode(OpCodes.INSTRUMENTED_YIELD_VALUE_A, "INSTRUMENTED_YIELD_VALUE", {HasArgument: true})],
+    [247, new OpCode(OpCodes.INSTRUMENTED_END_ASYNC_FOR_A, "INSTRUMENTED_END_ASYNC_FOR", {HasArgument: true})],
+    [248, new OpCode(OpCodes.INSTRUMENTED_LOAD_SUPER_ATTR_A, "INSTRUMENTED_LOAD_SUPER_ATTR", {HasArgument: true})],
+    [249, new OpCode(OpCodes.INSTRUMENTED_CALL_A, "INSTRUMENTED_CALL", {HasArgument: true})],
+    [250, new OpCode(OpCodes.INSTRUMENTED_CALL_KW_A, "INSTRUMENTED_CALL_KW", {HasArgument: true})],
+    [251, new OpCode(OpCodes.INSTRUMENTED_CALL_FUNCTION_EX_A, "INSTRUMENTED_CALL_FUNCTION_EX", {HasArgument: true})],
+    [252, new OpCode(OpCodes.INSTRUMENTED_JUMP_BACKWARD_A, "INSTRUMENTED_JUMP_BACKWARD", {HasArgument: true})],
+    [253, new OpCode(OpCodes.INSTRUMENTED_LINE_A, "INSTRUMENTED_LINE", {HasArgument: true})],
+    [254, new OpCode(OpCodes.ENTER_EXECUTOR_A, "ENTER_EXECUTOR", {HasArgument: true})],
+    [255, new OpCode(OpCodes.TRACE_RECORD_A, "TRACE_RECORD", {HasArgument: true})],
+    [256, new OpCode(OpCodes.ANNOTATIONS_PLACEHOLDER_A, "ANNOTATIONS_PLACEHOLDER", {HasArgument: true})],
+    [257, new OpCode(OpCodes.JUMP_A, "JUMP", {HasArgument: true})],
+    [258, new OpCode(OpCodes.JUMP_IF_FALSE_A, "JUMP_IF_FALSE", {HasArgument: true})],
+    [259, new OpCode(OpCodes.JUMP_IF_TRUE_A, "JUMP_IF_TRUE", {HasArgument: true})],
+    [260, new OpCode(OpCodes.JUMP_NO_INTERRUPT_A, "JUMP_NO_INTERRUPT", {HasArgument: true})],
+    [261, new OpCode(OpCodes.LOAD_CLOSURE_A, "LOAD_CLOSURE", {HasArgument: true, HasFree: true})],
+    [262, new OpCode(OpCodes.POP_BLOCK_A, "POP_BLOCK", {HasArgument: true})],
+    [263, new OpCode(OpCodes.SETUP_CLEANUP_A, "SETUP_CLEANUP", {HasArgument: true})],
+    [264, new OpCode(OpCodes.SETUP_FINALLY_A, "SETUP_FINALLY", {HasArgument: true})],
+    [265, new OpCode(OpCodes.SETUP_WITH_A, "SETUP_WITH", {HasArgument: true})],
+    [266, new OpCode(OpCodes.STORE_FAST_MAYBE_NULL_A, "STORE_FAST_MAYBE_NULL", {HasArgument: true})],
+];
+
+class Python3_15_OpCodes extends OpCodes {
+    constructor(co) {
+        super();
+        this.PopulateOpCodes(opcodes);
+        this.SetupByteCode(co);
+    }
+
+    PopulateOpCodes(opCodeList) {
+        for (let [idx, opcode] of opCodeList) {
+            this.OpCodeList[idx] = opcode;
+        }
+    }
+}
+
+module.exports = Python3_15_OpCodes;

package/lib/code_reader.js

@@ -1,146 +1,107 @@
-class CodeReader {
-    constructor(code, endian) {
-        this.endian = endian || 'B';
-        this._reader = Buffer.from(code);
-        this._pc = 0;
-    }
-
-    get pc() {
-        return this._pc;
-    }
-
-    set pc(pos) {
-        if (pos > this.length || pos < 0) {
-            pos = this.length;
-        }
-        this._pc = pos;
-    }
-
-    get length() {
-        return this._reader.length
-    }
-
-    get EOF() {
-        return this._pc >= this._reader.length;
-    }
-
-    readByte() {
-        try {
-            let value = this._reader.readUInt8(this.pc, true);
-            this.pc++;
-            return value;
-        } catch {
-            debugger;
-        }
-    }
-    
-    readUShort() {
-        try {
-            let value = this._reader[`readUInt16${this.endian}E`](this.pc, true);
-            this.pc += 2;
-            return value;
-        } catch {
-            debugger;
-        }
-    }
-
-    readShort() {
-        try {
-            let value = this._reader[`readInt16${this.endian}E`](this.pc, true);
-            this.pc += 2;
-            return value;
-        } catch {
-            debugger;
-        }
-    }
-
-    readInt() {
-        try {
-            let value = this._reader[`readInt32${this.endian}E`](this.pc, true);
-            this.pc += 4;
-            return value;
-        } catch {
-            debugger;
-        }
-    }
-
-    readUInt() {
-        try {
-            let value = this._reader[`readUInt32${this.endian}E`](this.pc, true);
-            this.pc += 4;
-            return value;
-        } catch (ex) {
-            debugger;
-        }
-    }
-    
-    readLong() {
-        try {
-            let high = this.readInt()
-            let low = this.readInt()
-            return {low, high};
-        } catch {
-            debugger;
-        }
-    }
-    
-    readULong() {
-        try {
-            let high = this.readUInt()
-            let low = this.readUInt()
-            return {low, high};
-        } catch {
-            debugger;
-        }
-    }
-
-    readFloat() {
-        try {
-            let value = this._reader[`readFloat${this.endian}E`](this.pc, true);
-            this.pc += 4;
-            return value;
-        } catch {
-            debugger;
-        }
-    }
-    
-    readDouble() {
-        try {
-            let value = this._reader[`readDouble${this.endian}E`](this.pc, true);
-            this.pc += 8;
-            return value;
-        } catch {
-            debugger;
-        }
-    }
-    
-    readBytes(length) {
-        try {
-            let value = this._reader.slice(this.pc, this.pc + length);
-            this.pc += length;
-            return value;
-        } catch {
-            debugger;
-        }
-    }
-
-    readString(length) {
-        try {
-            let value = this._reader.slice(this.pc, this.pc + length).toString('utf8');
-            this.pc += length;
-            return value;
-        } catch {
-            debugger;
-        }
-    }
-
-    peekByte() {
-        try {
-            return this._reader.readUInt8(this.pc, true);
-        } catch {
-            debugger;
-        }
-    }
-}
-
-module.exports = CodeReader;
+class CodeReaderError extends Error {
+    constructor(message, pc, length) {
+        super(`${message} (pc=${pc}, length=${length})`);
+        this.name = 'CodeReaderError';
+        this.pc = pc;
+        this.length = length;
+    }
+}
+
+class CodeReader {
+    constructor(code, endian) {
+        this.endian = endian || 'B';
+        this._reader = Buffer.from(code);
+        this._pc = 0;
+    }
+
+    get pc() {
+        return this._pc;
+    }
+
+    set pc(pos) {
+        if (pos > this.length || pos < 0) {
+            pos = this.length;
+        }
+        this._pc = pos;
+    }
+
+    get length() {
+        return this._reader.length
+    }
+
+    get EOF() {
+        return this._pc >= this._reader.length;
+    }
+
+    _read(label, size, fn) {
+        if (this._pc + size > this._reader.length) {
+            throw new CodeReaderError(`${label}: read past end of buffer`, this._pc, this._reader.length);
+        }
+        try {
+            const value = fn();
+            this._pc += size;
+            return value;
+        } catch (ex) {
+            if (ex instanceof CodeReaderError) throw ex;
+            throw new CodeReaderError(`${label}: ${ex.message}`, this._pc, this._reader.length);
+        }
+    }
+
+    readByte() {
+        return this._read('readByte', 1, () => this._reader.readUInt8(this._pc, true));
+    }
+
+    readUShort() {
+        return this._read('readUShort', 2, () => this._reader[`readUInt16${this.endian}E`](this._pc, true));
+    }
+
+    readShort() {
+        return this._read('readShort', 2, () => this._reader[`readInt16${this.endian}E`](this._pc, true));
+    }
+
+    readInt() {
+        return this._read('readInt', 4, () => this._reader[`readInt32${this.endian}E`](this._pc, true));
+    }
+
+    readUInt() {
+        return this._read('readUInt', 4, () => this._reader[`readUInt32${this.endian}E`](this._pc, true));
+    }
+
+    readLong() {
+        const high = this.readInt();
+        const low = this.readInt();
+        return {low, high};
+    }
+
+    readULong() {
+        const high = this.readUInt();
+        const low = this.readUInt();
+        return {low, high};
+    }
+
+    readFloat() {
+        return this._read('readFloat', 4, () => this._reader[`readFloat${this.endian}E`](this._pc, true));
+    }
+
+    readDouble() {
+        return this._read('readDouble', 8, () => this._reader[`readDouble${this.endian}E`](this._pc, true));
+    }
+
+    readBytes(length) {
+        return this._read(`readBytes(${length})`, length, () => this._reader.slice(this._pc, this._pc + length));
+    }
+
+    readString(length) {
+        return this._read(`readString(${length})`, length, () => this._reader.slice(this._pc, this._pc + length).toString('utf8'));
+    }
+
+    peekByte() {
+        if (this._pc >= this._reader.length) {
+            throw new CodeReaderError('peekByte: read past end of buffer', this._pc, this._reader.length);
+        }
+        return this._reader.readUInt8(this._pc, true);
+    }
+}
+
+module.exports = CodeReader;
+module.exports.CodeReaderError = CodeReaderError;

package/lib/handlers/collections_update.js

@@ -41,8 +41,57 @@ function processListAppend() {
     let value = this.dataStack.pop();
     let list = this.dataStack.top();
 
-    if (this.curBlock.blockType == AST.ASTBlock.BlockType.For && this.curBlock.comprehension) {
+    // Pre-3.8 list comprehensions can nest the LIST_APPEND inside if/and/or
+    // blocks (e.g. `[o for o in xs if cond]`), so curBlock may be an If/Else
+    // when the append fires. Walk up to find the enclosing For+comprehension.
+    let forBlock = null;
+    let ifBlocks = [];
+    for (let i = this.blocks.length - 1; i >= 0; i--) {
+        const blk = this.blocks[i];
+        if (blk.blockType == AST.ASTBlock.BlockType.For && blk.comprehension) {
+            forBlock = blk;
+            break;
+        }
+        if (blk.blockType == AST.ASTBlock.BlockType.If) {
+            ifBlocks.push(blk);
+        } else {
+            break;
+        }
+    }
+
+    if (!forBlock) {
+        // Async comprehension inner code: no For+comp block exists because
+        // GET_ANEXT iteration uses SETUP_EXCEPT instead of FOR_ITER.
+        // Save the appended value so the reconstruction in function_calls.js
+        // can use it as the comprehension's yield expression.
+        this.object._asyncCompYieldExpr = value;
+    }
+
+    if (forBlock) {
         this.dataStack.pop();
+        // Transfer any intervening if-filter conditions to the comprehension's
+        // for-block, then close the intermediate if-blocks so the For+comp is
+        // curBlock when JUMP_ABSOLUTE reaches the close path.
+        for (const ifBlk of ifBlocks) {
+            let cond = ifBlk.condition;
+            if (!cond) continue;
+            if (ifBlk.negative) {
+                const notCond = new AST.ASTUnary(cond, AST.ASTUnary.UnaryOp.Not);
+                notCond.line = this.code.Current.LineNo;
+                cond = notCond;
+            }
+            if (forBlock.condition) {
+                const andCond = new AST.ASTBinary(forBlock.condition, cond, AST.ASTBinary.BinOp.LogicalAnd);
+                andCond.line = this.code.Current.LineNo;
+                forBlock.condition = andCond;
+            } else {
+                forBlock.condition = cond;
+            }
+        }
+        while (this.curBlock !== forBlock && this.blocks.length > 1) {
+            this.blocks.pop();
+            this.curBlock = this.blocks.top();
+        }
         let node = new AST.ASTComprehension (value);
         node.line = this.code.Current.LineNo;
         this.dataStack.push(node);