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

numba_cuda/numba/cuda/core/ir_utils.py

@@ -215,7 +215,7 @@ def convert_size_to_var(size_var, typemap, scope, loc, nodes):
         size_assign = ir.Assign(ir.Const(size_var, loc), new_size, loc)
         nodes.append(size_assign)
         return new_size
-    assert isinstance(size_var, ir.Var)
+    assert isinstance(size_var, ir.var_types)
     return size_var
 
 
@@ -275,7 +275,7 @@ def mk_range_block(typemap, start, stop, step, calltypes, scope, loc):
 
 def _mk_range_args(typemap, start, stop, step, scope, loc):
     nodes = []
-    if isinstance(stop, ir.Var):
+    if isinstance(stop, ir.var_types):
         g_stop_var = stop
     else:
         assert isinstance(stop, int)
@@ -287,7 +287,7 @@ def _mk_range_args(typemap, start, stop, step, scope, loc):
     if start == 0 and step == 1:
         return nodes, [g_stop_var]
 
-    if isinstance(start, ir.Var):
+    if isinstance(start, ir.var_types):
         g_start_var = start
     else:
         assert isinstance(start, int)
@@ -299,7 +299,7 @@ def _mk_range_args(typemap, start, stop, step, scope, loc):
     if step == 1:
         return nodes, [g_start_var, g_stop_var]
 
-    if isinstance(step, ir.Var):
+    if isinstance(step, ir.var_types):
         g_step_var = step
     else:
         assert isinstance(step, int)
@@ -389,13 +389,10 @@ def get_name_var_table(blocks):
 def replace_var_names(blocks, namedict):
     """replace variables (ir.Var to ir.Var) from dictionary (name -> name)"""
     # remove identity values to avoid infinite loop
-    new_namedict = {}
-    for l, r in namedict.items():
-        if l != r:
-            new_namedict[l] = r
+    new_namedict = {l: r for l, r in namedict.items() if l != r}
 
     def replace_name(var, namedict):
-        assert isinstance(var, ir.Var)
+        assert isinstance(var, ir.var_types)
         while var.name in namedict:
             var = ir.Var(var.scope, namedict[var.name], var.loc)
         return var
@@ -404,7 +401,7 @@ def replace_var_names(blocks, namedict):
 
 
 def replace_var_callback(var, vardict):
-    assert isinstance(var, ir.Var)
+    assert isinstance(var, ir.var_types)
     while var.name in vardict.keys():
         assert vardict[var.name].name != var.name
         new_var = vardict[var.name]
@@ -415,10 +412,7 @@ def replace_var_callback(var, vardict):
 def replace_vars(blocks, vardict):
     """replace variables (ir.Var to ir.Var) from dictionary (name -> ir.Var)"""
     # remove identity values to avoid infinite loop
-    new_vardict = {}
-    for l, r in vardict.items():
-        if l != r.name:
-            new_vardict[l] = r
+    new_vardict = {l: r for l, r in vardict.items() if l != r.name}
     visit_vars(blocks, replace_var_callback, new_vardict)
 
 
@@ -451,44 +445,44 @@ def visit_vars_stmt(stmt, callback, cbdata):
         if isinstance(stmt, t):
             f(stmt, callback, cbdata)
             return
-    if isinstance(stmt, ir.Assign):
+    if isinstance(stmt, ir.assign_types):
         stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
         stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
-    elif isinstance(stmt, ir.Arg):
+    elif isinstance(stmt, ir.arg_types):
         stmt.name = visit_vars_inner(stmt.name, callback, cbdata)
-    elif isinstance(stmt, ir.Return):
+    elif isinstance(stmt, ir.return_types):
         stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
-    elif isinstance(stmt, ir.Raise):
+    elif isinstance(stmt, ir.raise_types):
         stmt.exception = visit_vars_inner(stmt.exception, callback, cbdata)
-    elif isinstance(stmt, ir.Branch):
+    elif isinstance(stmt, ir.branch_types):
         stmt.cond = visit_vars_inner(stmt.cond, callback, cbdata)
-    elif isinstance(stmt, ir.Jump):
+    elif isinstance(stmt, ir.jump_types):
         stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
-    elif isinstance(stmt, ir.Del):
+    elif isinstance(stmt, ir.del_types):
         # Because Del takes only a var name, we make up by
         # constructing a temporary variable.
         var = ir.Var(None, stmt.value, stmt.loc)
         var = visit_vars_inner(var, callback, cbdata)
         stmt.value = var.name
-    elif isinstance(stmt, ir.DelAttr):
+    elif isinstance(stmt, ir.delattr_types):
         stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
         stmt.attr = visit_vars_inner(stmt.attr, callback, cbdata)
-    elif isinstance(stmt, ir.SetAttr):
+    elif isinstance(stmt, ir.setattr_types):
         stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
         stmt.attr = visit_vars_inner(stmt.attr, callback, cbdata)
         stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
-    elif isinstance(stmt, ir.DelItem):
+    elif isinstance(stmt, ir.delitem_types):
         stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
         stmt.index = visit_vars_inner(stmt.index, callback, cbdata)
-    elif isinstance(stmt, ir.StaticSetItem):
+    elif isinstance(stmt, ir.staticsetitem_types):
         stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
         stmt.index_var = visit_vars_inner(stmt.index_var, callback, cbdata)
         stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
-    elif isinstance(stmt, ir.SetItem):
+    elif isinstance(stmt, ir.setitem_types):
         stmt.target = visit_vars_inner(stmt.target, callback, cbdata)
         stmt.index = visit_vars_inner(stmt.index, callback, cbdata)
         stmt.value = visit_vars_inner(stmt.value, callback, cbdata)
-    elif isinstance(stmt, ir.Print):
+    elif isinstance(stmt, ir.print_types):
         stmt.args = [visit_vars_inner(x, callback, cbdata) for x in stmt.args]
     else:
         # TODO: raise NotImplementedError("no replacement for IR node: ", stmt)
@@ -497,13 +491,13 @@ def visit_vars_stmt(stmt, callback, cbdata):
 
 
 def visit_vars_inner(node, callback, cbdata):
-    if isinstance(node, ir.Var):
+    if isinstance(node, ir.var_types):
         return callback(node, cbdata)
     elif isinstance(node, list):
         return [visit_vars_inner(n, callback, cbdata) for n in node]
     elif isinstance(node, tuple):
         return tuple([visit_vars_inner(n, callback, cbdata) for n in node])
-    elif isinstance(node, ir.Expr):
+    elif isinstance(node, ir.expr_types):
         # if node.op in ['binop', 'inplace_binop']:
         #     lhs = node.lhs.name
         #     rhs = node.rhs.name
@@ -511,7 +505,7 @@ def visit_vars_inner(node, callback, cbdata):
         #     node.rhs.name = callback, cbdata.get(rhs, rhs)
         for arg in node._kws.keys():
             node._kws[arg] = visit_vars_inner(node._kws[arg], callback, cbdata)
-    elif isinstance(node, ir.Yield):
+    elif isinstance(node, ir.yield_types):
         node.value = visit_vars_inner(node.value, callback, cbdata)
     return node
 
@@ -531,9 +525,9 @@ def add_offset_to_labels(blocks, offset):
                 for T, f in add_offset_to_labels_extensions.items():
                     if isinstance(inst, T):
                         f(inst, offset)
-        if isinstance(term, ir.Jump):
+        if isinstance(term, ir.jump_types):
             b.body[-1] = ir.Jump(term.target + offset, term.loc)
-        if isinstance(term, ir.Branch):
+        if isinstance(term, ir.branch_types):
             b.body[-1] = ir.Branch(
                 term.cond, term.truebr + offset, term.falsebr + offset, term.loc
             )
@@ -578,9 +572,9 @@ def flatten_labels(blocks):
         term = None
         if b.body:
             term = b.body[-1]
-        if isinstance(term, ir.Jump):
+        if isinstance(term, ir.jump_types):
             b.body[-1] = ir.Jump(l_map[term.target], term.loc)
-        if isinstance(term, ir.Branch):
+        if isinstance(term, ir.branch_types):
             b.body[-1] = ir.Branch(
                 term.cond, l_map[term.truebr], l_map[term.falsebr], term.loc
             )
@@ -591,11 +585,9 @@ def flatten_labels(blocks):
 def remove_dels(blocks):
     """remove ir.Del nodes"""
     for block in blocks.values():
-        new_body = []
-        for stmt in block.body:
-            if not isinstance(stmt, ir.Del):
-                new_body.append(stmt)
-        block.body = new_body
+        block.body = [
+            stmt for stmt in block.body if not isinstance(stmt, ir.del_types)
+        ]
     return
 
 
@@ -604,7 +596,9 @@ def remove_args(blocks):
     for block in blocks.values():
         new_body = []
         for stmt in block.body:
-            if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Arg):
+            if isinstance(stmt, ir.assign_types) and isinstance(
+                stmt.value, ir.arg_types
+            ):
                 continue
             new_body.append(stmt)
         block.body = new_body
@@ -737,7 +731,7 @@ def remove_dead_block(
                 continue
 
         # ignore assignments that their lhs is not live or lhs==rhs
-        if isinstance(stmt, ir.Assign):
+        if isinstance(stmt, ir.assign_types):
             lhs = stmt.target
             rhs = stmt.value
             if lhs.name not in lives and has_no_side_effect(
@@ -747,21 +741,21 @@ def remove_dead_block(
                     print("Statement was removed.")
                 removed = True
                 continue
-            if isinstance(rhs, ir.Var) and lhs.name == rhs.name:
+            if isinstance(rhs, ir.var_types) and lhs.name == rhs.name:
                 if config.DEBUG_ARRAY_OPT >= 2:
                     print("Statement was removed.")
                 removed = True
                 continue
             # TODO: remove other nodes like SetItem etc.
 
-        if isinstance(stmt, ir.Del):
+        if isinstance(stmt, ir.del_types):
             if stmt.value not in lives:
                 if config.DEBUG_ARRAY_OPT >= 2:
                     print("Statement was removed.")
                 removed = True
                 continue
 
-        if isinstance(stmt, ir.SetItem):
+        if isinstance(stmt, ir.setitem_types):
             name = stmt.target.name
             if name not in lives_n_aliases:
                 if config.DEBUG_ARRAY_OPT >= 2:
@@ -775,9 +769,9 @@ def remove_dead_block(
             lives |= uses
         else:
             lives |= {v.name for v in stmt.list_vars()}
-            if isinstance(stmt, ir.Assign):
+            if isinstance(stmt, ir.assign_types):
                 # make sure lhs is not used in rhs, e.g. a = g(a)
-                if isinstance(stmt.value, ir.Expr):
+                if isinstance(stmt.value, ir.expr_types):
                     rhs_vars = {v.name for v in stmt.value.list_vars()}
                     if lhs.name not in rhs_vars:
                         lives.remove(lhs.name)
@@ -809,7 +803,7 @@ def has_no_side_effect(rhs, lives, call_table):
     """
     from numba.cuda.extending import _Intrinsic
 
-    if isinstance(rhs, ir.Expr) and rhs.op == "call":
+    if isinstance(rhs, ir.expr_types) and rhs.op == "call":
         func_name = rhs.func.name
         if func_name not in call_table or call_table[func_name] == []:
             return False
@@ -843,11 +837,11 @@ def has_no_side_effect(rhs, lives, call_table):
             if f(rhs, lives, call_list):
                 return True
         return False
-    if isinstance(rhs, ir.Expr) and rhs.op == "inplace_binop":
+    if isinstance(rhs, ir.expr_types) and rhs.op == "inplace_binop":
         return rhs.lhs.name not in lives
-    if isinstance(rhs, ir.Yield):
+    if isinstance(rhs, ir.yield_types):
         return False
-    if isinstance(rhs, ir.Expr) and rhs.op == "pair_first":
+    if isinstance(rhs, ir.expr_types) and rhs.op == "pair_first":
         # don't remove pair_first since prange looks for it
         return False
     return True
@@ -861,7 +855,7 @@ def is_pure(rhs, lives, call_table):
     returns the same result.  This is not the case for things
     like calls to numpy.random.
     """
-    if isinstance(rhs, ir.Expr):
+    if isinstance(rhs, ir.expr_types):
         if rhs.op == "call":
             func_name = rhs.func.name
             if func_name not in call_table or call_table[func_name] == []:
@@ -882,7 +876,7 @@ def is_pure(rhs, lives, call_table):
             return False
         elif rhs.op == "getiter" or rhs.op == "iternext":
             return False
-    if isinstance(rhs, ir.Yield):
+    if isinstance(rhs, ir.yield_types):
         return False
     return True
 
@@ -926,39 +920,42 @@ def find_potential_aliases(
             if type(instr) in alias_analysis_extensions:
                 f = alias_analysis_extensions[type(instr)]
                 f(instr, args, typemap, func_ir, alias_map, arg_aliases)
-            if isinstance(instr, ir.Assign):
+            if isinstance(instr, ir.assign_types):
                 expr = instr.value
                 lhs = instr.target.name
                 # only mutable types can alias
                 if is_immutable_type(lhs, typemap):
                     continue
-                if isinstance(expr, ir.Var) and lhs != expr.name:
+                if isinstance(expr, ir.var_types) and lhs != expr.name:
                     _add_alias(lhs, expr.name, alias_map, arg_aliases)
                 # subarrays like A = B[0] for 2D B
-                if isinstance(expr, ir.Expr) and (
+                if isinstance(expr, ir.expr_types) and (
                     expr.op == "cast"
                     or expr.op in ["getitem", "static_getitem"]
                 ):
                     _add_alias(lhs, expr.value.name, alias_map, arg_aliases)
-                if isinstance(expr, ir.Expr) and expr.op == "inplace_binop":
+                if (
+                    isinstance(expr, ir.expr_types)
+                    and expr.op == "inplace_binop"
+                ):
                     _add_alias(lhs, expr.lhs.name, alias_map, arg_aliases)
                 # array attributes like A.T
                 if (
-                    isinstance(expr, ir.Expr)
+                    isinstance(expr, ir.expr_types)
                     and expr.op == "getattr"
                     and expr.attr in ["T", "ctypes", "flat"]
                 ):
                     _add_alias(lhs, expr.value.name, alias_map, arg_aliases)
                 # a = b.c.  a should alias b
                 if (
-                    isinstance(expr, ir.Expr)
+                    isinstance(expr, ir.expr_types)
                     and expr.op == "getattr"
                     and expr.attr not in ["shape"]
                     and expr.value.name in arg_aliases
                 ):
                     _add_alias(lhs, expr.value.name, alias_map, arg_aliases)
                 # calls that can create aliases such as B = A.ravel()
-                if isinstance(expr, ir.Expr) and expr.op == "call":
+                if isinstance(expr, ir.expr_types) and expr.op == "call":
                     fdef = guard(find_callname, func_ir, expr, typemap)
                     # TODO: sometimes gufunc backend creates duplicate code
                     # causing find_callname to fail. Example: test_argmax
@@ -974,7 +971,10 @@ def find_potential_aliases(
                         _add_alias(
                             lhs, expr.args[0].name, alias_map, arg_aliases
                         )
-                    if isinstance(fmod, ir.Var) and fname in np_alias_funcs:
+                    if (
+                        isinstance(fmod, ir.var_types)
+                        and fname in np_alias_funcs
+                    ):
                         _add_alias(lhs, fmod.name, alias_map, arg_aliases)
 
     # copy to avoid changing size during iteration
@@ -1068,7 +1068,7 @@ def init_copy_propagate_data(blocks, entry, typemap):
     gen_copies, extra_kill = get_block_copies(blocks, typemap)
     # set of all program copies
     all_copies = set()
-    for l, s in gen_copies.items():
+    for l in gen_copies.keys():
         all_copies |= gen_copies[l]
     kill_copies = {}
     for label, gen_set in gen_copies.items():
@@ -1114,8 +1114,7 @@ def get_block_copies(blocks, typemap):
             for T, f in copy_propagate_extensions.items():
                 if isinstance(stmt, T):
                     gen_set, kill_set = f(stmt, typemap)
-                    for lhs, rhs in gen_set:
-                        assign_dict[lhs] = rhs
+                    assign_dict.update(gen_set)
                     # if a=b is in dict and b is killed, a is also killed
                     new_assign_dict = {}
                     for l, r in assign_dict.items():
@@ -1125,9 +1124,9 @@ def get_block_copies(blocks, typemap):
                             extra_kill[label].add(l)
                     assign_dict = new_assign_dict
                     extra_kill[label] |= kill_set
-            if isinstance(stmt, ir.Assign):
+            if isinstance(stmt, ir.assign_types):
                 lhs = stmt.target.name
-                if isinstance(stmt.value, ir.Var):
+                if isinstance(stmt.value, ir.var_types):
                     rhs = stmt.value.name
                     # copy is valid only if same type (see
                     # TestCFunc.test_locals)
@@ -1139,7 +1138,7 @@ def get_block_copies(blocks, typemap):
                         assign_dict[lhs] = rhs
                         continue
                 if (
-                    isinstance(stmt.value, ir.Expr)
+                    isinstance(stmt.value, ir.expr_types)
                     and stmt.value.op == "inplace_binop"
                 ):
                     in1_var = stmt.value.lhs.name
@@ -1195,7 +1194,7 @@ def apply_copy_propagate(
                 )
             # only rhs of assignments should be replaced
             # e.g. if x=y is available, x in x=z shouldn't be replaced
-            elif isinstance(stmt, ir.Assign):
+            elif isinstance(stmt, ir.assign_types):
                 stmt.value = replace_vars_inner(stmt.value, var_dict)
             else:
                 replace_vars_stmt(stmt, var_dict)
@@ -1209,7 +1208,9 @@ def apply_copy_propagate(
                     for l, r in var_dict.copy().items():
                         if l in kill_set or r.name in kill_set:
                             var_dict.pop(l)
-            if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Var):
+            if isinstance(stmt, ir.assign_types) and isinstance(
+                stmt.value, ir.var_types
+            ):
                 lhs = stmt.target.name
                 rhs = stmt.value.name
                 # rhs could be replaced with lhs from previous copies
@@ -1227,8 +1228,8 @@ def apply_copy_propagate(
                             lhs_kill.append(k)
                     for k in lhs_kill:
                         var_dict.pop(k, None)
-            if isinstance(stmt, ir.Assign) and not isinstance(
-                stmt.value, ir.Var
+            if isinstance(stmt, ir.assign_types) and not isinstance(
+                stmt.value, ir.var_types
             ):
                 lhs = stmt.target.name
                 var_dict.pop(lhs, None)
@@ -1249,7 +1250,7 @@ def fix_setitem_type(stmt, typemap, calltypes):
     with 'A' layout. The replaced variable can be 'C' or 'F', so we update
     setitem call type reflect this (from matrix power test)
     """
-    if not isinstance(stmt, (ir.SetItem, ir.StaticSetItem)):
+    if not isinstance(stmt, ir.setitem_types + ir.staticsetitem_types):
         return
     t_typ = typemap[stmt.target.name]
     s_typ = calltypes[stmt].args[0]
@@ -1304,7 +1305,7 @@ def find_topo_order(blocks, cfg=None):
             seen.add(node)
             succs = cfg._succs[node]
             last_inst = blocks[node].body[-1]
-            if isinstance(last_inst, ir.Branch):
+            if isinstance(last_inst, ir.branch_types):
                 succs = [last_inst.truebr, last_inst.falsebr]
             for dest in succs:
                 if (node, dest) not in cfg._back_edges:
@@ -1351,12 +1352,12 @@ def get_call_table(
 
     for label in reversed(order):
         for inst in reversed(blocks[label].body):
-            if isinstance(inst, ir.Assign):
+            if isinstance(inst, ir.assign_types):
                 lhs = inst.target.name
                 rhs = inst.value
-                if isinstance(rhs, ir.Expr) and rhs.op == "call":
+                if isinstance(rhs, ir.expr_types) and rhs.op == "call":
                     call_table[rhs.func.name] = []
-                if isinstance(rhs, ir.Expr) and rhs.op == "getattr":
+                if isinstance(rhs, ir.expr_types) and rhs.op == "getattr":
                     if lhs in call_table:
                         call_table[lhs].append(rhs.attr)
                         reverse_call_table[rhs.value.name] = lhs
@@ -1364,19 +1365,19 @@ def get_call_table(
                         call_var = reverse_call_table[lhs]
                         call_table[call_var].append(rhs.attr)
                         reverse_call_table[rhs.value.name] = call_var
-                if isinstance(rhs, ir.Global):
+                if isinstance(rhs, ir.global_types):
                     if lhs in call_table:
                         call_table[lhs].append(rhs.value)
                     if lhs in reverse_call_table:
                         call_var = reverse_call_table[lhs]
                         call_table[call_var].append(rhs.value)
-                if isinstance(rhs, ir.FreeVar):
+                if isinstance(rhs, ir.freevar_types):
                     if lhs in call_table:
                         call_table[lhs].append(rhs.value)
                     if lhs in reverse_call_table:
                         call_var = reverse_call_table[lhs]
                         call_table[call_var].append(rhs.value)
-                if isinstance(rhs, ir.Var):
+                if isinstance(rhs, ir.var_types):
                     if lhs in call_table:
                         call_table[lhs].append(rhs.name)
                         reverse_call_table[rhs.name] = lhs
@@ -1401,12 +1402,14 @@ def get_tuple_table(blocks, tuple_table=None):
 
     for block in blocks.values():
         for inst in block.body:
-            if isinstance(inst, ir.Assign):
+            if isinstance(inst, ir.assign_types):
                 lhs = inst.target.name
                 rhs = inst.value
-                if isinstance(rhs, ir.Expr) and rhs.op == "build_tuple":
+                if isinstance(rhs, ir.expr_types) and rhs.op == "build_tuple":
                     tuple_table[lhs] = rhs.items
-                if isinstance(rhs, ir.Const) and isinstance(rhs.value, tuple):
+                if isinstance(rhs, ir.const_types) and isinstance(
+                    rhs.value, tuple
+                ):
                     tuple_table[lhs] = rhs.value
             for T, f in tuple_table_extensions.items():
                 if isinstance(inst, T):
@@ -1416,7 +1419,9 @@ def get_tuple_table(blocks, tuple_table=None):
 
 def get_stmt_writes(stmt):
     writes = set()
-    if isinstance(stmt, (ir.Assign, ir.SetItem, ir.StaticSetItem)):
+    if isinstance(
+        stmt, ir.assign_types + ir.setitem_types + ir.staticsetitem_types
+    ):
         writes.add(stmt.target.name)
     return writes
 
@@ -1430,7 +1435,7 @@ def rename_labels(blocks):
     # make a block with return last if available (just for readability)
     return_label = -1
     for l, b in blocks.items():
-        if isinstance(b.body[-1], ir.Return):
+        if isinstance(b.body[-1], ir.return_types):
             return_label = l
     # some cases like generators can have no return blocks
     if return_label != -1:
@@ -1446,9 +1451,9 @@ def rename_labels(blocks):
         term = b.terminator
         # create new IR nodes instead of mutating the existing one as copies of
         # the IR may also refer to the same nodes!
-        if isinstance(term, ir.Jump):
+        if isinstance(term, ir.jump_types):
             b.body[-1] = ir.Jump(label_map[term.target], term.loc)
-        if isinstance(term, ir.Branch):
+        if isinstance(term, ir.branch_types):
             b.body[-1] = ir.Branch(
                 term.cond,
                 label_map[term.truebr],
@@ -1472,7 +1477,9 @@ def simplify_CFG(blocks):
 
     def find_single_branch(label):
         block = blocks[label]
-        return len(block.body) == 1 and isinstance(block.body[0], ir.Branch)
+        return len(block.body) == 1 and isinstance(
+            block.body[0], ir.branch_types
+        )
 
     single_branch_blocks = list(filter(find_single_branch, blocks.keys()))
     marked_for_del = set()
@@ -1482,7 +1489,7 @@ def simplify_CFG(blocks):
         delete_block = True
         for p, q in predecessors:
             block = blocks[p]
-            if isinstance(block.body[-1], ir.Jump):
+            if isinstance(block.body[-1], ir.jump_types):
                 block.body[-1] = copy.copy(inst)
             else:
                 delete_block = False
@@ -1523,7 +1530,9 @@ def canonicalize_array_math(func_ir, typemap, calltypes, typingctx):
         block = blocks[label]
         new_body = []
         for stmt in block.body:
-            if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Expr):
+            if isinstance(stmt, ir.assign_types) and isinstance(
+                stmt.value, ir.expr_types
+            ):
                 lhs = stmt.target.name
                 rhs = stmt.value
                 # replace A.func with np.func, and save A in saved_arr_arg
@@ -1582,15 +1591,18 @@ def get_array_accesses(blocks, accesses=None):
 
     for block in blocks.values():
         for inst in block.body:
-            if isinstance(inst, ir.SetItem):
+            if isinstance(inst, ir.setitem_types):
                 accesses.add((inst.target.name, inst.index.name))
-            if isinstance(inst, ir.StaticSetItem):
+            if isinstance(inst, ir.staticsetitem_types):
                 accesses.add((inst.target.name, inst.index_var.name))
-            if isinstance(inst, ir.Assign):
+            if isinstance(inst, ir.assign_types):
                 rhs = inst.value
-                if isinstance(rhs, ir.Expr) and rhs.op == "getitem":
+                if isinstance(rhs, ir.expr_types) and rhs.op == "getitem":
                     accesses.add((rhs.value.name, rhs.index.name))
-                if isinstance(rhs, ir.Expr) and rhs.op == "static_getitem":
+                if (
+                    isinstance(rhs, ir.expr_types)
+                    and rhs.op == "static_getitem"
+                ):
                     index = rhs.index
                     # slice is unhashable, so just keep the variable
                     if index is None or is_slice_index(index):
@@ -1743,7 +1755,7 @@ def build_definitions(blocks, definitions=None):
 
     for block in blocks.values():
         for inst in block.body:
-            if isinstance(inst, ir.Assign):
+            if isinstance(inst, ir.assign_types):
                 name = inst.target.name
                 definition = definitions.get(name, [])
                 if definition == []:
@@ -1771,13 +1783,13 @@ def find_callname(
     """
     from numba.cuda.extending import _Intrinsic
 
-    require(isinstance(expr, ir.Expr) and expr.op == "call")
+    require(isinstance(expr, ir.expr_types) and expr.op == "call")
     callee = expr.func
     callee_def = definition_finder(func_ir, callee)
     attrs = []
     obj = None
     while True:
-        if isinstance(callee_def, (ir.Global, ir.FreeVar)):
+        if isinstance(callee_def, ir.global_types + ir.freevar_types):
             # require(callee_def.value == numpy)
             # these checks support modules like numpy, numpy.random as well as
             # calls like len() and intrinsics like assertEquiv
@@ -1829,7 +1841,9 @@ def find_callname(
                 if class_name != "module":
                     attrs.append(class_name)
             break
-        elif isinstance(callee_def, ir.Expr) and callee_def.op == "getattr":
+        elif (
+            isinstance(callee_def, ir.expr_types) and callee_def.op == "getattr"
+        ):
             obj = callee_def.value
             attrs.append(callee_def.attr)
             if typemap and obj.name in typemap:
@@ -1851,9 +1865,9 @@ def find_build_sequence(func_ir, var):
     operator, or raise GuardException otherwise.
     Note: only build_tuple is immutable, so use with care.
     """
-    require(isinstance(var, ir.Var))
+    require(isinstance(var, ir.var_types))
     var_def = get_definition(func_ir, var)
-    require(isinstance(var_def, ir.Expr))
+    require(isinstance(var_def, ir.expr_types))
     build_ops = ["build_tuple", "build_list", "build_set"]
     require(var_def.op in build_ops)
     return var_def.items, var_def.op
@@ -1863,9 +1877,11 @@ def find_const(func_ir, var):
     """Check if a variable is defined as constant, and return
     the constant value, or raise GuardException otherwise.
     """
-    require(isinstance(var, ir.Var))
+    require(isinstance(var, ir.var_types))
     var_def = get_definition(func_ir, var)
-    require(isinstance(var_def, (ir.Const, ir.Global, ir.FreeVar)))
+    require(
+        isinstance(var_def, ir.const_types + ir.global_types + ir.freevar_types)
+    )
     return var_def.value
 
 
@@ -1908,7 +1924,7 @@ def compile_to_numba_ir(
     # rename all variables to avoid conflict
     var_table = get_name_var_table(f_ir.blocks)
     new_var_dict = {}
-    for name, var in var_table.items():
+    for name in var_table.keys():
         new_var_dict[name] = mk_unique_var(name)
     replace_var_names(f_ir.blocks, new_var_dict)
 
@@ -2025,7 +2041,9 @@ def replace_arg_nodes(block, args):
     Replace ir.Arg(...) with variables
     """
     for stmt in block.body:
-        if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Arg):
+        if isinstance(stmt, ir.assign_types) and isinstance(
+            stmt.value, ir.arg_types
+        ):
             idx = stmt.value.index
             assert idx < len(args)
             stmt.value = args[idx]
@@ -2041,12 +2059,12 @@ def replace_returns(blocks, target, return_label):
         if not block.body:
             continue
         stmt = block.terminator
-        if isinstance(stmt, ir.Return):
+        if isinstance(stmt, ir.return_types):
             block.body.pop()  # remove return
             cast_stmt = block.body.pop()
             assert (
-                isinstance(cast_stmt, ir.Assign)
-                and isinstance(cast_stmt.value, ir.Expr)
+                isinstance(cast_stmt, ir.assign_types)
+                and isinstance(cast_stmt.value, ir.expr_types)
                 and cast_stmt.value.op == "cast"
             ), "invalid return cast"
             block.body.append(
@@ -2093,7 +2111,7 @@ def dump_blocks(blocks):
 def is_operator_or_getitem(expr):
     """true if expr is unary or binary operator or getitem"""
     return (
-        isinstance(expr, ir.Expr)
+        isinstance(expr, ir.expr_types)
         and getattr(expr, "op", False)
         and expr.op
         in ["unary", "binop", "inplace_binop", "getitem", "static_getitem"]
@@ -2108,15 +2126,15 @@ def is_get_setitem(stmt):
 def is_getitem(stmt):
     """true if stmt is a getitem or static_getitem assignment"""
     return (
-        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 in ["getitem", "static_getitem"]
     )
 
 
 def is_setitem(stmt):
     """true if stmt is a SetItem or StaticSetItem node"""
-    return isinstance(stmt, (ir.SetItem, ir.StaticSetItem))
+    return isinstance(stmt, ir.setitem_types + ir.staticsetitem_types)
 
 
 def index_var_of_get_setitem(stmt):
@@ -2128,7 +2146,7 @@ def index_var_of_get_setitem(stmt):
             return stmt.value.index_var
 
     if is_setitem(stmt):
-        if isinstance(stmt, ir.SetItem):
+        if isinstance(stmt, ir.setitem_types):
             return stmt.index
         else:
             return stmt.index_var
@@ -2143,7 +2161,7 @@ def set_index_var_of_get_setitem(stmt, new_index):
         else:
             stmt.value.index_var = new_index
     elif is_setitem(stmt):
-        if isinstance(stmt, ir.SetItem):
+        if isinstance(stmt, ir.setitem_types):
             stmt.index = new_index
         else:
             stmt.index_var = new_index
@@ -2242,10 +2260,10 @@ def find_outer_value(func_ir, var):
     or raise GuardException otherwise.
     """
     dfn = get_definition(func_ir, var)
-    if isinstance(dfn, (ir.Global, ir.FreeVar)):
+    if isinstance(dfn, ir.global_types + ir.freevar_types):
         return dfn.value
 
-    if isinstance(dfn, ir.Expr) and dfn.op == "getattr":
+    if isinstance(dfn, ir.expr_types) and dfn.op == "getattr":
         prev_val = find_outer_value(func_ir, dfn.value)
         try:
             val = getattr(prev_val, dfn.attr)
@@ -2288,9 +2306,9 @@ def raise_on_unsupported_feature(func_ir, typemap):
             raise UnsupportedError(msg, func_ir.loc)
 
     for blk in func_ir.blocks.values():
-        for stmt in blk.find_insts(ir.Assign):
+        for stmt in blk.find_insts(ir.assign_types):
             # This raises on finding `make_function`
-            if isinstance(stmt.value, ir.Expr):
+            if isinstance(stmt.value, ir.expr_types):
                 if stmt.value.op == "make_function":
                     val = stmt.value
 
@@ -2321,7 +2339,7 @@ def raise_on_unsupported_feature(func_ir, typemap):
                     raise UnsupportedError(msg, stmt.value.loc)
 
             # this checks for gdb initialization calls, only one is permitted
-            if isinstance(stmt.value, (ir.Global, ir.FreeVar)):
+            if isinstance(stmt.value, ir.global_types + ir.freevar_types):
                 val = stmt.value
                 val = getattr(val, "value", None)
                 if val is None:
@@ -2337,7 +2355,7 @@ def raise_on_unsupported_feature(func_ir, typemap):
                     gdb_calls.append(stmt.loc)  # report last seen location
 
             # this checks that np.<type> was called if view is called
-            if isinstance(stmt.value, ir.Expr):
+            if isinstance(stmt.value, ir.expr_types):
                 if stmt.value.op == "getattr" and stmt.value.attr == "view":
                     var = stmt.value.value.name
                     if isinstance(typemap[var], types.Array):
@@ -2363,7 +2381,7 @@ def raise_on_unsupported_feature(func_ir, typemap):
                     )
 
             # checks for globals that are also reflected
-            if isinstance(stmt.value, ir.Global):
+            if isinstance(stmt.value, ir.global_types):
                 ty = typemap[stmt.target.name]
                 msg = (
                     "The use of a %s type, assigned to variable '%s' in "
@@ -2380,7 +2398,10 @@ def raise_on_unsupported_feature(func_ir, typemap):
 
             # checks for generator expressions (yield in use when func_ir has
             # not been identified as a generator).
-            if isinstance(stmt.value, ir.Yield) and not func_ir.is_generator:
+            if (
+                isinstance(stmt.value, ir.yield_types)
+                and not func_ir.is_generator
+            ):
                 msg = "The use of generator expressions is unsupported."
                 raise UnsupportedError(msg, loc=stmt.loc)
 
@@ -2443,7 +2464,7 @@ def resolve_func_from_module(func_ir, node):
             except KeyError:  # multiple definitions
                 return None
             return resolve_mod(mod)
-        elif isinstance(mod, (ir.Global, ir.FreeVar)):
+        elif isinstance(mod, ir.global_types + ir.freevar_types):
             if isinstance(mod.value, pytypes.ModuleType):
                 return mod
         return None
@@ -2466,7 +2487,7 @@ def enforce_no_dels(func_ir):
     Enforce there being no ir.Del nodes in the IR.
     """
     for blk in func_ir.blocks.values():
-        dels = [x for x in blk.find_insts(ir.Del)]
+        dels = [x for x in blk.find_insts(ir.del_types)]
         if dels:
             msg = "Illegal IR, del found at: %s" % dels[0]
             raise CompilerError(msg, loc=dels[0].loc)
@@ -2522,7 +2543,7 @@ def convert_code_obj_to_function(code_obj, caller_ir):
                 "are multiple definitions present." % x
             )
             raise TypingError(msg, loc=code_obj.loc)
-        if isinstance(freevar_def, ir.Const):
+        if isinstance(freevar_def, ir.const_types):
             freevars.append(freevar_def.value)
         else:
             msg = (
@@ -2619,20 +2640,20 @@ def transfer_scope(block, scope):
 
 
 def is_setup_with(stmt):
-    return isinstance(stmt, ir.EnterWith)
+    return isinstance(stmt, ir.enterwith_types)
 
 
 def is_terminator(stmt):
-    return isinstance(stmt, ir.Terminator)
+    return isinstance(stmt, ir.terminator_types)
 
 
 def is_raise(stmt):
-    return isinstance(stmt, ir.Raise)
+    return isinstance(stmt, ir.raise_types)
 
 
 def is_return(stmt):
-    return isinstance(stmt, ir.Return)
+    return isinstance(stmt, ir.return_types)
 
 
 def is_pop_block(stmt):
-    return isinstance(stmt, ir.PopBlock)
+    return isinstance(stmt, ir.popblock_types)