numba-cuda 0.21.1__cp313-cp313-win_amd64.whl → 0.23.0__cp313-cp313-win_amd64.whl

numba_cuda/numba/cuda/core/interpreter.py

@@ -217,8 +217,8 @@ def _call_function_ex_replace_kws_large(
         # The first value must be a constant.
         const_stmt = old_body[search_start]
         if not (
-            isinstance(const_stmt, ir.Assign)
-            and isinstance(const_stmt.value, ir.Const)
+            isinstance(const_stmt, ir.assign_types)
+            and isinstance(const_stmt.value, ir.const_types)
         ):
             # We cannot handle this format so raise the
             # original error message.
@@ -231,8 +231,8 @@ def _call_function_ex_replace_kws_large(
         while search_start <= search_end and not found_getattr:
             getattr_stmt = old_body[search_start]
             if (
-                isinstance(getattr_stmt, ir.Assign)
-                and isinstance(getattr_stmt.value, ir.Expr)
+                isinstance(getattr_stmt, ir.assign_types)
+                and isinstance(getattr_stmt.value, ir.expr_types)
                 and getattr_stmt.value.op == "getattr"
                 and (getattr_stmt.value.value.name == buildmap_name)
                 and getattr_stmt.value.attr == "__setitem__"
@@ -262,8 +262,8 @@ def _call_function_ex_replace_kws_large(
             raise UnsupportedBytecodeError(errmsg)
         setitem_stmt = old_body[search_start + 1]
         if not (
-            isinstance(setitem_stmt, ir.Assign)
-            and isinstance(setitem_stmt.value, ir.Expr)
+            isinstance(setitem_stmt, ir.assign_types)
+            and isinstance(setitem_stmt.value, ir.expr_types)
             and setitem_stmt.value.op == "call"
             and (setitem_stmt.value.func.name == getattr_stmt.target.name)
             and len(setitem_stmt.value.args) == 2
@@ -366,8 +366,8 @@ def _call_function_ex_replace_args_large(
     # tuple.
     search_start = 0
     total_args = []
-    if isinstance(vararg_stmt, ir.Assign) and isinstance(
-        vararg_stmt.value, ir.Var
+    if isinstance(vararg_stmt, ir.assign_types) and isinstance(
+        vararg_stmt.value, ir.var_types
     ):
         target_name = vararg_stmt.value.name
         # If there is an initial assignment, delete it
@@ -387,9 +387,9 @@ def _call_function_ex_replace_args_large(
     while search_end >= search_start:
         concat_stmt = old_body[search_end]
         if (
-            isinstance(concat_stmt, ir.Assign)
+            isinstance(concat_stmt, ir.assign_types)
             and concat_stmt.target.name == target_name
-            and isinstance(concat_stmt.value, ir.Expr)
+            and isinstance(concat_stmt.value, ir.expr_types)
             and concat_stmt.value.op == "build_tuple"
             and not concat_stmt.value.items
         ):
@@ -404,9 +404,9 @@ def _call_function_ex_replace_args_large(
             # We expect to find another arg to append.
             # The first stmt must be a binop "add"
             if (search_end == search_start) or not (
-                isinstance(concat_stmt, ir.Assign)
+                isinstance(concat_stmt, ir.assign_types)
                 and (concat_stmt.target.name == target_name)
-                and isinstance(concat_stmt.value, ir.Expr)
+                and isinstance(concat_stmt.value, ir.expr_types)
                 and concat_stmt.value.op == "binop"
                 and concat_stmt.value.fn == operator.add
             ):
@@ -418,8 +418,8 @@ def _call_function_ex_replace_args_large(
             # build_tuple containing the arg.
             arg_tuple_stmt = old_body[search_end - 1]
             if not (
-                isinstance(arg_tuple_stmt, ir.Assign)
-                and isinstance(arg_tuple_stmt.value, ir.Expr)
+                isinstance(arg_tuple_stmt, ir.assign_types)
+                and isinstance(arg_tuple_stmt.value, ir.expr_types)
                 and (arg_tuple_stmt.value.op == "build_tuple")
                 and len(arg_tuple_stmt.value.items) == 1
             ):
@@ -448,7 +448,7 @@ def _call_function_ex_replace_args_large(
             keep_looking = True
             while search_end >= search_start and keep_looking:
                 next_stmt = old_body[search_end]
-                if isinstance(next_stmt, ir.Assign) and (
+                if isinstance(next_stmt, ir.assign_types) and (
                     next_stmt.target.name == target_name
                 ):
                     keep_looking = False
@@ -522,8 +522,8 @@ def peep_hole_call_function_ex_to_call_function_kw(func_ir):
         new_body = []
         for i, stmt in enumerate(blk.body):
             if (
-                isinstance(stmt, ir.Assign)
-                and isinstance(stmt.value, ir.Expr)
+                isinstance(stmt, ir.assign_types)
+                and isinstance(stmt.value, ir.expr_types)
                 and stmt.value.op == "call"
                 and stmt.value.varkwarg is not None
             ):
@@ -548,7 +548,7 @@ def peep_hole_call_function_ex_to_call_function_kw(func_ir):
                 while varkwarg_loc >= 0 and not found:
                     keyword_def = blk.body[varkwarg_loc]
                     if (
-                        isinstance(keyword_def, ir.Assign)
+                        isinstance(keyword_def, ir.assign_types)
                         and keyword_def.target.name == varkwarg.name
                     ):
                         found = True
@@ -558,7 +558,7 @@ def peep_hole_call_function_ex_to_call_function_kw(func_ir):
                     kws
                     or not found
                     or not (
-                        isinstance(keyword_def.value, ir.Expr)
+                        isinstance(keyword_def.value, ir.expr_types)
                         and keyword_def.value.op == "build_map"
                     )
                 ):
@@ -624,7 +624,7 @@ def peep_hole_call_function_ex_to_call_function_kw(func_ir):
                     while vararg_loc >= 0 and not found:
                         args_def = blk.body[vararg_loc]
                         if (
-                            isinstance(args_def, ir.Assign)
+                            isinstance(args_def, ir.assign_types)
                             and args_def.target.name == vararg.name
                         ):
                             found = True
@@ -635,7 +635,7 @@ def peep_hole_call_function_ex_to_call_function_kw(func_ir):
                         # then we can't handle this format.
                         raise UnsupportedBytecodeError(errmsg)
                     if (
-                        isinstance(args_def.value, ir.Expr)
+                        isinstance(args_def.value, ir.expr_types)
                         and args_def.value.op == "build_tuple"
                     ):
                         # n_args <= 30 case.
@@ -656,7 +656,7 @@ def peep_hole_call_function_ex_to_call_function_kw(func_ir):
                             already_deleted_defs,
                         )
                     elif (
-                        isinstance(args_def.value, ir.Expr)
+                        isinstance(args_def.value, ir.expr_types)
                         and args_def.value.op == "list_to_tuple"
                     ):
                         # If there is a call with vararg we need to check
@@ -708,8 +708,8 @@ def peep_hole_call_function_ex_to_call_function_kw(func_ir):
                 # Update the definition
                 func_ir._definitions[stmt.target.name].append(new_call)
             elif (
-                isinstance(stmt, ir.Assign)
-                and isinstance(stmt.value, ir.Expr)
+                isinstance(stmt, ir.assign_types)
+                and isinstance(stmt.value, ir.expr_types)
                 and stmt.value.op == "call"
                 and stmt.value.vararg is not None
             ):
@@ -725,7 +725,10 @@ def peep_hole_call_function_ex_to_call_function_kw(func_ir):
                     # If this value is still a list to tuple raise the
                     # exception.
                     expr = func_ir._definitions[vararg_name][0]
-                    if isinstance(expr, ir.Expr) and expr.op == "list_to_tuple":
+                    if (
+                        isinstance(expr, ir.expr_types)
+                        and expr.op == "list_to_tuple"
+                    ):
                         raise UnsupportedBytecodeError(errmsg)
 
             new_body.append(stmt)
@@ -780,17 +783,17 @@ def peep_hole_list_to_tuple(func_ir):
                 found = False
                 for idx in reversed(range(len(blk.body))):
                     stmt = blk.body[idx]
-                    if isinstance(stmt, ir.Assign):
+                    if isinstance(stmt, ir.assign_types):
                         value = stmt.value
                         if (
-                            isinstance(value, ir.Expr)
+                            isinstance(value, ir.expr_types)
                             and value.op == "list_to_tuple"
                         ):
                             target_list = value.info[0]
                             found = True
                             bt = (idx, stmt)
                     if found:
-                        if isinstance(stmt, ir.Assign):
+                        if isinstance(stmt, ir.assign_types):
                             if stmt.target.name == target_list:
                                 region = (bt, (idx, stmt))
                                 return region
@@ -812,8 +815,8 @@ def peep_hole_list_to_tuple(func_ir):
                 # Walk through the peep_hole and find things that are being
                 # "extend"ed and "append"ed to the BUILD_LIST
                 for x in peep_hole:
-                    if isinstance(x, ir.Assign):
-                        if isinstance(x.value, ir.Expr):
+                    if isinstance(x, ir.assign_types):
+                        if isinstance(x.value, ir.expr_types):
                             expr = x.value
                             if (
                                 expr.op == "getattr"
@@ -857,8 +860,8 @@ def peep_hole_list_to_tuple(func_ir):
                 t2l_agn = region[0][1]
                 acc = the_build_list
                 for x in peep_hole:
-                    if isinstance(x, ir.Assign):
-                        if isinstance(x.value, ir.Expr):
+                    if isinstance(x, ir.assign_types):
+                        if isinstance(x.value, ir.expr_types):
                             expr = x.value
                             if expr.op == "getattr":
                                 if (
@@ -877,7 +880,7 @@ def peep_hole_list_to_tuple(func_ir):
                                 fname = expr.func.name
                                 if fname in extends or fname in appends:
                                     arg = expr.args[0]
-                                    if isinstance(arg, ir.Var):
+                                    if isinstance(arg, ir.var_types):
                                         tmp_name = "%s_var_%s" % (
                                             fname,
                                             arg.name,
@@ -997,7 +1000,7 @@ def peep_hole_delete_with_exit(func_ir):
             # Any assignment that uses any of the dead variable is considered
             # dead.
             if used & dead_vars:
-                if isinstance(stmt, ir.Assign):
+                if isinstance(stmt, ir.assign_types):
                     dead_vars.add(stmt.target)
 
         new_body = []
@@ -1112,7 +1115,9 @@ def peep_hole_fuse_dict_add_updates(func_ir):
             # vars in statement. This is always the lhs with
             # a build_map.
             stmt_build_map_out = None
-            if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Expr):
+            if isinstance(stmt, ir.assign_types) and isinstance(
+                stmt.value, ir.expr_types
+            ):
                 if stmt.value.op == "build_map":
                     # Skip the output build_map when looking for used vars.
                     stmt_build_map_out = stmt.target.name
@@ -1130,9 +1135,9 @@ def peep_hole_fuse_dict_add_updates(func_ir):
                     getattr_stmt = blk.body[i - 1]
                     args = stmt.value.args
                     if (
-                        isinstance(getattr_stmt, ir.Assign)
+                        isinstance(getattr_stmt, ir.assign_types)
                         and getattr_stmt.target.name == func_name
-                        and isinstance(getattr_stmt.value, ir.Expr)
+                        and isinstance(getattr_stmt.value, ir.expr_types)
                         and getattr_stmt.value.op == "getattr"
                         and getattr_stmt.value.attr
                         in ("__setitem__", "_update_from_bytecode")
@@ -1207,8 +1212,8 @@ def peep_hole_fuse_dict_add_updates(func_ir):
             # will be removed when handling their call in the next
             # iteration.
             if not (
-                isinstance(stmt, ir.Assign)
-                and isinstance(stmt.value, ir.Expr)
+                isinstance(stmt, ir.assign_types)
+                and isinstance(stmt.value, ir.expr_types)
                 and stmt.value.op == "getattr"
                 and stmt.value.value.name in lit_map_use_idx
                 and stmt.value.attr in ("__setitem__", "_update_from_bytecode")
@@ -1249,7 +1254,7 @@ def peep_hole_split_at_pop_block(func_ir):
         # Gather locations of PopBlock
         pop_block_locs = []
         for i, inst in enumerate(blk.body):
-            if isinstance(inst, ir.PopBlock):
+            if isinstance(inst, ir.popblock_types):
                 pop_block_locs.append(i)
         # Rewrite block with PopBlock
         if pop_block_locs:
@@ -1301,10 +1306,14 @@ def _build_new_build_map(func_ir, name, old_body, old_lineno, new_items):
     for pair in new_items:
         k, v = pair
         key_def = ir_utils.guard(ir_utils.get_definition, func_ir, k)
-        if isinstance(key_def, (ir.Const, ir.Global, ir.FreeVar)):
+        if isinstance(
+            key_def, ir.const_types + ir.global_types + ir.freevar_types
+        ):
             literal_keys.append(key_def.value)
         value_def = ir_utils.guard(ir_utils.get_definition, func_ir, v)
-        if isinstance(value_def, (ir.Const, ir.Global, ir.FreeVar)):
+        if isinstance(
+            value_def, ir.const_types + ir.global_types + ir.freevar_types
+        ):
             values.append(value_def.value)
         else:
             # Append unknown value if not a literal.
@@ -1514,7 +1523,7 @@ class Interpreter(object):
         # Propagate the exception variables to LHS of assignment
         for varname, defnvars in self.definitions.items():
             for v in defnvars:
-                if isinstance(v, ir.Var):
+                if isinstance(v, ir.var_types):
                     k = v.name
                     if k in excvars:
                         excvars.add(varname)
@@ -1587,7 +1596,7 @@ class Interpreter(object):
             while self.syntax_blocks:
                 if offset >= self.syntax_blocks[-1].exit:
                     synblk = self.syntax_blocks.pop()
-                    if isinstance(synblk, ir.With):
+                    if isinstance(synblk, ir.with_types):
                         self.current_block.append(ir.PopBlock(self.loc))
                 else:
                     break
@@ -1684,11 +1693,11 @@ class Interpreter(object):
             # like a = b[i] = 1, so need to handle replaced temporaries in
             # later setitem/setattr nodes
             if (
-                isinstance(inst, (ir.SetItem, ir.SetAttr))
+                isinstance(inst, ir.setitem_types + ir.setattr_types)
                 and inst.value.name in replaced_var
             ):
                 inst.value = replaced_var[inst.value.name]
-            elif isinstance(inst, ir.Assign):
+            elif isinstance(inst, ir.assign_types):
                 if (
                     inst.target.is_temp
                     and inst.target.name in self.assigner.unused_dests
@@ -1698,7 +1707,7 @@ class Interpreter(object):
                 # like a = b = 1, so need to handle replaced temporaries in
                 # later assignments
                 if (
-                    isinstance(inst.value, ir.Var)
+                    isinstance(inst.value, ir.var_types)
                     and inst.value.name in replaced_var
                 ):
                     inst.value = replaced_var[inst.value.name]
@@ -1707,7 +1716,7 @@ class Interpreter(object):
                 # chained unpack cases may reuse temporary
                 # e.g. a = (b, c) = (x, y)
                 if (
-                    isinstance(inst.value, ir.Expr)
+                    isinstance(inst.value, ir.expr_types)
                     and inst.value.op == "exhaust_iter"
                     and inst.value.value.name in replaced_var
                 ):
@@ -1720,10 +1729,10 @@ class Interpreter(object):
                 # the temporary variable is not reused elsewhere since CPython
                 # bytecode is stack-based and this pattern corresponds to a pop
                 if (
-                    isinstance(inst.value, ir.Var)
+                    isinstance(inst.value, ir.var_types)
                     and inst.value.is_temp
                     and new_body
-                    and isinstance(new_body[-1], ir.Assign)
+                    and isinstance(new_body[-1], ir.assign_types)
                 ):
                     prev_assign = new_body[-1]
                     # _var_used_in_binop check makes sure we don't create a new
@@ -1753,7 +1762,7 @@ class Interpreter(object):
         in it as an argument
         """
         return (
-            isinstance(expr, ir.Expr)
+            isinstance(expr, ir.expr_types)
             and expr.op in ("binop", "inplace_binop")
             and (varname == expr.lhs.name or varname == expr.rhs.name)
         )
@@ -1832,7 +1841,7 @@ class Interpreter(object):
         if PYVERSION in ((3, 11), (3, 12), (3, 13)):
             if self.syntax_blocks:
                 top = self.syntax_blocks[-1]
-                if isinstance(top, ir.With):
+                if isinstance(top, ir.with_types):
                     if inst.offset >= top.exit:
                         self.current_block.append(ir.PopBlock(loc=self.loc))
                         self.syntax_blocks.pop()
@@ -1881,7 +1890,7 @@ class Interpreter(object):
             )
         else:
             target = self.current_scope.get_or_define(name, loc=self.loc)
-        if isinstance(value, ir.Var):
+        if isinstance(value, ir.var_types):
             value = self.assigner.assign(value, target)
         stmt = ir.Assign(value=value, target=target, loc=self.loc)
         self.current_block.append(stmt)
@@ -2649,7 +2658,7 @@ class Interpreter(object):
         # Find names const
         names = self.get(names)
         for inst in self.current_block.body:
-            if isinstance(inst, ir.Assign) and inst.target is names:
+            if isinstance(inst, ir.assign_types) and inst.target is names:
                 self.current_block.remove(inst)
                 # scan up the block looking for the values, remove them
                 # and find their name strings
@@ -2750,7 +2759,7 @@ class Interpreter(object):
         keyvar = self.get(keys)
         # TODO: refactor this pattern. occurred several times.
         for inst in self.current_block.body:
-            if isinstance(inst, ir.Assign) and inst.target is keyvar:
+            if isinstance(inst, ir.assign_types) and inst.target is keyvar:
                 self.current_block.remove(inst)
                 # scan up the block looking for the values, remove them
                 # and find their name strings
@@ -2776,7 +2785,7 @@ class Interpreter(object):
             if len(defns) != 1:
                 break
             defn = defns[0]
-            if not isinstance(defn, ir.Const):
+            if not isinstance(defn, ir.const_types):
                 break
             literal_items.append(defn.value)
 
@@ -2785,7 +2794,7 @@ class Interpreter(object):
             if len(defns) != 1:
                 return _UNKNOWN_VALUE(self.get(v).name)
             defn = defns[0]
-            if not isinstance(defn, ir.Const):
+            if not isinstance(defn, ir.const_types):
                 return _UNKNOWN_VALUE(self.get(v).name)
             return defn.value
 
@@ -2921,7 +2930,7 @@ class Interpreter(object):
                 if len(defns) != 1:
                     break
                 defn = defns[0]
-                if not isinstance(defn, ir.Const):
+                if not isinstance(defn, ir.const_types):
                     break
                 literal_items.append(defn.value)
             return literal_items
@@ -3196,7 +3205,7 @@ class Interpreter(object):
     def op_BREAK_LOOP(self, inst, end=None):
         if end is None:
             loop = self.syntax_blocks[-1]
-            assert isinstance(loop, ir.Loop)
+            assert isinstance(loop, ir.loop_types)
             end = loop.exit
         jmp = ir.Jump(target=end, loc=self.loc)
         self.current_block.append(jmp)
@@ -3408,7 +3417,7 @@ class Interpreter(object):
                 defaults = self.get(defaults)
 
         assume_code_const = self.definitions[code][0]
-        if not isinstance(assume_code_const, ir.Const):
+        if not isinstance(assume_code_const, ir.const_types):
             msg = (
                 "Unsupported use of closure. "
                 "Probably caused by complex control-flow constructs; "
@@ -3504,23 +3513,29 @@ class Interpreter(object):
 
         # is last emitted statement a build_tuple?
         stmt = self.current_block.body[-1]
-        ok = isinstance(stmt.value, ir.Expr) and stmt.value.op == "build_tuple"
+        ok = (
+            isinstance(stmt.value, ir.expr_types)
+            and stmt.value.op == "build_tuple"
+        )
         # check statements from self.current_block.body[-1] through to target,
         # make sure they are consts
         build_empty_list = None
         if ok:
             for stmt in reversed(self.current_block.body[:-1]):
-                if not isinstance(stmt, ir.Assign):
+                if not isinstance(stmt, ir.assign_types):
                     ok = False
                     break
                 # if its not a const, it needs to be the `build_list` for the
                 # target, else it's something else we don't know about so just
                 # bail
-                if isinstance(stmt.value, ir.Const):
+                if isinstance(stmt.value, ir.const_types):
                     continue
 
                 # it's not a const, check for target
-                elif isinstance(stmt.value, ir.Expr) and stmt.target == target:
+                elif (
+                    isinstance(stmt.value, ir.expr_types)
+                    and stmt.target == target
+                ):
                     build_empty_list = stmt
                     # it's only ok to do this if the target has no initializer
                     # already